1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* TODO: Emit .debug_line header even when there are no functions, since
24 the file numbers are used by .debug_info. Alternately, leave
25 out locations for types and decls.
26 Avoid talking about ctors and op= for PODs.
27 Factor out common prologue sequences into multiple CIEs. */
29 /* The first part of this file deals with the DWARF 2 frame unwind
30 information, which is also used by the GCC efficient exception handling
31 mechanism. The second part, controlled only by an #ifdef
32 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35 /* DWARF2 Abbreviation Glossary:
37 CFA = Canonical Frame Address
38 a fixed address on the stack which identifies a call frame.
39 We define it to be the value of SP just before the call insn.
40 The CFA register and offset, which may change during the course
41 of the function, are used to calculate its value at runtime.
43 CFI = Call Frame Instruction
44 an instruction for the DWARF2 abstract machine
46 CIE = Common Information Entry
47 information describing information common to one or more FDEs
49 DIE = Debugging Information Entry
51 FDE = Frame Description Entry
52 information describing the stack call frame, in particular,
53 how to restore registers
55 DW_CFA_... = DWARF2 CFA call frame instruction
56 DW_TAG_... = DWARF2 DIE tag */
60 #include "coretypes.h"
66 #include "double-int.h"
74 #include "fold-const.h"
75 #include "stringpool.h"
76 #include "stor-layout.h"
79 #include "hard-reg-set.h"
82 #include "hash-table.h"
87 #include "insn-config.h"
90 #include "statistics.h"
91 #include "fixed-value.h"
100 #include "dwarf2out.h"
101 #include "dwarf2asm.h"
105 #include "diagnostic.h"
106 #include "tree-pretty-print.h"
109 #include "common/common-target.h"
110 #include "langhooks.h"
111 #include "hash-map.h"
113 #include "plugin-api.h"
118 #include "dumpfile.h"
120 #include "tree-dfa.h"
121 #include "gdb/gdb-index.h"
122 #include "rtl-iter.h"
124 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
125 static rtx_insn *last_var_location_insn;
126 static rtx_insn *cached_next_real_insn;
127 static void dwarf2out_decl (tree);
129 #ifdef VMS_DEBUGGING_INFO
130 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
132 /* Define this macro to be a nonzero value if the directory specifications
133 which are output in the debug info should end with a separator. */
134 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
135 /* Define this macro to evaluate to a nonzero value if GCC should refrain
136 from generating indirect strings in DWARF2 debug information, for instance
137 if your target is stuck with an old version of GDB that is unable to
138 process them properly or uses VMS Debug. */
139 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
141 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
142 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
145 /* ??? Poison these here until it can be done generically. They've been
146 totally replaced in this file; make sure it stays that way. */
147 #undef DWARF2_UNWIND_INFO
148 #undef DWARF2_FRAME_INFO
149 #if (GCC_VERSION >= 3000)
150 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
153 /* The size of the target's pointer type. */
155 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
158 /* Array of RTXes referenced by the debugging information, which therefore
159 must be kept around forever. */
160 static GTY(()) vec<rtx, va_gc> *used_rtx_array;
162 /* A pointer to the base of a list of incomplete types which might be
163 completed at some later time. incomplete_types_list needs to be a
164 vec<tree, va_gc> *because we want to tell the garbage collector about
166 static GTY(()) vec<tree, va_gc> *incomplete_types;
168 /* A pointer to the base of a table of references to declaration
169 scopes. This table is a display which tracks the nesting
170 of declaration scopes at the current scope and containing
171 scopes. This table is used to find the proper place to
172 define type declaration DIE's. */
173 static GTY(()) vec<tree, va_gc> *decl_scope_table;
175 /* Pointers to various DWARF2 sections. */
176 static GTY(()) section *debug_info_section;
177 static GTY(()) section *debug_skeleton_info_section;
178 static GTY(()) section *debug_abbrev_section;
179 static GTY(()) section *debug_skeleton_abbrev_section;
180 static GTY(()) section *debug_aranges_section;
181 static GTY(()) section *debug_addr_section;
182 static GTY(()) section *debug_macinfo_section;
183 static GTY(()) section *debug_line_section;
184 static GTY(()) section *debug_skeleton_line_section;
185 static GTY(()) section *debug_loc_section;
186 static GTY(()) section *debug_pubnames_section;
187 static GTY(()) section *debug_pubtypes_section;
188 static GTY(()) section *debug_str_section;
189 static GTY(()) section *debug_str_dwo_section;
190 static GTY(()) section *debug_str_offsets_section;
191 static GTY(()) section *debug_ranges_section;
192 static GTY(()) section *debug_frame_section;
194 /* Maximum size (in bytes) of an artificially generated label. */
195 #define MAX_ARTIFICIAL_LABEL_BYTES 30
197 /* According to the (draft) DWARF 3 specification, the initial length
198 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
199 bytes are 0xffffffff, followed by the length stored in the next 8
202 However, the SGI/MIPS ABI uses an initial length which is equal to
203 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
205 #ifndef DWARF_INITIAL_LENGTH_SIZE
206 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
209 /* Round SIZE up to the nearest BOUNDARY. */
210 #define DWARF_ROUND(SIZE,BOUNDARY) \
211 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
213 /* CIE identifier. */
214 #if HOST_BITS_PER_WIDE_INT >= 64
215 #define DWARF_CIE_ID \
216 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
218 #define DWARF_CIE_ID DW_CIE_ID
222 /* A vector for a table that contains frame description
223 information for each routine. */
224 #define NOT_INDEXED (-1U)
225 #define NO_INDEX_ASSIGNED (-2U)
227 static GTY(()) vec<dw_fde_ref, va_gc> *fde_vec;
229 struct GTY((for_user)) indirect_string_node {
231 unsigned int refcount;
232 enum dwarf_form form;
237 struct indirect_string_hasher : ggc_hasher<indirect_string_node *>
239 typedef const char *compare_type;
241 static hashval_t hash (indirect_string_node *);
242 static bool equal (indirect_string_node *, const char *);
245 static GTY (()) hash_table<indirect_string_hasher> *debug_str_hash;
247 /* With split_debug_info, both the comp_dir and dwo_name go in the
248 main object file, rather than the dwo, similar to the force_direct
249 parameter elsewhere but with additional complications:
251 1) The string is needed in both the main object file and the dwo.
252 That is, the comp_dir and dwo_name will appear in both places.
254 2) Strings can use three forms: DW_FORM_string, DW_FORM_strp or
255 DW_FORM_GNU_str_index.
257 3) GCC chooses the form to use late, depending on the size and
260 Rather than forcing the all debug string handling functions and
261 callers to deal with these complications, simply use a separate,
262 special-cased string table for any attribute that should go in the
263 main object file. This limits the complexity to just the places
266 static GTY (()) hash_table<indirect_string_hasher> *skeleton_debug_str_hash;
268 static GTY(()) int dw2_string_counter;
270 /* True if the compilation unit places functions in more than one section. */
271 static GTY(()) bool have_multiple_function_sections = false;
273 /* Whether the default text and cold text sections have been used at all. */
275 static GTY(()) bool text_section_used = false;
276 static GTY(()) bool cold_text_section_used = false;
278 /* The default cold text section. */
279 static GTY(()) section *cold_text_section;
281 /* The DIE for C++14 'auto' in a function return type. */
282 static GTY(()) dw_die_ref auto_die;
284 /* The DIE for C++14 'decltype(auto)' in a function return type. */
285 static GTY(()) dw_die_ref decltype_auto_die;
287 /* Forward declarations for functions defined in this file. */
289 static char *stripattributes (const char *);
290 static void output_call_frame_info (int);
291 static void dwarf2out_note_section_used (void);
293 /* Personality decl of current unit. Used only when assembler does not support
295 static GTY(()) rtx current_unit_personality;
297 /* Data and reference forms for relocatable data. */
298 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
299 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
301 #ifndef DEBUG_FRAME_SECTION
302 #define DEBUG_FRAME_SECTION ".debug_frame"
305 #ifndef FUNC_BEGIN_LABEL
306 #define FUNC_BEGIN_LABEL "LFB"
309 #ifndef FUNC_END_LABEL
310 #define FUNC_END_LABEL "LFE"
313 #ifndef PROLOGUE_END_LABEL
314 #define PROLOGUE_END_LABEL "LPE"
317 #ifndef EPILOGUE_BEGIN_LABEL
318 #define EPILOGUE_BEGIN_LABEL "LEB"
321 #ifndef FRAME_BEGIN_LABEL
322 #define FRAME_BEGIN_LABEL "Lframe"
324 #define CIE_AFTER_SIZE_LABEL "LSCIE"
325 #define CIE_END_LABEL "LECIE"
326 #define FDE_LABEL "LSFDE"
327 #define FDE_AFTER_SIZE_LABEL "LASFDE"
328 #define FDE_END_LABEL "LEFDE"
329 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
330 #define LINE_NUMBER_END_LABEL "LELT"
331 #define LN_PROLOG_AS_LABEL "LASLTP"
332 #define LN_PROLOG_END_LABEL "LELTP"
333 #define DIE_LABEL_PREFIX "DW"
335 /* Match the base name of a file to the base name of a compilation unit. */
338 matches_main_base (const char *path)
340 /* Cache the last query. */
341 static const char *last_path = NULL;
342 static int last_match = 0;
343 if (path != last_path)
346 int length = base_of_path (path, &base);
348 last_match = (length == main_input_baselength
349 && memcmp (base, main_input_basename, length) == 0);
354 #ifdef DEBUG_DEBUG_STRUCT
357 dump_struct_debug (tree type, enum debug_info_usage usage,
358 enum debug_struct_file criterion, int generic,
359 int matches, int result)
361 /* Find the type name. */
362 tree type_decl = TYPE_STUB_DECL (type);
364 const char *name = 0;
365 if (TREE_CODE (t) == TYPE_DECL)
368 name = IDENTIFIER_POINTER (t);
370 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
372 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
373 matches ? "bas" : "hdr",
374 generic ? "gen" : "ord",
375 usage == DINFO_USAGE_DFN ? ";" :
376 usage == DINFO_USAGE_DIR_USE ? "." : "*",
378 (void*) type_decl, name);
381 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
382 dump_struct_debug (type, usage, criterion, generic, matches, result)
386 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
391 /* Get the number of HOST_WIDE_INTs needed to represent the precision
395 get_full_len (const wide_int &op)
397 return ((op.get_precision () + HOST_BITS_PER_WIDE_INT - 1)
398 / HOST_BITS_PER_WIDE_INT);
402 should_emit_struct_debug (tree type, enum debug_info_usage usage)
404 enum debug_struct_file criterion;
406 bool generic = lang_hooks.types.generic_p (type);
409 criterion = debug_struct_generic[usage];
411 criterion = debug_struct_ordinary[usage];
413 if (criterion == DINFO_STRUCT_FILE_NONE)
414 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
415 if (criterion == DINFO_STRUCT_FILE_ANY)
416 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
418 type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
420 if (type_decl != NULL)
422 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
423 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
425 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
426 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
429 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
432 /* Return a pointer to a copy of the section string name S with all
433 attributes stripped off, and an asterisk prepended (for assemble_name). */
436 stripattributes (const char *s)
438 char *stripped = XNEWVEC (char, strlen (s) + 2);
443 while (*s && *s != ',')
450 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
451 switch to the data section instead, and write out a synthetic start label
452 for collect2 the first time around. */
455 switch_to_eh_frame_section (bool back)
459 #ifdef EH_FRAME_SECTION_NAME
460 if (eh_frame_section == 0)
464 if (EH_TABLES_CAN_BE_READ_ONLY)
470 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
472 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
474 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
477 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
478 && (fde_encoding & 0x70) != DW_EH_PE_aligned
479 && (per_encoding & 0x70) != DW_EH_PE_absptr
480 && (per_encoding & 0x70) != DW_EH_PE_aligned
481 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
482 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
483 ? 0 : SECTION_WRITE);
486 flags = SECTION_WRITE;
487 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
489 #endif /* EH_FRAME_SECTION_NAME */
491 if (eh_frame_section)
492 switch_to_section (eh_frame_section);
495 /* We have no special eh_frame section. Put the information in
496 the data section and emit special labels to guide collect2. */
497 switch_to_section (data_section);
501 label = get_file_function_name ("F");
502 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
503 targetm.asm_out.globalize_label (asm_out_file,
504 IDENTIFIER_POINTER (label));
505 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
510 /* Switch [BACK] to the eh or debug frame table section, depending on
514 switch_to_frame_table_section (int for_eh, bool back)
517 switch_to_eh_frame_section (back);
520 if (!debug_frame_section)
521 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
522 SECTION_DEBUG, NULL);
523 switch_to_section (debug_frame_section);
527 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
529 enum dw_cfi_oprnd_type
530 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
535 case DW_CFA_GNU_window_save:
536 case DW_CFA_remember_state:
537 case DW_CFA_restore_state:
538 return dw_cfi_oprnd_unused;
541 case DW_CFA_advance_loc1:
542 case DW_CFA_advance_loc2:
543 case DW_CFA_advance_loc4:
544 case DW_CFA_MIPS_advance_loc8:
545 return dw_cfi_oprnd_addr;
548 case DW_CFA_offset_extended:
550 case DW_CFA_offset_extended_sf:
551 case DW_CFA_def_cfa_sf:
553 case DW_CFA_restore_extended:
554 case DW_CFA_undefined:
555 case DW_CFA_same_value:
556 case DW_CFA_def_cfa_register:
557 case DW_CFA_register:
558 case DW_CFA_expression:
559 return dw_cfi_oprnd_reg_num;
561 case DW_CFA_def_cfa_offset:
562 case DW_CFA_GNU_args_size:
563 case DW_CFA_def_cfa_offset_sf:
564 return dw_cfi_oprnd_offset;
566 case DW_CFA_def_cfa_expression:
567 return dw_cfi_oprnd_loc;
574 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
576 enum dw_cfi_oprnd_type
577 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
582 case DW_CFA_def_cfa_sf:
584 case DW_CFA_offset_extended_sf:
585 case DW_CFA_offset_extended:
586 return dw_cfi_oprnd_offset;
588 case DW_CFA_register:
589 return dw_cfi_oprnd_reg_num;
591 case DW_CFA_expression:
592 return dw_cfi_oprnd_loc;
595 return dw_cfi_oprnd_unused;
599 /* Output one FDE. */
602 output_fde (dw_fde_ref fde, bool for_eh, bool second,
603 char *section_start_label, int fde_encoding, char *augmentation,
604 bool any_lsda_needed, int lsda_encoding)
606 const char *begin, *end;
607 static unsigned int j;
610 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
612 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
614 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
615 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
616 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
617 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
618 " indicating 64-bit DWARF extension");
619 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
621 ASM_OUTPUT_LABEL (asm_out_file, l1);
624 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
626 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
627 debug_frame_section, "FDE CIE offset");
629 begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
630 end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
634 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
635 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
636 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
637 "FDE initial location");
638 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
639 end, begin, "FDE address range");
643 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
644 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
651 int size = size_of_encoded_value (lsda_encoding);
653 if (lsda_encoding == DW_EH_PE_aligned)
655 int offset = ( 4 /* Length */
657 + 2 * size_of_encoded_value (fde_encoding)
658 + 1 /* Augmentation size */ );
659 int pad = -offset & (PTR_SIZE - 1);
662 gcc_assert (size_of_uleb128 (size) == 1);
665 dw2_asm_output_data_uleb128 (size, "Augmentation size");
667 if (fde->uses_eh_lsda)
669 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
670 fde->funcdef_number);
671 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
672 gen_rtx_SYMBOL_REF (Pmode, l1),
674 "Language Specific Data Area");
678 if (lsda_encoding == DW_EH_PE_aligned)
679 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
680 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
681 "Language Specific Data Area (none)");
685 dw2_asm_output_data_uleb128 (0, "Augmentation size");
688 /* Loop through the Call Frame Instructions associated with this FDE. */
689 fde->dw_fde_current_label = begin;
691 size_t from, until, i;
694 until = vec_safe_length (fde->dw_fde_cfi);
696 if (fde->dw_fde_second_begin == NULL)
699 until = fde->dw_fde_switch_cfi_index;
701 from = fde->dw_fde_switch_cfi_index;
703 for (i = from; i < until; i++)
704 output_cfi ((*fde->dw_fde_cfi)[i], fde, for_eh);
707 /* If we are to emit a ref/link from function bodies to their frame tables,
708 do it now. This is typically performed to make sure that tables
709 associated with functions are dragged with them and not discarded in
710 garbage collecting links. We need to do this on a per function basis to
711 cope with -ffunction-sections. */
713 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
714 /* Switch to the function section, emit the ref to the tables, and
715 switch *back* into the table section. */
716 switch_to_section (function_section (fde->decl));
717 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
718 switch_to_frame_table_section (for_eh, true);
721 /* Pad the FDE out to an address sized boundary. */
722 ASM_OUTPUT_ALIGN (asm_out_file,
723 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
724 ASM_OUTPUT_LABEL (asm_out_file, l2);
729 /* Return true if frame description entry FDE is needed for EH. */
732 fde_needed_for_eh_p (dw_fde_ref fde)
734 if (flag_asynchronous_unwind_tables)
737 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
740 if (fde->uses_eh_lsda)
743 /* If exceptions are enabled, we have collected nothrow info. */
744 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
750 /* Output the call frame information used to record information
751 that relates to calculating the frame pointer, and records the
752 location of saved registers. */
755 output_call_frame_info (int for_eh)
760 char l1[20], l2[20], section_start_label[20];
761 bool any_lsda_needed = false;
762 char augmentation[6];
763 int augmentation_size;
764 int fde_encoding = DW_EH_PE_absptr;
765 int per_encoding = DW_EH_PE_absptr;
766 int lsda_encoding = DW_EH_PE_absptr;
768 rtx personality = NULL;
771 /* Don't emit a CIE if there won't be any FDEs. */
775 /* Nothing to do if the assembler's doing it all. */
776 if (dwarf2out_do_cfi_asm ())
779 /* If we don't have any functions we'll want to unwind out of, don't emit
780 any EH unwind information. If we make FDEs linkonce, we may have to
781 emit an empty label for an FDE that wouldn't otherwise be emitted. We
782 want to avoid having an FDE kept around when the function it refers to
783 is discarded. Example where this matters: a primary function template
784 in C++ requires EH information, an explicit specialization doesn't. */
787 bool any_eh_needed = false;
789 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
791 if (fde->uses_eh_lsda)
792 any_eh_needed = any_lsda_needed = true;
793 else if (fde_needed_for_eh_p (fde))
794 any_eh_needed = true;
795 else if (TARGET_USES_WEAK_UNWIND_INFO)
796 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
803 /* We're going to be generating comments, so turn on app. */
807 /* Switch to the proper frame section, first time. */
808 switch_to_frame_table_section (for_eh, false);
810 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
811 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
813 /* Output the CIE. */
814 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
815 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
816 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
817 dw2_asm_output_data (4, 0xffffffff,
818 "Initial length escape value indicating 64-bit DWARF extension");
819 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
820 "Length of Common Information Entry");
821 ASM_OUTPUT_LABEL (asm_out_file, l1);
823 /* Now that the CIE pointer is PC-relative for EH,
824 use 0 to identify the CIE. */
825 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
826 (for_eh ? 0 : DWARF_CIE_ID),
827 "CIE Identifier Tag");
829 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
830 use CIE version 1, unless that would produce incorrect results
831 due to overflowing the return register column. */
832 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
834 if (return_reg >= 256 || dwarf_version > 2)
836 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
839 augmentation_size = 0;
841 personality = current_unit_personality;
847 z Indicates that a uleb128 is present to size the
848 augmentation section.
849 L Indicates the encoding (and thus presence) of
850 an LSDA pointer in the FDE augmentation.
851 R Indicates a non-default pointer encoding for
853 P Indicates the presence of an encoding + language
854 personality routine in the CIE augmentation. */
856 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
857 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
858 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
860 p = augmentation + 1;
864 augmentation_size += 1 + size_of_encoded_value (per_encoding);
865 assemble_external_libcall (personality);
870 augmentation_size += 1;
872 if (fde_encoding != DW_EH_PE_absptr)
875 augmentation_size += 1;
877 if (p > augmentation + 1)
879 augmentation[0] = 'z';
883 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
884 if (personality && per_encoding == DW_EH_PE_aligned)
886 int offset = ( 4 /* Length */
888 + 1 /* CIE version */
889 + strlen (augmentation) + 1 /* Augmentation */
890 + size_of_uleb128 (1) /* Code alignment */
891 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
893 + 1 /* Augmentation size */
894 + 1 /* Personality encoding */ );
895 int pad = -offset & (PTR_SIZE - 1);
897 augmentation_size += pad;
899 /* Augmentations should be small, so there's scarce need to
900 iterate for a solution. Die if we exceed one uleb128 byte. */
901 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
905 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
906 if (dw_cie_version >= 4)
908 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
909 dw2_asm_output_data (1, 0, "CIE Segment Size");
911 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
912 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
913 "CIE Data Alignment Factor");
915 if (dw_cie_version == 1)
916 dw2_asm_output_data (1, return_reg, "CIE RA Column");
918 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
922 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
925 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
926 eh_data_format_name (per_encoding));
927 dw2_asm_output_encoded_addr_rtx (per_encoding,
933 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
934 eh_data_format_name (lsda_encoding));
936 if (fde_encoding != DW_EH_PE_absptr)
937 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
938 eh_data_format_name (fde_encoding));
941 FOR_EACH_VEC_ELT (*cie_cfi_vec, i, cfi)
942 output_cfi (cfi, NULL, for_eh);
944 /* Pad the CIE out to an address sized boundary. */
945 ASM_OUTPUT_ALIGN (asm_out_file,
946 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
947 ASM_OUTPUT_LABEL (asm_out_file, l2);
949 /* Loop through all of the FDE's. */
950 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
954 /* Don't emit EH unwind info for leaf functions that don't need it. */
955 if (for_eh && !fde_needed_for_eh_p (fde))
958 for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
959 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
960 augmentation, any_lsda_needed, lsda_encoding);
963 if (for_eh && targetm.terminate_dw2_eh_frame_info)
964 dw2_asm_output_data (4, 0, "End of Table");
966 /* Turn off app to make assembly quicker. */
971 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
974 dwarf2out_do_cfi_startproc (bool second)
978 rtx personality = get_personality_function (current_function_decl);
980 fprintf (asm_out_file, "\t.cfi_startproc\n");
984 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
987 /* ??? The GAS support isn't entirely consistent. We have to
988 handle indirect support ourselves, but PC-relative is done
989 in the assembler. Further, the assembler can't handle any
990 of the weirder relocation types. */
991 if (enc & DW_EH_PE_indirect)
992 ref = dw2_force_const_mem (ref, true);
994 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
995 output_addr_const (asm_out_file, ref);
996 fputc ('\n', asm_out_file);
999 if (crtl->uses_eh_lsda)
1003 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1004 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
1005 current_function_funcdef_no);
1006 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
1007 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
1009 if (enc & DW_EH_PE_indirect)
1010 ref = dw2_force_const_mem (ref, true);
1012 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
1013 output_addr_const (asm_out_file, ref);
1014 fputc ('\n', asm_out_file);
1018 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1019 this allocation may be done before pass_final. */
1022 dwarf2out_alloc_current_fde (void)
1026 fde = ggc_cleared_alloc<dw_fde_node> ();
1027 fde->decl = current_function_decl;
1028 fde->funcdef_number = current_function_funcdef_no;
1029 fde->fde_index = vec_safe_length (fde_vec);
1030 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
1031 fde->uses_eh_lsda = crtl->uses_eh_lsda;
1032 fde->nothrow = crtl->nothrow;
1033 fde->drap_reg = INVALID_REGNUM;
1034 fde->vdrap_reg = INVALID_REGNUM;
1036 /* Record the FDE associated with this function. */
1038 vec_safe_push (fde_vec, fde);
1043 /* Output a marker (i.e. a label) for the beginning of a function, before
1047 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
1048 const char *file ATTRIBUTE_UNUSED)
1050 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1056 current_function_func_begin_label = NULL;
1058 do_frame = dwarf2out_do_frame ();
1060 /* ??? current_function_func_begin_label is also used by except.c for
1061 call-site information. We must emit this label if it might be used. */
1063 && (!flag_exceptions
1064 || targetm_common.except_unwind_info (&global_options) == UI_SJLJ))
1067 fnsec = function_section (current_function_decl);
1068 switch_to_section (fnsec);
1069 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1070 current_function_funcdef_no);
1071 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
1072 current_function_funcdef_no);
1073 dup_label = xstrdup (label);
1074 current_function_func_begin_label = dup_label;
1076 /* We can elide the fde allocation if we're not emitting debug info. */
1080 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1081 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1082 would include pass_dwarf2_frame. If we've not created the FDE yet,
1086 fde = dwarf2out_alloc_current_fde ();
1088 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1089 fde->dw_fde_begin = dup_label;
1090 fde->dw_fde_current_label = dup_label;
1091 fde->in_std_section = (fnsec == text_section
1092 || (cold_text_section && fnsec == cold_text_section));
1094 /* We only want to output line number information for the genuine dwarf2
1095 prologue case, not the eh frame case. */
1096 #ifdef DWARF2_DEBUGGING_INFO
1098 dwarf2out_source_line (line, file, 0, true);
1101 if (dwarf2out_do_cfi_asm ())
1102 dwarf2out_do_cfi_startproc (false);
1105 rtx personality = get_personality_function (current_function_decl);
1106 if (!current_unit_personality)
1107 current_unit_personality = personality;
1109 /* We cannot keep a current personality per function as without CFI
1110 asm, at the point where we emit the CFI data, there is no current
1111 function anymore. */
1112 if (personality && current_unit_personality != personality)
1113 sorry ("multiple EH personalities are supported only with assemblers "
1114 "supporting .cfi_personality directive");
1118 /* Output a marker (i.e. a label) for the end of the generated code
1119 for a function prologue. This gets called *after* the prologue code has
1123 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
1124 const char *file ATTRIBUTE_UNUSED)
1126 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1128 /* Output a label to mark the endpoint of the code generated for this
1130 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1131 current_function_funcdef_no);
1132 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
1133 current_function_funcdef_no);
1134 cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1137 /* Output a marker (i.e. a label) for the beginning of the generated code
1138 for a function epilogue. This gets called *before* the prologue code has
1142 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1143 const char *file ATTRIBUTE_UNUSED)
1145 dw_fde_ref fde = cfun->fde;
1146 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1148 if (fde->dw_fde_vms_begin_epilogue)
1151 /* Output a label to mark the endpoint of the code generated for this
1153 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1154 current_function_funcdef_no);
1155 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
1156 current_function_funcdef_no);
1157 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1160 /* Output a marker (i.e. a label) for the absolute end of the generated code
1161 for a function definition. This gets called *after* the epilogue code has
1165 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1166 const char *file ATTRIBUTE_UNUSED)
1169 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1171 last_var_location_insn = NULL;
1172 cached_next_real_insn = NULL;
1174 if (dwarf2out_do_cfi_asm ())
1175 fprintf (asm_out_file, "\t.cfi_endproc\n");
1177 /* Output a label to mark the endpoint of the code generated for this
1179 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1180 current_function_funcdef_no);
1181 ASM_OUTPUT_LABEL (asm_out_file, label);
1183 gcc_assert (fde != NULL);
1184 if (fde->dw_fde_second_begin == NULL)
1185 fde->dw_fde_end = xstrdup (label);
1189 dwarf2out_frame_finish (void)
1191 /* Output call frame information. */
1192 if (targetm.debug_unwind_info () == UI_DWARF2)
1193 output_call_frame_info (0);
1195 /* Output another copy for the unwinder. */
1196 if ((flag_unwind_tables || flag_exceptions)
1197 && targetm_common.except_unwind_info (&global_options) == UI_DWARF2)
1198 output_call_frame_info (1);
1201 /* Note that the current function section is being used for code. */
1204 dwarf2out_note_section_used (void)
1206 section *sec = current_function_section ();
1207 if (sec == text_section)
1208 text_section_used = true;
1209 else if (sec == cold_text_section)
1210 cold_text_section_used = true;
1213 static void var_location_switch_text_section (void);
1214 static void set_cur_line_info_table (section *);
1217 dwarf2out_switch_text_section (void)
1220 dw_fde_ref fde = cfun->fde;
1222 gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
1224 if (!in_cold_section_p)
1226 fde->dw_fde_end = crtl->subsections.cold_section_end_label;
1227 fde->dw_fde_second_begin = crtl->subsections.hot_section_label;
1228 fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
1232 fde->dw_fde_end = crtl->subsections.hot_section_end_label;
1233 fde->dw_fde_second_begin = crtl->subsections.cold_section_label;
1234 fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
1236 have_multiple_function_sections = true;
1238 /* There is no need to mark used sections when not debugging. */
1239 if (cold_text_section != NULL)
1240 dwarf2out_note_section_used ();
1242 if (dwarf2out_do_cfi_asm ())
1243 fprintf (asm_out_file, "\t.cfi_endproc\n");
1245 /* Now do the real section switch. */
1246 sect = current_function_section ();
1247 switch_to_section (sect);
1249 fde->second_in_std_section
1250 = (sect == text_section
1251 || (cold_text_section && sect == cold_text_section));
1253 if (dwarf2out_do_cfi_asm ())
1254 dwarf2out_do_cfi_startproc (true);
1256 var_location_switch_text_section ();
1258 if (cold_text_section != NULL)
1259 set_cur_line_info_table (sect);
1262 /* And now, the subset of the debugging information support code necessary
1263 for emitting location expressions. */
1265 /* Data about a single source file. */
1266 struct GTY((for_user)) dwarf_file_data {
1267 const char * filename;
1271 typedef struct GTY(()) deferred_locations_struct
1275 } deferred_locations;
1278 static GTY(()) vec<deferred_locations, va_gc> *deferred_locations_list;
1281 /* Describe an entry into the .debug_addr section. */
1285 ate_kind_rtx_dtprel,
1289 typedef struct GTY((for_user)) addr_table_entry_struct {
1291 unsigned int refcount;
1293 union addr_table_entry_struct_union
1295 rtx GTY ((tag ("0"))) rtl;
1296 char * GTY ((tag ("1"))) label;
1298 GTY ((desc ("%1.kind"))) addr;
1302 /* Location lists are ranges + location descriptions for that range,
1303 so you can track variables that are in different places over
1304 their entire life. */
1305 typedef struct GTY(()) dw_loc_list_struct {
1306 dw_loc_list_ref dw_loc_next;
1307 const char *begin; /* Label and addr_entry for start of range */
1308 addr_table_entry *begin_entry;
1309 const char *end; /* Label for end of range */
1310 char *ll_symbol; /* Label for beginning of location list.
1311 Only on head of list */
1312 const char *section; /* Section this loclist is relative to */
1313 dw_loc_descr_ref expr;
1315 /* True if all addresses in this and subsequent lists are known to be
1318 /* True if this list has been replaced by dw_loc_next. */
1321 /* True if the range should be emitted even if begin and end
1326 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
1328 /* Convert a DWARF stack opcode into its string name. */
1331 dwarf_stack_op_name (unsigned int op)
1333 const char *name = get_DW_OP_name (op);
1338 return "OP_<unknown>";
1341 /* Return a pointer to a newly allocated location description. Location
1342 descriptions are simple expression terms that can be strung
1343 together to form more complicated location (address) descriptions. */
1345 static inline dw_loc_descr_ref
1346 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
1347 unsigned HOST_WIDE_INT oprnd2)
1349 dw_loc_descr_ref descr = ggc_cleared_alloc<dw_loc_descr_node> ();
1351 descr->dw_loc_opc = op;
1352 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
1353 descr->dw_loc_oprnd1.val_entry = NULL;
1354 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
1355 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
1356 descr->dw_loc_oprnd2.val_entry = NULL;
1357 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
1362 /* Return a pointer to a newly allocated location description for
1365 static inline dw_loc_descr_ref
1366 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
1369 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
1372 return new_loc_descr (DW_OP_bregx, reg, offset);
1375 /* Add a location description term to a location description expression. */
1378 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
1380 dw_loc_descr_ref *d;
1382 /* Find the end of the chain. */
1383 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
1389 /* Compare two location operands for exact equality. */
1392 dw_val_equal_p (dw_val_node *a, dw_val_node *b)
1394 if (a->val_class != b->val_class)
1396 switch (a->val_class)
1398 case dw_val_class_none:
1400 case dw_val_class_addr:
1401 return rtx_equal_p (a->v.val_addr, b->v.val_addr);
1403 case dw_val_class_offset:
1404 case dw_val_class_unsigned_const:
1405 case dw_val_class_const:
1406 case dw_val_class_range_list:
1407 case dw_val_class_lineptr:
1408 case dw_val_class_macptr:
1409 /* These are all HOST_WIDE_INT, signed or unsigned. */
1410 return a->v.val_unsigned == b->v.val_unsigned;
1412 case dw_val_class_loc:
1413 return a->v.val_loc == b->v.val_loc;
1414 case dw_val_class_loc_list:
1415 return a->v.val_loc_list == b->v.val_loc_list;
1416 case dw_val_class_die_ref:
1417 return a->v.val_die_ref.die == b->v.val_die_ref.die;
1418 case dw_val_class_fde_ref:
1419 return a->v.val_fde_index == b->v.val_fde_index;
1420 case dw_val_class_lbl_id:
1421 case dw_val_class_high_pc:
1422 return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0;
1423 case dw_val_class_str:
1424 return a->v.val_str == b->v.val_str;
1425 case dw_val_class_flag:
1426 return a->v.val_flag == b->v.val_flag;
1427 case dw_val_class_file:
1428 return a->v.val_file == b->v.val_file;
1429 case dw_val_class_decl_ref:
1430 return a->v.val_decl_ref == b->v.val_decl_ref;
1432 case dw_val_class_const_double:
1433 return (a->v.val_double.high == b->v.val_double.high
1434 && a->v.val_double.low == b->v.val_double.low);
1436 case dw_val_class_wide_int:
1437 return *a->v.val_wide == *b->v.val_wide;
1439 case dw_val_class_vec:
1441 size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length;
1442 size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length;
1444 return (a_len == b_len
1445 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len));
1448 case dw_val_class_data8:
1449 return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0;
1451 case dw_val_class_vms_delta:
1452 return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)
1453 && !strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1));
1458 /* Compare two location atoms for exact equality. */
1461 loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b)
1463 if (a->dw_loc_opc != b->dw_loc_opc)
1466 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1467 address size, but since we always allocate cleared storage it
1468 should be zero for other types of locations. */
1469 if (a->dtprel != b->dtprel)
1472 return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1)
1473 && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2));
1476 /* Compare two complete location expressions for exact equality. */
1479 loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b)
1485 if (a == NULL || b == NULL)
1487 if (!loc_descr_equal_p_1 (a, b))
1496 /* Add a constant OFFSET to a location expression. */
1499 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
1501 dw_loc_descr_ref loc;
1504 gcc_assert (*list_head != NULL);
1509 /* Find the end of the chain. */
1510 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
1514 if (loc->dw_loc_opc == DW_OP_fbreg
1515 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
1516 p = &loc->dw_loc_oprnd1.v.val_int;
1517 else if (loc->dw_loc_opc == DW_OP_bregx)
1518 p = &loc->dw_loc_oprnd2.v.val_int;
1520 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1521 offset. Don't optimize if an signed integer overflow would happen. */
1523 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1524 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1527 else if (offset > 0)
1528 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1532 loc->dw_loc_next = int_loc_descriptor (-offset);
1533 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
1537 /* Add a constant OFFSET to a location list. */
1540 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
1543 for (d = list_head; d != NULL; d = d->dw_loc_next)
1544 loc_descr_plus_const (&d->expr, offset);
1547 #define DWARF_REF_SIZE \
1548 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1550 static unsigned long int get_base_type_offset (dw_die_ref);
1552 /* Return the size of a location descriptor. */
1554 static unsigned long
1555 size_of_loc_descr (dw_loc_descr_ref loc)
1557 unsigned long size = 1;
1559 switch (loc->dw_loc_opc)
1562 size += DWARF2_ADDR_SIZE;
1564 case DW_OP_GNU_addr_index:
1565 case DW_OP_GNU_const_index:
1566 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
1567 size += size_of_uleb128 (loc->dw_loc_oprnd1.val_entry->index);
1586 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1589 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1594 case DW_OP_plus_uconst:
1595 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1633 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1636 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1639 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1642 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1643 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1646 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1648 case DW_OP_bit_piece:
1649 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1650 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
1652 case DW_OP_deref_size:
1653 case DW_OP_xderef_size:
1662 case DW_OP_call_ref:
1663 size += DWARF_REF_SIZE;
1665 case DW_OP_implicit_value:
1666 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1667 + loc->dw_loc_oprnd1.v.val_unsigned;
1669 case DW_OP_GNU_implicit_pointer:
1670 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1672 case DW_OP_GNU_entry_value:
1674 unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
1675 size += size_of_uleb128 (op_size) + op_size;
1678 case DW_OP_GNU_const_type:
1681 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1682 size += size_of_uleb128 (o) + 1;
1683 switch (loc->dw_loc_oprnd2.val_class)
1685 case dw_val_class_vec:
1686 size += loc->dw_loc_oprnd2.v.val_vec.length
1687 * loc->dw_loc_oprnd2.v.val_vec.elt_size;
1689 case dw_val_class_const:
1690 size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1692 case dw_val_class_const_double:
1693 size += HOST_BITS_PER_DOUBLE_INT / BITS_PER_UNIT;
1695 case dw_val_class_wide_int:
1696 size += (get_full_len (*loc->dw_loc_oprnd2.v.val_wide)
1697 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
1704 case DW_OP_GNU_regval_type:
1707 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1708 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1709 + size_of_uleb128 (o);
1712 case DW_OP_GNU_deref_type:
1715 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1716 size += 1 + size_of_uleb128 (o);
1719 case DW_OP_GNU_convert:
1720 case DW_OP_GNU_reinterpret:
1721 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
1722 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1726 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1727 size += size_of_uleb128 (o);
1730 case DW_OP_GNU_parameter_ref:
1740 /* Return the size of a series of location descriptors. */
1743 size_of_locs (dw_loc_descr_ref loc)
1748 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1749 field, to avoid writing to a PCH file. */
1750 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1752 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
1754 size += size_of_loc_descr (l);
1759 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1761 l->dw_loc_addr = size;
1762 size += size_of_loc_descr (l);
1768 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
1769 static void get_ref_die_offset_label (char *, dw_die_ref);
1770 static unsigned long int get_ref_die_offset (dw_die_ref);
1772 /* Output location description stack opcode's operands (if any).
1773 The for_eh_or_skip parameter controls whether register numbers are
1774 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1775 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1776 info). This should be suppressed for the cases that have not been converted
1777 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1780 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
1782 dw_val_ref val1 = &loc->dw_loc_oprnd1;
1783 dw_val_ref val2 = &loc->dw_loc_oprnd2;
1785 switch (loc->dw_loc_opc)
1787 #ifdef DWARF2_DEBUGGING_INFO
1790 dw2_asm_output_data (2, val1->v.val_int, NULL);
1795 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1796 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
1798 fputc ('\n', asm_out_file);
1803 dw2_asm_output_data (4, val1->v.val_int, NULL);
1808 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1809 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
1811 fputc ('\n', asm_out_file);
1816 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
1817 dw2_asm_output_data (8, val1->v.val_int, NULL);
1824 gcc_assert (val1->val_class == dw_val_class_loc);
1825 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
1827 dw2_asm_output_data (2, offset, NULL);
1830 case DW_OP_implicit_value:
1831 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1832 switch (val2->val_class)
1834 case dw_val_class_const:
1835 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
1837 case dw_val_class_vec:
1839 unsigned int elt_size = val2->v.val_vec.elt_size;
1840 unsigned int len = val2->v.val_vec.length;
1844 if (elt_size > sizeof (HOST_WIDE_INT))
1849 for (i = 0, p = val2->v.val_vec.array;
1852 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
1853 "fp or vector constant word %u", i);
1856 case dw_val_class_const_double:
1858 unsigned HOST_WIDE_INT first, second;
1860 if (WORDS_BIG_ENDIAN)
1862 first = val2->v.val_double.high;
1863 second = val2->v.val_double.low;
1867 first = val2->v.val_double.low;
1868 second = val2->v.val_double.high;
1870 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1872 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1876 case dw_val_class_wide_int:
1879 int len = get_full_len (*val2->v.val_wide);
1880 if (WORDS_BIG_ENDIAN)
1881 for (i = len - 1; i >= 0; --i)
1882 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1883 val2->v.val_wide->elt (i), NULL);
1885 for (i = 0; i < len; ++i)
1886 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1887 val2->v.val_wide->elt (i), NULL);
1890 case dw_val_class_addr:
1891 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
1892 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
1907 case DW_OP_implicit_value:
1908 /* We currently don't make any attempt to make sure these are
1909 aligned properly like we do for the main unwind info, so
1910 don't support emitting things larger than a byte if we're
1911 only doing unwinding. */
1916 dw2_asm_output_data (1, val1->v.val_int, NULL);
1919 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1922 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1925 dw2_asm_output_data (1, val1->v.val_int, NULL);
1927 case DW_OP_plus_uconst:
1928 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1962 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1966 unsigned r = val1->v.val_unsigned;
1967 if (for_eh_or_skip >= 0)
1968 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
1969 gcc_assert (size_of_uleb128 (r)
1970 == size_of_uleb128 (val1->v.val_unsigned));
1971 dw2_asm_output_data_uleb128 (r, NULL);
1975 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1979 unsigned r = val1->v.val_unsigned;
1980 if (for_eh_or_skip >= 0)
1981 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
1982 gcc_assert (size_of_uleb128 (r)
1983 == size_of_uleb128 (val1->v.val_unsigned));
1984 dw2_asm_output_data_uleb128 (r, NULL);
1985 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
1989 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1991 case DW_OP_bit_piece:
1992 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1993 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
1995 case DW_OP_deref_size:
1996 case DW_OP_xderef_size:
1997 dw2_asm_output_data (1, val1->v.val_int, NULL);
2003 if (targetm.asm_out.output_dwarf_dtprel)
2005 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
2008 fputc ('\n', asm_out_file);
2015 #ifdef DWARF2_DEBUGGING_INFO
2016 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2023 case DW_OP_GNU_addr_index:
2024 case DW_OP_GNU_const_index:
2025 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
2026 dw2_asm_output_data_uleb128 (loc->dw_loc_oprnd1.val_entry->index,
2027 "(index into .debug_addr)");
2030 case DW_OP_GNU_implicit_pointer:
2032 char label[MAX_ARTIFICIAL_LABEL_BYTES
2033 + HOST_BITS_PER_WIDE_INT / 2 + 2];
2034 gcc_assert (val1->val_class == dw_val_class_die_ref);
2035 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2036 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2037 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2041 case DW_OP_GNU_entry_value:
2042 dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
2043 output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
2046 case DW_OP_GNU_const_type:
2048 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
2050 dw2_asm_output_data_uleb128 (o, NULL);
2051 switch (val2->val_class)
2053 case dw_val_class_const:
2054 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2055 dw2_asm_output_data (1, l, NULL);
2056 dw2_asm_output_data (l, val2->v.val_int, NULL);
2058 case dw_val_class_vec:
2060 unsigned int elt_size = val2->v.val_vec.elt_size;
2061 unsigned int len = val2->v.val_vec.length;
2066 dw2_asm_output_data (1, l, NULL);
2067 if (elt_size > sizeof (HOST_WIDE_INT))
2072 for (i = 0, p = val2->v.val_vec.array;
2075 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2076 "fp or vector constant word %u", i);
2079 case dw_val_class_const_double:
2081 unsigned HOST_WIDE_INT first, second;
2082 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2084 dw2_asm_output_data (1, 2 * l, NULL);
2085 if (WORDS_BIG_ENDIAN)
2087 first = val2->v.val_double.high;
2088 second = val2->v.val_double.low;
2092 first = val2->v.val_double.low;
2093 second = val2->v.val_double.high;
2095 dw2_asm_output_data (l, first, NULL);
2096 dw2_asm_output_data (l, second, NULL);
2099 case dw_val_class_wide_int:
2102 int len = get_full_len (*val2->v.val_wide);
2103 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2105 dw2_asm_output_data (1, len * l, NULL);
2106 if (WORDS_BIG_ENDIAN)
2107 for (i = len - 1; i >= 0; --i)
2108 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2110 for (i = 0; i < len; ++i)
2111 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2119 case DW_OP_GNU_regval_type:
2121 unsigned r = val1->v.val_unsigned;
2122 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2124 if (for_eh_or_skip >= 0)
2126 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2127 gcc_assert (size_of_uleb128 (r)
2128 == size_of_uleb128 (val1->v.val_unsigned));
2130 dw2_asm_output_data_uleb128 (r, NULL);
2131 dw2_asm_output_data_uleb128 (o, NULL);
2134 case DW_OP_GNU_deref_type:
2136 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2138 dw2_asm_output_data (1, val1->v.val_int, NULL);
2139 dw2_asm_output_data_uleb128 (o, NULL);
2142 case DW_OP_GNU_convert:
2143 case DW_OP_GNU_reinterpret:
2144 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
2145 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2148 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
2150 dw2_asm_output_data_uleb128 (o, NULL);
2154 case DW_OP_GNU_parameter_ref:
2157 gcc_assert (val1->val_class == dw_val_class_die_ref);
2158 o = get_ref_die_offset (val1->v.val_die_ref.die);
2159 dw2_asm_output_data (4, o, NULL);
2164 /* Other codes have no operands. */
2169 /* Output a sequence of location operations.
2170 The for_eh_or_skip parameter controls whether register numbers are
2171 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2172 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2173 info). This should be suppressed for the cases that have not been converted
2174 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2177 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
2179 for (; loc != NULL; loc = loc->dw_loc_next)
2181 enum dwarf_location_atom opc = loc->dw_loc_opc;
2182 /* Output the opcode. */
2183 if (for_eh_or_skip >= 0
2184 && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2186 unsigned r = (opc - DW_OP_breg0);
2187 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2188 gcc_assert (r <= 31);
2189 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2191 else if (for_eh_or_skip >= 0
2192 && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2194 unsigned r = (opc - DW_OP_reg0);
2195 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2196 gcc_assert (r <= 31);
2197 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2200 dw2_asm_output_data (1, opc,
2201 "%s", dwarf_stack_op_name (opc));
2203 /* Output the operand(s) (if any). */
2204 output_loc_operands (loc, for_eh_or_skip);
2208 /* Output location description stack opcode's operands (if any).
2209 The output is single bytes on a line, suitable for .cfi_escape. */
2212 output_loc_operands_raw (dw_loc_descr_ref loc)
2214 dw_val_ref val1 = &loc->dw_loc_oprnd1;
2215 dw_val_ref val2 = &loc->dw_loc_oprnd2;
2217 switch (loc->dw_loc_opc)
2220 case DW_OP_GNU_addr_index:
2221 case DW_OP_GNU_const_index:
2222 case DW_OP_implicit_value:
2223 /* We cannot output addresses in .cfi_escape, only bytes. */
2229 case DW_OP_deref_size:
2230 case DW_OP_xderef_size:
2231 fputc (',', asm_out_file);
2232 dw2_asm_output_data_raw (1, val1->v.val_int);
2237 fputc (',', asm_out_file);
2238 dw2_asm_output_data_raw (2, val1->v.val_int);
2243 fputc (',', asm_out_file);
2244 dw2_asm_output_data_raw (4, val1->v.val_int);
2249 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2250 fputc (',', asm_out_file);
2251 dw2_asm_output_data_raw (8, val1->v.val_int);
2259 gcc_assert (val1->val_class == dw_val_class_loc);
2260 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2262 fputc (',', asm_out_file);
2263 dw2_asm_output_data_raw (2, offset);
2269 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2270 gcc_assert (size_of_uleb128 (r)
2271 == size_of_uleb128 (val1->v.val_unsigned));
2272 fputc (',', asm_out_file);
2273 dw2_asm_output_data_uleb128_raw (r);
2278 case DW_OP_plus_uconst:
2280 fputc (',', asm_out_file);
2281 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2284 case DW_OP_bit_piece:
2285 fputc (',', asm_out_file);
2286 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2287 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
2324 fputc (',', asm_out_file);
2325 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
2330 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2331 gcc_assert (size_of_uleb128 (r)
2332 == size_of_uleb128 (val1->v.val_unsigned));
2333 fputc (',', asm_out_file);
2334 dw2_asm_output_data_uleb128_raw (r);
2335 fputc (',', asm_out_file);
2336 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
2340 case DW_OP_GNU_implicit_pointer:
2341 case DW_OP_GNU_entry_value:
2342 case DW_OP_GNU_const_type:
2343 case DW_OP_GNU_regval_type:
2344 case DW_OP_GNU_deref_type:
2345 case DW_OP_GNU_convert:
2346 case DW_OP_GNU_reinterpret:
2347 case DW_OP_GNU_parameter_ref:
2352 /* Other codes have no operands. */
2358 output_loc_sequence_raw (dw_loc_descr_ref loc)
2362 enum dwarf_location_atom opc = loc->dw_loc_opc;
2363 /* Output the opcode. */
2364 if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2366 unsigned r = (opc - DW_OP_breg0);
2367 r = DWARF2_FRAME_REG_OUT (r, 1);
2368 gcc_assert (r <= 31);
2369 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2371 else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2373 unsigned r = (opc - DW_OP_reg0);
2374 r = DWARF2_FRAME_REG_OUT (r, 1);
2375 gcc_assert (r <= 31);
2376 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2378 /* Output the opcode. */
2379 fprintf (asm_out_file, "%#x", opc);
2380 output_loc_operands_raw (loc);
2382 if (!loc->dw_loc_next)
2384 loc = loc->dw_loc_next;
2386 fputc (',', asm_out_file);
2390 /* This function builds a dwarf location descriptor sequence from a
2391 dw_cfa_location, adding the given OFFSET to the result of the
2394 struct dw_loc_descr_node *
2395 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
2397 struct dw_loc_descr_node *head, *tmp;
2399 offset += cfa->offset;
2403 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
2404 head->dw_loc_oprnd1.val_class = dw_val_class_const;
2405 head->dw_loc_oprnd1.val_entry = NULL;
2406 tmp = new_loc_descr (DW_OP_deref, 0, 0);
2407 add_loc_descr (&head, tmp);
2410 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
2411 add_loc_descr (&head, tmp);
2415 head = new_reg_loc_descr (cfa->reg, offset);
2420 /* This function builds a dwarf location descriptor sequence for
2421 the address at OFFSET from the CFA when stack is aligned to
2424 struct dw_loc_descr_node *
2425 build_cfa_aligned_loc (dw_cfa_location *cfa,
2426 HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
2428 struct dw_loc_descr_node *head;
2429 unsigned int dwarf_fp
2430 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
2432 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2433 if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
2435 head = new_reg_loc_descr (dwarf_fp, 0);
2436 add_loc_descr (&head, int_loc_descriptor (alignment));
2437 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
2438 loc_descr_plus_const (&head, offset);
2441 head = new_reg_loc_descr (dwarf_fp, offset);
2445 /* And now, the support for symbolic debugging information. */
2447 /* .debug_str support. */
2449 static void dwarf2out_init (const char *);
2450 static void dwarf2out_finish (const char *);
2451 static void dwarf2out_assembly_start (void);
2452 static void dwarf2out_define (unsigned int, const char *);
2453 static void dwarf2out_undef (unsigned int, const char *);
2454 static void dwarf2out_start_source_file (unsigned, const char *);
2455 static void dwarf2out_end_source_file (unsigned);
2456 static void dwarf2out_function_decl (tree);
2457 static void dwarf2out_begin_block (unsigned, unsigned);
2458 static void dwarf2out_end_block (unsigned, unsigned);
2459 static bool dwarf2out_ignore_block (const_tree);
2460 static void dwarf2out_global_decl (tree);
2461 static void dwarf2out_type_decl (tree, int);
2462 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
2463 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
2465 static void dwarf2out_abstract_function (tree);
2466 static void dwarf2out_var_location (rtx_insn *);
2467 static void dwarf2out_begin_function (tree);
2468 static void dwarf2out_end_function (unsigned int);
2469 static void dwarf2out_set_name (tree, tree);
2471 /* The debug hooks structure. */
2473 const struct gcc_debug_hooks dwarf2_debug_hooks =
2477 dwarf2out_assembly_start,
2480 dwarf2out_start_source_file,
2481 dwarf2out_end_source_file,
2482 dwarf2out_begin_block,
2483 dwarf2out_end_block,
2484 dwarf2out_ignore_block,
2485 dwarf2out_source_line,
2486 dwarf2out_begin_prologue,
2487 #if VMS_DEBUGGING_INFO
2488 dwarf2out_vms_end_prologue,
2489 dwarf2out_vms_begin_epilogue,
2491 debug_nothing_int_charstar,
2492 debug_nothing_int_charstar,
2494 dwarf2out_end_epilogue,
2495 dwarf2out_begin_function,
2496 dwarf2out_end_function, /* end_function */
2497 dwarf2out_function_decl, /* function_decl */
2498 dwarf2out_global_decl,
2499 dwarf2out_type_decl, /* type_decl */
2500 dwarf2out_imported_module_or_decl,
2501 debug_nothing_tree, /* deferred_inline_function */
2502 /* The DWARF 2 backend tries to reduce debugging bloat by not
2503 emitting the abstract description of inline functions until
2504 something tries to reference them. */
2505 dwarf2out_abstract_function, /* outlining_inline_function */
2506 debug_nothing_rtx_code_label, /* label */
2507 debug_nothing_int, /* handle_pch */
2508 dwarf2out_var_location,
2509 dwarf2out_switch_text_section,
2511 1, /* start_end_main_source_file */
2512 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */
2515 /* NOTE: In the comments in this file, many references are made to
2516 "Debugging Information Entries". This term is abbreviated as `DIE'
2517 throughout the remainder of this file. */
2519 /* An internal representation of the DWARF output is built, and then
2520 walked to generate the DWARF debugging info. The walk of the internal
2521 representation is done after the entire program has been compiled.
2522 The types below are used to describe the internal representation. */
2524 /* Whether to put type DIEs into their own section .debug_types instead
2525 of making them part of the .debug_info section. Only supported for
2526 Dwarf V4 or higher and the user didn't disable them through
2527 -fno-debug-types-section. It is more efficient to put them in a
2528 separate comdat sections since the linker will then be able to
2529 remove duplicates. But not all tools support .debug_types sections
2532 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2534 /* Various DIE's use offsets relative to the beginning of the
2535 .debug_info section to refer to each other. */
2537 typedef long int dw_offset;
2539 /* Define typedefs here to avoid circular dependencies. */
2541 typedef struct dw_attr_struct *dw_attr_ref;
2542 typedef struct dw_line_info_struct *dw_line_info_ref;
2543 typedef struct pubname_struct *pubname_ref;
2544 typedef struct dw_ranges_struct *dw_ranges_ref;
2545 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
2546 typedef struct comdat_type_struct *comdat_type_node_ref;
2548 /* The entries in the line_info table more-or-less mirror the opcodes
2549 that are used in the real dwarf line table. Arrays of these entries
2550 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2553 enum dw_line_info_opcode {
2554 /* Emit DW_LNE_set_address; the operand is the label index. */
2557 /* Emit a row to the matrix with the given line. This may be done
2558 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2562 /* Emit a DW_LNS_set_file. */
2565 /* Emit a DW_LNS_set_column. */
2568 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2571 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2572 LI_set_prologue_end,
2573 LI_set_epilogue_begin,
2575 /* Emit a DW_LNE_set_discriminator. */
2576 LI_set_discriminator
2579 typedef struct GTY(()) dw_line_info_struct {
2580 enum dw_line_info_opcode opcode;
2582 } dw_line_info_entry;
2585 typedef struct GTY(()) dw_line_info_table_struct {
2586 /* The label that marks the end of this section. */
2587 const char *end_label;
2589 /* The values for the last row of the matrix, as collected in the table.
2590 These are used to minimize the changes to the next row. */
2591 unsigned int file_num;
2592 unsigned int line_num;
2593 unsigned int column_num;
2598 vec<dw_line_info_entry, va_gc> *entries;
2599 } dw_line_info_table;
2601 typedef dw_line_info_table *dw_line_info_table_p;
2604 /* Each DIE attribute has a field specifying the attribute kind,
2605 a link to the next attribute in the chain, and an attribute value.
2606 Attributes are typically linked below the DIE they modify. */
2608 typedef struct GTY(()) dw_attr_struct {
2609 enum dwarf_attribute dw_attr;
2610 dw_val_node dw_attr_val;
2615 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2616 The children of each node form a circular list linked by
2617 die_sib. die_child points to the node *before* the "first" child node. */
2619 typedef struct GTY((chain_circular ("%h.die_sib"), for_user)) die_struct {
2620 union die_symbol_or_type_node
2622 const char * GTY ((tag ("0"))) die_symbol;
2623 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
2625 GTY ((desc ("%0.comdat_type_p"))) die_id;
2626 vec<dw_attr_node, va_gc> *die_attr;
2627 dw_die_ref die_parent;
2628 dw_die_ref die_child;
2630 dw_die_ref die_definition; /* ref from a specification to its definition */
2631 dw_offset die_offset;
2632 unsigned long die_abbrev;
2634 unsigned int decl_id;
2635 enum dwarf_tag die_tag;
2636 /* Die is used and must not be pruned as unused. */
2637 BOOL_BITFIELD die_perennial_p : 1;
2638 BOOL_BITFIELD comdat_type_p : 1; /* DIE has a type signature */
2639 /* Lots of spare bits. */
2643 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2644 #define FOR_EACH_CHILD(die, c, expr) do { \
2645 c = die->die_child; \
2649 } while (c != die->die_child); \
2652 /* The pubname structure */
2654 typedef struct GTY(()) pubname_struct {
2661 struct GTY(()) dw_ranges_struct {
2662 /* If this is positive, it's a block number, otherwise it's a
2663 bitwise-negated index into dw_ranges_by_label. */
2667 /* A structure to hold a macinfo entry. */
2669 typedef struct GTY(()) macinfo_struct {
2671 unsigned HOST_WIDE_INT lineno;
2677 struct GTY(()) dw_ranges_by_label_struct {
2682 /* The comdat type node structure. */
2683 typedef struct GTY(()) comdat_type_struct
2685 dw_die_ref root_die;
2686 dw_die_ref type_die;
2687 dw_die_ref skeleton_die;
2688 char signature[DWARF_TYPE_SIGNATURE_SIZE];
2689 struct comdat_type_struct *next;
2693 /* The limbo die list structure. */
2694 typedef struct GTY(()) limbo_die_struct {
2697 struct limbo_die_struct *next;
2701 typedef struct skeleton_chain_struct
2705 struct skeleton_chain_struct *parent;
2707 skeleton_chain_node;
2709 /* Define a macro which returns nonzero for a TYPE_DECL which was
2710 implicitly generated for a type.
2712 Note that, unlike the C front-end (which generates a NULL named
2713 TYPE_DECL node for each complete tagged type, each array type,
2714 and each function type node created) the C++ front-end generates
2715 a _named_ TYPE_DECL node for each tagged type node created.
2716 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2717 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2718 front-end, but for each type, tagged or not. */
2720 #define TYPE_DECL_IS_STUB(decl) \
2721 (DECL_NAME (decl) == NULL_TREE \
2722 || (DECL_ARTIFICIAL (decl) \
2723 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2724 /* This is necessary for stub decls that \
2725 appear in nested inline functions. */ \
2726 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2727 && (decl_ultimate_origin (decl) \
2728 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2730 /* Information concerning the compilation unit's programming
2731 language, and compiler version. */
2733 /* Fixed size portion of the DWARF compilation unit header. */
2734 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2735 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2737 /* Fixed size portion of the DWARF comdat type unit header. */
2738 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2739 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2740 + DWARF_OFFSET_SIZE)
2742 /* Fixed size portion of public names info. */
2743 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2745 /* Fixed size portion of the address range info. */
2746 #define DWARF_ARANGES_HEADER_SIZE \
2747 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2748 DWARF2_ADDR_SIZE * 2) \
2749 - DWARF_INITIAL_LENGTH_SIZE)
2751 /* Size of padding portion in the address range info. It must be
2752 aligned to twice the pointer size. */
2753 #define DWARF_ARANGES_PAD_SIZE \
2754 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2755 DWARF2_ADDR_SIZE * 2) \
2756 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2758 /* Use assembler line directives if available. */
2759 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2760 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2761 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2763 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2767 /* Minimum line offset in a special line info. opcode.
2768 This value was chosen to give a reasonable range of values. */
2769 #define DWARF_LINE_BASE -10
2771 /* First special line opcode - leave room for the standard opcodes. */
2772 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2774 /* Range of line offsets in a special line info. opcode. */
2775 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2777 /* Flag that indicates the initial value of the is_stmt_start flag.
2778 In the present implementation, we do not mark any lines as
2779 the beginning of a source statement, because that information
2780 is not made available by the GCC front-end. */
2781 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2783 /* Maximum number of operations per instruction bundle. */
2784 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2785 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2788 /* This location is used by calc_die_sizes() to keep track
2789 the offset of each DIE within the .debug_info section. */
2790 static unsigned long next_die_offset;
2792 /* Record the root of the DIE's built for the current compilation unit. */
2793 static GTY(()) dw_die_ref single_comp_unit_die;
2795 /* A list of type DIEs that have been separated into comdat sections. */
2796 static GTY(()) comdat_type_node *comdat_type_list;
2798 /* A list of DIEs with a NULL parent waiting to be relocated. */
2799 static GTY(()) limbo_die_node *limbo_die_list;
2801 /* A list of DIEs for which we may have to generate
2802 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2803 static GTY(()) limbo_die_node *deferred_asm_name;
2805 struct dwarf_file_hasher : ggc_hasher<dwarf_file_data *>
2807 typedef const char *compare_type;
2809 static hashval_t hash (dwarf_file_data *);
2810 static bool equal (dwarf_file_data *, const char *);
2813 /* Filenames referenced by this compilation unit. */
2814 static GTY(()) hash_table<dwarf_file_hasher> *file_table;
2816 struct decl_die_hasher : ggc_hasher<die_node *>
2818 typedef tree compare_type;
2820 static hashval_t hash (die_node *);
2821 static bool equal (die_node *, tree);
2823 /* A hash table of references to DIE's that describe declarations.
2824 The key is a DECL_UID() which is a unique number identifying each decl. */
2825 static GTY (()) hash_table<decl_die_hasher> *decl_die_table;
2827 struct block_die_hasher : ggc_hasher<die_struct *>
2829 static hashval_t hash (die_struct *);
2830 static bool equal (die_struct *, die_struct *);
2833 /* A hash table of references to DIE's that describe COMMON blocks.
2834 The key is DECL_UID() ^ die_parent. */
2835 static GTY (()) hash_table<block_die_hasher> *common_block_die_table;
2837 typedef struct GTY(()) die_arg_entry_struct {
2843 /* Node of the variable location list. */
2844 struct GTY ((chain_next ("%h.next"))) var_loc_node {
2845 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2846 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2847 in mode of the EXPR_LIST node and first EXPR_LIST operand
2848 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2849 location or NULL for padding. For larger bitsizes,
2850 mode is 0 and first operand is a CONCAT with bitsize
2851 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2852 NULL as second operand. */
2854 const char * GTY (()) label;
2855 struct var_loc_node * GTY (()) next;
2858 /* Variable location list. */
2859 struct GTY ((for_user)) var_loc_list_def {
2860 struct var_loc_node * GTY (()) first;
2862 /* Pointer to the last but one or last element of the
2863 chained list. If the list is empty, both first and
2864 last are NULL, if the list contains just one node
2865 or the last node certainly is not redundant, it points
2866 to the last node, otherwise points to the last but one.
2867 Do not mark it for GC because it is marked through the chain. */
2868 struct var_loc_node * GTY ((skip ("%h"))) last;
2870 /* Pointer to the last element before section switch,
2871 if NULL, either sections weren't switched or first
2872 is after section switch. */
2873 struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
2875 /* DECL_UID of the variable decl. */
2876 unsigned int decl_id;
2878 typedef struct var_loc_list_def var_loc_list;
2880 /* Call argument location list. */
2881 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
2882 rtx GTY (()) call_arg_loc_note;
2883 const char * GTY (()) label;
2884 tree GTY (()) block;
2886 rtx GTY (()) symbol_ref;
2887 struct call_arg_loc_node * GTY (()) next;
2891 struct decl_loc_hasher : ggc_hasher<var_loc_list *>
2893 typedef const_tree compare_type;
2895 static hashval_t hash (var_loc_list *);
2896 static bool equal (var_loc_list *, const_tree);
2899 /* Table of decl location linked lists. */
2900 static GTY (()) hash_table<decl_loc_hasher> *decl_loc_table;
2902 /* Head and tail of call_arg_loc chain. */
2903 static GTY (()) struct call_arg_loc_node *call_arg_locations;
2904 static struct call_arg_loc_node *call_arg_loc_last;
2906 /* Number of call sites in the current function. */
2907 static int call_site_count = -1;
2908 /* Number of tail call sites in the current function. */
2909 static int tail_call_site_count = -1;
2911 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2913 static vec<dw_die_ref> block_map;
2915 /* A cached location list. */
2916 struct GTY ((for_user)) cached_dw_loc_list_def {
2917 /* The DECL_UID of the decl that this entry describes. */
2918 unsigned int decl_id;
2920 /* The cached location list. */
2921 dw_loc_list_ref loc_list;
2923 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
2925 struct dw_loc_list_hasher : ggc_hasher<cached_dw_loc_list *>
2928 typedef const_tree compare_type;
2930 static hashval_t hash (cached_dw_loc_list *);
2931 static bool equal (cached_dw_loc_list *, const_tree);
2934 /* Table of cached location lists. */
2935 static GTY (()) hash_table<dw_loc_list_hasher> *cached_dw_loc_list_table;
2937 /* A pointer to the base of a list of references to DIE's that
2938 are uniquely identified by their tag, presence/absence of
2939 children DIE's, and list of attribute/value pairs. */
2940 static GTY((length ("abbrev_die_table_allocated")))
2941 dw_die_ref *abbrev_die_table;
2943 /* Number of elements currently allocated for abbrev_die_table. */
2944 static GTY(()) unsigned abbrev_die_table_allocated;
2946 /* Number of elements in type_die_table currently in use. */
2947 static GTY(()) unsigned abbrev_die_table_in_use;
2949 /* Size (in elements) of increments by which we may expand the
2950 abbrev_die_table. */
2951 #define ABBREV_DIE_TABLE_INCREMENT 256
2953 /* A global counter for generating labels for line number data. */
2954 static unsigned int line_info_label_num;
2956 /* The current table to which we should emit line number information
2957 for the current function. This will be set up at the beginning of
2958 assembly for the function. */
2959 static dw_line_info_table *cur_line_info_table;
2961 /* The two default tables of line number info. */
2962 static GTY(()) dw_line_info_table *text_section_line_info;
2963 static GTY(()) dw_line_info_table *cold_text_section_line_info;
2965 /* The set of all non-default tables of line number info. */
2966 static GTY(()) vec<dw_line_info_table_p, va_gc> *separate_line_info;
2968 /* A flag to tell pubnames/types export if there is an info section to
2970 static bool info_section_emitted;
2972 /* A pointer to the base of a table that contains a list of publicly
2973 accessible names. */
2974 static GTY (()) vec<pubname_entry, va_gc> *pubname_table;
2976 /* A pointer to the base of a table that contains a list of publicly
2977 accessible types. */
2978 static GTY (()) vec<pubname_entry, va_gc> *pubtype_table;
2980 /* A pointer to the base of a table that contains a list of macro
2981 defines/undefines (and file start/end markers). */
2982 static GTY (()) vec<macinfo_entry, va_gc> *macinfo_table;
2984 /* True if .debug_macinfo or .debug_macros section is going to be
2986 #define have_macinfo \
2987 (debug_info_level >= DINFO_LEVEL_VERBOSE \
2988 && !macinfo_table->is_empty ())
2990 /* Array of dies for which we should generate .debug_ranges info. */
2991 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
2993 /* Number of elements currently allocated for ranges_table. */
2994 static GTY(()) unsigned ranges_table_allocated;
2996 /* Number of elements in ranges_table currently in use. */
2997 static GTY(()) unsigned ranges_table_in_use;
2999 /* Array of pairs of labels referenced in ranges_table. */
3000 static GTY ((length ("ranges_by_label_allocated")))
3001 dw_ranges_by_label_ref ranges_by_label;
3003 /* Number of elements currently allocated for ranges_by_label. */
3004 static GTY(()) unsigned ranges_by_label_allocated;
3006 /* Number of elements in ranges_by_label currently in use. */
3007 static GTY(()) unsigned ranges_by_label_in_use;
3009 /* Size (in elements) of increments by which we may expand the
3011 #define RANGES_TABLE_INCREMENT 64
3013 /* Whether we have location lists that need outputting */
3014 static GTY(()) bool have_location_lists;
3016 /* Unique label counter. */
3017 static GTY(()) unsigned int loclabel_num;
3019 /* Unique label counter for point-of-call tables. */
3020 static GTY(()) unsigned int poc_label_num;
3022 /* The last file entry emitted by maybe_emit_file(). */
3023 static GTY(()) struct dwarf_file_data * last_emitted_file;
3025 /* Number of internal labels generated by gen_internal_sym(). */
3026 static GTY(()) int label_num;
3028 /* Cached result of previous call to lookup_filename. */
3029 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
3031 static GTY(()) vec<die_arg_entry, va_gc> *tmpl_value_parm_die_table;
3033 /* Instances of generic types for which we need to generate debug
3034 info that describe their generic parameters and arguments. That
3035 generation needs to happen once all types are properly laid out so
3036 we do it at the end of compilation. */
3037 static GTY(()) vec<tree, va_gc> *generic_type_instances;
3039 /* Offset from the "steady-state frame pointer" to the frame base,
3040 within the current function. */
3041 static HOST_WIDE_INT frame_pointer_fb_offset;
3042 static bool frame_pointer_fb_offset_valid;
3044 static vec<dw_die_ref> base_types;
3046 /* Flags to represent a set of attribute classes for attributes that represent
3047 a scalar value (bounds, pointers, ...). */
3050 dw_scalar_form_constant = 0x01,
3051 dw_scalar_form_exprloc = 0x02,
3052 dw_scalar_form_reference = 0x04
3055 /* Forward declarations for functions defined in this file. */
3057 static int is_pseudo_reg (const_rtx);
3058 static tree type_main_variant (tree);
3059 static int is_tagged_type (const_tree);
3060 static const char *dwarf_tag_name (unsigned);
3061 static const char *dwarf_attr_name (unsigned);
3062 static const char *dwarf_form_name (unsigned);
3063 static tree decl_ultimate_origin (const_tree);
3064 static tree decl_class_context (tree);
3065 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3066 static inline enum dw_val_class AT_class (dw_attr_ref);
3067 static inline unsigned int AT_index (dw_attr_ref);
3068 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3069 static inline unsigned AT_flag (dw_attr_ref);
3070 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3071 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3072 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3073 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3074 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
3075 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
3076 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3077 unsigned int, unsigned char *);
3078 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
3079 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3080 static inline const char *AT_string (dw_attr_ref);
3081 static enum dwarf_form AT_string_form (dw_attr_ref);
3082 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3083 static void add_AT_specification (dw_die_ref, dw_die_ref);
3084 static inline dw_die_ref AT_ref (dw_attr_ref);
3085 static inline int AT_ref_external (dw_attr_ref);
3086 static inline void set_AT_ref_external (dw_attr_ref, int);
3087 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3088 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3089 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3090 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3092 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3093 static addr_table_entry *add_addr_table_entry (void *, enum ate_kind);
3094 static void remove_addr_table_entry (addr_table_entry *);
3095 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx, bool);
3096 static inline rtx AT_addr (dw_attr_ref);
3097 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3098 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3099 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3100 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3101 unsigned HOST_WIDE_INT);
3102 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3103 unsigned long, bool);
3104 static inline const char *AT_lbl (dw_attr_ref);
3105 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3106 static const char *get_AT_low_pc (dw_die_ref);
3107 static const char *get_AT_hi_pc (dw_die_ref);
3108 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3109 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3110 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3111 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3112 static bool is_cxx (void);
3113 static bool is_fortran (void);
3114 static bool is_ada (void);
3115 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3116 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3117 static void add_child_die (dw_die_ref, dw_die_ref);
3118 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3119 static dw_die_ref lookup_type_die (tree);
3120 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
3121 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
3122 static void equate_type_number_to_die (tree, dw_die_ref);
3123 static dw_die_ref lookup_decl_die (tree);
3124 static var_loc_list *lookup_decl_loc (const_tree);
3125 static void equate_decl_number_to_die (tree, dw_die_ref);
3126 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
3127 static void print_spaces (FILE *);
3128 static void print_die (dw_die_ref, FILE *);
3129 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3130 static dw_die_ref pop_compile_unit (dw_die_ref);
3131 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3132 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3133 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3134 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
3135 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
3136 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
3137 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
3138 struct md5_ctx *, int *);
3139 struct checksum_attributes;
3140 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
3141 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
3142 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
3143 static void generate_type_signature (dw_die_ref, comdat_type_node *);
3144 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3145 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
3146 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3147 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3148 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3149 static void compute_section_prefix (dw_die_ref);
3150 static int is_type_die (dw_die_ref);
3151 static int is_comdat_die (dw_die_ref);
3152 static int is_symbol_die (dw_die_ref);
3153 static inline bool is_template_instantiation (dw_die_ref);
3154 static void assign_symbol_names (dw_die_ref);
3155 static void break_out_includes (dw_die_ref);
3156 static int is_declaration_die (dw_die_ref);
3157 static int should_move_die_to_comdat (dw_die_ref);
3158 static dw_die_ref clone_as_declaration (dw_die_ref);
3159 static dw_die_ref clone_die (dw_die_ref);
3160 static dw_die_ref clone_tree (dw_die_ref);
3161 static dw_die_ref copy_declaration_context (dw_die_ref, dw_die_ref);
3162 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
3163 static void generate_skeleton_bottom_up (skeleton_chain_node *);
3164 static dw_die_ref generate_skeleton (dw_die_ref);
3165 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
3168 static void break_out_comdat_types (dw_die_ref);
3169 static void copy_decls_for_unworthy_types (dw_die_ref);
3171 static void add_sibling_attributes (dw_die_ref);
3172 static void output_location_lists (dw_die_ref);
3173 static int constant_size (unsigned HOST_WIDE_INT);
3174 static unsigned long size_of_die (dw_die_ref);
3175 static void calc_die_sizes (dw_die_ref);
3176 static void calc_base_type_die_sizes (void);
3177 static void mark_dies (dw_die_ref);
3178 static void unmark_dies (dw_die_ref);
3179 static void unmark_all_dies (dw_die_ref);
3180 static unsigned long size_of_pubnames (vec<pubname_entry, va_gc> *);
3181 static unsigned long size_of_aranges (void);
3182 static enum dwarf_form value_format (dw_attr_ref);
3183 static void output_value_format (dw_attr_ref);
3184 static void output_abbrev_section (void);
3185 static void output_die_abbrevs (unsigned long, dw_die_ref);
3186 static void output_die_symbol (dw_die_ref);
3187 static void output_die (dw_die_ref);
3188 static void output_compilation_unit_header (void);
3189 static void output_comp_unit (dw_die_ref, int);
3190 static void output_comdat_type_unit (comdat_type_node *);
3191 static const char *dwarf2_name (tree, int);
3192 static void add_pubname (tree, dw_die_ref);
3193 static void add_enumerator_pubname (const char *, dw_die_ref);
3194 static void add_pubname_string (const char *, dw_die_ref);
3195 static void add_pubtype (tree, dw_die_ref);
3196 static void output_pubnames (vec<pubname_entry, va_gc> *);
3197 static void output_aranges (unsigned long);
3198 static unsigned int add_ranges_num (int);
3199 static unsigned int add_ranges (const_tree);
3200 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
3202 static void output_ranges (void);
3203 static dw_line_info_table *new_line_info_table (void);
3204 static void output_line_info (bool);
3205 static void output_file_names (void);
3206 static dw_die_ref base_type_die (tree);
3207 static int is_base_type (tree);
3208 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
3209 static int decl_quals (const_tree);
3210 static dw_die_ref modified_type_die (tree, int, dw_die_ref);
3211 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
3212 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
3213 static int type_is_enum (const_tree);
3214 static unsigned int dbx_reg_number (const_rtx);
3215 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
3216 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
3217 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
3218 enum var_init_status);
3219 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
3220 enum var_init_status);
3221 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
3222 enum var_init_status);
3223 static int is_based_loc (const_rtx);
3224 static bool resolve_one_addr (rtx *);
3225 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
3226 enum var_init_status);
3227 static dw_loc_descr_ref loc_descriptor (rtx, machine_mode mode,
3228 enum var_init_status);
3229 struct loc_descr_context;
3230 static dw_loc_list_ref loc_list_from_tree (tree, int,
3231 const struct loc_descr_context *);
3232 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int,
3233 const struct loc_descr_context *);
3234 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3235 static tree field_type (const_tree);
3236 static unsigned int simple_type_align_in_bits (const_tree);
3237 static unsigned int simple_decl_align_in_bits (const_tree);
3238 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
3239 static HOST_WIDE_INT field_byte_offset (const_tree);
3240 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3242 static void add_data_member_location_attribute (dw_die_ref, tree);
3243 static bool add_const_value_attribute (dw_die_ref, rtx);
3244 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3245 static void insert_wide_int (const wide_int &, unsigned char *, int);
3246 static void insert_float (const_rtx, unsigned char *);
3247 static rtx rtl_for_decl_location (tree);
3248 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool,
3249 enum dwarf_attribute);
3250 static bool tree_add_const_value_attribute (dw_die_ref, tree);
3251 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
3252 static void add_name_attribute (dw_die_ref, const char *);
3253 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
3254 static void add_comp_dir_attribute (dw_die_ref);
3255 static void add_scalar_info (dw_die_ref, enum dwarf_attribute, tree, int,
3256 const struct loc_descr_context *);
3257 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree,
3258 const struct loc_descr_context *);
3259 static void add_subscript_info (dw_die_ref, tree, bool);
3260 static void add_byte_size_attribute (dw_die_ref, tree);
3261 static void add_bit_offset_attribute (dw_die_ref, tree);
3262 static void add_bit_size_attribute (dw_die_ref, tree);
3263 static void add_prototyped_attribute (dw_die_ref, tree);
3264 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
3265 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3266 static void add_src_coords_attributes (dw_die_ref, tree);
3267 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3268 static void push_decl_scope (tree);
3269 static void pop_decl_scope (void);
3270 static dw_die_ref scope_die_for (tree, dw_die_ref);
3271 static inline int local_scope_p (dw_die_ref);
3272 static inline int class_scope_p (dw_die_ref);
3273 static inline int class_or_namespace_scope_p (dw_die_ref);
3274 static void add_type_attribute (dw_die_ref, tree, int, dw_die_ref);
3275 static void add_calling_convention_attribute (dw_die_ref, tree);
3276 static const char *type_tag (const_tree);
3277 static tree member_declared_type (const_tree);
3279 static const char *decl_start_label (tree);
3281 static void gen_array_type_die (tree, dw_die_ref);
3282 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
3284 static void gen_entry_point_die (tree, dw_die_ref);
3286 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
3287 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
3288 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
3289 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3290 static void gen_formal_types_die (tree, dw_die_ref);
3291 static void gen_subprogram_die (tree, dw_die_ref);
3292 static void gen_variable_die (tree, tree, dw_die_ref);
3293 static void gen_const_die (tree, dw_die_ref);
3294 static void gen_label_die (tree, dw_die_ref);
3295 static void gen_lexical_block_die (tree, dw_die_ref);
3296 static void gen_inlined_subroutine_die (tree, dw_die_ref);
3297 static void gen_field_die (tree, dw_die_ref);
3298 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3299 static dw_die_ref gen_compile_unit_die (const char *);
3300 static void gen_inheritance_die (tree, tree, dw_die_ref);
3301 static void gen_member_die (tree, dw_die_ref);
3302 static void gen_struct_or_union_type_die (tree, dw_die_ref,
3303 enum debug_info_usage);
3304 static void gen_subroutine_type_die (tree, dw_die_ref);
3305 static void gen_typedef_die (tree, dw_die_ref);
3306 static void gen_type_die (tree, dw_die_ref);
3307 static void gen_block_die (tree, dw_die_ref);
3308 static void decls_for_scope (tree, dw_die_ref);
3309 static inline int is_redundant_typedef (const_tree);
3310 static bool is_naming_typedef_decl (const_tree);
3311 static inline dw_die_ref get_context_die (tree);
3312 static void gen_namespace_die (tree, dw_die_ref);
3313 static dw_die_ref gen_namelist_decl (tree, dw_die_ref, tree);
3314 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
3315 static dw_die_ref force_decl_die (tree);
3316 static dw_die_ref force_type_die (tree);
3317 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3318 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
3319 static struct dwarf_file_data * lookup_filename (const char *);
3320 static void retry_incomplete_types (void);
3321 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3322 static void gen_generic_params_dies (tree);
3323 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
3324 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
3325 static void splice_child_die (dw_die_ref, dw_die_ref);
3326 static int file_info_cmp (const void *, const void *);
3327 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3328 const char *, const char *);
3329 static void output_loc_list (dw_loc_list_ref);
3330 static char *gen_internal_sym (const char *);
3331 static bool want_pubnames (void);
3333 static void prune_unmark_dies (dw_die_ref);
3334 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
3335 static void prune_unused_types_mark (dw_die_ref, int);
3336 static void prune_unused_types_walk (dw_die_ref);
3337 static void prune_unused_types_walk_attribs (dw_die_ref);
3338 static void prune_unused_types_prune (dw_die_ref);
3339 static void prune_unused_types (void);
3340 static int maybe_emit_file (struct dwarf_file_data *fd);
3341 static inline const char *AT_vms_delta1 (dw_attr_ref);
3342 static inline const char *AT_vms_delta2 (dw_attr_ref);
3343 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
3344 const char *, const char *);
3345 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
3346 static void gen_remaining_tmpl_value_param_die_attribute (void);
3347 static bool generic_type_p (tree);
3348 static void schedule_generic_params_dies_gen (tree t);
3349 static void gen_scheduled_generic_parms_dies (void);
3351 static const char *comp_dir_string (void);
3353 static void hash_loc_operands (dw_loc_descr_ref, inchash::hash &);
3355 /* enum for tracking thread-local variables whose address is really an offset
3356 relative to the TLS pointer, which will need link-time relocation, but will
3357 not need relocation by the DWARF consumer. */
3365 /* Return the operator to use for an address of a variable. For dtprel_true, we
3366 use DW_OP_const*. For regular variables, which need both link-time
3367 relocation and consumer-level relocation (e.g., to account for shared objects
3368 loaded at a random address), we use DW_OP_addr*. */
3370 static inline enum dwarf_location_atom
3371 dw_addr_op (enum dtprel_bool dtprel)
3373 if (dtprel == dtprel_true)
3374 return (dwarf_split_debug_info ? DW_OP_GNU_const_index
3375 : (DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u));
3377 return dwarf_split_debug_info ? DW_OP_GNU_addr_index : DW_OP_addr;
3380 /* Return a pointer to a newly allocated address location description. If
3381 dwarf_split_debug_info is true, then record the address with the appropriate
3383 static inline dw_loc_descr_ref
3384 new_addr_loc_descr (rtx addr, enum dtprel_bool dtprel)
3386 dw_loc_descr_ref ref = new_loc_descr (dw_addr_op (dtprel), 0, 0);
3388 ref->dw_loc_oprnd1.val_class = dw_val_class_addr;
3389 ref->dw_loc_oprnd1.v.val_addr = addr;
3390 ref->dtprel = dtprel;
3391 if (dwarf_split_debug_info)
3392 ref->dw_loc_oprnd1.val_entry
3393 = add_addr_table_entry (addr,
3394 dtprel ? ate_kind_rtx_dtprel : ate_kind_rtx);
3396 ref->dw_loc_oprnd1.val_entry = NULL;
3401 /* Section names used to hold DWARF debugging information. */
3403 #ifndef DEBUG_INFO_SECTION
3404 #define DEBUG_INFO_SECTION ".debug_info"
3406 #ifndef DEBUG_DWO_INFO_SECTION
3407 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3409 #ifndef DEBUG_ABBREV_SECTION
3410 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3412 #ifndef DEBUG_DWO_ABBREV_SECTION
3413 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3415 #ifndef DEBUG_ARANGES_SECTION
3416 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3418 #ifndef DEBUG_ADDR_SECTION
3419 #define DEBUG_ADDR_SECTION ".debug_addr"
3421 #ifndef DEBUG_NORM_MACINFO_SECTION
3422 #define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo"
3424 #ifndef DEBUG_DWO_MACINFO_SECTION
3425 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3427 #ifndef DEBUG_MACINFO_SECTION
3428 #define DEBUG_MACINFO_SECTION \
3429 (!dwarf_split_debug_info \
3430 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION))
3432 #ifndef DEBUG_NORM_MACRO_SECTION
3433 #define DEBUG_NORM_MACRO_SECTION ".debug_macro"
3435 #ifndef DEBUG_DWO_MACRO_SECTION
3436 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3438 #ifndef DEBUG_MACRO_SECTION
3439 #define DEBUG_MACRO_SECTION \
3440 (!dwarf_split_debug_info \
3441 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION))
3443 #ifndef DEBUG_LINE_SECTION
3444 #define DEBUG_LINE_SECTION ".debug_line"
3446 #ifndef DEBUG_DWO_LINE_SECTION
3447 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3449 #ifndef DEBUG_LOC_SECTION
3450 #define DEBUG_LOC_SECTION ".debug_loc"
3452 #ifndef DEBUG_DWO_LOC_SECTION
3453 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3455 #ifndef DEBUG_PUBNAMES_SECTION
3456 #define DEBUG_PUBNAMES_SECTION \
3457 ((debug_generate_pub_sections == 2) \
3458 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3460 #ifndef DEBUG_PUBTYPES_SECTION
3461 #define DEBUG_PUBTYPES_SECTION \
3462 ((debug_generate_pub_sections == 2) \
3463 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3465 #define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets"
3466 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3467 #ifndef DEBUG_STR_OFFSETS_SECTION
3468 #define DEBUG_STR_OFFSETS_SECTION \
3469 (!dwarf_split_debug_info \
3470 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION))
3472 #ifndef DEBUG_STR_DWO_SECTION
3473 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3475 #ifndef DEBUG_STR_SECTION
3476 #define DEBUG_STR_SECTION ".debug_str"
3478 #ifndef DEBUG_RANGES_SECTION
3479 #define DEBUG_RANGES_SECTION ".debug_ranges"
3482 /* Standard ELF section names for compiled code and data. */
3483 #ifndef TEXT_SECTION_NAME
3484 #define TEXT_SECTION_NAME ".text"
3487 /* Section flags for .debug_macinfo/.debug_macro section. */
3488 #define DEBUG_MACRO_SECTION_FLAGS \
3489 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG)
3491 /* Section flags for .debug_str section. */
3492 #define DEBUG_STR_SECTION_FLAGS \
3493 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3494 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3497 /* Section flags for .debug_str.dwo section. */
3498 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3500 /* Labels we insert at beginning sections we can reference instead of
3501 the section names themselves. */
3503 #ifndef TEXT_SECTION_LABEL
3504 #define TEXT_SECTION_LABEL "Ltext"
3506 #ifndef COLD_TEXT_SECTION_LABEL
3507 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3509 #ifndef DEBUG_LINE_SECTION_LABEL
3510 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3512 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3513 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3515 #ifndef DEBUG_INFO_SECTION_LABEL
3516 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3518 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3519 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3521 #ifndef DEBUG_ABBREV_SECTION_LABEL
3522 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3524 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3525 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3527 #ifndef DEBUG_ADDR_SECTION_LABEL
3528 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3530 #ifndef DEBUG_LOC_SECTION_LABEL
3531 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3533 #ifndef DEBUG_RANGES_SECTION_LABEL
3534 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3536 #ifndef DEBUG_MACINFO_SECTION_LABEL
3537 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3539 #ifndef DEBUG_MACRO_SECTION_LABEL
3540 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3542 #define SKELETON_COMP_DIE_ABBREV 1
3543 #define SKELETON_TYPE_DIE_ABBREV 2
3545 /* Definitions of defaults for formats and names of various special
3546 (artificial) labels which may be generated within this file (when the -g
3547 options is used and DWARF2_DEBUGGING_INFO is in effect.
3548 If necessary, these may be overridden from within the tm.h file, but
3549 typically, overriding these defaults is unnecessary. */
3551 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3552 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3553 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3554 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3555 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3556 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3557 static char debug_skeleton_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3558 static char debug_skeleton_abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3559 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3560 static char debug_addr_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3561 static char debug_skeleton_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3562 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3563 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3564 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3566 #ifndef TEXT_END_LABEL
3567 #define TEXT_END_LABEL "Letext"
3569 #ifndef COLD_END_LABEL
3570 #define COLD_END_LABEL "Letext_cold"
3572 #ifndef BLOCK_BEGIN_LABEL
3573 #define BLOCK_BEGIN_LABEL "LBB"
3575 #ifndef BLOCK_END_LABEL
3576 #define BLOCK_END_LABEL "LBE"
3578 #ifndef LINE_CODE_LABEL
3579 #define LINE_CODE_LABEL "LM"
3583 /* Return the root of the DIE's built for the current compilation unit. */
3585 comp_unit_die (void)
3587 if (!single_comp_unit_die)
3588 single_comp_unit_die = gen_compile_unit_die (NULL);
3589 return single_comp_unit_die;
3592 /* We allow a language front-end to designate a function that is to be
3593 called to "demangle" any name before it is put into a DIE. */
3595 static const char *(*demangle_name_func) (const char *);
3598 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
3600 demangle_name_func = func;
3603 /* Test if rtl node points to a pseudo register. */
3606 is_pseudo_reg (const_rtx rtl)
3608 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3609 || (GET_CODE (rtl) == SUBREG
3610 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3613 /* Return a reference to a type, with its const and volatile qualifiers
3617 type_main_variant (tree type)
3619 type = TYPE_MAIN_VARIANT (type);
3621 /* ??? There really should be only one main variant among any group of
3622 variants of a given type (and all of the MAIN_VARIANT values for all
3623 members of the group should point to that one type) but sometimes the C
3624 front-end messes this up for array types, so we work around that bug
3626 if (TREE_CODE (type) == ARRAY_TYPE)
3627 while (type != TYPE_MAIN_VARIANT (type))
3628 type = TYPE_MAIN_VARIANT (type);
3633 /* Return nonzero if the given type node represents a tagged type. */
3636 is_tagged_type (const_tree type)
3638 enum tree_code code = TREE_CODE (type);
3640 return (code == RECORD_TYPE || code == UNION_TYPE
3641 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
3644 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3647 get_ref_die_offset_label (char *label, dw_die_ref ref)
3649 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
3652 /* Return die_offset of a DIE reference to a base type. */
3654 static unsigned long int
3655 get_base_type_offset (dw_die_ref ref)
3657 if (ref->die_offset)
3658 return ref->die_offset;
3659 if (comp_unit_die ()->die_abbrev)
3661 calc_base_type_die_sizes ();
3662 gcc_assert (ref->die_offset);
3664 return ref->die_offset;
3667 /* Return die_offset of a DIE reference other than base type. */
3669 static unsigned long int
3670 get_ref_die_offset (dw_die_ref ref)
3672 gcc_assert (ref->die_offset);
3673 return ref->die_offset;
3676 /* Convert a DIE tag into its string name. */
3679 dwarf_tag_name (unsigned int tag)
3681 const char *name = get_DW_TAG_name (tag);
3686 return "DW_TAG_<unknown>";
3689 /* Convert a DWARF attribute code into its string name. */
3692 dwarf_attr_name (unsigned int attr)
3698 #if VMS_DEBUGGING_INFO
3699 case DW_AT_HP_prologue:
3700 return "DW_AT_HP_prologue";
3702 case DW_AT_MIPS_loop_unroll_factor:
3703 return "DW_AT_MIPS_loop_unroll_factor";
3706 #if VMS_DEBUGGING_INFO
3707 case DW_AT_HP_epilogue:
3708 return "DW_AT_HP_epilogue";
3710 case DW_AT_MIPS_stride:
3711 return "DW_AT_MIPS_stride";
3715 name = get_DW_AT_name (attr);
3720 return "DW_AT_<unknown>";
3723 /* Convert a DWARF value form code into its string name. */
3726 dwarf_form_name (unsigned int form)
3728 const char *name = get_DW_FORM_name (form);
3733 return "DW_FORM_<unknown>";
3736 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3737 instance of an inlined instance of a decl which is local to an inline
3738 function, so we have to trace all of the way back through the origin chain
3739 to find out what sort of node actually served as the original seed for the
3743 decl_ultimate_origin (const_tree decl)
3745 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
3748 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
3749 we're trying to output the abstract instance of this function. */
3750 if (DECL_ABSTRACT_P (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
3753 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3754 most distant ancestor, this should never happen. */
3755 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
3757 return DECL_ABSTRACT_ORIGIN (decl);
3760 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3761 of a virtual function may refer to a base class, so we check the 'this'
3765 decl_class_context (tree decl)
3767 tree context = NULL_TREE;
3769 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3770 context = DECL_CONTEXT (decl);
3772 context = TYPE_MAIN_VARIANT
3773 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3775 if (context && !TYPE_P (context))
3776 context = NULL_TREE;
3781 /* Add an attribute/value pair to a DIE. */
3784 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
3786 /* Maybe this should be an assert? */
3790 vec_safe_reserve (die->die_attr, 1);
3791 vec_safe_push (die->die_attr, *attr);
3794 static inline enum dw_val_class
3795 AT_class (dw_attr_ref a)
3797 return a->dw_attr_val.val_class;
3800 /* Return the index for any attribute that will be referenced with a
3801 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
3802 are stored in dw_attr_val.v.val_str for reference counting
3805 static inline unsigned int
3806 AT_index (dw_attr_ref a)
3808 if (AT_class (a) == dw_val_class_str)
3809 return a->dw_attr_val.v.val_str->index;
3810 else if (a->dw_attr_val.val_entry != NULL)
3811 return a->dw_attr_val.val_entry->index;
3815 /* Add a flag value attribute to a DIE. */
3818 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
3822 attr.dw_attr = attr_kind;
3823 attr.dw_attr_val.val_class = dw_val_class_flag;
3824 attr.dw_attr_val.val_entry = NULL;
3825 attr.dw_attr_val.v.val_flag = flag;
3826 add_dwarf_attr (die, &attr);
3829 static inline unsigned
3830 AT_flag (dw_attr_ref a)
3832 gcc_assert (a && AT_class (a) == dw_val_class_flag);
3833 return a->dw_attr_val.v.val_flag;
3836 /* Add a signed integer attribute value to a DIE. */
3839 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
3843 attr.dw_attr = attr_kind;
3844 attr.dw_attr_val.val_class = dw_val_class_const;
3845 attr.dw_attr_val.val_entry = NULL;
3846 attr.dw_attr_val.v.val_int = int_val;
3847 add_dwarf_attr (die, &attr);
3850 static inline HOST_WIDE_INT
3851 AT_int (dw_attr_ref a)
3853 gcc_assert (a && AT_class (a) == dw_val_class_const);
3854 return a->dw_attr_val.v.val_int;
3857 /* Add an unsigned integer attribute value to a DIE. */
3860 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
3861 unsigned HOST_WIDE_INT unsigned_val)
3865 attr.dw_attr = attr_kind;
3866 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
3867 attr.dw_attr_val.val_entry = NULL;
3868 attr.dw_attr_val.v.val_unsigned = unsigned_val;
3869 add_dwarf_attr (die, &attr);
3872 static inline unsigned HOST_WIDE_INT
3873 AT_unsigned (dw_attr_ref a)
3875 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
3876 return a->dw_attr_val.v.val_unsigned;
3879 /* Add an unsigned wide integer attribute value to a DIE. */
3882 add_AT_wide (dw_die_ref die, enum dwarf_attribute attr_kind,
3887 attr.dw_attr = attr_kind;
3888 attr.dw_attr_val.val_class = dw_val_class_wide_int;
3889 attr.dw_attr_val.val_entry = NULL;
3890 attr.dw_attr_val.v.val_wide = ggc_alloc<wide_int> ();
3891 *attr.dw_attr_val.v.val_wide = w;
3892 add_dwarf_attr (die, &attr);
3895 /* Add an unsigned double integer attribute value to a DIE. */
3898 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
3899 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
3903 attr.dw_attr = attr_kind;
3904 attr.dw_attr_val.val_class = dw_val_class_const_double;
3905 attr.dw_attr_val.val_entry = NULL;
3906 attr.dw_attr_val.v.val_double.high = high;
3907 attr.dw_attr_val.v.val_double.low = low;
3908 add_dwarf_attr (die, &attr);
3911 /* Add a floating point attribute value to a DIE and return it. */
3914 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
3915 unsigned int length, unsigned int elt_size, unsigned char *array)
3919 attr.dw_attr = attr_kind;
3920 attr.dw_attr_val.val_class = dw_val_class_vec;
3921 attr.dw_attr_val.val_entry = NULL;
3922 attr.dw_attr_val.v.val_vec.length = length;
3923 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
3924 attr.dw_attr_val.v.val_vec.array = array;
3925 add_dwarf_attr (die, &attr);
3928 /* Add an 8-byte data attribute value to a DIE. */
3931 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
3932 unsigned char data8[8])
3936 attr.dw_attr = attr_kind;
3937 attr.dw_attr_val.val_class = dw_val_class_data8;
3938 attr.dw_attr_val.val_entry = NULL;
3939 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
3940 add_dwarf_attr (die, &attr);
3943 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
3944 dwarf_split_debug_info, address attributes in dies destined for the
3945 final executable have force_direct set to avoid using indexed
3949 add_AT_low_high_pc (dw_die_ref die, const char *lbl_low, const char *lbl_high,
3955 lbl_id = xstrdup (lbl_low);
3956 attr.dw_attr = DW_AT_low_pc;
3957 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
3958 attr.dw_attr_val.v.val_lbl_id = lbl_id;
3959 if (dwarf_split_debug_info && !force_direct)
3960 attr.dw_attr_val.val_entry
3961 = add_addr_table_entry (lbl_id, ate_kind_label);
3963 attr.dw_attr_val.val_entry = NULL;
3964 add_dwarf_attr (die, &attr);
3966 attr.dw_attr = DW_AT_high_pc;
3967 if (dwarf_version < 4)
3968 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
3970 attr.dw_attr_val.val_class = dw_val_class_high_pc;
3971 lbl_id = xstrdup (lbl_high);
3972 attr.dw_attr_val.v.val_lbl_id = lbl_id;
3973 if (attr.dw_attr_val.val_class == dw_val_class_lbl_id
3974 && dwarf_split_debug_info && !force_direct)
3975 attr.dw_attr_val.val_entry
3976 = add_addr_table_entry (lbl_id, ate_kind_label);
3978 attr.dw_attr_val.val_entry = NULL;
3979 add_dwarf_attr (die, &attr);
3982 /* Hash and equality functions for debug_str_hash. */
3985 indirect_string_hasher::hash (indirect_string_node *x)
3987 return htab_hash_string (x->str);
3991 indirect_string_hasher::equal (indirect_string_node *x1, const char *x2)
3993 return strcmp (x1->str, x2) == 0;
3996 /* Add STR to the given string hash table. */
3998 static struct indirect_string_node *
3999 find_AT_string_in_table (const char *str,
4000 hash_table<indirect_string_hasher> *table)
4002 struct indirect_string_node *node;
4004 indirect_string_node **slot
4005 = table->find_slot_with_hash (str, htab_hash_string (str), INSERT);
4008 node = ggc_cleared_alloc<indirect_string_node> ();
4009 node->str = ggc_strdup (str);
4019 /* Add STR to the indirect string hash table. */
4021 static struct indirect_string_node *
4022 find_AT_string (const char *str)
4024 if (! debug_str_hash)
4025 debug_str_hash = hash_table<indirect_string_hasher>::create_ggc (10);
4027 return find_AT_string_in_table (str, debug_str_hash);
4030 /* Add a string attribute value to a DIE. */
4033 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4036 struct indirect_string_node *node;
4038 node = find_AT_string (str);
4040 attr.dw_attr = attr_kind;
4041 attr.dw_attr_val.val_class = dw_val_class_str;
4042 attr.dw_attr_val.val_entry = NULL;
4043 attr.dw_attr_val.v.val_str = node;
4044 add_dwarf_attr (die, &attr);
4047 static inline const char *
4048 AT_string (dw_attr_ref a)
4050 gcc_assert (a && AT_class (a) == dw_val_class_str);
4051 return a->dw_attr_val.v.val_str->str;
4054 /* Call this function directly to bypass AT_string_form's logic to put
4055 the string inline in the die. */
4058 set_indirect_string (struct indirect_string_node *node)
4061 /* Already indirect is a no op. */
4062 if (node->form == DW_FORM_strp || node->form == DW_FORM_GNU_str_index)
4064 gcc_assert (node->label);
4067 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4068 ++dw2_string_counter;
4069 node->label = xstrdup (label);
4071 if (!dwarf_split_debug_info)
4073 node->form = DW_FORM_strp;
4074 node->index = NOT_INDEXED;
4078 node->form = DW_FORM_GNU_str_index;
4079 node->index = NO_INDEX_ASSIGNED;
4083 /* Find out whether a string should be output inline in DIE
4084 or out-of-line in .debug_str section. */
4086 static enum dwarf_form
4087 find_string_form (struct indirect_string_node *node)
4094 len = strlen (node->str) + 1;
4096 /* If the string is shorter or equal to the size of the reference, it is
4097 always better to put it inline. */
4098 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4099 return node->form = DW_FORM_string;
4101 /* If we cannot expect the linker to merge strings in .debug_str
4102 section, only put it into .debug_str if it is worth even in this
4104 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4105 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
4106 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
4107 return node->form = DW_FORM_string;
4109 set_indirect_string (node);
4114 /* Find out whether the string referenced from the attribute should be
4115 output inline in DIE or out-of-line in .debug_str section. */
4117 static enum dwarf_form
4118 AT_string_form (dw_attr_ref a)
4120 gcc_assert (a && AT_class (a) == dw_val_class_str);
4121 return find_string_form (a->dw_attr_val.v.val_str);
4124 /* Add a DIE reference attribute value to a DIE. */
4127 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
4131 #ifdef ENABLE_CHECKING
4132 gcc_assert (targ_die != NULL);
4134 /* With LTO we can end up trying to reference something we didn't create
4135 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4136 if (targ_die == NULL)
4140 attr.dw_attr = attr_kind;
4141 attr.dw_attr_val.val_class = dw_val_class_die_ref;
4142 attr.dw_attr_val.val_entry = NULL;
4143 attr.dw_attr_val.v.val_die_ref.die = targ_die;
4144 attr.dw_attr_val.v.val_die_ref.external = 0;
4145 add_dwarf_attr (die, &attr);
4148 /* Change DIE reference REF to point to NEW_DIE instead. */
4151 change_AT_die_ref (dw_attr_ref ref, dw_die_ref new_die)
4153 gcc_assert (ref->dw_attr_val.val_class == dw_val_class_die_ref);
4154 ref->dw_attr_val.v.val_die_ref.die = new_die;
4155 ref->dw_attr_val.v.val_die_ref.external = 0;
4158 /* Add an AT_specification attribute to a DIE, and also make the back
4159 pointer from the specification to the definition. */
4162 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
4164 add_AT_die_ref (die, DW_AT_specification, targ_die);
4165 gcc_assert (!targ_die->die_definition);
4166 targ_die->die_definition = die;
4169 static inline dw_die_ref
4170 AT_ref (dw_attr_ref a)
4172 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4173 return a->dw_attr_val.v.val_die_ref.die;
4177 AT_ref_external (dw_attr_ref a)
4179 if (a && AT_class (a) == dw_val_class_die_ref)
4180 return a->dw_attr_val.v.val_die_ref.external;
4186 set_AT_ref_external (dw_attr_ref a, int i)
4188 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4189 a->dw_attr_val.v.val_die_ref.external = i;
4192 /* Add an FDE reference attribute value to a DIE. */
4195 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
4199 attr.dw_attr = attr_kind;
4200 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
4201 attr.dw_attr_val.val_entry = NULL;
4202 attr.dw_attr_val.v.val_fde_index = targ_fde;
4203 add_dwarf_attr (die, &attr);
4206 /* Add a location description attribute value to a DIE. */
4209 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
4213 attr.dw_attr = attr_kind;
4214 attr.dw_attr_val.val_class = dw_val_class_loc;
4215 attr.dw_attr_val.val_entry = NULL;
4216 attr.dw_attr_val.v.val_loc = loc;
4217 add_dwarf_attr (die, &attr);
4220 static inline dw_loc_descr_ref
4221 AT_loc (dw_attr_ref a)
4223 gcc_assert (a && AT_class (a) == dw_val_class_loc);
4224 return a->dw_attr_val.v.val_loc;
4228 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
4232 attr.dw_attr = attr_kind;
4233 attr.dw_attr_val.val_class = dw_val_class_loc_list;
4234 attr.dw_attr_val.val_entry = NULL;
4235 attr.dw_attr_val.v.val_loc_list = loc_list;
4236 add_dwarf_attr (die, &attr);
4237 have_location_lists = true;
4240 static inline dw_loc_list_ref
4241 AT_loc_list (dw_attr_ref a)
4243 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4244 return a->dw_attr_val.v.val_loc_list;
4247 static inline dw_loc_list_ref *
4248 AT_loc_list_ptr (dw_attr_ref a)
4250 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4251 return &a->dw_attr_val.v.val_loc_list;
4254 struct addr_hasher : ggc_hasher<addr_table_entry *>
4256 static hashval_t hash (addr_table_entry *);
4257 static bool equal (addr_table_entry *, addr_table_entry *);
4260 /* Table of entries into the .debug_addr section. */
4262 static GTY (()) hash_table<addr_hasher> *addr_index_table;
4264 /* Hash an address_table_entry. */
4267 addr_hasher::hash (addr_table_entry *a)
4269 inchash::hash hstate;
4275 case ate_kind_rtx_dtprel:
4278 case ate_kind_label:
4279 return htab_hash_string (a->addr.label);
4283 inchash::add_rtx (a->addr.rtl, hstate);
4284 return hstate.end ();
4287 /* Determine equality for two address_table_entries. */
4290 addr_hasher::equal (addr_table_entry *a1, addr_table_entry *a2)
4292 if (a1->kind != a2->kind)
4297 case ate_kind_rtx_dtprel:
4298 return rtx_equal_p (a1->addr.rtl, a2->addr.rtl);
4299 case ate_kind_label:
4300 return strcmp (a1->addr.label, a2->addr.label) == 0;
4306 /* Initialize an addr_table_entry. */
4309 init_addr_table_entry (addr_table_entry *e, enum ate_kind kind, void *addr)
4315 case ate_kind_rtx_dtprel:
4316 e->addr.rtl = (rtx) addr;
4318 case ate_kind_label:
4319 e->addr.label = (char *) addr;
4323 e->index = NO_INDEX_ASSIGNED;
4326 /* Add attr to the address table entry to the table. Defer setting an
4327 index until output time. */
4329 static addr_table_entry *
4330 add_addr_table_entry (void *addr, enum ate_kind kind)
4332 addr_table_entry *node;
4333 addr_table_entry finder;
4335 gcc_assert (dwarf_split_debug_info);
4336 if (! addr_index_table)
4337 addr_index_table = hash_table<addr_hasher>::create_ggc (10);
4338 init_addr_table_entry (&finder, kind, addr);
4339 addr_table_entry **slot = addr_index_table->find_slot (&finder, INSERT);
4341 if (*slot == HTAB_EMPTY_ENTRY)
4343 node = ggc_cleared_alloc<addr_table_entry> ();
4344 init_addr_table_entry (node, kind, addr);
4354 /* Remove an entry from the addr table by decrementing its refcount.
4355 Strictly, decrementing the refcount would be enough, but the
4356 assertion that the entry is actually in the table has found
4360 remove_addr_table_entry (addr_table_entry *entry)
4362 gcc_assert (dwarf_split_debug_info && addr_index_table);
4363 /* After an index is assigned, the table is frozen. */
4364 gcc_assert (entry->refcount > 0 && entry->index == NO_INDEX_ASSIGNED);
4368 /* Given a location list, remove all addresses it refers to from the
4372 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr)
4374 for (; descr; descr = descr->dw_loc_next)
4375 if (descr->dw_loc_oprnd1.val_entry != NULL)
4377 gcc_assert (descr->dw_loc_oprnd1.val_entry->index == NO_INDEX_ASSIGNED);
4378 remove_addr_table_entry (descr->dw_loc_oprnd1.val_entry);
4382 /* A helper function for dwarf2out_finish called through
4383 htab_traverse. Assign an addr_table_entry its index. All entries
4384 must be collected into the table when this function is called,
4385 because the indexing code relies on htab_traverse to traverse nodes
4386 in the same order for each run. */
4389 index_addr_table_entry (addr_table_entry **h, unsigned int *index)
4391 addr_table_entry *node = *h;
4393 /* Don't index unreferenced nodes. */
4394 if (node->refcount == 0)
4397 gcc_assert (node->index == NO_INDEX_ASSIGNED);
4398 node->index = *index;
4404 /* Add an address constant attribute value to a DIE. When using
4405 dwarf_split_debug_info, address attributes in dies destined for the
4406 final executable should be direct references--setting the parameter
4407 force_direct ensures this behavior. */
4410 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr,
4415 attr.dw_attr = attr_kind;
4416 attr.dw_attr_val.val_class = dw_val_class_addr;
4417 attr.dw_attr_val.v.val_addr = addr;
4418 if (dwarf_split_debug_info && !force_direct)
4419 attr.dw_attr_val.val_entry = add_addr_table_entry (addr, ate_kind_rtx);
4421 attr.dw_attr_val.val_entry = NULL;
4422 add_dwarf_attr (die, &attr);
4425 /* Get the RTX from to an address DIE attribute. */
4428 AT_addr (dw_attr_ref a)
4430 gcc_assert (a && AT_class (a) == dw_val_class_addr);
4431 return a->dw_attr_val.v.val_addr;
4434 /* Add a file attribute value to a DIE. */
4437 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
4438 struct dwarf_file_data *fd)
4442 attr.dw_attr = attr_kind;
4443 attr.dw_attr_val.val_class = dw_val_class_file;
4444 attr.dw_attr_val.val_entry = NULL;
4445 attr.dw_attr_val.v.val_file = fd;
4446 add_dwarf_attr (die, &attr);
4449 /* Get the dwarf_file_data from a file DIE attribute. */
4451 static inline struct dwarf_file_data *
4452 AT_file (dw_attr_ref a)
4454 gcc_assert (a && AT_class (a) == dw_val_class_file);
4455 return a->dw_attr_val.v.val_file;
4458 /* Add a vms delta attribute value to a DIE. */
4461 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
4462 const char *lbl1, const char *lbl2)
4466 attr.dw_attr = attr_kind;
4467 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
4468 attr.dw_attr_val.val_entry = NULL;
4469 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
4470 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
4471 add_dwarf_attr (die, &attr);
4474 /* Add a label identifier attribute value to a DIE. */
4477 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind,
4482 attr.dw_attr = attr_kind;
4483 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
4484 attr.dw_attr_val.val_entry = NULL;
4485 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
4486 if (dwarf_split_debug_info)
4487 attr.dw_attr_val.val_entry
4488 = add_addr_table_entry (attr.dw_attr_val.v.val_lbl_id,
4490 add_dwarf_attr (die, &attr);
4493 /* Add a section offset attribute value to a DIE, an offset into the
4494 debug_line section. */
4497 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4502 attr.dw_attr = attr_kind;
4503 attr.dw_attr_val.val_class = dw_val_class_lineptr;
4504 attr.dw_attr_val.val_entry = NULL;
4505 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4506 add_dwarf_attr (die, &attr);
4509 /* Add a section offset attribute value to a DIE, an offset into the
4510 debug_macinfo section. */
4513 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4518 attr.dw_attr = attr_kind;
4519 attr.dw_attr_val.val_class = dw_val_class_macptr;
4520 attr.dw_attr_val.val_entry = NULL;
4521 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4522 add_dwarf_attr (die, &attr);
4525 /* Add an offset attribute value to a DIE. */
4528 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
4529 unsigned HOST_WIDE_INT offset)
4533 attr.dw_attr = attr_kind;
4534 attr.dw_attr_val.val_class = dw_val_class_offset;
4535 attr.dw_attr_val.val_entry = NULL;
4536 attr.dw_attr_val.v.val_offset = offset;
4537 add_dwarf_attr (die, &attr);
4540 /* Add a range_list attribute value to a DIE. When using
4541 dwarf_split_debug_info, address attributes in dies destined for the
4542 final executable should be direct references--setting the parameter
4543 force_direct ensures this behavior. */
4545 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4546 #define RELOCATED_OFFSET (NULL)
4549 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
4550 long unsigned int offset, bool force_direct)
4554 attr.dw_attr = attr_kind;
4555 attr.dw_attr_val.val_class = dw_val_class_range_list;
4556 /* For the range_list attribute, use val_entry to store whether the
4557 offset should follow split-debug-info or normal semantics. This
4558 value is read in output_range_list_offset. */
4559 if (dwarf_split_debug_info && !force_direct)
4560 attr.dw_attr_val.val_entry = UNRELOCATED_OFFSET;
4562 attr.dw_attr_val.val_entry = RELOCATED_OFFSET;
4563 attr.dw_attr_val.v.val_offset = offset;
4564 add_dwarf_attr (die, &attr);
4567 /* Return the start label of a delta attribute. */
4569 static inline const char *
4570 AT_vms_delta1 (dw_attr_ref a)
4572 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4573 return a->dw_attr_val.v.val_vms_delta.lbl1;
4576 /* Return the end label of a delta attribute. */
4578 static inline const char *
4579 AT_vms_delta2 (dw_attr_ref a)
4581 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4582 return a->dw_attr_val.v.val_vms_delta.lbl2;
4585 static inline const char *
4586 AT_lbl (dw_attr_ref a)
4588 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
4589 || AT_class (a) == dw_val_class_lineptr
4590 || AT_class (a) == dw_val_class_macptr
4591 || AT_class (a) == dw_val_class_high_pc));
4592 return a->dw_attr_val.v.val_lbl_id;
4595 /* Get the attribute of type attr_kind. */
4598 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4602 dw_die_ref spec = NULL;
4607 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
4608 if (a->dw_attr == attr_kind)
4610 else if (a->dw_attr == DW_AT_specification
4611 || a->dw_attr == DW_AT_abstract_origin)
4615 return get_AT (spec, attr_kind);
4620 /* Returns the parent of the declaration of DIE. */
4623 get_die_parent (dw_die_ref die)
4630 if ((t = get_AT_ref (die, DW_AT_abstract_origin))
4631 || (t = get_AT_ref (die, DW_AT_specification)))
4634 return die->die_parent;
4637 /* Return the "low pc" attribute value, typically associated with a subprogram
4638 DIE. Return null if the "low pc" attribute is either not present, or if it
4639 cannot be represented as an assembler label identifier. */
4641 static inline const char *
4642 get_AT_low_pc (dw_die_ref die)
4644 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
4646 return a ? AT_lbl (a) : NULL;
4649 /* Return the "high pc" attribute value, typically associated with a subprogram
4650 DIE. Return null if the "high pc" attribute is either not present, or if it
4651 cannot be represented as an assembler label identifier. */
4653 static inline const char *
4654 get_AT_hi_pc (dw_die_ref die)
4656 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4658 return a ? AT_lbl (a) : NULL;
4661 /* Return the value of the string attribute designated by ATTR_KIND, or
4662 NULL if it is not present. */
4664 static inline const char *
4665 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
4667 dw_attr_ref a = get_AT (die, attr_kind);
4669 return a ? AT_string (a) : NULL;
4672 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4673 if it is not present. */
4676 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
4678 dw_attr_ref a = get_AT (die, attr_kind);
4680 return a ? AT_flag (a) : 0;
4683 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4684 if it is not present. */
4686 static inline unsigned
4687 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
4689 dw_attr_ref a = get_AT (die, attr_kind);
4691 return a ? AT_unsigned (a) : 0;
4694 static inline dw_die_ref
4695 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
4697 dw_attr_ref a = get_AT (die, attr_kind);
4699 return a ? AT_ref (a) : NULL;
4702 static inline struct dwarf_file_data *
4703 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
4705 dw_attr_ref a = get_AT (die, attr_kind);
4707 return a ? AT_file (a) : NULL;
4710 /* Return TRUE if the language is C++. */
4715 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4717 return (lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus
4718 || lang == DW_LANG_C_plus_plus_11 || lang == DW_LANG_C_plus_plus_14);
4721 /* Return TRUE if the language is Java. */
4726 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4728 return lang == DW_LANG_Java;
4731 /* Return TRUE if the language is Fortran. */
4736 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4738 return (lang == DW_LANG_Fortran77
4739 || lang == DW_LANG_Fortran90
4740 || lang == DW_LANG_Fortran95
4741 || lang == DW_LANG_Fortran03
4742 || lang == DW_LANG_Fortran08);
4745 /* Return TRUE if the language is Ada. */
4750 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4752 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
4755 /* Remove the specified attribute if present. */
4758 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4766 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
4767 if (a->dw_attr == attr_kind)
4769 if (AT_class (a) == dw_val_class_str)
4770 if (a->dw_attr_val.v.val_str->refcount)
4771 a->dw_attr_val.v.val_str->refcount--;
4773 /* vec::ordered_remove should help reduce the number of abbrevs
4775 die->die_attr->ordered_remove (ix);
4780 /* Remove CHILD from its parent. PREV must have the property that
4781 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4784 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
4786 gcc_assert (child->die_parent == prev->die_parent);
4787 gcc_assert (prev->die_sib == child);
4790 gcc_assert (child->die_parent->die_child == child);
4794 prev->die_sib = child->die_sib;
4795 if (child->die_parent->die_child == child)
4796 child->die_parent->die_child = prev;
4799 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4800 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4803 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
4805 dw_die_ref parent = old_child->die_parent;
4807 gcc_assert (parent == prev->die_parent);
4808 gcc_assert (prev->die_sib == old_child);
4810 new_child->die_parent = parent;
4811 if (prev == old_child)
4813 gcc_assert (parent->die_child == old_child);
4814 new_child->die_sib = new_child;
4818 prev->die_sib = new_child;
4819 new_child->die_sib = old_child->die_sib;
4821 if (old_child->die_parent->die_child == old_child)
4822 old_child->die_parent->die_child = new_child;
4825 /* Move all children from OLD_PARENT to NEW_PARENT. */
4828 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
4831 new_parent->die_child = old_parent->die_child;
4832 old_parent->die_child = NULL;
4833 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
4836 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4840 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
4846 dw_die_ref prev = c;
4848 while (c->die_tag == tag)
4850 remove_child_with_prev (c, prev);
4851 /* Might have removed every child. */
4852 if (c == c->die_sib)
4856 } while (c != die->die_child);
4859 /* Add a CHILD_DIE as the last child of DIE. */
4862 add_child_die (dw_die_ref die, dw_die_ref child_die)
4864 /* FIXME this should probably be an assert. */
4865 if (! die || ! child_die)
4867 gcc_assert (die != child_die);
4869 child_die->die_parent = die;
4872 child_die->die_sib = die->die_child->die_sib;
4873 die->die_child->die_sib = child_die;
4876 child_die->die_sib = child_die;
4877 die->die_child = child_die;
4880 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4881 is the specification, to the end of PARENT's list of children.
4882 This is done by removing and re-adding it. */
4885 splice_child_die (dw_die_ref parent, dw_die_ref child)
4889 /* We want the declaration DIE from inside the class, not the
4890 specification DIE at toplevel. */
4891 if (child->die_parent != parent)
4893 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
4899 gcc_assert (child->die_parent == parent
4900 || (child->die_parent
4901 == get_AT_ref (parent, DW_AT_specification)));
4903 for (p = child->die_parent->die_child; ; p = p->die_sib)
4904 if (p->die_sib == child)
4906 remove_child_with_prev (child, p);
4910 add_child_die (parent, child);
4913 /* Return a pointer to a newly created DIE node. */
4915 static inline dw_die_ref
4916 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
4918 dw_die_ref die = ggc_cleared_alloc<die_node> ();
4920 die->die_tag = tag_value;
4922 if (parent_die != NULL)
4923 add_child_die (parent_die, die);
4926 limbo_die_node *limbo_node;
4928 limbo_node = ggc_cleared_alloc<limbo_die_node> ();
4929 limbo_node->die = die;
4930 limbo_node->created_for = t;
4931 limbo_node->next = limbo_die_list;
4932 limbo_die_list = limbo_node;
4938 /* Return the DIE associated with the given type specifier. */
4940 static inline dw_die_ref
4941 lookup_type_die (tree type)
4943 return TYPE_SYMTAB_DIE (type);
4946 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
4947 anonymous type named by the typedef TYPE_DIE, return the DIE of the
4948 anonymous type instead the one of the naming typedef. */
4950 static inline dw_die_ref
4951 strip_naming_typedef (tree type, dw_die_ref type_die)
4954 && TREE_CODE (type) == RECORD_TYPE
4956 && type_die->die_tag == DW_TAG_typedef
4957 && is_naming_typedef_decl (TYPE_NAME (type)))
4958 type_die = get_AT_ref (type_die, DW_AT_type);
4962 /* Like lookup_type_die, but if type is an anonymous type named by a
4963 typedef[1], return the DIE of the anonymous type instead the one of
4964 the naming typedef. This is because in gen_typedef_die, we did
4965 equate the anonymous struct named by the typedef with the DIE of
4966 the naming typedef. So by default, lookup_type_die on an anonymous
4967 struct yields the DIE of the naming typedef.
4969 [1]: Read the comment of is_naming_typedef_decl to learn about what
4970 a naming typedef is. */
4972 static inline dw_die_ref
4973 lookup_type_die_strip_naming_typedef (tree type)
4975 dw_die_ref die = lookup_type_die (type);
4976 return strip_naming_typedef (type, die);
4979 /* Equate a DIE to a given type specifier. */
4982 equate_type_number_to_die (tree type, dw_die_ref type_die)
4984 TYPE_SYMTAB_DIE (type) = type_die;
4987 /* Returns a hash value for X (which really is a die_struct). */
4990 decl_die_hasher::hash (die_node *x)
4992 return (hashval_t) x->decl_id;
4995 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
4998 decl_die_hasher::equal (die_node *x, tree y)
5000 return (x->decl_id == DECL_UID (y));
5003 /* Return the DIE associated with a given declaration. */
5005 static inline dw_die_ref
5006 lookup_decl_die (tree decl)
5008 return decl_die_table->find_with_hash (decl, DECL_UID (decl));
5011 /* Returns a hash value for X (which really is a var_loc_list). */
5014 decl_loc_hasher::hash (var_loc_list *x)
5016 return (hashval_t) x->decl_id;
5019 /* Return nonzero if decl_id of var_loc_list X is the same as
5023 decl_loc_hasher::equal (var_loc_list *x, const_tree y)
5025 return (x->decl_id == DECL_UID (y));
5028 /* Return the var_loc list associated with a given declaration. */
5030 static inline var_loc_list *
5031 lookup_decl_loc (const_tree decl)
5033 if (!decl_loc_table)
5035 return decl_loc_table->find_with_hash (decl, DECL_UID (decl));
5038 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5041 dw_loc_list_hasher::hash (cached_dw_loc_list *x)
5043 return (hashval_t) x->decl_id;
5046 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5050 dw_loc_list_hasher::equal (cached_dw_loc_list *x, const_tree y)
5052 return (x->decl_id == DECL_UID (y));
5055 /* Equate a DIE to a particular declaration. */
5058 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5060 unsigned int decl_id = DECL_UID (decl);
5062 *decl_die_table->find_slot_with_hash (decl, decl_id, INSERT) = decl_die;
5063 decl_die->decl_id = decl_id;
5066 /* Return how many bits covers PIECE EXPR_LIST. */
5068 static HOST_WIDE_INT
5069 decl_piece_bitsize (rtx piece)
5071 int ret = (int) GET_MODE (piece);
5074 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
5075 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
5076 return INTVAL (XEXP (XEXP (piece, 0), 0));
5079 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5082 decl_piece_varloc_ptr (rtx piece)
5084 if ((int) GET_MODE (piece))
5085 return &XEXP (piece, 0);
5087 return &XEXP (XEXP (piece, 0), 1);
5090 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5091 Next is the chain of following piece nodes. */
5093 static rtx_expr_list *
5094 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
5096 if (bitsize > 0 && bitsize <= (int) MAX_MACHINE_MODE)
5097 return alloc_EXPR_LIST (bitsize, loc_note, next);
5099 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
5104 /* Return rtx that should be stored into loc field for
5105 LOC_NOTE and BITPOS/BITSIZE. */
5108 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
5109 HOST_WIDE_INT bitsize)
5113 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
5115 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
5120 /* This function either modifies location piece list *DEST in
5121 place (if SRC and INNER is NULL), or copies location piece list
5122 *SRC to *DEST while modifying it. Location BITPOS is modified
5123 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5124 not copied and if needed some padding around it is added.
5125 When modifying in place, DEST should point to EXPR_LIST where
5126 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5127 to the start of the whole list and INNER points to the EXPR_LIST
5128 where earlier pieces cover PIECE_BITPOS bits. */
5131 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
5132 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
5133 HOST_WIDE_INT bitsize, rtx loc_note)
5136 bool copy = inner != NULL;
5140 /* First copy all nodes preceding the current bitpos. */
5141 while (src != inner)
5143 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5144 decl_piece_bitsize (*src), NULL_RTX);
5145 dest = &XEXP (*dest, 1);
5146 src = &XEXP (*src, 1);
5149 /* Add padding if needed. */
5150 if (bitpos != piece_bitpos)
5152 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
5153 copy ? NULL_RTX : *dest);
5154 dest = &XEXP (*dest, 1);
5156 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
5159 /* A piece with correct bitpos and bitsize already exist,
5160 just update the location for it and return. */
5161 *decl_piece_varloc_ptr (*dest) = loc_note;
5164 /* Add the piece that changed. */
5165 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
5166 dest = &XEXP (*dest, 1);
5167 /* Skip over pieces that overlap it. */
5168 diff = bitpos - piece_bitpos + bitsize;
5171 while (diff > 0 && *src)
5174 diff -= decl_piece_bitsize (piece);
5176 src = &XEXP (piece, 1);
5179 *src = XEXP (piece, 1);
5180 free_EXPR_LIST_node (piece);
5183 /* Add padding if needed. */
5184 if (diff < 0 && *src)
5188 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
5189 dest = &XEXP (*dest, 1);
5193 /* Finally copy all nodes following it. */
5196 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5197 decl_piece_bitsize (*src), NULL_RTX);
5198 dest = &XEXP (*dest, 1);
5199 src = &XEXP (*src, 1);
5203 /* Add a variable location node to the linked list for DECL. */
5205 static struct var_loc_node *
5206 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label)
5208 unsigned int decl_id;
5210 struct var_loc_node *loc = NULL;
5211 HOST_WIDE_INT bitsize = -1, bitpos = -1;
5213 if (TREE_CODE (decl) == VAR_DECL
5214 && DECL_HAS_DEBUG_EXPR_P (decl))
5216 tree realdecl = DECL_DEBUG_EXPR (decl);
5217 if (handled_component_p (realdecl)
5218 || (TREE_CODE (realdecl) == MEM_REF
5219 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
5221 HOST_WIDE_INT maxsize;
5224 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize);
5225 if (!DECL_P (innerdecl)
5226 || DECL_IGNORED_P (innerdecl)
5227 || TREE_STATIC (innerdecl)
5229 || bitpos + bitsize > 256
5230 || bitsize != maxsize)
5236 decl_id = DECL_UID (decl);
5238 = decl_loc_table->find_slot_with_hash (decl, decl_id, INSERT);
5241 temp = ggc_cleared_alloc<var_loc_list> ();
5242 temp->decl_id = decl_id;
5248 /* For PARM_DECLs try to keep around the original incoming value,
5249 even if that means we'll emit a zero-range .debug_loc entry. */
5251 && temp->first == temp->last
5252 && TREE_CODE (decl) == PARM_DECL
5253 && NOTE_P (temp->first->loc)
5254 && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl
5255 && DECL_INCOMING_RTL (decl)
5256 && NOTE_VAR_LOCATION_LOC (temp->first->loc)
5257 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp->first->loc))
5258 == GET_CODE (DECL_INCOMING_RTL (decl))
5259 && prev_real_insn (temp->first->loc) == NULL_RTX
5261 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->first->loc),
5262 NOTE_VAR_LOCATION_LOC (loc_note))
5263 || (NOTE_VAR_LOCATION_STATUS (temp->first->loc)
5264 != NOTE_VAR_LOCATION_STATUS (loc_note))))
5266 loc = ggc_cleared_alloc<var_loc_node> ();
5267 temp->first->next = loc;
5269 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5271 else if (temp->last)
5273 struct var_loc_node *last = temp->last, *unused = NULL;
5274 rtx *piece_loc = NULL, last_loc_note;
5275 HOST_WIDE_INT piece_bitpos = 0;
5279 gcc_assert (last->next == NULL);
5281 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
5283 piece_loc = &last->loc;
5286 HOST_WIDE_INT cur_bitsize = decl_piece_bitsize (*piece_loc);
5287 if (piece_bitpos + cur_bitsize > bitpos)
5289 piece_bitpos += cur_bitsize;
5290 piece_loc = &XEXP (*piece_loc, 1);
5294 /* TEMP->LAST here is either pointer to the last but one or
5295 last element in the chained list, LAST is pointer to the
5297 if (label && strcmp (last->label, label) == 0)
5299 /* For SRA optimized variables if there weren't any real
5300 insns since last note, just modify the last node. */
5301 if (piece_loc != NULL)
5303 adjust_piece_list (piece_loc, NULL, NULL,
5304 bitpos, piece_bitpos, bitsize, loc_note);
5307 /* If the last note doesn't cover any instructions, remove it. */
5308 if (temp->last != last)
5310 temp->last->next = NULL;
5313 gcc_assert (strcmp (last->label, label) != 0);
5317 gcc_assert (temp->first == temp->last
5318 || (temp->first->next == temp->last
5319 && TREE_CODE (decl) == PARM_DECL));
5320 memset (temp->last, '\0', sizeof (*temp->last));
5321 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
5325 if (bitsize == -1 && NOTE_P (last->loc))
5326 last_loc_note = last->loc;
5327 else if (piece_loc != NULL
5328 && *piece_loc != NULL_RTX
5329 && piece_bitpos == bitpos
5330 && decl_piece_bitsize (*piece_loc) == bitsize)
5331 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
5333 last_loc_note = NULL_RTX;
5334 /* If the current location is the same as the end of the list,
5335 and either both or neither of the locations is uninitialized,
5336 we have nothing to do. */
5337 if (last_loc_note == NULL_RTX
5338 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
5339 NOTE_VAR_LOCATION_LOC (loc_note)))
5340 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5341 != NOTE_VAR_LOCATION_STATUS (loc_note))
5342 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5343 == VAR_INIT_STATUS_UNINITIALIZED)
5344 || (NOTE_VAR_LOCATION_STATUS (loc_note)
5345 == VAR_INIT_STATUS_UNINITIALIZED))))
5347 /* Add LOC to the end of list and update LAST. If the last
5348 element of the list has been removed above, reuse its
5349 memory for the new node, otherwise allocate a new one. */
5353 memset (loc, '\0', sizeof (*loc));
5356 loc = ggc_cleared_alloc<var_loc_node> ();
5357 if (bitsize == -1 || piece_loc == NULL)
5358 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5360 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
5361 bitpos, piece_bitpos, bitsize, loc_note);
5363 /* Ensure TEMP->LAST will point either to the new last but one
5364 element of the chain, or to the last element in it. */
5365 if (last != temp->last)
5373 loc = ggc_cleared_alloc<var_loc_node> ();
5376 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5381 /* Keep track of the number of spaces used to indent the
5382 output of the debugging routines that print the structure of
5383 the DIE internal representation. */
5384 static int print_indent;
5386 /* Indent the line the number of spaces given by print_indent. */
5389 print_spaces (FILE *outfile)
5391 fprintf (outfile, "%*s", print_indent, "");
5394 /* Print a type signature in hex. */
5397 print_signature (FILE *outfile, char *sig)
5401 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
5402 fprintf (outfile, "%02x", sig[i] & 0xff);
5405 static void print_loc_descr (dw_loc_descr_ref, FILE *);
5407 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
5408 RECURSE, output location descriptor operations. */
5411 print_dw_val (dw_val_node *val, bool recurse, FILE *outfile)
5413 switch (val->val_class)
5415 case dw_val_class_addr:
5416 fprintf (outfile, "address");
5418 case dw_val_class_offset:
5419 fprintf (outfile, "offset");
5421 case dw_val_class_loc:
5422 fprintf (outfile, "location descriptor");
5423 if (val->v.val_loc == NULL)
5424 fprintf (outfile, " -> <null>\n");
5427 fprintf (outfile, ":\n");
5429 print_loc_descr (val->v.val_loc, outfile);
5433 fprintf (outfile, " (%p)\n", (void *) val->v.val_loc);
5435 case dw_val_class_loc_list:
5436 fprintf (outfile, "location list -> label:%s",
5437 val->v.val_loc_list->ll_symbol);
5439 case dw_val_class_range_list:
5440 fprintf (outfile, "range list");
5442 case dw_val_class_const:
5443 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, val->v.val_int);
5445 case dw_val_class_unsigned_const:
5446 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, val->v.val_unsigned);
5448 case dw_val_class_const_double:
5449 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
5450 HOST_WIDE_INT_PRINT_UNSIGNED")",
5451 val->v.val_double.high,
5452 val->v.val_double.low);
5454 case dw_val_class_wide_int:
5456 int i = val->v.val_wide->get_len ();
5457 fprintf (outfile, "constant (");
5459 if (val->v.val_wide->elt (i - 1) == 0)
5460 fprintf (outfile, "0x");
5461 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX,
5462 val->v.val_wide->elt (--i));
5464 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX,
5465 val->v.val_wide->elt (i));
5466 fprintf (outfile, ")");
5469 case dw_val_class_vec:
5470 fprintf (outfile, "floating-point or vector constant");
5472 case dw_val_class_flag:
5473 fprintf (outfile, "%u", val->v.val_flag);
5475 case dw_val_class_die_ref:
5476 if (val->v.val_die_ref.die != NULL)
5478 dw_die_ref die = val->v.val_die_ref.die;
5480 if (die->comdat_type_p)
5482 fprintf (outfile, "die -> signature: ");
5483 print_signature (outfile,
5484 die->die_id.die_type_node->signature);
5486 else if (die->die_id.die_symbol)
5487 fprintf (outfile, "die -> label: %s", die->die_id.die_symbol);
5489 fprintf (outfile, "die -> %ld", die->die_offset);
5490 fprintf (outfile, " (%p)", (void *) die);
5493 fprintf (outfile, "die -> <null>");
5495 case dw_val_class_vms_delta:
5496 fprintf (outfile, "delta: @slotcount(%s-%s)",
5497 val->v.val_vms_delta.lbl2, val->v.val_vms_delta.lbl1);
5499 case dw_val_class_lbl_id:
5500 case dw_val_class_lineptr:
5501 case dw_val_class_macptr:
5502 case dw_val_class_high_pc:
5503 fprintf (outfile, "label: %s", val->v.val_lbl_id);
5505 case dw_val_class_str:
5506 if (val->v.val_str->str != NULL)
5507 fprintf (outfile, "\"%s\"", val->v.val_str->str);
5509 fprintf (outfile, "<null>");
5511 case dw_val_class_file:
5512 fprintf (outfile, "\"%s\" (%d)", val->v.val_file->filename,
5513 val->v.val_file->emitted_number);
5515 case dw_val_class_data8:
5519 for (i = 0; i < 8; i++)
5520 fprintf (outfile, "%02x", val->v.val_data8[i]);
5528 /* Likewise, for a DIE attribute. */
5531 print_attribute (dw_attr_ref a, bool recurse, FILE *outfile)
5533 print_dw_val (&a->dw_attr_val, recurse, outfile);
5537 /* Print the list of operands in the LOC location description to OUTFILE. This
5538 routine is a debugging aid only. */
5541 print_loc_descr (dw_loc_descr_ref loc, FILE *outfile)
5543 dw_loc_descr_ref l = loc;
5547 print_spaces (outfile);
5548 fprintf (outfile, "<null>\n");
5552 for (l = loc; l != NULL; l = l->dw_loc_next)
5554 print_spaces (outfile);
5555 fprintf (outfile, "(%p) %s",
5557 dwarf_stack_op_name (l->dw_loc_opc));
5558 if (l->dw_loc_oprnd1.val_class != dw_val_class_none)
5560 fprintf (outfile, " ");
5561 print_dw_val (&l->dw_loc_oprnd1, false, outfile);
5563 if (l->dw_loc_oprnd2.val_class != dw_val_class_none)
5565 fprintf (outfile, ", ");
5566 print_dw_val (&l->dw_loc_oprnd2, false, outfile);
5568 fprintf (outfile, "\n");
5572 /* Print the information associated with a given DIE, and its children.
5573 This routine is a debugging aid only. */
5576 print_die (dw_die_ref die, FILE *outfile)
5582 print_spaces (outfile);
5583 fprintf (outfile, "DIE %4ld: %s (%p)\n",
5584 die->die_offset, dwarf_tag_name (die->die_tag),
5586 print_spaces (outfile);
5587 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5588 fprintf (outfile, " offset: %ld", die->die_offset);
5589 fprintf (outfile, " mark: %d\n", die->die_mark);
5591 if (die->comdat_type_p)
5593 print_spaces (outfile);
5594 fprintf (outfile, " signature: ");
5595 print_signature (outfile, die->die_id.die_type_node->signature);
5596 fprintf (outfile, "\n");
5599 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5601 print_spaces (outfile);
5602 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5604 print_attribute (a, true, outfile);
5605 fprintf (outfile, "\n");
5608 if (die->die_child != NULL)
5611 FOR_EACH_CHILD (die, c, print_die (c, outfile));
5614 if (print_indent == 0)
5615 fprintf (outfile, "\n");
5618 /* Print the list of operations in the LOC location description. */
5621 debug_dwarf_loc_descr (dw_loc_descr_ref loc)
5623 print_loc_descr (loc, stderr);
5626 /* Print the information collected for a given DIE. */
5629 debug_dwarf_die (dw_die_ref die)
5631 print_die (die, stderr);
5635 debug (die_struct &ref)
5637 print_die (&ref, stderr);
5641 debug (die_struct *ptr)
5646 fprintf (stderr, "<nil>\n");
5650 /* Print all DWARF information collected for the compilation unit.
5651 This routine is a debugging aid only. */
5657 print_die (comp_unit_die (), stderr);
5660 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5661 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5662 DIE that marks the start of the DIEs for this include file. */
5665 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5667 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5668 dw_die_ref new_unit = gen_compile_unit_die (filename);
5670 new_unit->die_sib = old_unit;
5674 /* Close an include-file CU and reopen the enclosing one. */
5677 pop_compile_unit (dw_die_ref old_unit)
5679 dw_die_ref new_unit = old_unit->die_sib;
5681 old_unit->die_sib = NULL;
5685 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5686 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), 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)
5695 inchash::hash hstate;
5698 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
5700 hash_loc_operands (loc, hstate);
5701 hash = hstate.end();
5705 /* Calculate the checksum of an attribute. */
5708 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5710 dw_loc_descr_ref loc;
5713 CHECKSUM (at->dw_attr);
5715 /* We don't care that this was compiled with a different compiler
5716 snapshot; if the output is the same, that's what matters. */
5717 if (at->dw_attr == DW_AT_producer)
5720 switch (AT_class (at))
5722 case dw_val_class_const:
5723 CHECKSUM (at->dw_attr_val.v.val_int);
5725 case dw_val_class_unsigned_const:
5726 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5728 case dw_val_class_const_double:
5729 CHECKSUM (at->dw_attr_val.v.val_double);
5731 case dw_val_class_wide_int:
5732 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
5733 get_full_len (*at->dw_attr_val.v.val_wide)
5734 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
5736 case dw_val_class_vec:
5737 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
5738 (at->dw_attr_val.v.val_vec.length
5739 * at->dw_attr_val.v.val_vec.elt_size));
5741 case dw_val_class_flag:
5742 CHECKSUM (at->dw_attr_val.v.val_flag);
5744 case dw_val_class_str:
5745 CHECKSUM_STRING (AT_string (at));
5748 case dw_val_class_addr:
5750 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5751 CHECKSUM_STRING (XSTR (r, 0));
5754 case dw_val_class_offset:
5755 CHECKSUM (at->dw_attr_val.v.val_offset);
5758 case dw_val_class_loc:
5759 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5760 loc_checksum (loc, ctx);
5763 case dw_val_class_die_ref:
5764 die_checksum (AT_ref (at), ctx, mark);
5767 case dw_val_class_fde_ref:
5768 case dw_val_class_vms_delta:
5769 case dw_val_class_lbl_id:
5770 case dw_val_class_lineptr:
5771 case dw_val_class_macptr:
5772 case dw_val_class_high_pc:
5775 case dw_val_class_file:
5776 CHECKSUM_STRING (AT_file (at)->filename);
5779 case dw_val_class_data8:
5780 CHECKSUM (at->dw_attr_val.v.val_data8);
5788 /* Calculate the checksum of a DIE. */
5791 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5797 /* To avoid infinite recursion. */
5800 CHECKSUM (die->die_mark);
5803 die->die_mark = ++(*mark);
5805 CHECKSUM (die->die_tag);
5807 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5808 attr_checksum (a, ctx, mark);
5810 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
5814 #undef CHECKSUM_BLOCK
5815 #undef CHECKSUM_STRING
5817 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5818 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5819 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5820 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5821 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5822 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5823 #define CHECKSUM_ATTR(FOO) \
5824 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5826 /* Calculate the checksum of a number in signed LEB128 format. */
5829 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
5836 byte = (value & 0x7f);
5838 more = !((value == 0 && (byte & 0x40) == 0)
5839 || (value == -1 && (byte & 0x40) != 0));
5848 /* Calculate the checksum of a number in unsigned LEB128 format. */
5851 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
5855 unsigned char byte = (value & 0x7f);
5858 /* More bytes to follow. */
5866 /* Checksum the context of the DIE. This adds the names of any
5867 surrounding namespaces or structures to the checksum. */
5870 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
5874 int tag = die->die_tag;
5876 if (tag != DW_TAG_namespace
5877 && tag != DW_TAG_structure_type
5878 && tag != DW_TAG_class_type)
5881 name = get_AT_string (die, DW_AT_name);
5883 spec = get_AT_ref (die, DW_AT_specification);
5887 if (die->die_parent != NULL)
5888 checksum_die_context (die->die_parent, ctx);
5890 CHECKSUM_ULEB128 ('C');
5891 CHECKSUM_ULEB128 (tag);
5893 CHECKSUM_STRING (name);
5896 /* Calculate the checksum of a location expression. */
5899 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5901 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5902 were emitted as a DW_FORM_sdata instead of a location expression. */
5903 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
5905 CHECKSUM_ULEB128 (DW_FORM_sdata);
5906 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
5910 /* Otherwise, just checksum the raw location expression. */
5913 inchash::hash hstate;
5916 CHECKSUM_ULEB128 (loc->dtprel);
5917 CHECKSUM_ULEB128 (loc->dw_loc_opc);
5918 hash_loc_operands (loc, hstate);
5919 hash = hstate.end ();
5921 loc = loc->dw_loc_next;
5925 /* Calculate the checksum of an attribute. */
5928 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
5929 struct md5_ctx *ctx, int *mark)
5931 dw_loc_descr_ref loc;
5934 if (AT_class (at) == dw_val_class_die_ref)
5936 dw_die_ref target_die = AT_ref (at);
5938 /* For pointer and reference types, we checksum only the (qualified)
5939 name of the target type (if there is a name). For friend entries,
5940 we checksum only the (qualified) name of the target type or function.
5941 This allows the checksum to remain the same whether the target type
5942 is complete or not. */
5943 if ((at->dw_attr == DW_AT_type
5944 && (tag == DW_TAG_pointer_type
5945 || tag == DW_TAG_reference_type
5946 || tag == DW_TAG_rvalue_reference_type
5947 || tag == DW_TAG_ptr_to_member_type))
5948 || (at->dw_attr == DW_AT_friend
5949 && tag == DW_TAG_friend))
5951 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
5953 if (name_attr != NULL)
5955 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5959 CHECKSUM_ULEB128 ('N');
5960 CHECKSUM_ULEB128 (at->dw_attr);
5961 if (decl->die_parent != NULL)
5962 checksum_die_context (decl->die_parent, ctx);
5963 CHECKSUM_ULEB128 ('E');
5964 CHECKSUM_STRING (AT_string (name_attr));
5969 /* For all other references to another DIE, we check to see if the
5970 target DIE has already been visited. If it has, we emit a
5971 backward reference; if not, we descend recursively. */
5972 if (target_die->die_mark > 0)
5974 CHECKSUM_ULEB128 ('R');
5975 CHECKSUM_ULEB128 (at->dw_attr);
5976 CHECKSUM_ULEB128 (target_die->die_mark);
5980 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5984 target_die->die_mark = ++(*mark);
5985 CHECKSUM_ULEB128 ('T');
5986 CHECKSUM_ULEB128 (at->dw_attr);
5987 if (decl->die_parent != NULL)
5988 checksum_die_context (decl->die_parent, ctx);
5989 die_checksum_ordered (target_die, ctx, mark);
5994 CHECKSUM_ULEB128 ('A');
5995 CHECKSUM_ULEB128 (at->dw_attr);
5997 switch (AT_class (at))
5999 case dw_val_class_const:
6000 CHECKSUM_ULEB128 (DW_FORM_sdata);
6001 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
6004 case dw_val_class_unsigned_const:
6005 CHECKSUM_ULEB128 (DW_FORM_sdata);
6006 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
6009 case dw_val_class_const_double:
6010 CHECKSUM_ULEB128 (DW_FORM_block);
6011 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
6012 CHECKSUM (at->dw_attr_val.v.val_double);
6015 case dw_val_class_wide_int:
6016 CHECKSUM_ULEB128 (DW_FORM_block);
6017 CHECKSUM_ULEB128 (get_full_len (*at->dw_attr_val.v.val_wide)
6018 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
6019 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
6020 get_full_len (*at->dw_attr_val.v.val_wide)
6021 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
6024 case dw_val_class_vec:
6025 CHECKSUM_ULEB128 (DW_FORM_block);
6026 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_vec.length
6027 * at->dw_attr_val.v.val_vec.elt_size);
6028 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
6029 (at->dw_attr_val.v.val_vec.length
6030 * at->dw_attr_val.v.val_vec.elt_size));
6033 case dw_val_class_flag:
6034 CHECKSUM_ULEB128 (DW_FORM_flag);
6035 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
6038 case dw_val_class_str:
6039 CHECKSUM_ULEB128 (DW_FORM_string);
6040 CHECKSUM_STRING (AT_string (at));
6043 case dw_val_class_addr:
6045 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6046 CHECKSUM_ULEB128 (DW_FORM_string);
6047 CHECKSUM_STRING (XSTR (r, 0));
6050 case dw_val_class_offset:
6051 CHECKSUM_ULEB128 (DW_FORM_sdata);
6052 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
6055 case dw_val_class_loc:
6056 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6057 loc_checksum_ordered (loc, ctx);
6060 case dw_val_class_fde_ref:
6061 case dw_val_class_lbl_id:
6062 case dw_val_class_lineptr:
6063 case dw_val_class_macptr:
6064 case dw_val_class_high_pc:
6067 case dw_val_class_file:
6068 CHECKSUM_ULEB128 (DW_FORM_string);
6069 CHECKSUM_STRING (AT_file (at)->filename);
6072 case dw_val_class_data8:
6073 CHECKSUM (at->dw_attr_val.v.val_data8);
6081 struct checksum_attributes
6083 dw_attr_ref at_name;
6084 dw_attr_ref at_type;
6085 dw_attr_ref at_friend;
6086 dw_attr_ref at_accessibility;
6087 dw_attr_ref at_address_class;
6088 dw_attr_ref at_allocated;
6089 dw_attr_ref at_artificial;
6090 dw_attr_ref at_associated;
6091 dw_attr_ref at_binary_scale;
6092 dw_attr_ref at_bit_offset;
6093 dw_attr_ref at_bit_size;
6094 dw_attr_ref at_bit_stride;
6095 dw_attr_ref at_byte_size;
6096 dw_attr_ref at_byte_stride;
6097 dw_attr_ref at_const_value;
6098 dw_attr_ref at_containing_type;
6099 dw_attr_ref at_count;
6100 dw_attr_ref at_data_location;
6101 dw_attr_ref at_data_member_location;
6102 dw_attr_ref at_decimal_scale;
6103 dw_attr_ref at_decimal_sign;
6104 dw_attr_ref at_default_value;
6105 dw_attr_ref at_digit_count;
6106 dw_attr_ref at_discr;
6107 dw_attr_ref at_discr_list;
6108 dw_attr_ref at_discr_value;
6109 dw_attr_ref at_encoding;
6110 dw_attr_ref at_endianity;
6111 dw_attr_ref at_explicit;
6112 dw_attr_ref at_is_optional;
6113 dw_attr_ref at_location;
6114 dw_attr_ref at_lower_bound;
6115 dw_attr_ref at_mutable;
6116 dw_attr_ref at_ordering;
6117 dw_attr_ref at_picture_string;
6118 dw_attr_ref at_prototyped;
6119 dw_attr_ref at_small;
6120 dw_attr_ref at_segment;
6121 dw_attr_ref at_string_length;
6122 dw_attr_ref at_threads_scaled;
6123 dw_attr_ref at_upper_bound;
6124 dw_attr_ref at_use_location;
6125 dw_attr_ref at_use_UTF8;
6126 dw_attr_ref at_variable_parameter;
6127 dw_attr_ref at_virtuality;
6128 dw_attr_ref at_visibility;
6129 dw_attr_ref at_vtable_elem_location;
6132 /* Collect the attributes that we will want to use for the checksum. */
6135 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
6140 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
6151 attrs->at_friend = a;
6153 case DW_AT_accessibility:
6154 attrs->at_accessibility = a;
6156 case DW_AT_address_class:
6157 attrs->at_address_class = a;
6159 case DW_AT_allocated:
6160 attrs->at_allocated = a;
6162 case DW_AT_artificial:
6163 attrs->at_artificial = a;
6165 case DW_AT_associated:
6166 attrs->at_associated = a;
6168 case DW_AT_binary_scale:
6169 attrs->at_binary_scale = a;
6171 case DW_AT_bit_offset:
6172 attrs->at_bit_offset = a;
6174 case DW_AT_bit_size:
6175 attrs->at_bit_size = a;
6177 case DW_AT_bit_stride:
6178 attrs->at_bit_stride = a;
6180 case DW_AT_byte_size:
6181 attrs->at_byte_size = a;
6183 case DW_AT_byte_stride:
6184 attrs->at_byte_stride = a;
6186 case DW_AT_const_value:
6187 attrs->at_const_value = a;
6189 case DW_AT_containing_type:
6190 attrs->at_containing_type = a;
6193 attrs->at_count = a;
6195 case DW_AT_data_location:
6196 attrs->at_data_location = a;
6198 case DW_AT_data_member_location:
6199 attrs->at_data_member_location = a;
6201 case DW_AT_decimal_scale:
6202 attrs->at_decimal_scale = a;
6204 case DW_AT_decimal_sign:
6205 attrs->at_decimal_sign = a;
6207 case DW_AT_default_value:
6208 attrs->at_default_value = a;
6210 case DW_AT_digit_count:
6211 attrs->at_digit_count = a;
6214 attrs->at_discr = a;
6216 case DW_AT_discr_list:
6217 attrs->at_discr_list = a;
6219 case DW_AT_discr_value:
6220 attrs->at_discr_value = a;
6222 case DW_AT_encoding:
6223 attrs->at_encoding = a;
6225 case DW_AT_endianity:
6226 attrs->at_endianity = a;
6228 case DW_AT_explicit:
6229 attrs->at_explicit = a;
6231 case DW_AT_is_optional:
6232 attrs->at_is_optional = a;
6234 case DW_AT_location:
6235 attrs->at_location = a;
6237 case DW_AT_lower_bound:
6238 attrs->at_lower_bound = a;
6241 attrs->at_mutable = a;
6243 case DW_AT_ordering:
6244 attrs->at_ordering = a;
6246 case DW_AT_picture_string:
6247 attrs->at_picture_string = a;
6249 case DW_AT_prototyped:
6250 attrs->at_prototyped = a;
6253 attrs->at_small = a;
6256 attrs->at_segment = a;
6258 case DW_AT_string_length:
6259 attrs->at_string_length = a;
6261 case DW_AT_threads_scaled:
6262 attrs->at_threads_scaled = a;
6264 case DW_AT_upper_bound:
6265 attrs->at_upper_bound = a;
6267 case DW_AT_use_location:
6268 attrs->at_use_location = a;
6270 case DW_AT_use_UTF8:
6271 attrs->at_use_UTF8 = a;
6273 case DW_AT_variable_parameter:
6274 attrs->at_variable_parameter = a;
6276 case DW_AT_virtuality:
6277 attrs->at_virtuality = a;
6279 case DW_AT_visibility:
6280 attrs->at_visibility = a;
6282 case DW_AT_vtable_elem_location:
6283 attrs->at_vtable_elem_location = a;
6291 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6294 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6298 struct checksum_attributes attrs;
6300 CHECKSUM_ULEB128 ('D');
6301 CHECKSUM_ULEB128 (die->die_tag);
6303 memset (&attrs, 0, sizeof (attrs));
6305 decl = get_AT_ref (die, DW_AT_specification);
6307 collect_checksum_attributes (&attrs, decl);
6308 collect_checksum_attributes (&attrs, die);
6310 CHECKSUM_ATTR (attrs.at_name);
6311 CHECKSUM_ATTR (attrs.at_accessibility);
6312 CHECKSUM_ATTR (attrs.at_address_class);
6313 CHECKSUM_ATTR (attrs.at_allocated);
6314 CHECKSUM_ATTR (attrs.at_artificial);
6315 CHECKSUM_ATTR (attrs.at_associated);
6316 CHECKSUM_ATTR (attrs.at_binary_scale);
6317 CHECKSUM_ATTR (attrs.at_bit_offset);
6318 CHECKSUM_ATTR (attrs.at_bit_size);
6319 CHECKSUM_ATTR (attrs.at_bit_stride);
6320 CHECKSUM_ATTR (attrs.at_byte_size);
6321 CHECKSUM_ATTR (attrs.at_byte_stride);
6322 CHECKSUM_ATTR (attrs.at_const_value);
6323 CHECKSUM_ATTR (attrs.at_containing_type);
6324 CHECKSUM_ATTR (attrs.at_count);
6325 CHECKSUM_ATTR (attrs.at_data_location);
6326 CHECKSUM_ATTR (attrs.at_data_member_location);
6327 CHECKSUM_ATTR (attrs.at_decimal_scale);
6328 CHECKSUM_ATTR (attrs.at_decimal_sign);
6329 CHECKSUM_ATTR (attrs.at_default_value);
6330 CHECKSUM_ATTR (attrs.at_digit_count);
6331 CHECKSUM_ATTR (attrs.at_discr);
6332 CHECKSUM_ATTR (attrs.at_discr_list);
6333 CHECKSUM_ATTR (attrs.at_discr_value);
6334 CHECKSUM_ATTR (attrs.at_encoding);
6335 CHECKSUM_ATTR (attrs.at_endianity);
6336 CHECKSUM_ATTR (attrs.at_explicit);
6337 CHECKSUM_ATTR (attrs.at_is_optional);
6338 CHECKSUM_ATTR (attrs.at_location);
6339 CHECKSUM_ATTR (attrs.at_lower_bound);
6340 CHECKSUM_ATTR (attrs.at_mutable);
6341 CHECKSUM_ATTR (attrs.at_ordering);
6342 CHECKSUM_ATTR (attrs.at_picture_string);
6343 CHECKSUM_ATTR (attrs.at_prototyped);
6344 CHECKSUM_ATTR (attrs.at_small);
6345 CHECKSUM_ATTR (attrs.at_segment);
6346 CHECKSUM_ATTR (attrs.at_string_length);
6347 CHECKSUM_ATTR (attrs.at_threads_scaled);
6348 CHECKSUM_ATTR (attrs.at_upper_bound);
6349 CHECKSUM_ATTR (attrs.at_use_location);
6350 CHECKSUM_ATTR (attrs.at_use_UTF8);
6351 CHECKSUM_ATTR (attrs.at_variable_parameter);
6352 CHECKSUM_ATTR (attrs.at_virtuality);
6353 CHECKSUM_ATTR (attrs.at_visibility);
6354 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
6355 CHECKSUM_ATTR (attrs.at_type);
6356 CHECKSUM_ATTR (attrs.at_friend);
6358 /* Checksum the child DIEs. */
6361 dw_attr_ref name_attr;
6364 name_attr = get_AT (c, DW_AT_name);
6365 if (is_template_instantiation (c))
6367 /* Ignore instantiations of member type and function templates. */
6369 else if (name_attr != NULL
6370 && (is_type_die (c) || c->die_tag == DW_TAG_subprogram))
6372 /* Use a shallow checksum for named nested types and member
6374 CHECKSUM_ULEB128 ('S');
6375 CHECKSUM_ULEB128 (c->die_tag);
6376 CHECKSUM_STRING (AT_string (name_attr));
6380 /* Use a deep checksum for other children. */
6381 /* Mark this DIE so it gets processed when unmarking. */
6382 if (c->die_mark == 0)
6384 die_checksum_ordered (c, ctx, mark);
6386 } while (c != die->die_child);
6388 CHECKSUM_ULEB128 (0);
6391 /* Add a type name and tag to a hash. */
6393 die_odr_checksum (int tag, const char *name, md5_ctx *ctx)
6395 CHECKSUM_ULEB128 (tag);
6396 CHECKSUM_STRING (name);
6400 #undef CHECKSUM_STRING
6401 #undef CHECKSUM_ATTR
6402 #undef CHECKSUM_LEB128
6403 #undef CHECKSUM_ULEB128
6405 /* Generate the type signature for DIE. This is computed by generating an
6406 MD5 checksum over the DIE's tag, its relevant attributes, and its
6407 children. Attributes that are references to other DIEs are processed
6408 by recursion, using the MARK field to prevent infinite recursion.
6409 If the DIE is nested inside a namespace or another type, we also
6410 need to include that context in the signature. The lower 64 bits
6411 of the resulting MD5 checksum comprise the signature. */
6414 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
6418 unsigned char checksum[16];
6423 name = get_AT_string (die, DW_AT_name);
6424 decl = get_AT_ref (die, DW_AT_specification);
6425 parent = get_die_parent (die);
6427 /* First, compute a signature for just the type name (and its surrounding
6428 context, if any. This is stored in the type unit DIE for link-time
6429 ODR (one-definition rule) checking. */
6431 if (is_cxx () && name != NULL)
6433 md5_init_ctx (&ctx);
6435 /* Checksum the names of surrounding namespaces and structures. */
6437 checksum_die_context (parent, &ctx);
6439 /* Checksum the current DIE. */
6440 die_odr_checksum (die->die_tag, name, &ctx);
6441 md5_finish_ctx (&ctx, checksum);
6443 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
6446 /* Next, compute the complete type signature. */
6448 md5_init_ctx (&ctx);
6450 die->die_mark = mark;
6452 /* Checksum the names of surrounding namespaces and structures. */
6454 checksum_die_context (parent, &ctx);
6456 /* Checksum the DIE and its children. */
6457 die_checksum_ordered (die, &ctx, &mark);
6458 unmark_all_dies (die);
6459 md5_finish_ctx (&ctx, checksum);
6461 /* Store the signature in the type node and link the type DIE and the
6462 type node together. */
6463 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
6464 DWARF_TYPE_SIGNATURE_SIZE);
6465 die->comdat_type_p = true;
6466 die->die_id.die_type_node = type_node;
6467 type_node->type_die = die;
6469 /* If the DIE is a specification, link its declaration to the type node
6473 decl->comdat_type_p = true;
6474 decl->die_id.die_type_node = type_node;
6478 /* Do the location expressions look same? */
6480 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6482 return loc1->dw_loc_opc == loc2->dw_loc_opc
6483 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6484 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6487 /* Do the values look the same? */
6489 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6491 dw_loc_descr_ref loc1, loc2;
6494 if (v1->val_class != v2->val_class)
6497 switch (v1->val_class)
6499 case dw_val_class_const:
6500 return v1->v.val_int == v2->v.val_int;
6501 case dw_val_class_unsigned_const:
6502 return v1->v.val_unsigned == v2->v.val_unsigned;
6503 case dw_val_class_const_double:
6504 return v1->v.val_double.high == v2->v.val_double.high
6505 && v1->v.val_double.low == v2->v.val_double.low;
6506 case dw_val_class_wide_int:
6507 return *v1->v.val_wide == *v2->v.val_wide;
6508 case dw_val_class_vec:
6509 if (v1->v.val_vec.length != v2->v.val_vec.length
6510 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6512 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6513 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6516 case dw_val_class_flag:
6517 return v1->v.val_flag == v2->v.val_flag;
6518 case dw_val_class_str:
6519 return !strcmp (v1->v.val_str->str, v2->v.val_str->str);
6521 case dw_val_class_addr:
6522 r1 = v1->v.val_addr;
6523 r2 = v2->v.val_addr;
6524 if (GET_CODE (r1) != GET_CODE (r2))
6526 return !rtx_equal_p (r1, r2);
6528 case dw_val_class_offset:
6529 return v1->v.val_offset == v2->v.val_offset;
6531 case dw_val_class_loc:
6532 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6534 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6535 if (!same_loc_p (loc1, loc2, mark))
6537 return !loc1 && !loc2;
6539 case dw_val_class_die_ref:
6540 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6542 case dw_val_class_fde_ref:
6543 case dw_val_class_vms_delta:
6544 case dw_val_class_lbl_id:
6545 case dw_val_class_lineptr:
6546 case dw_val_class_macptr:
6547 case dw_val_class_high_pc:
6550 case dw_val_class_file:
6551 return v1->v.val_file == v2->v.val_file;
6553 case dw_val_class_data8:
6554 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
6561 /* Do the attributes look the same? */
6564 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6566 if (at1->dw_attr != at2->dw_attr)
6569 /* We don't care that this was compiled with a different compiler
6570 snapshot; if the output is the same, that's what matters. */
6571 if (at1->dw_attr == DW_AT_producer)
6574 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6577 /* Do the dies look the same? */
6580 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6586 /* To avoid infinite recursion. */
6588 return die1->die_mark == die2->die_mark;
6589 die1->die_mark = die2->die_mark = ++(*mark);
6591 if (die1->die_tag != die2->die_tag)
6594 if (vec_safe_length (die1->die_attr) != vec_safe_length (die2->die_attr))
6597 FOR_EACH_VEC_SAFE_ELT (die1->die_attr, ix, a1)
6598 if (!same_attr_p (a1, &(*die2->die_attr)[ix], mark))
6601 c1 = die1->die_child;
6602 c2 = die2->die_child;
6611 if (!same_die_p (c1, c2, mark))
6615 if (c1 == die1->die_child)
6617 if (c2 == die2->die_child)
6627 /* Do the dies look the same? Wrapper around same_die_p. */
6630 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6633 int ret = same_die_p (die1, die2, &mark);
6635 unmark_all_dies (die1);
6636 unmark_all_dies (die2);
6641 /* The prefix to attach to symbols on DIEs in the current comdat debug
6643 static const char *comdat_symbol_id;
6645 /* The index of the current symbol within the current comdat CU. */
6646 static unsigned int comdat_symbol_number;
6648 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6649 children, and set comdat_symbol_id accordingly. */
6652 compute_section_prefix (dw_die_ref unit_die)
6654 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6655 const char *base = die_name ? lbasename (die_name) : "anonymous";
6656 char *name = XALLOCAVEC (char, strlen (base) + 64);
6659 unsigned char checksum[16];
6662 /* Compute the checksum of the DIE, then append part of it as hex digits to
6663 the name filename of the unit. */
6665 md5_init_ctx (&ctx);
6667 die_checksum (unit_die, &ctx, &mark);
6668 unmark_all_dies (unit_die);
6669 md5_finish_ctx (&ctx, checksum);
6671 sprintf (name, "%s.", base);
6672 clean_symbol_name (name);
6674 p = name + strlen (name);
6675 for (i = 0; i < 4; i++)
6677 sprintf (p, "%.2x", checksum[i]);
6681 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
6682 comdat_symbol_number = 0;
6685 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6688 is_type_die (dw_die_ref die)
6690 switch (die->die_tag)
6692 case DW_TAG_array_type:
6693 case DW_TAG_class_type:
6694 case DW_TAG_interface_type:
6695 case DW_TAG_enumeration_type:
6696 case DW_TAG_pointer_type:
6697 case DW_TAG_reference_type:
6698 case DW_TAG_rvalue_reference_type:
6699 case DW_TAG_string_type:
6700 case DW_TAG_structure_type:
6701 case DW_TAG_subroutine_type:
6702 case DW_TAG_union_type:
6703 case DW_TAG_ptr_to_member_type:
6704 case DW_TAG_set_type:
6705 case DW_TAG_subrange_type:
6706 case DW_TAG_base_type:
6707 case DW_TAG_const_type:
6708 case DW_TAG_file_type:
6709 case DW_TAG_packed_type:
6710 case DW_TAG_volatile_type:
6711 case DW_TAG_typedef:
6718 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6719 Basically, we want to choose the bits that are likely to be shared between
6720 compilations (types) and leave out the bits that are specific to individual
6721 compilations (functions). */
6724 is_comdat_die (dw_die_ref c)
6726 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6727 we do for stabs. The advantage is a greater likelihood of sharing between
6728 objects that don't include headers in the same order (and therefore would
6729 put the base types in a different comdat). jason 8/28/00 */
6731 if (c->die_tag == DW_TAG_base_type)
6734 if (c->die_tag == DW_TAG_pointer_type
6735 || c->die_tag == DW_TAG_reference_type
6736 || c->die_tag == DW_TAG_rvalue_reference_type
6737 || c->die_tag == DW_TAG_const_type
6738 || c->die_tag == DW_TAG_volatile_type)
6740 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6742 return t ? is_comdat_die (t) : 0;
6745 return is_type_die (c);
6748 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6749 compilation unit. */
6752 is_symbol_die (dw_die_ref c)
6754 return (is_type_die (c)
6755 || is_declaration_die (c)
6756 || c->die_tag == DW_TAG_namespace
6757 || c->die_tag == DW_TAG_module);
6760 /* Returns true iff C is a compile-unit DIE. */
6763 is_cu_die (dw_die_ref c)
6765 return c && c->die_tag == DW_TAG_compile_unit;
6768 /* Returns true iff C is a unit DIE of some sort. */
6771 is_unit_die (dw_die_ref c)
6773 return c && (c->die_tag == DW_TAG_compile_unit
6774 || c->die_tag == DW_TAG_partial_unit
6775 || c->die_tag == DW_TAG_type_unit);
6778 /* Returns true iff C is a namespace DIE. */
6781 is_namespace_die (dw_die_ref c)
6783 return c && c->die_tag == DW_TAG_namespace;
6786 /* Returns true iff C is a class or structure DIE. */
6789 is_class_die (dw_die_ref c)
6791 return c && (c->die_tag == DW_TAG_class_type
6792 || c->die_tag == DW_TAG_structure_type);
6795 /* Return non-zero if this DIE is a template parameter. */
6798 is_template_parameter (dw_die_ref die)
6800 switch (die->die_tag)
6802 case DW_TAG_template_type_param:
6803 case DW_TAG_template_value_param:
6804 case DW_TAG_GNU_template_template_param:
6805 case DW_TAG_GNU_template_parameter_pack:
6812 /* Return non-zero if this DIE represents a template instantiation. */
6815 is_template_instantiation (dw_die_ref die)
6819 if (!is_type_die (die) && die->die_tag != DW_TAG_subprogram)
6821 FOR_EACH_CHILD (die, c, if (is_template_parameter (c)) return true);
6826 gen_internal_sym (const char *prefix)
6830 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6831 return xstrdup (buf);
6834 /* Assign symbols to all worthy DIEs under DIE. */
6837 assign_symbol_names (dw_die_ref die)
6841 if (is_symbol_die (die) && !die->comdat_type_p)
6843 if (comdat_symbol_id)
6845 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
6847 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6848 comdat_symbol_id, comdat_symbol_number++);
6849 die->die_id.die_symbol = xstrdup (p);
6852 die->die_id.die_symbol = gen_internal_sym ("LDIE");
6855 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6858 struct cu_hash_table_entry
6861 unsigned min_comdat_num, max_comdat_num;
6862 struct cu_hash_table_entry *next;
6865 /* Helpers to manipulate hash table of CUs. */
6867 struct cu_hash_table_entry_hasher
6869 typedef cu_hash_table_entry *value_type;
6870 typedef die_struct *compare_type;
6871 static inline hashval_t hash (const cu_hash_table_entry *);
6872 static inline bool equal (const cu_hash_table_entry *, const die_struct *);
6873 static inline void remove (cu_hash_table_entry *);
6877 cu_hash_table_entry_hasher::hash (const cu_hash_table_entry *entry)
6879 return htab_hash_string (entry->cu->die_id.die_symbol);
6883 cu_hash_table_entry_hasher::equal (const cu_hash_table_entry *entry1,
6884 const die_struct *entry2)
6886 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
6890 cu_hash_table_entry_hasher::remove (cu_hash_table_entry *entry)
6892 struct cu_hash_table_entry *next;
6902 typedef hash_table<cu_hash_table_entry_hasher> cu_hash_type;
6904 /* Check whether we have already seen this CU and set up SYM_NUM
6907 check_duplicate_cu (dw_die_ref cu, cu_hash_type *htable, unsigned int *sym_num)
6909 struct cu_hash_table_entry dummy;
6910 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6912 dummy.max_comdat_num = 0;
6914 slot = htable->find_slot_with_hash (cu,
6915 htab_hash_string (cu->die_id.die_symbol),
6919 for (; entry; last = entry, entry = entry->next)
6921 if (same_die_p_wrap (cu, entry->cu))
6927 *sym_num = entry->min_comdat_num;
6931 entry = XCNEW (struct cu_hash_table_entry);
6933 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6934 entry->next = *slot;
6940 /* Record SYM_NUM to record of CU in HTABLE. */
6942 record_comdat_symbol_number (dw_die_ref cu, cu_hash_type *htable,
6943 unsigned int sym_num)
6945 struct cu_hash_table_entry **slot, *entry;
6947 slot = htable->find_slot_with_hash (cu,
6948 htab_hash_string (cu->die_id.die_symbol),
6952 entry->max_comdat_num = sym_num;
6955 /* Traverse the DIE (which is always comp_unit_die), and set up
6956 additional compilation units for each of the include files we see
6957 bracketed by BINCL/EINCL. */
6960 break_out_includes (dw_die_ref die)
6963 dw_die_ref unit = NULL;
6964 limbo_die_node *node, **pnode;
6968 dw_die_ref prev = c;
6970 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6971 || (unit && is_comdat_die (c)))
6973 dw_die_ref next = c->die_sib;
6975 /* This DIE is for a secondary CU; remove it from the main one. */
6976 remove_child_with_prev (c, prev);
6978 if (c->die_tag == DW_TAG_GNU_BINCL)
6979 unit = push_new_compile_unit (unit, c);
6980 else if (c->die_tag == DW_TAG_GNU_EINCL)
6981 unit = pop_compile_unit (unit);
6983 add_child_die (unit, c);
6985 if (c == die->die_child)
6988 } while (c != die->die_child);
6991 /* We can only use this in debugging, since the frontend doesn't check
6992 to make sure that we leave every include file we enter. */
6996 assign_symbol_names (die);
6997 cu_hash_type cu_hash_table (10);
6998 for (node = limbo_die_list, pnode = &limbo_die_list;
7004 compute_section_prefix (node->die);
7005 is_dupl = check_duplicate_cu (node->die, &cu_hash_table,
7006 &comdat_symbol_number);
7007 assign_symbol_names (node->die);
7009 *pnode = node->next;
7012 pnode = &node->next;
7013 record_comdat_symbol_number (node->die, &cu_hash_table,
7014 comdat_symbol_number);
7019 /* Return non-zero if this DIE is a declaration. */
7022 is_declaration_die (dw_die_ref die)
7027 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7028 if (a->dw_attr == DW_AT_declaration)
7034 /* Return non-zero if this DIE is nested inside a subprogram. */
7037 is_nested_in_subprogram (dw_die_ref die)
7039 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
7043 return local_scope_p (decl);
7046 /* Return non-zero if this DIE contains a defining declaration of a
7050 contains_subprogram_definition (dw_die_ref die)
7054 if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die))
7056 FOR_EACH_CHILD (die, c, if (contains_subprogram_definition (c)) return 1);
7060 /* Return non-zero if this is a type DIE that should be moved to a
7061 COMDAT .debug_types section. */
7064 should_move_die_to_comdat (dw_die_ref die)
7066 switch (die->die_tag)
7068 case DW_TAG_class_type:
7069 case DW_TAG_structure_type:
7070 case DW_TAG_enumeration_type:
7071 case DW_TAG_union_type:
7072 /* Don't move declarations, inlined instances, types nested in a
7073 subprogram, or types that contain subprogram definitions. */
7074 if (is_declaration_die (die)
7075 || get_AT (die, DW_AT_abstract_origin)
7076 || is_nested_in_subprogram (die)
7077 || contains_subprogram_definition (die))
7080 case DW_TAG_array_type:
7081 case DW_TAG_interface_type:
7082 case DW_TAG_pointer_type:
7083 case DW_TAG_reference_type:
7084 case DW_TAG_rvalue_reference_type:
7085 case DW_TAG_string_type:
7086 case DW_TAG_subroutine_type:
7087 case DW_TAG_ptr_to_member_type:
7088 case DW_TAG_set_type:
7089 case DW_TAG_subrange_type:
7090 case DW_TAG_base_type:
7091 case DW_TAG_const_type:
7092 case DW_TAG_file_type:
7093 case DW_TAG_packed_type:
7094 case DW_TAG_volatile_type:
7095 case DW_TAG_typedef:
7101 /* Make a clone of DIE. */
7104 clone_die (dw_die_ref die)
7110 clone = ggc_cleared_alloc<die_node> ();
7111 clone->die_tag = die->die_tag;
7113 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7114 add_dwarf_attr (clone, a);
7119 /* Make a clone of the tree rooted at DIE. */
7122 clone_tree (dw_die_ref die)
7125 dw_die_ref clone = clone_die (die);
7127 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree (c)));
7132 /* Make a clone of DIE as a declaration. */
7135 clone_as_declaration (dw_die_ref die)
7142 /* If the DIE is already a declaration, just clone it. */
7143 if (is_declaration_die (die))
7144 return clone_die (die);
7146 /* If the DIE is a specification, just clone its declaration DIE. */
7147 decl = get_AT_ref (die, DW_AT_specification);
7150 clone = clone_die (decl);
7151 if (die->comdat_type_p)
7152 add_AT_die_ref (clone, DW_AT_signature, die);
7156 clone = ggc_cleared_alloc<die_node> ();
7157 clone->die_tag = die->die_tag;
7159 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7161 /* We don't want to copy over all attributes.
7162 For example we don't want DW_AT_byte_size because otherwise we will no
7163 longer have a declaration and GDB will treat it as a definition. */
7167 case DW_AT_abstract_origin:
7168 case DW_AT_artificial:
7169 case DW_AT_containing_type:
7170 case DW_AT_external:
7173 case DW_AT_virtuality:
7174 case DW_AT_linkage_name:
7175 case DW_AT_MIPS_linkage_name:
7176 add_dwarf_attr (clone, a);
7178 case DW_AT_byte_size:
7184 if (die->comdat_type_p)
7185 add_AT_die_ref (clone, DW_AT_signature, die);
7187 add_AT_flag (clone, DW_AT_declaration, 1);
7192 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7194 struct decl_table_entry
7200 /* Helpers to manipulate hash table of copied declarations. */
7202 /* Hashtable helpers. */
7204 struct decl_table_entry_hasher : typed_free_remove <decl_table_entry>
7206 typedef decl_table_entry *value_type;
7207 typedef die_struct *compare_type;
7208 static inline hashval_t hash (const decl_table_entry *);
7209 static inline bool equal (const decl_table_entry *, const die_struct *);
7213 decl_table_entry_hasher::hash (const decl_table_entry *entry)
7215 return htab_hash_pointer (entry->orig);
7219 decl_table_entry_hasher::equal (const decl_table_entry *entry1,
7220 const die_struct *entry2)
7222 return entry1->orig == entry2;
7225 typedef hash_table<decl_table_entry_hasher> decl_hash_type;
7227 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7228 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7229 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7230 to check if the ancestor has already been copied into UNIT. */
7233 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die,
7234 decl_hash_type *decl_table)
7236 dw_die_ref parent = die->die_parent;
7237 dw_die_ref new_parent = unit;
7239 decl_table_entry **slot = NULL;
7240 struct decl_table_entry *entry = NULL;
7244 /* Check if the entry has already been copied to UNIT. */
7245 slot = decl_table->find_slot_with_hash (die, htab_hash_pointer (die),
7247 if (*slot != HTAB_EMPTY_ENTRY)
7253 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7254 entry = XCNEW (struct decl_table_entry);
7262 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
7265 if (!is_unit_die (parent))
7266 new_parent = copy_ancestor_tree (unit, parent, decl_table);
7269 copy = clone_as_declaration (die);
7270 add_child_die (new_parent, copy);
7274 /* Record the pointer to the copy. */
7280 /* Copy the declaration context to the new type unit DIE. This includes
7281 any surrounding namespace or type declarations. If the DIE has an
7282 AT_specification attribute, it also includes attributes and children
7283 attached to the specification, and returns a pointer to the original
7284 parent of the declaration DIE. Returns NULL otherwise. */
7287 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
7290 dw_die_ref new_decl;
7291 dw_die_ref orig_parent = NULL;
7293 decl = get_AT_ref (die, DW_AT_specification);
7302 /* The original DIE will be changed to a declaration, and must
7303 be moved to be a child of the original declaration DIE. */
7304 orig_parent = decl->die_parent;
7306 /* Copy the type node pointer from the new DIE to the original
7307 declaration DIE so we can forward references later. */
7308 decl->comdat_type_p = true;
7309 decl->die_id.die_type_node = die->die_id.die_type_node;
7311 remove_AT (die, DW_AT_specification);
7313 FOR_EACH_VEC_SAFE_ELT (decl->die_attr, ix, a)
7315 if (a->dw_attr != DW_AT_name
7316 && a->dw_attr != DW_AT_declaration
7317 && a->dw_attr != DW_AT_external)
7318 add_dwarf_attr (die, a);
7321 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree (c)));
7324 if (decl->die_parent != NULL
7325 && !is_unit_die (decl->die_parent))
7327 new_decl = copy_ancestor_tree (unit, decl, NULL);
7328 if (new_decl != NULL)
7330 remove_AT (new_decl, DW_AT_signature);
7331 add_AT_specification (die, new_decl);
7338 /* Generate the skeleton ancestor tree for the given NODE, then clone
7339 the DIE and add the clone into the tree. */
7342 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
7344 if (node->new_die != NULL)
7347 node->new_die = clone_as_declaration (node->old_die);
7349 if (node->parent != NULL)
7351 generate_skeleton_ancestor_tree (node->parent);
7352 add_child_die (node->parent->new_die, node->new_die);
7356 /* Generate a skeleton tree of DIEs containing any declarations that are
7357 found in the original tree. We traverse the tree looking for declaration
7358 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7361 generate_skeleton_bottom_up (skeleton_chain_node *parent)
7363 skeleton_chain_node node;
7366 dw_die_ref prev = NULL;
7367 dw_die_ref next = NULL;
7369 node.parent = parent;
7371 first = c = parent->old_die->die_child;
7375 if (prev == NULL || prev->die_sib == c)
7378 next = (c == first ? NULL : c->die_sib);
7380 node.new_die = NULL;
7381 if (is_declaration_die (c))
7383 if (is_template_instantiation (c))
7385 /* Instantiated templates do not need to be cloned into the
7386 type unit. Just move the DIE and its children back to
7387 the skeleton tree (in the main CU). */
7388 remove_child_with_prev (c, prev);
7389 add_child_die (parent->new_die, c);
7394 /* Clone the existing DIE, move the original to the skeleton
7395 tree (which is in the main CU), and put the clone, with
7396 all the original's children, where the original came from
7397 (which is about to be moved to the type unit). */
7398 dw_die_ref clone = clone_die (c);
7399 move_all_children (c, clone);
7401 /* If the original has a DW_AT_object_pointer attribute,
7402 it would now point to a child DIE just moved to the
7403 cloned tree, so we need to remove that attribute from
7405 remove_AT (c, DW_AT_object_pointer);
7407 replace_child (c, clone, prev);
7408 generate_skeleton_ancestor_tree (parent);
7409 add_child_die (parent->new_die, c);
7414 generate_skeleton_bottom_up (&node);
7415 } while (next != NULL);
7418 /* Wrapper function for generate_skeleton_bottom_up. */
7421 generate_skeleton (dw_die_ref die)
7423 skeleton_chain_node node;
7426 node.new_die = NULL;
7429 /* If this type definition is nested inside another type,
7430 and is not an instantiation of a template, always leave
7431 at least a declaration in its place. */
7432 if (die->die_parent != NULL
7433 && is_type_die (die->die_parent)
7434 && !is_template_instantiation (die))
7435 node.new_die = clone_as_declaration (die);
7437 generate_skeleton_bottom_up (&node);
7438 return node.new_die;
7441 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7442 declaration. The original DIE is moved to a new compile unit so that
7443 existing references to it follow it to the new location. If any of the
7444 original DIE's descendants is a declaration, we need to replace the
7445 original DIE with a skeleton tree and move the declarations back into the
7449 remove_child_or_replace_with_skeleton (dw_die_ref unit, dw_die_ref child,
7452 dw_die_ref skeleton, orig_parent;
7454 /* Copy the declaration context to the type unit DIE. If the returned
7455 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7457 orig_parent = copy_declaration_context (unit, child);
7459 skeleton = generate_skeleton (child);
7460 if (skeleton == NULL)
7461 remove_child_with_prev (child, prev);
7464 skeleton->comdat_type_p = true;
7465 skeleton->die_id.die_type_node = child->die_id.die_type_node;
7467 /* If the original DIE was a specification, we need to put
7468 the skeleton under the parent DIE of the declaration.
7469 This leaves the original declaration in the tree, but
7470 it will be pruned later since there are no longer any
7471 references to it. */
7472 if (orig_parent != NULL)
7474 remove_child_with_prev (child, prev);
7475 add_child_die (orig_parent, skeleton);
7478 replace_child (child, skeleton, prev);
7484 /* Traverse the DIE and set up additional .debug_types sections for each
7485 type worthy of being placed in a COMDAT section. */
7488 break_out_comdat_types (dw_die_ref die)
7492 dw_die_ref prev = NULL;
7493 dw_die_ref next = NULL;
7494 dw_die_ref unit = NULL;
7496 first = c = die->die_child;
7500 if (prev == NULL || prev->die_sib == c)
7503 next = (c == first ? NULL : c->die_sib);
7504 if (should_move_die_to_comdat (c))
7506 dw_die_ref replacement;
7507 comdat_type_node_ref type_node;
7509 /* Break out nested types into their own type units. */
7510 break_out_comdat_types (c);
7512 /* Create a new type unit DIE as the root for the new tree, and
7513 add it to the list of comdat types. */
7514 unit = new_die (DW_TAG_type_unit, NULL, NULL);
7515 add_AT_unsigned (unit, DW_AT_language,
7516 get_AT_unsigned (comp_unit_die (), DW_AT_language));
7517 type_node = ggc_cleared_alloc<comdat_type_node> ();
7518 type_node->root_die = unit;
7519 type_node->next = comdat_type_list;
7520 comdat_type_list = type_node;
7522 /* Generate the type signature. */
7523 generate_type_signature (c, type_node);
7525 /* Copy the declaration context, attributes, and children of the
7526 declaration into the new type unit DIE, then remove this DIE
7527 from the main CU (or replace it with a skeleton if necessary). */
7528 replacement = remove_child_or_replace_with_skeleton (unit, c, prev);
7529 type_node->skeleton_die = replacement;
7531 /* Add the DIE to the new compunit. */
7532 add_child_die (unit, c);
7534 if (replacement != NULL)
7537 else if (c->die_tag == DW_TAG_namespace
7538 || c->die_tag == DW_TAG_class_type
7539 || c->die_tag == DW_TAG_structure_type
7540 || c->die_tag == DW_TAG_union_type)
7542 /* Look for nested types that can be broken out. */
7543 break_out_comdat_types (c);
7545 } while (next != NULL);
7548 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
7549 Enter all the cloned children into the hash table decl_table. */
7552 clone_tree_partial (dw_die_ref die, decl_hash_type *decl_table)
7556 struct decl_table_entry *entry;
7557 decl_table_entry **slot;
7559 if (die->die_tag == DW_TAG_subprogram)
7560 clone = clone_as_declaration (die);
7562 clone = clone_die (die);
7564 slot = decl_table->find_slot_with_hash (die,
7565 htab_hash_pointer (die), INSERT);
7567 /* Assert that DIE isn't in the hash table yet. If it would be there
7568 before, the ancestors would be necessarily there as well, therefore
7569 clone_tree_partial wouldn't be called. */
7570 gcc_assert (*slot == HTAB_EMPTY_ENTRY);
7572 entry = XCNEW (struct decl_table_entry);
7574 entry->copy = clone;
7577 if (die->die_tag != DW_TAG_subprogram)
7578 FOR_EACH_CHILD (die, c,
7579 add_child_die (clone, clone_tree_partial (c, decl_table)));
7584 /* Walk the DIE and its children, looking for references to incomplete
7585 or trivial types that are unmarked (i.e., that are not in the current
7589 copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type *decl_table)
7595 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7597 if (AT_class (a) == dw_val_class_die_ref)
7599 dw_die_ref targ = AT_ref (a);
7600 decl_table_entry **slot;
7601 struct decl_table_entry *entry;
7603 if (targ->die_mark != 0 || targ->comdat_type_p)
7606 slot = decl_table->find_slot_with_hash (targ,
7607 htab_hash_pointer (targ),
7610 if (*slot != HTAB_EMPTY_ENTRY)
7612 /* TARG has already been copied, so we just need to
7613 modify the reference to point to the copy. */
7615 a->dw_attr_val.v.val_die_ref.die = entry->copy;
7619 dw_die_ref parent = unit;
7620 dw_die_ref copy = clone_die (targ);
7622 /* Record in DECL_TABLE that TARG has been copied.
7623 Need to do this now, before the recursive call,
7624 because DECL_TABLE may be expanded and SLOT
7625 would no longer be a valid pointer. */
7626 entry = XCNEW (struct decl_table_entry);
7631 /* If TARG is not a declaration DIE, we need to copy its
7633 if (!is_declaration_die (targ))
7637 add_child_die (copy,
7638 clone_tree_partial (c, decl_table)));
7641 /* Make sure the cloned tree is marked as part of the
7645 /* If TARG has surrounding context, copy its ancestor tree
7646 into the new type unit. */
7647 if (targ->die_parent != NULL
7648 && !is_unit_die (targ->die_parent))
7649 parent = copy_ancestor_tree (unit, targ->die_parent,
7652 add_child_die (parent, copy);
7653 a->dw_attr_val.v.val_die_ref.die = copy;
7655 /* Make sure the newly-copied DIE is walked. If it was
7656 installed in a previously-added context, it won't
7657 get visited otherwise. */
7660 /* Find the highest point of the newly-added tree,
7661 mark each node along the way, and walk from there. */
7662 parent->die_mark = 1;
7663 while (parent->die_parent
7664 && parent->die_parent->die_mark == 0)
7666 parent = parent->die_parent;
7667 parent->die_mark = 1;
7669 copy_decls_walk (unit, parent, decl_table);
7675 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
7678 /* Copy declarations for "unworthy" types into the new comdat section.
7679 Incomplete types, modified types, and certain other types aren't broken
7680 out into comdat sections of their own, so they don't have a signature,
7681 and we need to copy the declaration into the same section so that we
7682 don't have an external reference. */
7685 copy_decls_for_unworthy_types (dw_die_ref unit)
7688 decl_hash_type decl_table (10);
7689 copy_decls_walk (unit, unit, &decl_table);
7693 /* Traverse the DIE and add a sibling attribute if it may have the
7694 effect of speeding up access to siblings. To save some space,
7695 avoid generating sibling attributes for DIE's without children. */
7698 add_sibling_attributes (dw_die_ref die)
7702 if (! die->die_child)
7705 if (die->die_parent && die != die->die_parent->die_child)
7706 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7708 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7711 /* Output all location lists for the DIE and its children. */
7714 output_location_lists (dw_die_ref die)
7720 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7721 if (AT_class (a) == dw_val_class_loc_list)
7722 output_loc_list (AT_loc_list (a));
7724 FOR_EACH_CHILD (die, c, output_location_lists (c));
7727 /* We want to limit the number of external references, because they are
7728 larger than local references: a relocation takes multiple words, and
7729 even a sig8 reference is always eight bytes, whereas a local reference
7730 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
7731 So if we encounter multiple external references to the same type DIE, we
7732 make a local typedef stub for it and redirect all references there.
7734 This is the element of the hash table for keeping track of these
7744 /* Hashtable helpers. */
7746 struct external_ref_hasher : typed_free_remove <external_ref>
7748 typedef external_ref *value_type;
7749 typedef external_ref *compare_type;
7750 static inline hashval_t hash (const external_ref *);
7751 static inline bool equal (const external_ref *, const external_ref *);
7755 external_ref_hasher::hash (const external_ref *r)
7757 dw_die_ref die = r->type;
7760 /* We can't use the address of the DIE for hashing, because
7761 that will make the order of the stub DIEs non-deterministic. */
7762 if (! die->comdat_type_p)
7763 /* We have a symbol; use it to compute a hash. */
7764 h = htab_hash_string (die->die_id.die_symbol);
7767 /* We have a type signature; use a subset of the bits as the hash.
7768 The 8-byte signature is at least as large as hashval_t. */
7769 comdat_type_node_ref type_node = die->die_id.die_type_node;
7770 memcpy (&h, type_node->signature, sizeof (h));
7776 external_ref_hasher::equal (const external_ref *r1, const external_ref *r2)
7778 return r1->type == r2->type;
7781 typedef hash_table<external_ref_hasher> external_ref_hash_type;
7783 /* Return a pointer to the external_ref for references to DIE. */
7785 static struct external_ref *
7786 lookup_external_ref (external_ref_hash_type *map, dw_die_ref die)
7788 struct external_ref ref, *ref_p;
7789 external_ref **slot;
7792 slot = map->find_slot (&ref, INSERT);
7793 if (*slot != HTAB_EMPTY_ENTRY)
7796 ref_p = XCNEW (struct external_ref);
7802 /* Subroutine of optimize_external_refs, below.
7804 If we see a type skeleton, record it as our stub. If we see external
7805 references, remember how many we've seen. */
7808 optimize_external_refs_1 (dw_die_ref die, external_ref_hash_type *map)
7813 struct external_ref *ref_p;
7815 if (is_type_die (die)
7816 && (c = get_AT_ref (die, DW_AT_signature)))
7818 /* This is a local skeleton; use it for local references. */
7819 ref_p = lookup_external_ref (map, c);
7823 /* Scan the DIE references, and remember any that refer to DIEs from
7824 other CUs (i.e. those which are not marked). */
7825 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7826 if (AT_class (a) == dw_val_class_die_ref
7827 && (c = AT_ref (a))->die_mark == 0
7830 ref_p = lookup_external_ref (map, c);
7834 FOR_EACH_CHILD (die, c, optimize_external_refs_1 (c, map));
7837 /* htab_traverse callback function for optimize_external_refs, below. SLOT
7838 points to an external_ref, DATA is the CU we're processing. If we don't
7839 already have a local stub, and we have multiple refs, build a stub. */
7842 dwarf2_build_local_stub (external_ref **slot, dw_die_ref data)
7844 struct external_ref *ref_p = *slot;
7846 if (ref_p->stub == NULL && ref_p->n_refs > 1 && !dwarf_strict)
7848 /* We have multiple references to this type, so build a small stub.
7849 Both of these forms are a bit dodgy from the perspective of the
7850 DWARF standard, since technically they should have names. */
7851 dw_die_ref cu = data;
7852 dw_die_ref type = ref_p->type;
7853 dw_die_ref stub = NULL;
7855 if (type->comdat_type_p)
7857 /* If we refer to this type via sig8, use AT_signature. */
7858 stub = new_die (type->die_tag, cu, NULL_TREE);
7859 add_AT_die_ref (stub, DW_AT_signature, type);
7863 /* Otherwise, use a typedef with no name. */
7864 stub = new_die (DW_TAG_typedef, cu, NULL_TREE);
7865 add_AT_die_ref (stub, DW_AT_type, type);
7874 /* DIE is a unit; look through all the DIE references to see if there are
7875 any external references to types, and if so, create local stubs for
7876 them which will be applied in build_abbrev_table. This is useful because
7877 references to local DIEs are smaller. */
7879 static external_ref_hash_type *
7880 optimize_external_refs (dw_die_ref die)
7882 external_ref_hash_type *map = new external_ref_hash_type (10);
7883 optimize_external_refs_1 (die, map);
7884 map->traverse <dw_die_ref, dwarf2_build_local_stub> (die);
7888 /* The format of each DIE (and its attribute value pairs) is encoded in an
7889 abbreviation table. This routine builds the abbreviation table and assigns
7890 a unique abbreviation id for each abbreviation entry. The children of each
7891 die are visited recursively. */
7894 build_abbrev_table (dw_die_ref die, external_ref_hash_type *extern_map)
7896 unsigned long abbrev_id;
7897 unsigned int n_alloc;
7902 /* Scan the DIE references, and replace any that refer to
7903 DIEs from other CUs (i.e. those which are not marked) with
7904 the local stubs we built in optimize_external_refs. */
7905 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7906 if (AT_class (a) == dw_val_class_die_ref
7907 && (c = AT_ref (a))->die_mark == 0)
7909 struct external_ref *ref_p;
7910 gcc_assert (AT_ref (a)->comdat_type_p || AT_ref (a)->die_id.die_symbol);
7912 ref_p = lookup_external_ref (extern_map, c);
7913 if (ref_p->stub && ref_p->stub != die)
7914 change_AT_die_ref (a, ref_p->stub);
7916 /* We aren't changing this reference, so mark it external. */
7917 set_AT_ref_external (a, 1);
7920 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7922 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7923 dw_attr_ref die_a, abbrev_a;
7927 if (abbrev->die_tag != die->die_tag)
7929 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7932 if (vec_safe_length (abbrev->die_attr) != vec_safe_length (die->die_attr))
7935 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, die_a)
7937 abbrev_a = &(*abbrev->die_attr)[ix];
7938 if ((abbrev_a->dw_attr != die_a->dw_attr)
7939 || (value_format (abbrev_a) != value_format (die_a)))
7949 if (abbrev_id >= abbrev_die_table_in_use)
7951 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7953 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7954 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7957 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7958 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7959 abbrev_die_table_allocated = n_alloc;
7962 ++abbrev_die_table_in_use;
7963 abbrev_die_table[abbrev_id] = die;
7966 die->die_abbrev = abbrev_id;
7967 FOR_EACH_CHILD (die, c, build_abbrev_table (c, extern_map));
7970 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7973 constant_size (unsigned HOST_WIDE_INT value)
7980 log = floor_log2 (value);
7983 log = 1 << (floor_log2 (log) + 1);
7988 /* Return the size of a DIE as it is represented in the
7989 .debug_info section. */
7991 static unsigned long
7992 size_of_die (dw_die_ref die)
7994 unsigned long size = 0;
7997 enum dwarf_form form;
7999 size += size_of_uleb128 (die->die_abbrev);
8000 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8002 switch (AT_class (a))
8004 case dw_val_class_addr:
8005 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8007 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8008 size += size_of_uleb128 (AT_index (a));
8011 size += DWARF2_ADDR_SIZE;
8013 case dw_val_class_offset:
8014 size += DWARF_OFFSET_SIZE;
8016 case dw_val_class_loc:
8018 unsigned long lsize = size_of_locs (AT_loc (a));
8021 if (dwarf_version >= 4)
8022 size += size_of_uleb128 (lsize);
8024 size += constant_size (lsize);
8028 case dw_val_class_loc_list:
8029 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8031 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8032 size += size_of_uleb128 (AT_index (a));
8035 size += DWARF_OFFSET_SIZE;
8037 case dw_val_class_range_list:
8038 size += DWARF_OFFSET_SIZE;
8040 case dw_val_class_const:
8041 size += size_of_sleb128 (AT_int (a));
8043 case dw_val_class_unsigned_const:
8045 int csize = constant_size (AT_unsigned (a));
8046 if (dwarf_version == 3
8047 && a->dw_attr == DW_AT_data_member_location
8049 size += size_of_uleb128 (AT_unsigned (a));
8054 case dw_val_class_const_double:
8055 size += HOST_BITS_PER_DOUBLE_INT / HOST_BITS_PER_CHAR;
8056 if (HOST_BITS_PER_WIDE_INT >= 64)
8059 case dw_val_class_wide_int:
8060 size += (get_full_len (*a->dw_attr_val.v.val_wide)
8061 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
8062 if (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT
8066 case dw_val_class_vec:
8067 size += constant_size (a->dw_attr_val.v.val_vec.length
8068 * a->dw_attr_val.v.val_vec.elt_size)
8069 + a->dw_attr_val.v.val_vec.length
8070 * a->dw_attr_val.v.val_vec.elt_size; /* block */
8072 case dw_val_class_flag:
8073 if (dwarf_version >= 4)
8074 /* Currently all add_AT_flag calls pass in 1 as last argument,
8075 so DW_FORM_flag_present can be used. If that ever changes,
8076 we'll need to use DW_FORM_flag and have some optimization
8077 in build_abbrev_table that will change those to
8078 DW_FORM_flag_present if it is set to 1 in all DIEs using
8079 the same abbrev entry. */
8080 gcc_assert (a->dw_attr_val.v.val_flag == 1);
8084 case dw_val_class_die_ref:
8085 if (AT_ref_external (a))
8087 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
8088 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
8089 is sized by target address length, whereas in DWARF3
8090 it's always sized as an offset. */
8091 if (use_debug_types)
8092 size += DWARF_TYPE_SIGNATURE_SIZE;
8093 else if (dwarf_version == 2)
8094 size += DWARF2_ADDR_SIZE;
8096 size += DWARF_OFFSET_SIZE;
8099 size += DWARF_OFFSET_SIZE;
8101 case dw_val_class_fde_ref:
8102 size += DWARF_OFFSET_SIZE;
8104 case dw_val_class_lbl_id:
8105 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8107 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8108 size += size_of_uleb128 (AT_index (a));
8111 size += DWARF2_ADDR_SIZE;
8113 case dw_val_class_lineptr:
8114 case dw_val_class_macptr:
8115 size += DWARF_OFFSET_SIZE;
8117 case dw_val_class_str:
8118 form = AT_string_form (a);
8119 if (form == DW_FORM_strp)
8120 size += DWARF_OFFSET_SIZE;
8121 else if (form == DW_FORM_GNU_str_index)
8122 size += size_of_uleb128 (AT_index (a));
8124 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
8126 case dw_val_class_file:
8127 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
8129 case dw_val_class_data8:
8132 case dw_val_class_vms_delta:
8133 size += DWARF_OFFSET_SIZE;
8135 case dw_val_class_high_pc:
8136 size += DWARF2_ADDR_SIZE;
8146 /* Size the debugging information associated with a given DIE. Visits the
8147 DIE's children recursively. Updates the global variable next_die_offset, on
8148 each time through. Uses the current value of next_die_offset to update the
8149 die_offset field in each DIE. */
8152 calc_die_sizes (dw_die_ref die)
8156 gcc_assert (die->die_offset == 0
8157 || (unsigned long int) die->die_offset == next_die_offset);
8158 die->die_offset = next_die_offset;
8159 next_die_offset += size_of_die (die);
8161 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
8163 if (die->die_child != NULL)
8164 /* Count the null byte used to terminate sibling lists. */
8165 next_die_offset += 1;
8168 /* Size just the base type children at the start of the CU.
8169 This is needed because build_abbrev needs to size locs
8170 and sizing of type based stack ops needs to know die_offset
8171 values for the base types. */
8174 calc_base_type_die_sizes (void)
8176 unsigned long die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8178 dw_die_ref base_type;
8179 #if ENABLE_ASSERT_CHECKING
8180 dw_die_ref prev = comp_unit_die ()->die_child;
8183 die_offset += size_of_die (comp_unit_die ());
8184 for (i = 0; base_types.iterate (i, &base_type); i++)
8186 #if ENABLE_ASSERT_CHECKING
8187 gcc_assert (base_type->die_offset == 0
8188 && prev->die_sib == base_type
8189 && base_type->die_child == NULL
8190 && base_type->die_abbrev);
8193 base_type->die_offset = die_offset;
8194 die_offset += size_of_die (base_type);
8198 /* Set the marks for a die and its children. We do this so
8199 that we know whether or not a reference needs to use FORM_ref_addr; only
8200 DIEs in the same CU will be marked. We used to clear out the offset
8201 and use that as the flag, but ran into ordering problems. */
8204 mark_dies (dw_die_ref die)
8208 gcc_assert (!die->die_mark);
8211 FOR_EACH_CHILD (die, c, mark_dies (c));
8214 /* Clear the marks for a die and its children. */
8217 unmark_dies (dw_die_ref die)
8221 if (! use_debug_types)
8222 gcc_assert (die->die_mark);
8225 FOR_EACH_CHILD (die, c, unmark_dies (c));
8228 /* Clear the marks for a die, its children and referred dies. */
8231 unmark_all_dies (dw_die_ref die)
8241 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
8243 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8244 if (AT_class (a) == dw_val_class_die_ref)
8245 unmark_all_dies (AT_ref (a));
8248 /* Calculate if the entry should appear in the final output file. It may be
8249 from a pruned a type. */
8252 include_pubname_in_output (vec<pubname_entry, va_gc> *table, pubname_entry *p)
8254 /* By limiting gnu pubnames to definitions only, gold can generate a
8255 gdb index without entries for declarations, which don't include
8256 enough information to be useful. */
8257 if (debug_generate_pub_sections == 2 && is_declaration_die (p->die))
8260 if (table == pubname_table)
8262 /* Enumerator names are part of the pubname table, but the
8263 parent DW_TAG_enumeration_type die may have been pruned.
8264 Don't output them if that is the case. */
8265 if (p->die->die_tag == DW_TAG_enumerator &&
8266 (p->die->die_parent == NULL
8267 || !p->die->die_parent->die_perennial_p))
8270 /* Everything else in the pubname table is included. */
8274 /* The pubtypes table shouldn't include types that have been
8276 return (p->die->die_offset != 0
8277 || !flag_eliminate_unused_debug_types);
8280 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8281 generated for the compilation unit. */
8283 static unsigned long
8284 size_of_pubnames (vec<pubname_entry, va_gc> *names)
8289 int space_for_flags = (debug_generate_pub_sections == 2) ? 1 : 0;
8291 size = DWARF_PUBNAMES_HEADER_SIZE;
8292 FOR_EACH_VEC_ELT (*names, i, p)
8293 if (include_pubname_in_output (names, p))
8294 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1 + space_for_flags;
8296 size += DWARF_OFFSET_SIZE;
8300 /* Return the size of the information in the .debug_aranges section. */
8302 static unsigned long
8303 size_of_aranges (void)
8307 size = DWARF_ARANGES_HEADER_SIZE;
8309 /* Count the address/length pair for this compilation unit. */
8310 if (text_section_used)
8311 size += 2 * DWARF2_ADDR_SIZE;
8312 if (cold_text_section_used)
8313 size += 2 * DWARF2_ADDR_SIZE;
8314 if (have_multiple_function_sections)
8319 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
8321 if (DECL_IGNORED_P (fde->decl))
8323 if (!fde->in_std_section)
8324 size += 2 * DWARF2_ADDR_SIZE;
8325 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
8326 size += 2 * DWARF2_ADDR_SIZE;
8330 /* Count the two zero words used to terminated the address range table. */
8331 size += 2 * DWARF2_ADDR_SIZE;
8335 /* Select the encoding of an attribute value. */
8337 static enum dwarf_form
8338 value_format (dw_attr_ref a)
8340 switch (AT_class (a))
8342 case dw_val_class_addr:
8343 /* Only very few attributes allow DW_FORM_addr. */
8348 case DW_AT_entry_pc:
8349 case DW_AT_trampoline:
8350 return (AT_index (a) == NOT_INDEXED
8351 ? DW_FORM_addr : DW_FORM_GNU_addr_index);
8355 switch (DWARF2_ADDR_SIZE)
8358 return DW_FORM_data1;
8360 return DW_FORM_data2;
8362 return DW_FORM_data4;
8364 return DW_FORM_data8;
8368 case dw_val_class_range_list:
8369 case dw_val_class_loc_list:
8370 if (dwarf_version >= 4)
8371 return DW_FORM_sec_offset;
8373 case dw_val_class_vms_delta:
8374 case dw_val_class_offset:
8375 switch (DWARF_OFFSET_SIZE)
8378 return DW_FORM_data4;
8380 return DW_FORM_data8;
8384 case dw_val_class_loc:
8385 if (dwarf_version >= 4)
8386 return DW_FORM_exprloc;
8387 switch (constant_size (size_of_locs (AT_loc (a))))
8390 return DW_FORM_block1;
8392 return DW_FORM_block2;
8394 return DW_FORM_block4;
8398 case dw_val_class_const:
8399 return DW_FORM_sdata;
8400 case dw_val_class_unsigned_const:
8401 switch (constant_size (AT_unsigned (a)))
8404 return DW_FORM_data1;
8406 return DW_FORM_data2;
8408 /* In DWARF3 DW_AT_data_member_location with
8409 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8410 constant, so we need to use DW_FORM_udata if we need
8411 a large constant. */
8412 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
8413 return DW_FORM_udata;
8414 return DW_FORM_data4;
8416 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
8417 return DW_FORM_udata;
8418 return DW_FORM_data8;
8422 case dw_val_class_const_double:
8423 switch (HOST_BITS_PER_WIDE_INT)
8426 return DW_FORM_data2;
8428 return DW_FORM_data4;
8430 return DW_FORM_data8;
8433 return DW_FORM_block1;
8435 case dw_val_class_wide_int:
8436 switch (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT)
8439 return DW_FORM_data1;
8441 return DW_FORM_data2;
8443 return DW_FORM_data4;
8445 return DW_FORM_data8;
8447 return DW_FORM_block1;
8449 case dw_val_class_vec:
8450 switch (constant_size (a->dw_attr_val.v.val_vec.length
8451 * a->dw_attr_val.v.val_vec.elt_size))
8454 return DW_FORM_block1;
8456 return DW_FORM_block2;
8458 return DW_FORM_block4;
8462 case dw_val_class_flag:
8463 if (dwarf_version >= 4)
8465 /* Currently all add_AT_flag calls pass in 1 as last argument,
8466 so DW_FORM_flag_present can be used. If that ever changes,
8467 we'll need to use DW_FORM_flag and have some optimization
8468 in build_abbrev_table that will change those to
8469 DW_FORM_flag_present if it is set to 1 in all DIEs using
8470 the same abbrev entry. */
8471 gcc_assert (a->dw_attr_val.v.val_flag == 1);
8472 return DW_FORM_flag_present;
8474 return DW_FORM_flag;
8475 case dw_val_class_die_ref:
8476 if (AT_ref_external (a))
8477 return use_debug_types ? DW_FORM_ref_sig8 : DW_FORM_ref_addr;
8480 case dw_val_class_fde_ref:
8481 return DW_FORM_data;
8482 case dw_val_class_lbl_id:
8483 return (AT_index (a) == NOT_INDEXED
8484 ? DW_FORM_addr : DW_FORM_GNU_addr_index);
8485 case dw_val_class_lineptr:
8486 case dw_val_class_macptr:
8487 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
8488 case dw_val_class_str:
8489 return AT_string_form (a);
8490 case dw_val_class_file:
8491 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
8494 return DW_FORM_data1;
8496 return DW_FORM_data2;
8498 return DW_FORM_data4;
8503 case dw_val_class_data8:
8504 return DW_FORM_data8;
8506 case dw_val_class_high_pc:
8507 switch (DWARF2_ADDR_SIZE)
8510 return DW_FORM_data1;
8512 return DW_FORM_data2;
8514 return DW_FORM_data4;
8516 return DW_FORM_data8;
8526 /* Output the encoding of an attribute value. */
8529 output_value_format (dw_attr_ref a)
8531 enum dwarf_form form = value_format (a);
8533 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
8536 /* Given a die and id, produce the appropriate abbreviations. */
8539 output_die_abbrevs (unsigned long abbrev_id, dw_die_ref abbrev)
8544 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
8545 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
8546 dwarf_tag_name (abbrev->die_tag));
8548 if (abbrev->die_child != NULL)
8549 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
8551 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
8553 for (ix = 0; vec_safe_iterate (abbrev->die_attr, ix, &a_attr); ix++)
8555 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
8556 dwarf_attr_name (a_attr->dw_attr));
8557 output_value_format (a_attr);
8560 dw2_asm_output_data (1, 0, NULL);
8561 dw2_asm_output_data (1, 0, NULL);
8565 /* Output the .debug_abbrev section which defines the DIE abbreviation
8569 output_abbrev_section (void)
8571 unsigned long abbrev_id;
8573 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8574 output_die_abbrevs (abbrev_id, abbrev_die_table[abbrev_id]);
8576 /* Terminate the table. */
8577 dw2_asm_output_data (1, 0, NULL);
8580 /* Output a symbol we can use to refer to this DIE from another CU. */
8583 output_die_symbol (dw_die_ref die)
8585 const char *sym = die->die_id.die_symbol;
8587 gcc_assert (!die->comdat_type_p);
8592 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
8593 /* We make these global, not weak; if the target doesn't support
8594 .linkonce, it doesn't support combining the sections, so debugging
8596 targetm.asm_out.globalize_label (asm_out_file, sym);
8598 ASM_OUTPUT_LABEL (asm_out_file, sym);
8601 /* Return a new location list, given the begin and end range, and the
8604 static inline dw_loc_list_ref
8605 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
8606 const char *section)
8608 dw_loc_list_ref retlist = ggc_cleared_alloc<dw_loc_list_node> ();
8610 retlist->begin = begin;
8611 retlist->begin_entry = NULL;
8613 retlist->expr = expr;
8614 retlist->section = section;
8619 /* Generate a new internal symbol for this location list node, if it
8620 hasn't got one yet. */
8623 gen_llsym (dw_loc_list_ref list)
8625 gcc_assert (!list->ll_symbol);
8626 list->ll_symbol = gen_internal_sym ("LLST");
8629 /* Output the location list given to us. */
8632 output_loc_list (dw_loc_list_ref list_head)
8634 dw_loc_list_ref curr = list_head;
8636 if (list_head->emitted)
8638 list_head->emitted = true;
8640 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
8642 /* Walk the location list, and output each range + expression. */
8643 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
8646 /* Don't output an entry that starts and ends at the same address. */
8647 if (strcmp (curr->begin, curr->end) == 0 && !curr->force)
8649 size = size_of_locs (curr->expr);
8650 /* If the expression is too large, drop it on the floor. We could
8651 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8652 in the expression, but >= 64KB expressions for a single value
8653 in a single range are unlikely very useful. */
8656 if (dwarf_split_debug_info)
8658 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry,
8659 "Location list start/length entry (%s)",
8660 list_head->ll_symbol);
8661 dw2_asm_output_data_uleb128 (curr->begin_entry->index,
8662 "Location list range start index (%s)",
8664 /* The length field is 4 bytes. If we ever need to support
8665 an 8-byte length, we can add a new DW_LLE code or fall back
8666 to DW_LLE_GNU_start_end_entry. */
8667 dw2_asm_output_delta (4, curr->end, curr->begin,
8668 "Location list range length (%s)",
8669 list_head->ll_symbol);
8671 else if (!have_multiple_function_sections)
8673 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
8674 "Location list begin address (%s)",
8675 list_head->ll_symbol);
8676 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
8677 "Location list end address (%s)",
8678 list_head->ll_symbol);
8682 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
8683 "Location list begin address (%s)",
8684 list_head->ll_symbol);
8685 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
8686 "Location list end address (%s)",
8687 list_head->ll_symbol);
8690 /* Output the block length for this list of location operations. */
8691 gcc_assert (size <= 0xffff);
8692 dw2_asm_output_data (2, size, "%s", "Location expression size");
8694 output_loc_sequence (curr->expr, -1);
8697 if (dwarf_split_debug_info)
8698 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry,
8699 "Location list terminator (%s)",
8700 list_head->ll_symbol);
8703 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8704 "Location list terminator begin (%s)",
8705 list_head->ll_symbol);
8706 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8707 "Location list terminator end (%s)",
8708 list_head->ll_symbol);
8712 /* Output a range_list offset into the debug_range section. Emit a
8713 relocated reference if val_entry is NULL, otherwise, emit an
8714 indirect reference. */
8717 output_range_list_offset (dw_attr_ref a)
8719 const char *name = dwarf_attr_name (a->dw_attr);
8721 if (a->dw_attr_val.val_entry == RELOCATED_OFFSET)
8723 char *p = strchr (ranges_section_label, '\0');
8724 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, a->dw_attr_val.v.val_offset);
8725 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8726 debug_ranges_section, "%s", name);
8730 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8731 "%s (offset from %s)", name, ranges_section_label);
8734 /* Output the offset into the debug_loc section. */
8737 output_loc_list_offset (dw_attr_ref a)
8739 char *sym = AT_loc_list (a)->ll_symbol;
8742 if (dwarf_split_debug_info)
8743 dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym, loc_section_label,
8744 "%s", dwarf_attr_name (a->dw_attr));
8746 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8747 "%s", dwarf_attr_name (a->dw_attr));
8750 /* Output an attribute's index or value appropriately. */
8753 output_attr_index_or_value (dw_attr_ref a)
8755 const char *name = dwarf_attr_name (a->dw_attr);
8757 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8759 dw2_asm_output_data_uleb128 (AT_index (a), "%s", name);
8762 switch (AT_class (a))
8764 case dw_val_class_addr:
8765 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8767 case dw_val_class_high_pc:
8768 case dw_val_class_lbl_id:
8769 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8771 case dw_val_class_loc_list:
8772 output_loc_list_offset (a);
8779 /* Output a type signature. */
8782 output_signature (const char *sig, const char *name)
8786 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8787 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
8790 /* Output the DIE and its attributes. Called recursively to generate
8791 the definitions of each child DIE. */
8794 output_die (dw_die_ref die)
8801 /* If someone in another CU might refer to us, set up a symbol for
8802 them to point to. */
8803 if (! die->comdat_type_p && die->die_id.die_symbol)
8804 output_die_symbol (die);
8806 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
8807 (unsigned long)die->die_offset,
8808 dwarf_tag_name (die->die_tag));
8810 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8812 const char *name = dwarf_attr_name (a->dw_attr);
8814 switch (AT_class (a))
8816 case dw_val_class_addr:
8817 output_attr_index_or_value (a);
8820 case dw_val_class_offset:
8821 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8825 case dw_val_class_range_list:
8826 output_range_list_offset (a);
8829 case dw_val_class_loc:
8830 size = size_of_locs (AT_loc (a));
8832 /* Output the block length for this list of location operations. */
8833 if (dwarf_version >= 4)
8834 dw2_asm_output_data_uleb128 (size, "%s", name);
8836 dw2_asm_output_data (constant_size (size), size, "%s", name);
8838 output_loc_sequence (AT_loc (a), -1);
8841 case dw_val_class_const:
8842 /* ??? It would be slightly more efficient to use a scheme like is
8843 used for unsigned constants below, but gdb 4.x does not sign
8844 extend. Gdb 5.x does sign extend. */
8845 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8848 case dw_val_class_unsigned_const:
8850 int csize = constant_size (AT_unsigned (a));
8851 if (dwarf_version == 3
8852 && a->dw_attr == DW_AT_data_member_location
8854 dw2_asm_output_data_uleb128 (AT_unsigned (a), "%s", name);
8856 dw2_asm_output_data (csize, AT_unsigned (a), "%s", name);
8860 case dw_val_class_const_double:
8862 unsigned HOST_WIDE_INT first, second;
8864 if (HOST_BITS_PER_WIDE_INT >= 64)
8865 dw2_asm_output_data (1,
8866 HOST_BITS_PER_DOUBLE_INT
8867 / HOST_BITS_PER_CHAR,
8870 if (WORDS_BIG_ENDIAN)
8872 first = a->dw_attr_val.v.val_double.high;
8873 second = a->dw_attr_val.v.val_double.low;
8877 first = a->dw_attr_val.v.val_double.low;
8878 second = a->dw_attr_val.v.val_double.high;
8881 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8883 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8888 case dw_val_class_wide_int:
8891 int len = get_full_len (*a->dw_attr_val.v.val_wide);
8892 int l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
8893 if (len * HOST_BITS_PER_WIDE_INT > 64)
8894 dw2_asm_output_data (1, get_full_len (*a->dw_attr_val.v.val_wide) * l,
8897 if (WORDS_BIG_ENDIAN)
8898 for (i = len - 1; i >= 0; --i)
8900 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
8905 for (i = 0; i < len; ++i)
8907 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
8914 case dw_val_class_vec:
8916 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8917 unsigned int len = a->dw_attr_val.v.val_vec.length;
8921 dw2_asm_output_data (constant_size (len * elt_size),
8922 len * elt_size, "%s", name);
8923 if (elt_size > sizeof (HOST_WIDE_INT))
8928 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8931 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8932 "fp or vector constant word %u", i);
8936 case dw_val_class_flag:
8937 if (dwarf_version >= 4)
8939 /* Currently all add_AT_flag calls pass in 1 as last argument,
8940 so DW_FORM_flag_present can be used. If that ever changes,
8941 we'll need to use DW_FORM_flag and have some optimization
8942 in build_abbrev_table that will change those to
8943 DW_FORM_flag_present if it is set to 1 in all DIEs using
8944 the same abbrev entry. */
8945 gcc_assert (AT_flag (a) == 1);
8947 fprintf (asm_out_file, "\t\t\t%s %s\n",
8948 ASM_COMMENT_START, name);
8951 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8954 case dw_val_class_loc_list:
8955 output_attr_index_or_value (a);
8958 case dw_val_class_die_ref:
8959 if (AT_ref_external (a))
8961 if (AT_ref (a)->comdat_type_p)
8963 comdat_type_node_ref type_node =
8964 AT_ref (a)->die_id.die_type_node;
8966 gcc_assert (type_node);
8967 output_signature (type_node->signature, name);
8971 const char *sym = AT_ref (a)->die_id.die_symbol;
8975 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8976 length, whereas in DWARF3 it's always sized as an
8978 if (dwarf_version == 2)
8979 size = DWARF2_ADDR_SIZE;
8981 size = DWARF_OFFSET_SIZE;
8982 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
8988 gcc_assert (AT_ref (a)->die_offset);
8989 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8994 case dw_val_class_fde_ref:
8998 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8999 a->dw_attr_val.v.val_fde_index * 2);
9000 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
9005 case dw_val_class_vms_delta:
9006 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
9007 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
9008 AT_vms_delta2 (a), AT_vms_delta1 (a),
9011 dw2_asm_output_delta (DWARF_OFFSET_SIZE,
9012 AT_vms_delta2 (a), AT_vms_delta1 (a),
9017 case dw_val_class_lbl_id:
9018 output_attr_index_or_value (a);
9021 case dw_val_class_lineptr:
9022 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9023 debug_line_section, "%s", name);
9026 case dw_val_class_macptr:
9027 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9028 debug_macinfo_section, "%s", name);
9031 case dw_val_class_str:
9032 if (a->dw_attr_val.v.val_str->form == DW_FORM_strp)
9033 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
9034 a->dw_attr_val.v.val_str->label,
9036 "%s: \"%s\"", name, AT_string (a));
9037 else if (a->dw_attr_val.v.val_str->form == DW_FORM_GNU_str_index)
9038 dw2_asm_output_data_uleb128 (AT_index (a),
9039 "%s: \"%s\"", name, AT_string (a));
9041 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
9044 case dw_val_class_file:
9046 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
9048 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
9049 a->dw_attr_val.v.val_file->filename);
9053 case dw_val_class_data8:
9057 for (i = 0; i < 8; i++)
9058 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
9059 i == 0 ? "%s" : NULL, name);
9063 case dw_val_class_high_pc:
9064 dw2_asm_output_delta (DWARF2_ADDR_SIZE, AT_lbl (a),
9065 get_AT_low_pc (die), "DW_AT_high_pc");
9073 FOR_EACH_CHILD (die, c, output_die (c));
9075 /* Add null byte to terminate sibling list. */
9076 if (die->die_child != NULL)
9077 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
9078 (unsigned long) die->die_offset);
9081 /* Output the compilation unit that appears at the beginning of the
9082 .debug_info section, and precedes the DIE descriptions. */
9085 output_compilation_unit_header (void)
9087 /* We don't support actual DWARFv5 units yet, we just use some
9088 DWARFv5 draft DIE tags in DWARFv4 format. */
9089 int ver = dwarf_version < 5 ? dwarf_version : 4;
9091 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9092 dw2_asm_output_data (4, 0xffffffff,
9093 "Initial length escape value indicating 64-bit DWARF extension");
9094 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9095 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
9096 "Length of Compilation Unit Info");
9097 dw2_asm_output_data (2, ver, "DWARF version number");
9098 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
9099 debug_abbrev_section,
9100 "Offset Into Abbrev. Section");
9101 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9104 /* Output the compilation unit DIE and its children. */
9107 output_comp_unit (dw_die_ref die, int output_if_empty)
9109 const char *secname, *oldsym;
9112 /* Unless we are outputting main CU, we may throw away empty ones. */
9113 if (!output_if_empty && die->die_child == NULL)
9116 /* Even if there are no children of this DIE, we must output the information
9117 about the compilation unit. Otherwise, on an empty translation unit, we
9118 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
9119 will then complain when examining the file. First mark all the DIEs in
9120 this CU so we know which get local refs. */
9123 external_ref_hash_type *extern_map = optimize_external_refs (die);
9125 build_abbrev_table (die, extern_map);
9129 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9130 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
9131 calc_die_sizes (die);
9133 oldsym = die->die_id.die_symbol;
9136 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
9138 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
9140 die->die_id.die_symbol = NULL;
9141 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9145 switch_to_section (debug_info_section);
9146 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
9147 info_section_emitted = true;
9150 /* Output debugging information. */
9151 output_compilation_unit_header ();
9154 /* Leave the marks on the main CU, so we can check them in
9159 die->die_id.die_symbol = oldsym;
9163 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
9164 and .debug_pubtypes. This is configured per-target, but can be
9165 overridden by the -gpubnames or -gno-pubnames options. */
9168 want_pubnames (void)
9170 if (debug_info_level <= DINFO_LEVEL_TERSE)
9172 if (debug_generate_pub_sections != -1)
9173 return debug_generate_pub_sections;
9174 return targetm.want_debug_pub_sections;
9177 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
9180 add_AT_pubnames (dw_die_ref die)
9182 if (want_pubnames ())
9183 add_AT_flag (die, DW_AT_GNU_pubnames, 1);
9186 /* Add a string attribute value to a skeleton DIE. */
9189 add_skeleton_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind,
9193 struct indirect_string_node *node;
9195 if (! skeleton_debug_str_hash)
9196 skeleton_debug_str_hash
9197 = hash_table<indirect_string_hasher>::create_ggc (10);
9199 node = find_AT_string_in_table (str, skeleton_debug_str_hash);
9200 find_string_form (node);
9201 if (node->form == DW_FORM_GNU_str_index)
9202 node->form = DW_FORM_strp;
9204 attr.dw_attr = attr_kind;
9205 attr.dw_attr_val.val_class = dw_val_class_str;
9206 attr.dw_attr_val.val_entry = NULL;
9207 attr.dw_attr_val.v.val_str = node;
9208 add_dwarf_attr (die, &attr);
9211 /* Helper function to generate top-level dies for skeleton debug_info and
9215 add_top_level_skeleton_die_attrs (dw_die_ref die)
9217 const char *dwo_file_name = concat (aux_base_name, ".dwo", NULL);
9218 const char *comp_dir = comp_dir_string ();
9220 add_skeleton_AT_string (die, DW_AT_GNU_dwo_name, dwo_file_name);
9221 if (comp_dir != NULL)
9222 add_skeleton_AT_string (die, DW_AT_comp_dir, comp_dir);
9223 add_AT_pubnames (die);
9224 add_AT_lineptr (die, DW_AT_GNU_addr_base, debug_addr_section_label);
9227 /* Output skeleton debug sections that point to the dwo file. */
9230 output_skeleton_debug_sections (dw_die_ref comp_unit)
9232 /* We don't support actual DWARFv5 units yet, we just use some
9233 DWARFv5 draft DIE tags in DWARFv4 format. */
9234 int ver = dwarf_version < 5 ? dwarf_version : 4;
9236 /* These attributes will be found in the full debug_info section. */
9237 remove_AT (comp_unit, DW_AT_producer);
9238 remove_AT (comp_unit, DW_AT_language);
9240 switch_to_section (debug_skeleton_info_section);
9241 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_info_section_label);
9243 /* Produce the skeleton compilation-unit header. This one differs enough from
9244 a normal CU header that it's better not to call output_compilation_unit
9246 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9247 dw2_asm_output_data (4, 0xffffffff,
9248 "Initial length escape value indicating 64-bit DWARF extension");
9250 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9251 DWARF_COMPILE_UNIT_HEADER_SIZE
9252 - DWARF_INITIAL_LENGTH_SIZE
9253 + size_of_die (comp_unit),
9254 "Length of Compilation Unit Info");
9255 dw2_asm_output_data (2, ver, "DWARF version number");
9256 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_abbrev_section_label,
9257 debug_abbrev_section,
9258 "Offset Into Abbrev. Section");
9259 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9261 comp_unit->die_abbrev = SKELETON_COMP_DIE_ABBREV;
9262 output_die (comp_unit);
9264 /* Build the skeleton debug_abbrev section. */
9265 switch_to_section (debug_skeleton_abbrev_section);
9266 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_abbrev_section_label);
9268 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV, comp_unit);
9270 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
9273 /* Output a comdat type unit DIE and its children. */
9276 output_comdat_type_unit (comdat_type_node *node)
9278 const char *secname;
9281 #if defined (OBJECT_FORMAT_ELF)
9285 /* First mark all the DIEs in this CU so we know which get local refs. */
9286 mark_dies (node->root_die);
9288 external_ref_hash_type *extern_map = optimize_external_refs (node->root_die);
9290 build_abbrev_table (node->root_die, extern_map);
9295 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9296 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
9297 calc_die_sizes (node->root_die);
9299 #if defined (OBJECT_FORMAT_ELF)
9300 if (!dwarf_split_debug_info)
9301 secname = ".debug_types";
9303 secname = ".debug_types.dwo";
9305 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
9306 sprintf (tmp, "wt.");
9307 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
9308 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
9309 comdat_key = get_identifier (tmp);
9310 targetm.asm_out.named_section (secname,
9311 SECTION_DEBUG | SECTION_LINKONCE,
9314 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
9315 sprintf (tmp, ".gnu.linkonce.wt.");
9316 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
9317 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
9319 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9322 /* Output debugging information. */
9323 output_compilation_unit_header ();
9324 output_signature (node->signature, "Type Signature");
9325 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
9326 "Offset to Type DIE");
9327 output_die (node->root_die);
9329 unmark_dies (node->root_die);
9332 /* Return the DWARF2/3 pubname associated with a decl. */
9335 dwarf2_name (tree decl, int scope)
9337 if (DECL_NAMELESS (decl))
9339 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
9342 /* Add a new entry to .debug_pubnames if appropriate. */
9345 add_pubname_string (const char *str, dw_die_ref die)
9350 e.name = xstrdup (str);
9351 vec_safe_push (pubname_table, e);
9355 add_pubname (tree decl, dw_die_ref die)
9357 if (!want_pubnames ())
9360 /* Don't add items to the table when we expect that the consumer will have
9361 just read the enclosing die. For example, if the consumer is looking at a
9362 class_member, it will either be inside the class already, or will have just
9363 looked up the class to find the member. Either way, searching the class is
9364 faster than searching the index. */
9365 if ((TREE_PUBLIC (decl) && !class_scope_p (die->die_parent))
9366 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
9368 const char *name = dwarf2_name (decl, 1);
9371 add_pubname_string (name, die);
9375 /* Add an enumerator to the pubnames section. */
9378 add_enumerator_pubname (const char *scope_name, dw_die_ref die)
9382 gcc_assert (scope_name);
9383 e.name = concat (scope_name, get_AT_string (die, DW_AT_name), NULL);
9385 vec_safe_push (pubname_table, e);
9388 /* Add a new entry to .debug_pubtypes if appropriate. */
9391 add_pubtype (tree decl, dw_die_ref die)
9395 if (!want_pubnames ())
9398 if ((TREE_PUBLIC (decl)
9399 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
9400 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
9403 const char *scope_name = "";
9404 const char *sep = is_cxx () ? "::" : ".";
9407 scope = TYPE_P (decl) ? TYPE_CONTEXT (decl) : NULL;
9408 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9410 scope_name = lang_hooks.dwarf_name (scope, 1);
9411 if (scope_name != NULL && scope_name[0] != '\0')
9412 scope_name = concat (scope_name, sep, NULL);
9418 name = type_tag (decl);
9420 name = lang_hooks.dwarf_name (decl, 1);
9422 /* If we don't have a name for the type, there's no point in adding
9424 if (name != NULL && name[0] != '\0')
9427 e.name = concat (scope_name, name, NULL);
9428 vec_safe_push (pubtype_table, e);
9431 /* Although it might be more consistent to add the pubinfo for the
9432 enumerators as their dies are created, they should only be added if the
9433 enum type meets the criteria above. So rather than re-check the parent
9434 enum type whenever an enumerator die is created, just output them all
9435 here. This isn't protected by the name conditional because anonymous
9436 enums don't have names. */
9437 if (die->die_tag == DW_TAG_enumeration_type)
9441 FOR_EACH_CHILD (die, c, add_enumerator_pubname (scope_name, c));
9446 /* Output a single entry in the pubnames table. */
9449 output_pubname (dw_offset die_offset, pubname_entry *entry)
9451 dw_die_ref die = entry->die;
9452 int is_static = get_AT_flag (die, DW_AT_external) ? 0 : 1;
9454 dw2_asm_output_data (DWARF_OFFSET_SIZE, die_offset, "DIE offset");
9456 if (debug_generate_pub_sections == 2)
9458 /* This logic follows gdb's method for determining the value of the flag
9460 uint32_t flags = GDB_INDEX_SYMBOL_KIND_NONE;
9461 switch (die->die_tag)
9463 case DW_TAG_typedef:
9464 case DW_TAG_base_type:
9465 case DW_TAG_subrange_type:
9466 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9467 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9469 case DW_TAG_enumerator:
9470 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9471 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9472 if (!is_cxx () && !is_java ())
9473 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9475 case DW_TAG_subprogram:
9476 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9477 GDB_INDEX_SYMBOL_KIND_FUNCTION);
9479 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9481 case DW_TAG_constant:
9482 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9483 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9484 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9486 case DW_TAG_variable:
9487 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9488 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9489 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9491 case DW_TAG_namespace:
9492 case DW_TAG_imported_declaration:
9493 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9495 case DW_TAG_class_type:
9496 case DW_TAG_interface_type:
9497 case DW_TAG_structure_type:
9498 case DW_TAG_union_type:
9499 case DW_TAG_enumeration_type:
9500 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9501 if (!is_cxx () && !is_java ())
9502 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9505 /* An unusual tag. Leave the flag-byte empty. */
9508 dw2_asm_output_data (1, flags >> GDB_INDEX_CU_BITSIZE,
9512 dw2_asm_output_nstring (entry->name, -1, "external name");
9516 /* Output the public names table used to speed up access to externally
9517 visible names; or the public types table used to find type definitions. */
9520 output_pubnames (vec<pubname_entry, va_gc> *names)
9523 unsigned long pubnames_length = size_of_pubnames (names);
9526 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9527 dw2_asm_output_data (4, 0xffffffff,
9528 "Initial length escape value indicating 64-bit DWARF extension");
9529 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, "Pub Info Length");
9531 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9532 dw2_asm_output_data (2, 2, "DWARF Version");
9534 if (dwarf_split_debug_info)
9535 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
9536 debug_skeleton_info_section,
9537 "Offset of Compilation Unit Info");
9539 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9541 "Offset of Compilation Unit Info");
9542 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
9543 "Compilation Unit Length");
9545 FOR_EACH_VEC_ELT (*names, i, pub)
9547 if (include_pubname_in_output (names, pub))
9549 dw_offset die_offset = pub->die->die_offset;
9551 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9552 if (names == pubname_table && pub->die->die_tag != DW_TAG_enumerator)
9553 gcc_assert (pub->die->die_mark);
9555 /* If we're putting types in their own .debug_types sections,
9556 the .debug_pubtypes table will still point to the compile
9557 unit (not the type unit), so we want to use the offset of
9558 the skeleton DIE (if there is one). */
9559 if (pub->die->comdat_type_p && names == pubtype_table)
9561 comdat_type_node_ref type_node = pub->die->die_id.die_type_node;
9563 if (type_node != NULL)
9564 die_offset = (type_node->skeleton_die != NULL
9565 ? type_node->skeleton_die->die_offset
9566 : comp_unit_die ()->die_offset);
9569 output_pubname (die_offset, pub);
9573 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
9576 /* Output public names and types tables if necessary. */
9579 output_pubtables (void)
9581 if (!want_pubnames () || !info_section_emitted)
9584 switch_to_section (debug_pubnames_section);
9585 output_pubnames (pubname_table);
9586 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
9587 It shouldn't hurt to emit it always, since pure DWARF2 consumers
9588 simply won't look for the section. */
9589 switch_to_section (debug_pubtypes_section);
9590 output_pubnames (pubtype_table);
9594 /* Output the information that goes into the .debug_aranges table.
9595 Namely, define the beginning and ending address range of the
9596 text section generated for this compilation unit. */
9599 output_aranges (unsigned long aranges_length)
9603 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9604 dw2_asm_output_data (4, 0xffffffff,
9605 "Initial length escape value indicating 64-bit DWARF extension");
9606 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
9607 "Length of Address Ranges Info");
9608 /* Version number for aranges is still 2, even up to DWARF5. */
9609 dw2_asm_output_data (2, 2, "DWARF Version");
9610 if (dwarf_split_debug_info)
9611 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
9612 debug_skeleton_info_section,
9613 "Offset of Compilation Unit Info");
9615 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9617 "Offset of Compilation Unit Info");
9618 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
9619 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9621 /* We need to align to twice the pointer size here. */
9622 if (DWARF_ARANGES_PAD_SIZE)
9624 /* Pad using a 2 byte words so that padding is correct for any
9626 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9627 2 * DWARF2_ADDR_SIZE);
9628 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
9629 dw2_asm_output_data (2, 0, NULL);
9632 /* It is necessary not to output these entries if the sections were
9633 not used; if the sections were not used, the length will be 0 and
9634 the address may end up as 0 if the section is discarded by ld
9635 --gc-sections, leaving an invalid (0, 0) entry that can be
9636 confused with the terminator. */
9637 if (text_section_used)
9639 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
9640 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
9641 text_section_label, "Length");
9643 if (cold_text_section_used)
9645 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
9647 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
9648 cold_text_section_label, "Length");
9651 if (have_multiple_function_sections)
9656 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
9658 if (DECL_IGNORED_P (fde->decl))
9660 if (!fde->in_std_section)
9662 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
9664 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end,
9665 fde->dw_fde_begin, "Length");
9667 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
9669 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_second_begin,
9671 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_second_end,
9672 fde->dw_fde_second_begin, "Length");
9677 /* Output the terminator words. */
9678 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9679 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9682 /* Add a new entry to .debug_ranges. Return the offset at which it
9686 add_ranges_num (int num)
9688 unsigned int in_use = ranges_table_in_use;
9690 if (in_use == ranges_table_allocated)
9692 ranges_table_allocated += RANGES_TABLE_INCREMENT;
9693 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
9694 ranges_table_allocated);
9695 memset (ranges_table + ranges_table_in_use, 0,
9696 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
9699 ranges_table[in_use].num = num;
9700 ranges_table_in_use = in_use + 1;
9702 return in_use * 2 * DWARF2_ADDR_SIZE;
9705 /* Add a new entry to .debug_ranges corresponding to a block, or a
9706 range terminator if BLOCK is NULL. */
9709 add_ranges (const_tree block)
9711 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
9714 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
9715 When using dwarf_split_debug_info, address attributes in dies destined
9716 for the final executable should be direct references--setting the
9717 parameter force_direct ensures this behavior. */
9720 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
9721 bool *added, bool force_direct)
9723 unsigned int in_use = ranges_by_label_in_use;
9724 unsigned int offset;
9726 if (in_use == ranges_by_label_allocated)
9728 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
9729 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
9731 ranges_by_label_allocated);
9732 memset (ranges_by_label + ranges_by_label_in_use, 0,
9733 RANGES_TABLE_INCREMENT
9734 * sizeof (struct dw_ranges_by_label_struct));
9737 ranges_by_label[in_use].begin = begin;
9738 ranges_by_label[in_use].end = end;
9739 ranges_by_label_in_use = in_use + 1;
9741 offset = add_ranges_num (-(int)in_use - 1);
9744 add_AT_range_list (die, DW_AT_ranges, offset, force_direct);
9750 output_ranges (void)
9753 static const char *const start_fmt = "Offset %#x";
9754 const char *fmt = start_fmt;
9756 for (i = 0; i < ranges_table_in_use; i++)
9758 int block_num = ranges_table[i].num;
9762 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
9763 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
9765 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
9766 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
9768 /* If all code is in the text section, then the compilation
9769 unit base address defaults to DW_AT_low_pc, which is the
9770 base of the text section. */
9771 if (!have_multiple_function_sections)
9773 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
9775 fmt, i * 2 * DWARF2_ADDR_SIZE);
9776 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
9777 text_section_label, NULL);
9780 /* Otherwise, the compilation unit base address is zero,
9781 which allows us to use absolute addresses, and not worry
9782 about whether the target supports cross-section
9786 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
9787 fmt, i * 2 * DWARF2_ADDR_SIZE);
9788 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
9794 /* Negative block_num stands for an index into ranges_by_label. */
9795 else if (block_num < 0)
9797 int lab_idx = - block_num - 1;
9799 if (!have_multiple_function_sections)
9803 /* If we ever use add_ranges_by_labels () for a single
9804 function section, all we have to do is to take out
9806 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9807 ranges_by_label[lab_idx].begin,
9809 fmt, i * 2 * DWARF2_ADDR_SIZE);
9810 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9811 ranges_by_label[lab_idx].end,
9812 text_section_label, NULL);
9817 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9818 ranges_by_label[lab_idx].begin,
9819 fmt, i * 2 * DWARF2_ADDR_SIZE);
9820 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9821 ranges_by_label[lab_idx].end,
9827 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9828 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9834 /* Data structure containing information about input files. */
9837 const char *path; /* Complete file name. */
9838 const char *fname; /* File name part. */
9839 int length; /* Length of entire string. */
9840 struct dwarf_file_data * file_idx; /* Index in input file table. */
9841 int dir_idx; /* Index in directory table. */
9844 /* Data structure containing information about directories with source
9848 const char *path; /* Path including directory name. */
9849 int length; /* Path length. */
9850 int prefix; /* Index of directory entry which is a prefix. */
9851 int count; /* Number of files in this directory. */
9852 int dir_idx; /* Index of directory used as base. */
9855 /* Callback function for file_info comparison. We sort by looking at
9856 the directories in the path. */
9859 file_info_cmp (const void *p1, const void *p2)
9861 const struct file_info *const s1 = (const struct file_info *) p1;
9862 const struct file_info *const s2 = (const struct file_info *) p2;
9863 const unsigned char *cp1;
9864 const unsigned char *cp2;
9866 /* Take care of file names without directories. We need to make sure that
9867 we return consistent values to qsort since some will get confused if
9868 we return the same value when identical operands are passed in opposite
9869 orders. So if neither has a directory, return 0 and otherwise return
9870 1 or -1 depending on which one has the directory. */
9871 if ((s1->path == s1->fname || s2->path == s2->fname))
9872 return (s2->path == s2->fname) - (s1->path == s1->fname);
9874 cp1 = (const unsigned char *) s1->path;
9875 cp2 = (const unsigned char *) s2->path;
9881 /* Reached the end of the first path? If so, handle like above. */
9882 if ((cp1 == (const unsigned char *) s1->fname)
9883 || (cp2 == (const unsigned char *) s2->fname))
9884 return ((cp2 == (const unsigned char *) s2->fname)
9885 - (cp1 == (const unsigned char *) s1->fname));
9887 /* Character of current path component the same? */
9888 else if (*cp1 != *cp2)
9893 struct file_name_acquire_data
9895 struct file_info *files;
9900 /* Traversal function for the hash table. */
9903 file_name_acquire (dwarf_file_data **slot, file_name_acquire_data *fnad)
9905 struct dwarf_file_data *d = *slot;
9906 struct file_info *fi;
9909 gcc_assert (fnad->max_files >= d->emitted_number);
9911 if (! d->emitted_number)
9914 gcc_assert (fnad->max_files != fnad->used_files);
9916 fi = fnad->files + fnad->used_files++;
9918 /* Skip all leading "./". */
9920 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
9923 /* Create a new array entry. */
9925 fi->length = strlen (f);
9928 /* Search for the file name part. */
9929 f = strrchr (f, DIR_SEPARATOR);
9930 #if defined (DIR_SEPARATOR_2)
9932 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
9936 if (f == NULL || f < g)
9942 fi->fname = f == NULL ? fi->path : f + 1;
9946 /* Output the directory table and the file name table. We try to minimize
9947 the total amount of memory needed. A heuristic is used to avoid large
9948 slowdowns with many input files. */
9951 output_file_names (void)
9953 struct file_name_acquire_data fnad;
9955 struct file_info *files;
9956 struct dir_info *dirs;
9964 if (!last_emitted_file)
9966 dw2_asm_output_data (1, 0, "End directory table");
9967 dw2_asm_output_data (1, 0, "End file name table");
9971 numfiles = last_emitted_file->emitted_number;
9973 /* Allocate the various arrays we need. */
9974 files = XALLOCAVEC (struct file_info, numfiles);
9975 dirs = XALLOCAVEC (struct dir_info, numfiles);
9978 fnad.used_files = 0;
9979 fnad.max_files = numfiles;
9980 file_table->traverse<file_name_acquire_data *, file_name_acquire> (&fnad);
9981 gcc_assert (fnad.used_files == fnad.max_files);
9983 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
9985 /* Find all the different directories used. */
9986 dirs[0].path = files[0].path;
9987 dirs[0].length = files[0].fname - files[0].path;
9988 dirs[0].prefix = -1;
9990 dirs[0].dir_idx = 0;
9991 files[0].dir_idx = 0;
9994 for (i = 1; i < numfiles; i++)
9995 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
9996 && memcmp (dirs[ndirs - 1].path, files[i].path,
9997 dirs[ndirs - 1].length) == 0)
9999 /* Same directory as last entry. */
10000 files[i].dir_idx = ndirs - 1;
10001 ++dirs[ndirs - 1].count;
10007 /* This is a new directory. */
10008 dirs[ndirs].path = files[i].path;
10009 dirs[ndirs].length = files[i].fname - files[i].path;
10010 dirs[ndirs].count = 1;
10011 dirs[ndirs].dir_idx = ndirs;
10012 files[i].dir_idx = ndirs;
10014 /* Search for a prefix. */
10015 dirs[ndirs].prefix = -1;
10016 for (j = 0; j < ndirs; j++)
10017 if (dirs[j].length < dirs[ndirs].length
10018 && dirs[j].length > 1
10019 && (dirs[ndirs].prefix == -1
10020 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
10021 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
10022 dirs[ndirs].prefix = j;
10027 /* Now to the actual work. We have to find a subset of the directories which
10028 allow expressing the file name using references to the directory table
10029 with the least amount of characters. We do not do an exhaustive search
10030 where we would have to check out every combination of every single
10031 possible prefix. Instead we use a heuristic which provides nearly optimal
10032 results in most cases and never is much off. */
10033 saved = XALLOCAVEC (int, ndirs);
10034 savehere = XALLOCAVEC (int, ndirs);
10036 memset (saved, '\0', ndirs * sizeof (saved[0]));
10037 for (i = 0; i < ndirs; i++)
10042 /* We can always save some space for the current directory. But this
10043 does not mean it will be enough to justify adding the directory. */
10044 savehere[i] = dirs[i].length;
10045 total = (savehere[i] - saved[i]) * dirs[i].count;
10047 for (j = i + 1; j < ndirs; j++)
10050 if (saved[j] < dirs[i].length)
10052 /* Determine whether the dirs[i] path is a prefix of the
10056 k = dirs[j].prefix;
10057 while (k != -1 && k != (int) i)
10058 k = dirs[k].prefix;
10062 /* Yes it is. We can possibly save some memory by
10063 writing the filenames in dirs[j] relative to
10065 savehere[j] = dirs[i].length;
10066 total += (savehere[j] - saved[j]) * dirs[j].count;
10071 /* Check whether we can save enough to justify adding the dirs[i]
10073 if (total > dirs[i].length + 1)
10075 /* It's worthwhile adding. */
10076 for (j = i; j < ndirs; j++)
10077 if (savehere[j] > 0)
10079 /* Remember how much we saved for this directory so far. */
10080 saved[j] = savehere[j];
10082 /* Remember the prefix directory. */
10083 dirs[j].dir_idx = i;
10088 /* Emit the directory name table. */
10089 idx_offset = dirs[0].length > 0 ? 1 : 0;
10090 for (i = 1 - idx_offset; i < ndirs; i++)
10091 dw2_asm_output_nstring (dirs[i].path,
10093 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
10094 "Directory Entry: %#x", i + idx_offset);
10096 dw2_asm_output_data (1, 0, "End directory table");
10098 /* We have to emit them in the order of emitted_number since that's
10099 used in the debug info generation. To do this efficiently we
10100 generate a back-mapping of the indices first. */
10101 backmap = XALLOCAVEC (int, numfiles);
10102 for (i = 0; i < numfiles; i++)
10103 backmap[files[i].file_idx->emitted_number - 1] = i;
10105 /* Now write all the file names. */
10106 for (i = 0; i < numfiles; i++)
10108 int file_idx = backmap[i];
10109 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
10111 #ifdef VMS_DEBUGGING_INFO
10112 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
10114 /* Setting these fields can lead to debugger miscomparisons,
10115 but VMS Debug requires them to be set correctly. */
10120 int maxfilelen = strlen (files[file_idx].path)
10121 + dirs[dir_idx].length
10122 + MAX_VMS_VERSION_LEN + 1;
10123 char *filebuf = XALLOCAVEC (char, maxfilelen);
10125 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
10126 snprintf (filebuf, maxfilelen, "%s;%d",
10127 files[file_idx].path + dirs[dir_idx].length, ver);
10129 dw2_asm_output_nstring
10130 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1);
10132 /* Include directory index. */
10133 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
10135 /* Modification time. */
10136 dw2_asm_output_data_uleb128
10137 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
10141 /* File length in bytes. */
10142 dw2_asm_output_data_uleb128
10143 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
10147 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
10148 "File Entry: %#x", (unsigned) i + 1);
10150 /* Include directory index. */
10151 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
10153 /* Modification time. */
10154 dw2_asm_output_data_uleb128 (0, NULL);
10156 /* File length in bytes. */
10157 dw2_asm_output_data_uleb128 (0, NULL);
10158 #endif /* VMS_DEBUGGING_INFO */
10161 dw2_asm_output_data (1, 0, "End file name table");
10165 /* Output one line number table into the .debug_line section. */
10168 output_one_line_info_table (dw_line_info_table *table)
10170 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
10171 unsigned int current_line = 1;
10172 bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
10173 dw_line_info_entry *ent;
10176 FOR_EACH_VEC_SAFE_ELT (table->entries, i, ent)
10178 switch (ent->opcode)
10180 case LI_set_address:
10181 /* ??? Unfortunately, we have little choice here currently, and
10182 must always use the most general form. GCC does not know the
10183 address delta itself, so we can't use DW_LNS_advance_pc. Many
10184 ports do have length attributes which will give an upper bound
10185 on the address range. We could perhaps use length attributes
10186 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
10187 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
10189 /* This can handle any delta. This takes
10190 4+DWARF2_ADDR_SIZE bytes. */
10191 dw2_asm_output_data (1, 0, "set address %s", line_label);
10192 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10193 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10194 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10198 if (ent->val == current_line)
10200 /* We still need to start a new row, so output a copy insn. */
10201 dw2_asm_output_data (1, DW_LNS_copy,
10202 "copy line %u", current_line);
10206 int line_offset = ent->val - current_line;
10207 int line_delta = line_offset - DWARF_LINE_BASE;
10209 current_line = ent->val;
10210 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
10212 /* This can handle deltas from -10 to 234, using the current
10213 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
10214 This takes 1 byte. */
10215 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
10216 "line %u", current_line);
10220 /* This can handle any delta. This takes at least 4 bytes,
10221 depending on the value being encoded. */
10222 dw2_asm_output_data (1, DW_LNS_advance_line,
10223 "advance to line %u", current_line);
10224 dw2_asm_output_data_sleb128 (line_offset, NULL);
10225 dw2_asm_output_data (1, DW_LNS_copy, NULL);
10231 dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val);
10232 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
10235 case LI_set_column:
10236 dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val);
10237 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
10240 case LI_negate_stmt:
10241 current_is_stmt = !current_is_stmt;
10242 dw2_asm_output_data (1, DW_LNS_negate_stmt,
10243 "is_stmt %d", current_is_stmt);
10246 case LI_set_prologue_end:
10247 dw2_asm_output_data (1, DW_LNS_set_prologue_end,
10248 "set prologue end");
10251 case LI_set_epilogue_begin:
10252 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin,
10253 "set epilogue begin");
10256 case LI_set_discriminator:
10257 dw2_asm_output_data (1, 0, "discriminator %u", ent->val);
10258 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL);
10259 dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL);
10260 dw2_asm_output_data_uleb128 (ent->val, NULL);
10265 /* Emit debug info for the address of the end of the table. */
10266 dw2_asm_output_data (1, 0, "set address %s", table->end_label);
10267 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10268 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10269 dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL);
10271 dw2_asm_output_data (1, 0, "end sequence");
10272 dw2_asm_output_data_uleb128 (1, NULL);
10273 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
10276 /* Output the source line number correspondence information. This
10277 information goes into the .debug_line section. */
10280 output_line_info (bool prologue_only)
10282 char l1[20], l2[20], p1[20], p2[20];
10283 /* We don't support DWARFv5 line tables yet. */
10284 int ver = dwarf_version < 5 ? dwarf_version : 4;
10285 bool saw_one = false;
10288 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
10289 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
10290 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
10291 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
10293 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
10294 dw2_asm_output_data (4, 0xffffffff,
10295 "Initial length escape value indicating 64-bit DWARF extension");
10296 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
10297 "Length of Source Line Info");
10298 ASM_OUTPUT_LABEL (asm_out_file, l1);
10300 dw2_asm_output_data (2, ver, "DWARF Version");
10301 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
10302 ASM_OUTPUT_LABEL (asm_out_file, p1);
10304 /* Define the architecture-dependent minimum instruction length (in bytes).
10305 In this implementation of DWARF, this field is used for information
10306 purposes only. Since GCC generates assembly language, we have no
10307 a priori knowledge of how many instruction bytes are generated for each
10308 source line, and therefore can use only the DW_LNE_set_address and
10309 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10310 this as '1', which is "correct enough" for all architectures,
10311 and don't let the target override. */
10312 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10315 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
10316 "Maximum Operations Per Instruction");
10317 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
10318 "Default is_stmt_start flag");
10319 dw2_asm_output_data (1, DWARF_LINE_BASE,
10320 "Line Base Value (Special Opcodes)");
10321 dw2_asm_output_data (1, DWARF_LINE_RANGE,
10322 "Line Range Value (Special Opcodes)");
10323 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
10324 "Special Opcode Base");
10326 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
10331 case DW_LNS_advance_pc:
10332 case DW_LNS_advance_line:
10333 case DW_LNS_set_file:
10334 case DW_LNS_set_column:
10335 case DW_LNS_fixed_advance_pc:
10336 case DW_LNS_set_isa:
10344 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
10348 /* Write out the information about the files we use. */
10349 output_file_names ();
10350 ASM_OUTPUT_LABEL (asm_out_file, p2);
10353 /* Output the marker for the end of the line number info. */
10354 ASM_OUTPUT_LABEL (asm_out_file, l2);
10358 if (separate_line_info)
10360 dw_line_info_table *table;
10363 FOR_EACH_VEC_ELT (*separate_line_info, i, table)
10366 output_one_line_info_table (table);
10370 if (cold_text_section_line_info && cold_text_section_line_info->in_use)
10372 output_one_line_info_table (cold_text_section_line_info);
10376 /* ??? Some Darwin linkers crash on a .debug_line section with no
10377 sequences. Further, merely a DW_LNE_end_sequence entry is not
10378 sufficient -- the address column must also be initialized.
10379 Make sure to output at least one set_address/end_sequence pair,
10380 choosing .text since that section is always present. */
10381 if (text_section_line_info->in_use || !saw_one)
10382 output_one_line_info_table (text_section_line_info);
10384 /* Output the marker for the end of the line number info. */
10385 ASM_OUTPUT_LABEL (asm_out_file, l2);
10388 /* Given a pointer to a tree node for some base type, return a pointer to
10389 a DIE that describes the given type.
10391 This routine must only be called for GCC type nodes that correspond to
10392 Dwarf base (fundamental) types. */
10395 base_type_die (tree type)
10397 dw_die_ref base_type_result;
10398 enum dwarf_type encoding;
10400 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
10403 /* If this is a subtype that should not be emitted as a subrange type,
10404 use the base type. See subrange_type_for_debug_p. */
10405 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
10406 type = TREE_TYPE (type);
10408 switch (TREE_CODE (type))
10411 if ((dwarf_version >= 4 || !dwarf_strict)
10412 && TYPE_NAME (type)
10413 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10414 && DECL_IS_BUILTIN (TYPE_NAME (type))
10415 && DECL_NAME (TYPE_NAME (type)))
10417 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
10418 if (strcmp (name, "char16_t") == 0
10419 || strcmp (name, "char32_t") == 0)
10421 encoding = DW_ATE_UTF;
10425 if (TYPE_STRING_FLAG (type))
10427 if (TYPE_UNSIGNED (type))
10428 encoding = DW_ATE_unsigned_char;
10430 encoding = DW_ATE_signed_char;
10432 else if (TYPE_UNSIGNED (type))
10433 encoding = DW_ATE_unsigned;
10435 encoding = DW_ATE_signed;
10439 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
10441 if (dwarf_version >= 3 || !dwarf_strict)
10442 encoding = DW_ATE_decimal_float;
10444 encoding = DW_ATE_lo_user;
10447 encoding = DW_ATE_float;
10450 case FIXED_POINT_TYPE:
10451 if (!(dwarf_version >= 3 || !dwarf_strict))
10452 encoding = DW_ATE_lo_user;
10453 else if (TYPE_UNSIGNED (type))
10454 encoding = DW_ATE_unsigned_fixed;
10456 encoding = DW_ATE_signed_fixed;
10459 /* Dwarf2 doesn't know anything about complex ints, so use
10460 a user defined type for it. */
10462 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
10463 encoding = DW_ATE_complex_float;
10465 encoding = DW_ATE_lo_user;
10469 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10470 encoding = DW_ATE_boolean;
10474 /* No other TREE_CODEs are Dwarf fundamental types. */
10475 gcc_unreachable ();
10478 base_type_result = new_die (DW_TAG_base_type, comp_unit_die (), type);
10480 add_AT_unsigned (base_type_result, DW_AT_byte_size,
10481 int_size_in_bytes (type));
10482 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
10483 add_pubtype (type, base_type_result);
10485 return base_type_result;
10488 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10489 named 'auto' in its type: return true for it, false otherwise. */
10492 is_cxx_auto (tree type)
10496 tree name = TYPE_IDENTIFIER (type);
10497 if (name == get_identifier ("auto")
10498 || name == get_identifier ("decltype(auto)"))
10504 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10505 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10508 is_base_type (tree type)
10510 switch (TREE_CODE (type))
10516 case FIXED_POINT_TYPE:
10519 case POINTER_BOUNDS_TYPE:
10525 case QUAL_UNION_TYPE:
10526 case ENUMERAL_TYPE:
10527 case FUNCTION_TYPE:
10530 case REFERENCE_TYPE:
10538 if (is_cxx_auto (type))
10540 gcc_unreachable ();
10546 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10547 node, return the size in bits for the type if it is a constant, or else
10548 return the alignment for the type if the type's size is not constant, or
10549 else return BITS_PER_WORD if the type actually turns out to be an
10550 ERROR_MARK node. */
10552 static inline unsigned HOST_WIDE_INT
10553 simple_type_size_in_bits (const_tree type)
10555 if (TREE_CODE (type) == ERROR_MARK)
10556 return BITS_PER_WORD;
10557 else if (TYPE_SIZE (type) == NULL_TREE)
10559 else if (tree_fits_uhwi_p (TYPE_SIZE (type)))
10560 return tree_to_uhwi (TYPE_SIZE (type));
10562 return TYPE_ALIGN (type);
10565 /* Similarly, but return an offset_int instead of UHWI. */
10567 static inline offset_int
10568 offset_int_type_size_in_bits (const_tree type)
10570 if (TREE_CODE (type) == ERROR_MARK)
10571 return BITS_PER_WORD;
10572 else if (TYPE_SIZE (type) == NULL_TREE)
10574 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
10575 return wi::to_offset (TYPE_SIZE (type));
10577 return TYPE_ALIGN (type);
10580 /* Given a pointer to a tree node for a subrange type, return a pointer
10581 to a DIE that describes the given type. */
10584 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
10586 dw_die_ref subrange_die;
10587 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
10589 if (context_die == NULL)
10590 context_die = comp_unit_die ();
10592 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
10594 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
10596 /* The size of the subrange type and its base type do not match,
10597 so we need to generate a size attribute for the subrange type. */
10598 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
10602 add_bound_info (subrange_die, DW_AT_lower_bound, low, NULL);
10604 add_bound_info (subrange_die, DW_AT_upper_bound, high, NULL);
10606 return subrange_die;
10609 /* Returns the (const and/or volatile) cv_qualifiers associated with
10610 the decl node. This will normally be augmented with the
10611 cv_qualifiers of the underlying type in add_type_attribute. */
10614 decl_quals (const_tree decl)
10616 return ((TREE_READONLY (decl)
10617 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED)
10618 | (TREE_THIS_VOLATILE (decl)
10619 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED));
10622 /* Determine the TYPE whose qualifiers match the largest strict subset
10623 of the given TYPE_QUALS, and return its qualifiers. Ignore all
10624 qualifiers outside QUAL_MASK. */
10627 get_nearest_type_subqualifiers (tree type, int type_quals, int qual_mask)
10630 int best_rank = 0, best_qual = 0, max_rank;
10632 type_quals &= qual_mask;
10633 max_rank = popcount_hwi (type_quals) - 1;
10635 for (t = TYPE_MAIN_VARIANT (type); t && best_rank < max_rank;
10636 t = TYPE_NEXT_VARIANT (t))
10638 int q = TYPE_QUALS (t) & qual_mask;
10640 if ((q & type_quals) == q && q != type_quals
10641 && check_base_type (t, type))
10643 int rank = popcount_hwi (q);
10645 if (rank > best_rank)
10656 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10657 entry that chains various modifiers in front of the given type. */
10660 modified_type_die (tree type, int cv_quals, dw_die_ref context_die)
10662 enum tree_code code = TREE_CODE (type);
10663 dw_die_ref mod_type_die;
10664 dw_die_ref sub_die = NULL;
10665 tree item_type = NULL;
10666 tree qualified_type;
10667 tree name, low, high;
10668 dw_die_ref mod_scope;
10669 /* Only these cv-qualifiers are currently handled. */
10670 const int cv_qual_mask = (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE
10671 | TYPE_QUAL_RESTRICT | TYPE_QUAL_ATOMIC);
10673 if (code == ERROR_MARK)
10676 cv_quals &= cv_qual_mask;
10678 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
10679 tag modifier (and not an attribute) old consumers won't be able
10681 if (dwarf_version < 3)
10682 cv_quals &= ~TYPE_QUAL_RESTRICT;
10684 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
10685 if (dwarf_version < 5)
10686 cv_quals &= ~TYPE_QUAL_ATOMIC;
10688 /* See if we already have the appropriately qualified variant of
10690 qualified_type = get_qualified_type (type, cv_quals);
10692 if (qualified_type == sizetype
10693 && TYPE_NAME (qualified_type)
10694 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
10696 tree t = TREE_TYPE (TYPE_NAME (qualified_type));
10698 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE
10699 && TYPE_PRECISION (t)
10700 == TYPE_PRECISION (qualified_type)
10701 && TYPE_UNSIGNED (t)
10702 == TYPE_UNSIGNED (qualified_type));
10703 qualified_type = t;
10706 /* If we do, then we can just use its DIE, if it exists. */
10707 if (qualified_type)
10709 mod_type_die = lookup_type_die (qualified_type);
10711 return mod_type_die;
10714 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
10716 /* Handle C typedef types. */
10717 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)
10718 && !DECL_ARTIFICIAL (name))
10720 tree dtype = TREE_TYPE (name);
10722 if (qualified_type == dtype)
10724 /* For a named type, use the typedef. */
10725 gen_type_die (qualified_type, context_die);
10726 return lookup_type_die (qualified_type);
10730 int dquals = TYPE_QUALS_NO_ADDR_SPACE (dtype);
10731 dquals &= cv_qual_mask;
10732 if ((dquals & ~cv_quals) != TYPE_UNQUALIFIED
10733 || (cv_quals == dquals && DECL_ORIGINAL_TYPE (name) != type))
10734 /* cv-unqualified version of named type. Just use
10735 the unnamed type to which it refers. */
10736 return modified_type_die (DECL_ORIGINAL_TYPE (name),
10737 cv_quals, context_die);
10738 /* Else cv-qualified version of named type; fall through. */
10742 mod_scope = scope_die_for (type, context_die);
10746 struct qual_info { int q; enum dwarf_tag t; };
10747 static const struct qual_info qual_info[] =
10749 { TYPE_QUAL_ATOMIC, DW_TAG_atomic_type },
10750 { TYPE_QUAL_RESTRICT, DW_TAG_restrict_type },
10751 { TYPE_QUAL_VOLATILE, DW_TAG_volatile_type },
10752 { TYPE_QUAL_CONST, DW_TAG_const_type },
10757 /* Determine a lesser qualified type that most closely matches
10758 this one. Then generate DW_TAG_* entries for the remaining
10760 sub_quals = get_nearest_type_subqualifiers (type, cv_quals,
10762 mod_type_die = modified_type_die (type, sub_quals, context_die);
10764 for (i = 0; i < sizeof (qual_info) / sizeof (qual_info[0]); i++)
10765 if (qual_info[i].q & cv_quals & ~sub_quals)
10767 dw_die_ref d = new_die (qual_info[i].t, mod_scope, type);
10769 add_AT_die_ref (d, DW_AT_type, mod_type_die);
10773 else if (code == POINTER_TYPE)
10775 mod_type_die = new_die (DW_TAG_pointer_type, mod_scope, type);
10776 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10777 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10778 item_type = TREE_TYPE (type);
10779 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
10780 add_AT_unsigned (mod_type_die, DW_AT_address_class,
10781 TYPE_ADDR_SPACE (item_type));
10783 else if (code == REFERENCE_TYPE)
10785 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
10786 mod_type_die = new_die (DW_TAG_rvalue_reference_type, mod_scope,
10789 mod_type_die = new_die (DW_TAG_reference_type, mod_scope, type);
10790 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10791 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10792 item_type = TREE_TYPE (type);
10793 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
10794 add_AT_unsigned (mod_type_die, DW_AT_address_class,
10795 TYPE_ADDR_SPACE (item_type));
10797 else if (code == INTEGER_TYPE
10798 && TREE_TYPE (type) != NULL_TREE
10799 && subrange_type_for_debug_p (type, &low, &high))
10801 mod_type_die = subrange_type_die (type, low, high, context_die);
10802 item_type = TREE_TYPE (type);
10804 else if (is_base_type (type))
10805 mod_type_die = base_type_die (type);
10808 gen_type_die (type, context_die);
10810 /* We have to get the type_main_variant here (and pass that to the
10811 `lookup_type_die' routine) because the ..._TYPE node we have
10812 might simply be a *copy* of some original type node (where the
10813 copy was created to help us keep track of typedef names) and
10814 that copy might have a different TYPE_UID from the original
10816 if (TREE_CODE (type) != VECTOR_TYPE)
10817 return lookup_type_die (type_main_variant (type));
10819 /* Vectors have the debugging information in the type,
10820 not the main variant. */
10821 return lookup_type_die (type);
10824 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10825 don't output a DW_TAG_typedef, since there isn't one in the
10826 user's program; just attach a DW_AT_name to the type.
10827 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10828 if the base type already has the same name. */
10830 && ((TREE_CODE (name) != TYPE_DECL
10831 && (qualified_type == TYPE_MAIN_VARIANT (type)
10832 || (cv_quals == TYPE_UNQUALIFIED)))
10833 || (TREE_CODE (name) == TYPE_DECL
10834 && TREE_TYPE (name) == qualified_type
10835 && DECL_NAME (name))))
10837 if (TREE_CODE (name) == TYPE_DECL)
10838 /* Could just call add_name_and_src_coords_attributes here,
10839 but since this is a builtin type it doesn't have any
10840 useful source coordinates anyway. */
10841 name = DECL_NAME (name);
10842 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
10844 /* This probably indicates a bug. */
10845 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
10847 name = TYPE_IDENTIFIER (type);
10848 add_name_attribute (mod_type_die,
10849 name ? IDENTIFIER_POINTER (name) : "__unknown__");
10852 if (qualified_type)
10853 equate_type_number_to_die (qualified_type, mod_type_die);
10856 /* We must do this after the equate_type_number_to_die call, in case
10857 this is a recursive type. This ensures that the modified_type_die
10858 recursion will terminate even if the type is recursive. Recursive
10859 types are possible in Ada. */
10860 sub_die = modified_type_die (item_type,
10861 TYPE_QUALS_NO_ADDR_SPACE (item_type),
10864 if (sub_die != NULL)
10865 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
10867 add_gnat_descriptive_type_attribute (mod_type_die, type, context_die);
10868 if (TYPE_ARTIFICIAL (type))
10869 add_AT_flag (mod_type_die, DW_AT_artificial, 1);
10871 return mod_type_die;
10874 /* Generate DIEs for the generic parameters of T.
10875 T must be either a generic type or a generic function.
10876 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10879 gen_generic_params_dies (tree t)
10883 dw_die_ref die = NULL;
10886 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
10890 die = lookup_type_die (t);
10891 else if (DECL_P (t))
10892 die = lookup_decl_die (t);
10896 parms = lang_hooks.get_innermost_generic_parms (t);
10898 /* T has no generic parameter. It means T is neither a generic type
10899 or function. End of story. */
10902 parms_num = TREE_VEC_LENGTH (parms);
10903 args = lang_hooks.get_innermost_generic_args (t);
10904 if (TREE_CHAIN (args) && TREE_CODE (TREE_CHAIN (args)) == INTEGER_CST)
10905 non_default = int_cst_value (TREE_CHAIN (args));
10907 non_default = TREE_VEC_LENGTH (args);
10908 for (i = 0; i < parms_num; i++)
10910 tree parm, arg, arg_pack_elems;
10911 dw_die_ref parm_die;
10913 parm = TREE_VEC_ELT (parms, i);
10914 arg = TREE_VEC_ELT (args, i);
10915 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
10916 gcc_assert (parm && TREE_VALUE (parm) && arg);
10918 if (parm && TREE_VALUE (parm) && arg)
10920 /* If PARM represents a template parameter pack,
10921 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10922 by DW_TAG_template_*_parameter DIEs for the argument
10923 pack elements of ARG. Note that ARG would then be
10924 an argument pack. */
10925 if (arg_pack_elems)
10926 parm_die = template_parameter_pack_die (TREE_VALUE (parm),
10930 parm_die = generic_parameter_die (TREE_VALUE (parm), arg,
10931 true /* emit name */, die);
10932 if (i >= non_default)
10933 add_AT_flag (parm_die, DW_AT_default_value, 1);
10938 /* Create and return a DIE for PARM which should be
10939 the representation of a generic type parameter.
10940 For instance, in the C++ front end, PARM would be a template parameter.
10941 ARG is the argument to PARM.
10942 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10944 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10945 as a child node. */
10948 generic_parameter_die (tree parm, tree arg,
10950 dw_die_ref parent_die)
10952 dw_die_ref tmpl_die = NULL;
10953 const char *name = NULL;
10955 if (!parm || !DECL_NAME (parm) || !arg)
10958 /* We support non-type generic parameters and arguments,
10959 type generic parameters and arguments, as well as
10960 generic generic parameters (a.k.a. template template parameters in C++)
10962 if (TREE_CODE (parm) == PARM_DECL)
10963 /* PARM is a nontype generic parameter */
10964 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
10965 else if (TREE_CODE (parm) == TYPE_DECL)
10966 /* PARM is a type generic parameter. */
10967 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
10968 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10969 /* PARM is a generic generic parameter.
10970 Its DIE is a GNU extension. It shall have a
10971 DW_AT_name attribute to represent the name of the template template
10972 parameter, and a DW_AT_GNU_template_name attribute to represent the
10973 name of the template template argument. */
10974 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
10977 gcc_unreachable ();
10983 /* If PARM is a generic parameter pack, it means we are
10984 emitting debug info for a template argument pack element.
10985 In other terms, ARG is a template argument pack element.
10986 In that case, we don't emit any DW_AT_name attribute for
10990 name = IDENTIFIER_POINTER (DECL_NAME (parm));
10992 add_AT_string (tmpl_die, DW_AT_name, name);
10995 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10997 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10998 TMPL_DIE should have a child DW_AT_type attribute that is set
10999 to the type of the argument to PARM, which is ARG.
11000 If PARM is a type generic parameter, TMPL_DIE should have a
11001 child DW_AT_type that is set to ARG. */
11002 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
11003 add_type_attribute (tmpl_die, tmpl_type,
11004 (TREE_THIS_VOLATILE (tmpl_type)
11005 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED),
11010 /* So TMPL_DIE is a DIE representing a
11011 a generic generic template parameter, a.k.a template template
11012 parameter in C++ and arg is a template. */
11014 /* The DW_AT_GNU_template_name attribute of the DIE must be set
11015 to the name of the argument. */
11016 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
11018 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
11021 if (TREE_CODE (parm) == PARM_DECL)
11022 /* So PARM is a non-type generic parameter.
11023 DWARF3 5.6.8 says we must set a DW_AT_const_value child
11024 attribute of TMPL_DIE which value represents the value
11026 We must be careful here:
11027 The value of ARG might reference some function decls.
11028 We might currently be emitting debug info for a generic
11029 type and types are emitted before function decls, we don't
11030 know if the function decls referenced by ARG will actually be
11031 emitted after cgraph computations.
11032 So must defer the generation of the DW_AT_const_value to
11033 after cgraph is ready. */
11034 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
11040 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
11041 PARM_PACK must be a template parameter pack. The returned DIE
11042 will be child DIE of PARENT_DIE. */
11045 template_parameter_pack_die (tree parm_pack,
11046 tree parm_pack_args,
11047 dw_die_ref parent_die)
11052 gcc_assert (parent_die && parm_pack);
11054 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
11055 add_name_and_src_coords_attributes (die, parm_pack);
11056 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
11057 generic_parameter_die (parm_pack,
11058 TREE_VEC_ELT (parm_pack_args, j),
11059 false /* Don't emit DW_AT_name */,
11064 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
11065 an enumerated type. */
11068 type_is_enum (const_tree type)
11070 return TREE_CODE (type) == ENUMERAL_TYPE;
11073 /* Return the DBX register number described by a given RTL node. */
11075 static unsigned int
11076 dbx_reg_number (const_rtx rtl)
11078 unsigned regno = REGNO (rtl);
11080 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
11082 #ifdef LEAF_REG_REMAP
11083 if (crtl->uses_only_leaf_regs)
11085 int leaf_reg = LEAF_REG_REMAP (regno);
11086 if (leaf_reg != -1)
11087 regno = (unsigned) leaf_reg;
11091 regno = DBX_REGISTER_NUMBER (regno);
11092 gcc_assert (regno != INVALID_REGNUM);
11096 /* Optionally add a DW_OP_piece term to a location description expression.
11097 DW_OP_piece is only added if the location description expression already
11098 doesn't end with DW_OP_piece. */
11101 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
11103 dw_loc_descr_ref loc;
11105 if (*list_head != NULL)
11107 /* Find the end of the chain. */
11108 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
11111 if (loc->dw_loc_opc != DW_OP_piece)
11112 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
11116 /* Return a location descriptor that designates a machine register or
11117 zero if there is none. */
11119 static dw_loc_descr_ref
11120 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
11124 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
11127 /* We only use "frame base" when we're sure we're talking about the
11128 post-prologue local stack frame. We do this by *not* running
11129 register elimination until this point, and recognizing the special
11130 argument pointer and soft frame pointer rtx's.
11131 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
11132 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
11133 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
11135 dw_loc_descr_ref result = NULL;
11137 if (dwarf_version >= 4 || !dwarf_strict)
11139 result = mem_loc_descriptor (rtl, GET_MODE (rtl), VOIDmode,
11142 add_loc_descr (&result,
11143 new_loc_descr (DW_OP_stack_value, 0, 0));
11148 regs = targetm.dwarf_register_span (rtl);
11150 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
11151 return multiple_reg_loc_descriptor (rtl, regs, initialized);
11154 unsigned int dbx_regnum = dbx_reg_number (rtl);
11155 if (dbx_regnum == IGNORED_DWARF_REGNUM)
11157 return one_reg_loc_descriptor (dbx_regnum, initialized);
11161 /* Return a location descriptor that designates a machine register for
11162 a given hard register number. */
11164 static dw_loc_descr_ref
11165 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
11167 dw_loc_descr_ref reg_loc_descr;
11171 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
11173 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
11175 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11176 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11178 return reg_loc_descr;
11181 /* Given an RTL of a register, return a location descriptor that
11182 designates a value that spans more than one register. */
11184 static dw_loc_descr_ref
11185 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
11186 enum var_init_status initialized)
11189 dw_loc_descr_ref loc_result = NULL;
11191 /* Simple, contiguous registers. */
11192 if (regs == NULL_RTX)
11194 unsigned reg = REGNO (rtl);
11197 #ifdef LEAF_REG_REMAP
11198 if (crtl->uses_only_leaf_regs)
11200 int leaf_reg = LEAF_REG_REMAP (reg);
11201 if (leaf_reg != -1)
11202 reg = (unsigned) leaf_reg;
11206 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
11207 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
11209 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
11214 dw_loc_descr_ref t;
11216 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
11217 VAR_INIT_STATUS_INITIALIZED);
11218 add_loc_descr (&loc_result, t);
11219 add_loc_descr_op_piece (&loc_result, size);
11225 /* Now onto stupid register sets in non contiguous locations. */
11227 gcc_assert (GET_CODE (regs) == PARALLEL);
11229 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
11232 for (i = 0; i < XVECLEN (regs, 0); ++i)
11234 dw_loc_descr_ref t;
11236 t = one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs, 0, i)),
11237 VAR_INIT_STATUS_INITIALIZED);
11238 add_loc_descr (&loc_result, t);
11239 add_loc_descr_op_piece (&loc_result, size);
11242 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
11243 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11247 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT);
11249 /* Return a location descriptor that designates a constant i,
11250 as a compound operation from constant (i >> shift), constant shift
11253 static dw_loc_descr_ref
11254 int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
11256 dw_loc_descr_ref ret = int_loc_descriptor (i >> shift);
11257 add_loc_descr (&ret, int_loc_descriptor (shift));
11258 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
11262 /* Return a location descriptor that designates a constant. */
11264 static dw_loc_descr_ref
11265 int_loc_descriptor (HOST_WIDE_INT i)
11267 enum dwarf_location_atom op;
11269 /* Pick the smallest representation of a constant, rather than just
11270 defaulting to the LEB encoding. */
11273 int clz = clz_hwi (i);
11274 int ctz = ctz_hwi (i);
11276 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
11277 else if (i <= 0xff)
11278 op = DW_OP_const1u;
11279 else if (i <= 0xffff)
11280 op = DW_OP_const2u;
11281 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
11282 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
11283 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
11284 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
11285 while DW_OP_const4u is 5 bytes. */
11286 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 5);
11287 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11288 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
11289 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
11290 while DW_OP_const4u is 5 bytes. */
11291 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
11292 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
11293 op = DW_OP_const4u;
11294 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11295 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
11296 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11297 while DW_OP_constu of constant >= 0x100000000 takes at least
11299 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
11300 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
11301 && clz + 16 + (size_of_uleb128 (i) > 5 ? 255 : 31)
11302 >= HOST_BITS_PER_WIDE_INT)
11303 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11304 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11305 while DW_OP_constu takes in this case at least 6 bytes. */
11306 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 16);
11307 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
11308 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
11309 && size_of_uleb128 (i) > 6)
11310 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11311 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 32);
11318 op = DW_OP_const1s;
11319 else if (i >= -0x8000)
11320 op = DW_OP_const2s;
11321 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
11323 if (size_of_int_loc_descriptor (i) < 5)
11325 dw_loc_descr_ref ret = int_loc_descriptor (-i);
11326 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11329 op = DW_OP_const4s;
11333 if (size_of_int_loc_descriptor (i)
11334 < (unsigned long) 1 + size_of_sleb128 (i))
11336 dw_loc_descr_ref ret = int_loc_descriptor (-i);
11337 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11344 return new_loc_descr (op, i, 0);
11347 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11348 without actually allocating it. */
11350 static unsigned long
11351 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
11353 return size_of_int_loc_descriptor (i >> shift)
11354 + size_of_int_loc_descriptor (shift)
11358 /* Return size_of_locs (int_loc_descriptor (i)) without
11359 actually allocating it. */
11361 static unsigned long
11362 size_of_int_loc_descriptor (HOST_WIDE_INT i)
11371 else if (i <= 0xff)
11373 else if (i <= 0xffff)
11377 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
11378 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
11379 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11381 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11382 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
11383 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11385 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
11387 s = size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
11388 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11389 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
11390 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11392 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
11393 && clz + 16 + (s > 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT)
11394 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11396 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
11397 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
11399 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11408 else if (i >= -0x8000)
11410 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
11412 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
11414 s = size_of_int_loc_descriptor (-i) + 1;
11422 unsigned long r = 1 + size_of_sleb128 (i);
11423 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
11425 s = size_of_int_loc_descriptor (-i) + 1;
11434 /* Return loc description representing "address" of integer value.
11435 This can appear only as toplevel expression. */
11437 static dw_loc_descr_ref
11438 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
11441 dw_loc_descr_ref loc_result = NULL;
11443 if (!(dwarf_version >= 4 || !dwarf_strict))
11446 litsize = size_of_int_loc_descriptor (i);
11447 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11448 is more compact. For DW_OP_stack_value we need:
11449 litsize + 1 (DW_OP_stack_value)
11450 and for DW_OP_implicit_value:
11451 1 (DW_OP_implicit_value) + 1 (length) + size. */
11452 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
11454 loc_result = int_loc_descriptor (i);
11455 add_loc_descr (&loc_result,
11456 new_loc_descr (DW_OP_stack_value, 0, 0));
11460 loc_result = new_loc_descr (DW_OP_implicit_value,
11462 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
11463 loc_result->dw_loc_oprnd2.v.val_int = i;
11467 /* Return a location descriptor that designates a base+offset location. */
11469 static dw_loc_descr_ref
11470 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
11471 enum var_init_status initialized)
11473 unsigned int regno;
11474 dw_loc_descr_ref result;
11475 dw_fde_ref fde = cfun->fde;
11477 /* We only use "frame base" when we're sure we're talking about the
11478 post-prologue local stack frame. We do this by *not* running
11479 register elimination until this point, and recognizing the special
11480 argument pointer and soft frame pointer rtx's. */
11481 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
11483 rtx elim = (ira_use_lra_p
11484 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
11485 : eliminate_regs (reg, VOIDmode, NULL_RTX));
11489 if (GET_CODE (elim) == PLUS)
11491 offset += INTVAL (XEXP (elim, 1));
11492 elim = XEXP (elim, 0);
11494 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11495 && (elim == hard_frame_pointer_rtx
11496 || elim == stack_pointer_rtx))
11497 || elim == (frame_pointer_needed
11498 ? hard_frame_pointer_rtx
11499 : stack_pointer_rtx));
11501 /* If drap register is used to align stack, use frame
11502 pointer + offset to access stack variables. If stack
11503 is aligned without drap, use stack pointer + offset to
11504 access stack variables. */
11505 if (crtl->stack_realign_tried
11506 && reg == frame_pointer_rtx)
11509 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
11510 ? HARD_FRAME_POINTER_REGNUM
11512 return new_reg_loc_descr (base_reg, offset);
11515 gcc_assert (frame_pointer_fb_offset_valid);
11516 offset += frame_pointer_fb_offset;
11517 return new_loc_descr (DW_OP_fbreg, offset, 0);
11521 regno = REGNO (reg);
11522 #ifdef LEAF_REG_REMAP
11523 if (crtl->uses_only_leaf_regs)
11525 int leaf_reg = LEAF_REG_REMAP (regno);
11526 if (leaf_reg != -1)
11527 regno = (unsigned) leaf_reg;
11530 regno = DWARF_FRAME_REGNUM (regno);
11532 if (!optimize && fde
11533 && (fde->drap_reg == regno || fde->vdrap_reg == regno))
11535 /* Use cfa+offset to represent the location of arguments passed
11536 on the stack when drap is used to align stack.
11537 Only do this when not optimizing, for optimized code var-tracking
11538 is supposed to track where the arguments live and the register
11539 used as vdrap or drap in some spot might be used for something
11540 else in other part of the routine. */
11541 return new_loc_descr (DW_OP_fbreg, offset, 0);
11545 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
11548 result = new_loc_descr (DW_OP_bregx, regno, offset);
11550 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11551 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11556 /* Return true if this RTL expression describes a base+offset calculation. */
11559 is_based_loc (const_rtx rtl)
11561 return (GET_CODE (rtl) == PLUS
11562 && ((REG_P (XEXP (rtl, 0))
11563 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
11564 && CONST_INT_P (XEXP (rtl, 1)))));
11567 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11570 static dw_loc_descr_ref
11571 tls_mem_loc_descriptor (rtx mem)
11574 dw_loc_descr_ref loc_result;
11576 if (MEM_EXPR (mem) == NULL_TREE || !MEM_OFFSET_KNOWN_P (mem))
11579 base = get_base_address (MEM_EXPR (mem));
11581 || TREE_CODE (base) != VAR_DECL
11582 || !DECL_THREAD_LOCAL_P (base))
11585 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1, NULL);
11586 if (loc_result == NULL)
11589 if (MEM_OFFSET (mem))
11590 loc_descr_plus_const (&loc_result, MEM_OFFSET (mem));
11595 /* Output debug info about reason why we failed to expand expression as dwarf
11599 expansion_failed (tree expr, rtx rtl, char const *reason)
11601 if (dump_file && (dump_flags & TDF_DETAILS))
11603 fprintf (dump_file, "Failed to expand as dwarf: ");
11605 print_generic_expr (dump_file, expr, dump_flags);
11608 fprintf (dump_file, "\n");
11609 print_rtl (dump_file, rtl);
11611 fprintf (dump_file, "\nReason: %s\n", reason);
11615 /* Helper function for const_ok_for_output. */
11618 const_ok_for_output_1 (rtx rtl)
11620 if (GET_CODE (rtl) == UNSPEC)
11622 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11623 we can't express it in the debug info. */
11624 #ifdef ENABLE_CHECKING
11625 /* Don't complain about TLS UNSPECs, those are just too hard to
11626 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11627 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11628 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11629 if (XVECLEN (rtl, 0) == 0
11630 || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
11631 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE)
11632 inform (current_function_decl
11633 ? DECL_SOURCE_LOCATION (current_function_decl)
11634 : UNKNOWN_LOCATION,
11635 #if NUM_UNSPEC_VALUES > 0
11636 "non-delegitimized UNSPEC %s (%d) found in variable location",
11637 ((XINT (rtl, 1) >= 0 && XINT (rtl, 1) < NUM_UNSPEC_VALUES)
11638 ? unspec_strings[XINT (rtl, 1)] : "unknown"),
11641 "non-delegitimized UNSPEC %d found in variable location",
11645 expansion_failed (NULL_TREE, rtl,
11646 "UNSPEC hasn't been delegitimized.\n");
11650 if (targetm.const_not_ok_for_debug_p (rtl))
11652 expansion_failed (NULL_TREE, rtl,
11653 "Expression rejected for debug by the backend.\n");
11657 /* FIXME: Refer to PR60655. It is possible for simplification
11658 of rtl expressions in var tracking to produce such expressions.
11659 We should really identify / validate expressions
11660 enclosed in CONST that can be handled by assemblers on various
11661 targets and only handle legitimate cases here. */
11662 if (GET_CODE (rtl) != SYMBOL_REF)
11664 if (GET_CODE (rtl) == NOT)
11669 if (CONSTANT_POOL_ADDRESS_P (rtl))
11672 get_pool_constant_mark (rtl, &marked);
11673 /* If all references to this pool constant were optimized away,
11674 it was not output and thus we can't represent it. */
11677 expansion_failed (NULL_TREE, rtl,
11678 "Constant was removed from constant pool.\n");
11683 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11686 /* Avoid references to external symbols in debug info, on several targets
11687 the linker might even refuse to link when linking a shared library,
11688 and in many other cases the relocations for .debug_info/.debug_loc are
11689 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11690 to be defined within the same shared library or executable are fine. */
11691 if (SYMBOL_REF_EXTERNAL_P (rtl))
11693 tree decl = SYMBOL_REF_DECL (rtl);
11695 if (decl == NULL || !targetm.binds_local_p (decl))
11697 expansion_failed (NULL_TREE, rtl,
11698 "Symbol not defined in current TU.\n");
11706 /* Return true if constant RTL can be emitted in DW_OP_addr or
11707 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11708 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11711 const_ok_for_output (rtx rtl)
11713 if (GET_CODE (rtl) == SYMBOL_REF)
11714 return const_ok_for_output_1 (rtl);
11716 if (GET_CODE (rtl) == CONST)
11718 subrtx_var_iterator::array_type array;
11719 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 0), ALL)
11720 if (!const_ok_for_output_1 (*iter))
11728 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11729 if possible, NULL otherwise. */
11732 base_type_for_mode (machine_mode mode, bool unsignedp)
11734 dw_die_ref type_die;
11735 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
11739 switch (TREE_CODE (type))
11747 type_die = lookup_type_die (type);
11749 type_die = modified_type_die (type, TYPE_UNQUALIFIED, comp_unit_die ());
11750 if (type_die == NULL || type_die->die_tag != DW_TAG_base_type)
11755 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11756 type matching MODE, or, if MODE is narrower than or as wide as
11757 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11760 static dw_loc_descr_ref
11761 convert_descriptor_to_mode (machine_mode mode, dw_loc_descr_ref op)
11763 machine_mode outer_mode = mode;
11764 dw_die_ref type_die;
11765 dw_loc_descr_ref cvt;
11767 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
11769 add_loc_descr (&op, new_loc_descr (DW_OP_GNU_convert, 0, 0));
11772 type_die = base_type_for_mode (outer_mode, 1);
11773 if (type_die == NULL)
11775 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11776 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11777 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11778 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11779 add_loc_descr (&op, cvt);
11783 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11785 static dw_loc_descr_ref
11786 compare_loc_descriptor (enum dwarf_location_atom op, dw_loc_descr_ref op0,
11787 dw_loc_descr_ref op1)
11789 dw_loc_descr_ref ret = op0;
11790 add_loc_descr (&ret, op1);
11791 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
11792 if (STORE_FLAG_VALUE != 1)
11794 add_loc_descr (&ret, int_loc_descriptor (STORE_FLAG_VALUE));
11795 add_loc_descr (&ret, new_loc_descr (DW_OP_mul, 0, 0));
11800 /* Return location descriptor for signed comparison OP RTL. */
11802 static dw_loc_descr_ref
11803 scompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
11804 machine_mode mem_mode)
11806 machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
11807 dw_loc_descr_ref op0, op1;
11810 if (op_mode == VOIDmode)
11811 op_mode = GET_MODE (XEXP (rtl, 1));
11812 if (op_mode == VOIDmode)
11816 && (GET_MODE_CLASS (op_mode) != MODE_INT
11817 || GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE))
11820 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
11821 VAR_INIT_STATUS_INITIALIZED);
11822 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
11823 VAR_INIT_STATUS_INITIALIZED);
11825 if (op0 == NULL || op1 == NULL)
11828 if (GET_MODE_CLASS (op_mode) != MODE_INT
11829 || GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
11830 return compare_loc_descriptor (op, op0, op1);
11832 if (GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
11834 dw_die_ref type_die = base_type_for_mode (op_mode, 0);
11835 dw_loc_descr_ref cvt;
11837 if (type_die == NULL)
11839 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11840 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11841 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11842 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11843 add_loc_descr (&op0, cvt);
11844 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11845 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11846 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11847 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11848 add_loc_descr (&op1, cvt);
11849 return compare_loc_descriptor (op, op0, op1);
11852 shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode)) * BITS_PER_UNIT;
11853 /* For eq/ne, if the operands are known to be zero-extended,
11854 there is no need to do the fancy shifting up. */
11855 if (op == DW_OP_eq || op == DW_OP_ne)
11857 dw_loc_descr_ref last0, last1;
11858 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
11860 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
11862 /* deref_size zero extends, and for constants we can check
11863 whether they are zero extended or not. */
11864 if (((last0->dw_loc_opc == DW_OP_deref_size
11865 && last0->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
11866 || (CONST_INT_P (XEXP (rtl, 0))
11867 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
11868 == (INTVAL (XEXP (rtl, 0)) & GET_MODE_MASK (op_mode))))
11869 && ((last1->dw_loc_opc == DW_OP_deref_size
11870 && last1->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
11871 || (CONST_INT_P (XEXP (rtl, 1))
11872 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 1))
11873 == (INTVAL (XEXP (rtl, 1)) & GET_MODE_MASK (op_mode)))))
11874 return compare_loc_descriptor (op, op0, op1);
11876 /* EQ/NE comparison against constant in narrower type than
11877 DWARF2_ADDR_SIZE can be performed either as
11878 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11881 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11882 DW_OP_{eq,ne}. Pick whatever is shorter. */
11883 if (CONST_INT_P (XEXP (rtl, 1))
11884 && GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
11885 && (size_of_int_loc_descriptor (shift) + 1
11886 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift)
11887 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode)) + 1
11888 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1))
11889 & GET_MODE_MASK (op_mode))))
11891 add_loc_descr (&op0, int_loc_descriptor (GET_MODE_MASK (op_mode)));
11892 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11893 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1))
11894 & GET_MODE_MASK (op_mode));
11895 return compare_loc_descriptor (op, op0, op1);
11898 add_loc_descr (&op0, int_loc_descriptor (shift));
11899 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11900 if (CONST_INT_P (XEXP (rtl, 1)))
11901 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
11904 add_loc_descr (&op1, int_loc_descriptor (shift));
11905 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11907 return compare_loc_descriptor (op, op0, op1);
11910 /* Return location descriptor for unsigned comparison OP RTL. */
11912 static dw_loc_descr_ref
11913 ucompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
11914 machine_mode mem_mode)
11916 machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
11917 dw_loc_descr_ref op0, op1;
11919 if (op_mode == VOIDmode)
11920 op_mode = GET_MODE (XEXP (rtl, 1));
11921 if (op_mode == VOIDmode)
11923 if (GET_MODE_CLASS (op_mode) != MODE_INT)
11926 if (dwarf_strict && GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
11929 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
11930 VAR_INIT_STATUS_INITIALIZED);
11931 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
11932 VAR_INIT_STATUS_INITIALIZED);
11934 if (op0 == NULL || op1 == NULL)
11937 if (GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
11939 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
11940 dw_loc_descr_ref last0, last1;
11941 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
11943 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
11945 if (CONST_INT_P (XEXP (rtl, 0)))
11946 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
11947 /* deref_size zero extends, so no need to mask it again. */
11948 else if (last0->dw_loc_opc != DW_OP_deref_size
11949 || last0->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
11951 add_loc_descr (&op0, int_loc_descriptor (mask));
11952 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11954 if (CONST_INT_P (XEXP (rtl, 1)))
11955 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
11956 /* deref_size zero extends, so no need to mask it again. */
11957 else if (last1->dw_loc_opc != DW_OP_deref_size
11958 || last1->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
11960 add_loc_descr (&op1, int_loc_descriptor (mask));
11961 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
11964 else if (GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
11966 HOST_WIDE_INT bias = 1;
11967 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
11968 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11969 if (CONST_INT_P (XEXP (rtl, 1)))
11970 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
11971 + INTVAL (XEXP (rtl, 1)));
11973 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
11976 return compare_loc_descriptor (op, op0, op1);
11979 /* Return location descriptor for {U,S}{MIN,MAX}. */
11981 static dw_loc_descr_ref
11982 minmax_loc_descriptor (rtx rtl, machine_mode mode,
11983 machine_mode mem_mode)
11985 enum dwarf_location_atom op;
11986 dw_loc_descr_ref op0, op1, ret;
11987 dw_loc_descr_ref bra_node, drop_node;
11990 && (GET_MODE_CLASS (mode) != MODE_INT
11991 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE))
11994 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11995 VAR_INIT_STATUS_INITIALIZED);
11996 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
11997 VAR_INIT_STATUS_INITIALIZED);
11999 if (op0 == NULL || op1 == NULL)
12002 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
12003 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
12004 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
12005 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
12007 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12009 HOST_WIDE_INT mask = GET_MODE_MASK (mode);
12010 add_loc_descr (&op0, int_loc_descriptor (mask));
12011 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
12012 add_loc_descr (&op1, int_loc_descriptor (mask));
12013 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
12015 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
12017 HOST_WIDE_INT bias = 1;
12018 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
12019 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
12020 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
12023 else if (GET_MODE_CLASS (mode) == MODE_INT
12024 && GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12026 int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (mode)) * BITS_PER_UNIT;
12027 add_loc_descr (&op0, int_loc_descriptor (shift));
12028 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
12029 add_loc_descr (&op1, int_loc_descriptor (shift));
12030 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
12032 else if (GET_MODE_CLASS (mode) == MODE_INT
12033 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12035 dw_die_ref type_die = base_type_for_mode (mode, 0);
12036 dw_loc_descr_ref cvt;
12037 if (type_die == NULL)
12039 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12040 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12041 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12042 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12043 add_loc_descr (&op0, cvt);
12044 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12045 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12046 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12047 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12048 add_loc_descr (&op1, cvt);
12051 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
12056 add_loc_descr (&ret, op1);
12057 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
12058 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
12059 add_loc_descr (&ret, bra_node);
12060 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12061 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
12062 add_loc_descr (&ret, drop_node);
12063 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12064 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
12065 if ((GET_CODE (rtl) == SMIN || GET_CODE (rtl) == SMAX)
12066 && GET_MODE_CLASS (mode) == MODE_INT
12067 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12068 ret = convert_descriptor_to_mode (mode, ret);
12072 /* Helper function for mem_loc_descriptor. Perform OP binary op,
12073 but after converting arguments to type_die, afterwards
12074 convert back to unsigned. */
12076 static dw_loc_descr_ref
12077 typed_binop (enum dwarf_location_atom op, rtx rtl, dw_die_ref type_die,
12078 machine_mode mode, machine_mode mem_mode)
12080 dw_loc_descr_ref cvt, op0, op1;
12082 if (type_die == NULL)
12084 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12085 VAR_INIT_STATUS_INITIALIZED);
12086 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12087 VAR_INIT_STATUS_INITIALIZED);
12088 if (op0 == NULL || op1 == NULL)
12090 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12091 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12092 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12093 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12094 add_loc_descr (&op0, cvt);
12095 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12096 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12097 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12098 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12099 add_loc_descr (&op1, cvt);
12100 add_loc_descr (&op0, op1);
12101 add_loc_descr (&op0, new_loc_descr (op, 0, 0));
12102 return convert_descriptor_to_mode (mode, op0);
12105 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
12106 const0 is DW_OP_lit0 or corresponding typed constant,
12107 const1 is DW_OP_lit1 or corresponding typed constant
12108 and constMSB is constant with just the MSB bit set
12110 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12111 L1: const0 DW_OP_swap
12112 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
12113 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12118 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12119 L1: const0 DW_OP_swap
12120 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12121 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12126 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
12127 L1: const1 DW_OP_swap
12128 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12129 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12133 static dw_loc_descr_ref
12134 clz_loc_descriptor (rtx rtl, machine_mode mode,
12135 machine_mode mem_mode)
12137 dw_loc_descr_ref op0, ret, tmp;
12138 HOST_WIDE_INT valv;
12139 dw_loc_descr_ref l1jump, l1label;
12140 dw_loc_descr_ref l2jump, l2label;
12141 dw_loc_descr_ref l3jump, l3label;
12142 dw_loc_descr_ref l4jump, l4label;
12145 if (GET_MODE_CLASS (mode) != MODE_INT
12146 || GET_MODE (XEXP (rtl, 0)) != mode)
12149 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12150 VAR_INIT_STATUS_INITIALIZED);
12154 if (GET_CODE (rtl) == CLZ)
12156 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode, valv))
12157 valv = GET_MODE_BITSIZE (mode);
12159 else if (GET_CODE (rtl) == FFS)
12161 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode, valv))
12162 valv = GET_MODE_BITSIZE (mode);
12163 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12164 l1jump = new_loc_descr (DW_OP_bra, 0, 0);
12165 add_loc_descr (&ret, l1jump);
12166 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
12167 tmp = mem_loc_descriptor (GEN_INT (valv), mode, mem_mode,
12168 VAR_INIT_STATUS_INITIALIZED);
12171 add_loc_descr (&ret, tmp);
12172 l4jump = new_loc_descr (DW_OP_skip, 0, 0);
12173 add_loc_descr (&ret, l4jump);
12174 l1label = mem_loc_descriptor (GET_CODE (rtl) == FFS
12175 ? const1_rtx : const0_rtx,
12177 VAR_INIT_STATUS_INITIALIZED);
12178 if (l1label == NULL)
12180 add_loc_descr (&ret, l1label);
12181 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12182 l2label = new_loc_descr (DW_OP_dup, 0, 0);
12183 add_loc_descr (&ret, l2label);
12184 if (GET_CODE (rtl) != CLZ)
12186 else if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
12187 msb = GEN_INT ((unsigned HOST_WIDE_INT) 1
12188 << (GET_MODE_BITSIZE (mode) - 1));
12190 msb = immed_wide_int_const
12191 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode) - 1,
12192 GET_MODE_PRECISION (mode)), mode);
12193 if (GET_CODE (msb) == CONST_INT && INTVAL (msb) < 0)
12194 tmp = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
12195 ? DW_OP_const4u : HOST_BITS_PER_WIDE_INT == 64
12196 ? DW_OP_const8u : DW_OP_constu, INTVAL (msb), 0);
12198 tmp = mem_loc_descriptor (msb, mode, mem_mode,
12199 VAR_INIT_STATUS_INITIALIZED);
12202 add_loc_descr (&ret, tmp);
12203 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12204 l3jump = new_loc_descr (DW_OP_bra, 0, 0);
12205 add_loc_descr (&ret, l3jump);
12206 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12207 VAR_INIT_STATUS_INITIALIZED);
12210 add_loc_descr (&ret, tmp);
12211 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == CLZ
12212 ? DW_OP_shl : DW_OP_shr, 0, 0));
12213 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12214 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 1, 0));
12215 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12216 l2jump = new_loc_descr (DW_OP_skip, 0, 0);
12217 add_loc_descr (&ret, l2jump);
12218 l3label = new_loc_descr (DW_OP_drop, 0, 0);
12219 add_loc_descr (&ret, l3label);
12220 l4label = new_loc_descr (DW_OP_nop, 0, 0);
12221 add_loc_descr (&ret, l4label);
12222 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12223 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12224 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12225 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12226 l3jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12227 l3jump->dw_loc_oprnd1.v.val_loc = l3label;
12228 l4jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12229 l4jump->dw_loc_oprnd1.v.val_loc = l4label;
12233 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
12234 const1 is DW_OP_lit1 or corresponding typed constant):
12236 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12237 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12241 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12242 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12245 static dw_loc_descr_ref
12246 popcount_loc_descriptor (rtx rtl, machine_mode mode,
12247 machine_mode mem_mode)
12249 dw_loc_descr_ref op0, ret, tmp;
12250 dw_loc_descr_ref l1jump, l1label;
12251 dw_loc_descr_ref l2jump, l2label;
12253 if (GET_MODE_CLASS (mode) != MODE_INT
12254 || GET_MODE (XEXP (rtl, 0)) != mode)
12257 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12258 VAR_INIT_STATUS_INITIALIZED);
12262 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12263 VAR_INIT_STATUS_INITIALIZED);
12266 add_loc_descr (&ret, tmp);
12267 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12268 l1label = new_loc_descr (DW_OP_dup, 0, 0);
12269 add_loc_descr (&ret, l1label);
12270 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
12271 add_loc_descr (&ret, l2jump);
12272 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12273 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
12274 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12275 VAR_INIT_STATUS_INITIALIZED);
12278 add_loc_descr (&ret, tmp);
12279 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12280 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == POPCOUNT
12281 ? DW_OP_plus : DW_OP_xor, 0, 0));
12282 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12283 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12284 VAR_INIT_STATUS_INITIALIZED);
12285 add_loc_descr (&ret, tmp);
12286 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12287 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
12288 add_loc_descr (&ret, l1jump);
12289 l2label = new_loc_descr (DW_OP_drop, 0, 0);
12290 add_loc_descr (&ret, l2label);
12291 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12292 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12293 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12294 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12298 /* BSWAP (constS is initial shift count, either 56 or 24):
12300 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
12301 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
12302 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
12303 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
12304 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
12306 static dw_loc_descr_ref
12307 bswap_loc_descriptor (rtx rtl, machine_mode mode,
12308 machine_mode mem_mode)
12310 dw_loc_descr_ref op0, ret, tmp;
12311 dw_loc_descr_ref l1jump, l1label;
12312 dw_loc_descr_ref l2jump, l2label;
12314 if (GET_MODE_CLASS (mode) != MODE_INT
12315 || BITS_PER_UNIT != 8
12316 || (GET_MODE_BITSIZE (mode) != 32
12317 && GET_MODE_BITSIZE (mode) != 64))
12320 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12321 VAR_INIT_STATUS_INITIALIZED);
12326 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
12328 VAR_INIT_STATUS_INITIALIZED);
12331 add_loc_descr (&ret, tmp);
12332 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12333 VAR_INIT_STATUS_INITIALIZED);
12336 add_loc_descr (&ret, tmp);
12337 l1label = new_loc_descr (DW_OP_pick, 2, 0);
12338 add_loc_descr (&ret, l1label);
12339 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
12341 VAR_INIT_STATUS_INITIALIZED);
12342 add_loc_descr (&ret, tmp);
12343 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 3, 0));
12344 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
12345 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12346 tmp = mem_loc_descriptor (GEN_INT (255), mode, mem_mode,
12347 VAR_INIT_STATUS_INITIALIZED);
12350 add_loc_descr (&ret, tmp);
12351 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12352 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 2, 0));
12353 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
12354 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
12355 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12356 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12357 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12358 VAR_INIT_STATUS_INITIALIZED);
12359 add_loc_descr (&ret, tmp);
12360 add_loc_descr (&ret, new_loc_descr (DW_OP_eq, 0, 0));
12361 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
12362 add_loc_descr (&ret, l2jump);
12363 tmp = mem_loc_descriptor (GEN_INT (8), mode, mem_mode,
12364 VAR_INIT_STATUS_INITIALIZED);
12365 add_loc_descr (&ret, tmp);
12366 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
12367 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12368 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
12369 add_loc_descr (&ret, l1jump);
12370 l2label = new_loc_descr (DW_OP_drop, 0, 0);
12371 add_loc_descr (&ret, l2label);
12372 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12373 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
12374 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12375 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12376 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12377 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12381 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12382 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12383 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12384 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12386 ROTATERT is similar:
12387 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12388 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12389 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12391 static dw_loc_descr_ref
12392 rotate_loc_descriptor (rtx rtl, machine_mode mode,
12393 machine_mode mem_mode)
12395 rtx rtlop1 = XEXP (rtl, 1);
12396 dw_loc_descr_ref op0, op1, ret, mask[2] = { NULL, NULL };
12399 if (GET_MODE_CLASS (mode) != MODE_INT)
12402 if (GET_MODE (rtlop1) != VOIDmode
12403 && GET_MODE_BITSIZE (GET_MODE (rtlop1)) < GET_MODE_BITSIZE (mode))
12404 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
12405 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12406 VAR_INIT_STATUS_INITIALIZED);
12407 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
12408 VAR_INIT_STATUS_INITIALIZED);
12409 if (op0 == NULL || op1 == NULL)
12411 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12412 for (i = 0; i < 2; i++)
12414 if (GET_MODE_BITSIZE (mode) < HOST_BITS_PER_WIDE_INT)
12415 mask[i] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode)),
12417 VAR_INIT_STATUS_INITIALIZED);
12418 else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
12419 mask[i] = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
12421 : HOST_BITS_PER_WIDE_INT == 64
12422 ? DW_OP_const8u : DW_OP_constu,
12423 GET_MODE_MASK (mode), 0);
12426 if (mask[i] == NULL)
12428 add_loc_descr (&mask[i], new_loc_descr (DW_OP_and, 0, 0));
12431 add_loc_descr (&ret, op1);
12432 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
12433 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
12434 if (GET_CODE (rtl) == ROTATERT)
12436 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
12437 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
12438 GET_MODE_BITSIZE (mode), 0));
12440 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
12441 if (mask[0] != NULL)
12442 add_loc_descr (&ret, mask[0]);
12443 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
12444 if (mask[1] != NULL)
12446 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12447 add_loc_descr (&ret, mask[1]);
12448 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12450 if (GET_CODE (rtl) == ROTATE)
12452 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
12453 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
12454 GET_MODE_BITSIZE (mode), 0));
12456 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12457 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
12461 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12462 for DEBUG_PARAMETER_REF RTL. */
12464 static dw_loc_descr_ref
12465 parameter_ref_descriptor (rtx rtl)
12467 dw_loc_descr_ref ret;
12472 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl)) == PARM_DECL);
12473 ref = lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl));
12474 ret = new_loc_descr (DW_OP_GNU_parameter_ref, 0, 0);
12477 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12478 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
12479 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
12483 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
12484 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_PARAMETER_REF_DECL (rtl);
12489 /* The following routine converts the RTL for a variable or parameter
12490 (resident in memory) into an equivalent Dwarf representation of a
12491 mechanism for getting the address of that same variable onto the top of a
12492 hypothetical "address evaluation" stack.
12494 When creating memory location descriptors, we are effectively transforming
12495 the RTL for a memory-resident object into its Dwarf postfix expression
12496 equivalent. This routine recursively descends an RTL tree, turning
12497 it into Dwarf postfix code as it goes.
12499 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12501 MEM_MODE is the mode of the memory reference, needed to handle some
12502 autoincrement addressing modes.
12504 Return 0 if we can't represent the location. */
12507 mem_loc_descriptor (rtx rtl, machine_mode mode,
12508 machine_mode mem_mode,
12509 enum var_init_status initialized)
12511 dw_loc_descr_ref mem_loc_result = NULL;
12512 enum dwarf_location_atom op;
12513 dw_loc_descr_ref op0, op1;
12514 rtx inner = NULL_RTX;
12516 if (mode == VOIDmode)
12517 mode = GET_MODE (rtl);
12519 /* Note that for a dynamically sized array, the location we will generate a
12520 description of here will be the lowest numbered location which is
12521 actually within the array. That's *not* necessarily the same as the
12522 zeroth element of the array. */
12524 rtl = targetm.delegitimize_address (rtl);
12526 if (mode != GET_MODE (rtl) && GET_MODE (rtl) != VOIDmode)
12529 switch (GET_CODE (rtl))
12534 return mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, initialized);
12537 /* The case of a subreg may arise when we have a local (register)
12538 variable or a formal (register) parameter which doesn't quite fill
12539 up an entire register. For now, just assume that it is
12540 legitimate to make the Dwarf info refer to the whole register which
12541 contains the given subreg. */
12542 if (!subreg_lowpart_p (rtl))
12544 inner = SUBREG_REG (rtl);
12546 if (inner == NULL_RTX)
12547 inner = XEXP (rtl, 0);
12548 if (GET_MODE_CLASS (mode) == MODE_INT
12549 && GET_MODE_CLASS (GET_MODE (inner)) == MODE_INT
12550 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12551 #ifdef POINTERS_EXTEND_UNSIGNED
12552 || (mode == Pmode && mem_mode != VOIDmode)
12555 && GET_MODE_SIZE (GET_MODE (inner)) <= DWARF2_ADDR_SIZE)
12557 mem_loc_result = mem_loc_descriptor (inner,
12559 mem_mode, initialized);
12564 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (inner)))
12566 if (GET_MODE_SIZE (mode) != GET_MODE_SIZE (GET_MODE (inner))
12567 && (GET_MODE_CLASS (mode) != MODE_INT
12568 || GET_MODE_CLASS (GET_MODE (inner)) != MODE_INT))
12572 dw_die_ref type_die;
12573 dw_loc_descr_ref cvt;
12575 mem_loc_result = mem_loc_descriptor (inner,
12577 mem_mode, initialized);
12578 if (mem_loc_result == NULL)
12580 type_die = base_type_for_mode (mode,
12581 GET_MODE_CLASS (mode) == MODE_INT);
12582 if (type_die == NULL)
12584 mem_loc_result = NULL;
12587 if (GET_MODE_SIZE (mode)
12588 != GET_MODE_SIZE (GET_MODE (inner)))
12589 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12591 cvt = new_loc_descr (DW_OP_GNU_reinterpret, 0, 0);
12592 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12593 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12594 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12595 add_loc_descr (&mem_loc_result, cvt);
12600 if (GET_MODE_CLASS (mode) != MODE_INT
12601 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12602 && rtl != arg_pointer_rtx
12603 && rtl != frame_pointer_rtx
12604 #ifdef POINTERS_EXTEND_UNSIGNED
12605 && (mode != Pmode || mem_mode == VOIDmode)
12609 dw_die_ref type_die;
12610 unsigned int dbx_regnum;
12614 if (REGNO (rtl) > FIRST_PSEUDO_REGISTER)
12616 type_die = base_type_for_mode (mode,
12617 GET_MODE_CLASS (mode) == MODE_INT);
12618 if (type_die == NULL)
12621 dbx_regnum = dbx_reg_number (rtl);
12622 if (dbx_regnum == IGNORED_DWARF_REGNUM)
12624 mem_loc_result = new_loc_descr (DW_OP_GNU_regval_type,
12626 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
12627 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die;
12628 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0;
12631 /* Whenever a register number forms a part of the description of the
12632 method for calculating the (dynamic) address of a memory resident
12633 object, DWARF rules require the register number be referred to as
12634 a "base register". This distinction is not based in any way upon
12635 what category of register the hardware believes the given register
12636 belongs to. This is strictly DWARF terminology we're dealing with
12637 here. Note that in cases where the location of a memory-resident
12638 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12639 OP_CONST (0)) the actual DWARF location descriptor that we generate
12640 may just be OP_BASEREG (basereg). This may look deceptively like
12641 the object in question was allocated to a register (rather than in
12642 memory) so DWARF consumers need to be aware of the subtle
12643 distinction between OP_REG and OP_BASEREG. */
12644 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
12645 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
12646 else if (stack_realign_drap
12648 && crtl->args.internal_arg_pointer == rtl
12649 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
12651 /* If RTL is internal_arg_pointer, which has been optimized
12652 out, use DRAP instead. */
12653 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
12654 VAR_INIT_STATUS_INITIALIZED);
12660 if (GET_MODE_CLASS (mode) != MODE_INT)
12662 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
12663 mem_mode, VAR_INIT_STATUS_INITIALIZED);
12666 else if (GET_CODE (rtl) == ZERO_EXTEND
12667 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12668 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
12669 < HOST_BITS_PER_WIDE_INT
12670 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12671 to expand zero extend as two shifts instead of
12673 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= 4)
12675 machine_mode imode = GET_MODE (XEXP (rtl, 0));
12676 mem_loc_result = op0;
12677 add_loc_descr (&mem_loc_result,
12678 int_loc_descriptor (GET_MODE_MASK (imode)));
12679 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_and, 0, 0));
12681 else if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
12683 int shift = DWARF2_ADDR_SIZE
12684 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
12685 shift *= BITS_PER_UNIT;
12686 if (GET_CODE (rtl) == SIGN_EXTEND)
12690 mem_loc_result = op0;
12691 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12692 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
12693 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12694 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12696 else if (!dwarf_strict)
12698 dw_die_ref type_die1, type_die2;
12699 dw_loc_descr_ref cvt;
12701 type_die1 = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
12702 GET_CODE (rtl) == ZERO_EXTEND);
12703 if (type_die1 == NULL)
12705 type_die2 = base_type_for_mode (mode, 1);
12706 if (type_die2 == NULL)
12708 mem_loc_result = op0;
12709 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12710 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12711 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die1;
12712 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12713 add_loc_descr (&mem_loc_result, cvt);
12714 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12715 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12716 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die2;
12717 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12718 add_loc_descr (&mem_loc_result, cvt);
12724 rtx new_rtl = avoid_constant_pool_reference (rtl);
12725 if (new_rtl != rtl)
12727 mem_loc_result = mem_loc_descriptor (new_rtl, mode, mem_mode,
12729 if (mem_loc_result != NULL)
12730 return mem_loc_result;
12733 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0),
12734 get_address_mode (rtl), mode,
12735 VAR_INIT_STATUS_INITIALIZED);
12736 if (mem_loc_result == NULL)
12737 mem_loc_result = tls_mem_loc_descriptor (rtl);
12738 if (mem_loc_result != NULL)
12740 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12741 || GET_MODE_CLASS (mode) != MODE_INT)
12743 dw_die_ref type_die;
12744 dw_loc_descr_ref deref;
12749 = base_type_for_mode (mode, GET_MODE_CLASS (mode) == MODE_INT);
12750 if (type_die == NULL)
12752 deref = new_loc_descr (DW_OP_GNU_deref_type,
12753 GET_MODE_SIZE (mode), 0);
12754 deref->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
12755 deref->dw_loc_oprnd2.v.val_die_ref.die = type_die;
12756 deref->dw_loc_oprnd2.v.val_die_ref.external = 0;
12757 add_loc_descr (&mem_loc_result, deref);
12759 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
12760 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
12762 add_loc_descr (&mem_loc_result,
12763 new_loc_descr (DW_OP_deref_size,
12764 GET_MODE_SIZE (mode), 0));
12769 return mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, initialized);
12772 /* Some ports can transform a symbol ref into a label ref, because
12773 the symbol ref is too far away and has to be dumped into a constant
12777 if ((GET_MODE_CLASS (mode) != MODE_INT
12778 && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
12779 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12780 #ifdef POINTERS_EXTEND_UNSIGNED
12781 && (mode != Pmode || mem_mode == VOIDmode)
12785 if (GET_CODE (rtl) == SYMBOL_REF
12786 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
12788 dw_loc_descr_ref temp;
12790 /* If this is not defined, we have no way to emit the data. */
12791 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
12794 temp = new_addr_loc_descr (rtl, dtprel_true);
12796 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
12797 add_loc_descr (&mem_loc_result, temp);
12802 if (!const_ok_for_output (rtl))
12804 if (GET_CODE (rtl) == CONST)
12805 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12811 mem_loc_result = new_addr_loc_descr (rtl, dtprel_false);
12812 vec_safe_push (used_rtx_array, rtl);
12818 case DEBUG_IMPLICIT_PTR:
12819 expansion_failed (NULL_TREE, rtl,
12820 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12826 if (REG_P (ENTRY_VALUE_EXP (rtl)))
12828 if (GET_MODE_CLASS (mode) != MODE_INT
12829 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12830 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
12831 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12834 unsigned int dbx_regnum = dbx_reg_number (ENTRY_VALUE_EXP (rtl));
12835 if (dbx_regnum == IGNORED_DWARF_REGNUM)
12837 op0 = one_reg_loc_descriptor (dbx_regnum,
12838 VAR_INIT_STATUS_INITIALIZED);
12841 else if (MEM_P (ENTRY_VALUE_EXP (rtl))
12842 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl), 0)))
12844 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
12845 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12846 if (op0 && op0->dw_loc_opc == DW_OP_fbreg)
12850 gcc_unreachable ();
12853 mem_loc_result = new_loc_descr (DW_OP_GNU_entry_value, 0, 0);
12854 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_loc;
12855 mem_loc_result->dw_loc_oprnd1.v.val_loc = op0;
12858 case DEBUG_PARAMETER_REF:
12859 mem_loc_result = parameter_ref_descriptor (rtl);
12863 /* Extract the PLUS expression nested inside and fall into
12864 PLUS code below. */
12865 rtl = XEXP (rtl, 1);
12870 /* Turn these into a PLUS expression and fall into the PLUS code
12872 rtl = gen_rtx_PLUS (mode, XEXP (rtl, 0),
12873 gen_int_mode (GET_CODE (rtl) == PRE_INC
12874 ? GET_MODE_UNIT_SIZE (mem_mode)
12875 : -GET_MODE_UNIT_SIZE (mem_mode),
12878 /* ... fall through ... */
12882 if (is_based_loc (rtl)
12883 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12884 || XEXP (rtl, 0) == arg_pointer_rtx
12885 || XEXP (rtl, 0) == frame_pointer_rtx)
12886 && GET_MODE_CLASS (mode) == MODE_INT)
12887 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
12888 INTVAL (XEXP (rtl, 1)),
12889 VAR_INIT_STATUS_INITIALIZED);
12892 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12893 VAR_INIT_STATUS_INITIALIZED);
12894 if (mem_loc_result == 0)
12897 if (CONST_INT_P (XEXP (rtl, 1))
12898 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
12899 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
12902 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12903 VAR_INIT_STATUS_INITIALIZED);
12906 add_loc_descr (&mem_loc_result, op1);
12907 add_loc_descr (&mem_loc_result,
12908 new_loc_descr (DW_OP_plus, 0, 0));
12913 /* If a pseudo-reg is optimized away, it is possible for it to
12914 be replaced with a MEM containing a multiply or shift. */
12925 && GET_MODE_CLASS (mode) == MODE_INT
12926 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12928 mem_loc_result = typed_binop (DW_OP_div, rtl,
12929 base_type_for_mode (mode, 0),
12953 if (GET_MODE_CLASS (mode) != MODE_INT)
12955 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12956 VAR_INIT_STATUS_INITIALIZED);
12958 rtx rtlop1 = XEXP (rtl, 1);
12959 if (GET_MODE (rtlop1) != VOIDmode
12960 && GET_MODE_BITSIZE (GET_MODE (rtlop1))
12961 < GET_MODE_BITSIZE (mode))
12962 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
12963 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
12964 VAR_INIT_STATUS_INITIALIZED);
12967 if (op0 == 0 || op1 == 0)
12970 mem_loc_result = op0;
12971 add_loc_descr (&mem_loc_result, op1);
12972 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12988 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12989 VAR_INIT_STATUS_INITIALIZED);
12990 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12991 VAR_INIT_STATUS_INITIALIZED);
12993 if (op0 == 0 || op1 == 0)
12996 mem_loc_result = op0;
12997 add_loc_descr (&mem_loc_result, op1);
12998 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13002 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE && !dwarf_strict)
13004 mem_loc_result = typed_binop (DW_OP_mod, rtl,
13005 base_type_for_mode (mode, 0),
13010 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
13011 VAR_INIT_STATUS_INITIALIZED);
13012 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
13013 VAR_INIT_STATUS_INITIALIZED);
13015 if (op0 == 0 || op1 == 0)
13018 mem_loc_result = op0;
13019 add_loc_descr (&mem_loc_result, op1);
13020 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13021 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13022 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
13023 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13024 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
13028 if (!dwarf_strict && GET_MODE_CLASS (mode) == MODE_INT)
13030 if (GET_MODE_CLASS (mode) > DWARF2_ADDR_SIZE)
13035 mem_loc_result = typed_binop (DW_OP_div, rtl,
13036 base_type_for_mode (mode, 1),
13054 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
13055 VAR_INIT_STATUS_INITIALIZED);
13060 mem_loc_result = op0;
13061 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13065 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
13066 #ifdef POINTERS_EXTEND_UNSIGNED
13068 && mem_mode != VOIDmode
13069 && trunc_int_for_mode (INTVAL (rtl), ptr_mode) == INTVAL (rtl))
13073 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13077 && (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT
13078 || GET_MODE_BITSIZE (mode) == HOST_BITS_PER_DOUBLE_INT))
13080 dw_die_ref type_die = base_type_for_mode (mode, 1);
13081 machine_mode amode;
13082 if (type_die == NULL)
13084 amode = mode_for_size (DWARF2_ADDR_SIZE * BITS_PER_UNIT,
13086 if (INTVAL (rtl) >= 0
13087 && amode != BLKmode
13088 && trunc_int_for_mode (INTVAL (rtl), amode) == INTVAL (rtl)
13089 /* const DW_OP_GNU_convert <XXX> vs.
13090 DW_OP_GNU_const_type <XXX, 1, const>. */
13091 && size_of_int_loc_descriptor (INTVAL (rtl)) + 1 + 1
13092 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode))
13094 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13095 op0 = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13096 op0->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13097 op0->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13098 op0->dw_loc_oprnd1.v.val_die_ref.external = 0;
13099 add_loc_descr (&mem_loc_result, op0);
13100 return mem_loc_result;
13102 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0,
13104 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13105 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13106 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13107 if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
13108 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
13111 mem_loc_result->dw_loc_oprnd2.val_class
13112 = dw_val_class_const_double;
13113 mem_loc_result->dw_loc_oprnd2.v.val_double
13114 = double_int::from_shwi (INTVAL (rtl));
13122 dw_die_ref type_die;
13124 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
13125 CONST_DOUBLE rtx could represent either a large integer
13126 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
13127 the value is always a floating point constant.
13129 When it is an integer, a CONST_DOUBLE is used whenever
13130 the constant requires 2 HWIs to be adequately represented.
13131 We output CONST_DOUBLEs as blocks. */
13132 if (mode == VOIDmode
13133 || (GET_MODE (rtl) == VOIDmode
13134 && GET_MODE_BITSIZE (mode) != HOST_BITS_PER_DOUBLE_INT))
13136 type_die = base_type_for_mode (mode,
13137 GET_MODE_CLASS (mode) == MODE_INT);
13138 if (type_die == NULL)
13140 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
13141 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13142 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13143 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13144 #if TARGET_SUPPORTS_WIDE_INT == 0
13145 if (!SCALAR_FLOAT_MODE_P (mode))
13147 mem_loc_result->dw_loc_oprnd2.val_class
13148 = dw_val_class_const_double;
13149 mem_loc_result->dw_loc_oprnd2.v.val_double
13150 = rtx_to_double_int (rtl);
13155 unsigned int length = GET_MODE_SIZE (mode);
13156 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
13158 insert_float (rtl, array);
13159 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13160 mem_loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
13161 mem_loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
13162 mem_loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13167 case CONST_WIDE_INT:
13170 dw_die_ref type_die;
13172 type_die = base_type_for_mode (mode,
13173 GET_MODE_CLASS (mode) == MODE_INT);
13174 if (type_die == NULL)
13176 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
13177 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13178 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13179 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13180 mem_loc_result->dw_loc_oprnd2.val_class
13181 = dw_val_class_wide_int;
13182 mem_loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
13183 *mem_loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode);
13188 mem_loc_result = scompare_loc_descriptor (DW_OP_eq, rtl, mem_mode);
13192 mem_loc_result = scompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
13196 mem_loc_result = scompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
13200 mem_loc_result = scompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
13204 mem_loc_result = scompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
13208 mem_loc_result = scompare_loc_descriptor (DW_OP_ne, rtl, mem_mode);
13212 mem_loc_result = ucompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
13216 mem_loc_result = ucompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
13220 mem_loc_result = ucompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
13224 mem_loc_result = ucompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
13229 if (GET_MODE_CLASS (mode) != MODE_INT)
13234 mem_loc_result = minmax_loc_descriptor (rtl, mode, mem_mode);
13239 if (CONST_INT_P (XEXP (rtl, 1))
13240 && CONST_INT_P (XEXP (rtl, 2))
13241 && ((unsigned) INTVAL (XEXP (rtl, 1))
13242 + (unsigned) INTVAL (XEXP (rtl, 2))
13243 <= GET_MODE_BITSIZE (mode))
13244 && GET_MODE_CLASS (mode) == MODE_INT
13245 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
13246 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
13249 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
13250 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13253 if (GET_CODE (rtl) == SIGN_EXTRACT)
13257 mem_loc_result = op0;
13258 size = INTVAL (XEXP (rtl, 1));
13259 shift = INTVAL (XEXP (rtl, 2));
13260 if (BITS_BIG_ENDIAN)
13261 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
13263 if (shift + size != (int) DWARF2_ADDR_SIZE)
13265 add_loc_descr (&mem_loc_result,
13266 int_loc_descriptor (DWARF2_ADDR_SIZE
13268 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
13270 if (size != (int) DWARF2_ADDR_SIZE)
13272 add_loc_descr (&mem_loc_result,
13273 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
13274 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13281 dw_loc_descr_ref op2, bra_node, drop_node;
13282 op0 = mem_loc_descriptor (XEXP (rtl, 0),
13283 GET_MODE (XEXP (rtl, 0)) == VOIDmode
13284 ? word_mode : GET_MODE (XEXP (rtl, 0)),
13285 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13286 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
13287 VAR_INIT_STATUS_INITIALIZED);
13288 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode, mem_mode,
13289 VAR_INIT_STATUS_INITIALIZED);
13290 if (op0 == NULL || op1 == NULL || op2 == NULL)
13293 mem_loc_result = op1;
13294 add_loc_descr (&mem_loc_result, op2);
13295 add_loc_descr (&mem_loc_result, op0);
13296 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
13297 add_loc_descr (&mem_loc_result, bra_node);
13298 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
13299 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
13300 add_loc_descr (&mem_loc_result, drop_node);
13301 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
13302 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
13307 case FLOAT_TRUNCATE:
13309 case UNSIGNED_FLOAT:
13314 dw_die_ref type_die;
13315 dw_loc_descr_ref cvt;
13317 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
13318 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13321 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) == MODE_INT
13322 && (GET_CODE (rtl) == FLOAT
13323 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)))
13324 <= DWARF2_ADDR_SIZE))
13326 type_die = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
13327 GET_CODE (rtl) == UNSIGNED_FLOAT);
13328 if (type_die == NULL)
13330 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13331 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13332 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13333 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13334 add_loc_descr (&op0, cvt);
13336 type_die = base_type_for_mode (mode, GET_CODE (rtl) == UNSIGNED_FIX);
13337 if (type_die == NULL)
13339 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13340 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13341 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13342 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13343 add_loc_descr (&op0, cvt);
13344 if (GET_MODE_CLASS (mode) == MODE_INT
13345 && (GET_CODE (rtl) == FIX
13346 || GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE))
13348 op0 = convert_descriptor_to_mode (mode, op0);
13352 mem_loc_result = op0;
13359 mem_loc_result = clz_loc_descriptor (rtl, mode, mem_mode);
13364 mem_loc_result = popcount_loc_descriptor (rtl, mode, mem_mode);
13368 mem_loc_result = bswap_loc_descriptor (rtl, mode, mem_mode);
13373 mem_loc_result = rotate_loc_descriptor (rtl, mode, mem_mode);
13377 /* In theory, we could implement the above. */
13378 /* DWARF cannot represent the unsigned compare operations
13403 case FRACT_CONVERT:
13404 case UNSIGNED_FRACT_CONVERT:
13406 case UNSIGNED_SAT_FRACT:
13412 case VEC_DUPLICATE:
13416 case STRICT_LOW_PART:
13421 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13422 can't express it in the debug info. This can happen e.g. with some
13427 resolve_one_addr (&rtl);
13431 #ifdef ENABLE_CHECKING
13432 print_rtl (stderr, rtl);
13433 gcc_unreachable ();
13439 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13440 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13442 return mem_loc_result;
13445 /* Return a descriptor that describes the concatenation of two locations.
13446 This is typically a complex variable. */
13448 static dw_loc_descr_ref
13449 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
13451 dw_loc_descr_ref cc_loc_result = NULL;
13452 dw_loc_descr_ref x0_ref
13453 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13454 dw_loc_descr_ref x1_ref
13455 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13457 if (x0_ref == 0 || x1_ref == 0)
13460 cc_loc_result = x0_ref;
13461 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
13463 add_loc_descr (&cc_loc_result, x1_ref);
13464 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
13466 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13467 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13469 return cc_loc_result;
13472 /* Return a descriptor that describes the concatenation of N
13475 static dw_loc_descr_ref
13476 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
13479 dw_loc_descr_ref cc_loc_result = NULL;
13480 unsigned int n = XVECLEN (concatn, 0);
13482 for (i = 0; i < n; ++i)
13484 dw_loc_descr_ref ref;
13485 rtx x = XVECEXP (concatn, 0, i);
13487 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13491 add_loc_descr (&cc_loc_result, ref);
13492 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
13495 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13496 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13498 return cc_loc_result;
13501 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13502 for DEBUG_IMPLICIT_PTR RTL. */
13504 static dw_loc_descr_ref
13505 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
13507 dw_loc_descr_ref ret;
13512 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
13513 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
13514 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
13515 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
13516 ret = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
13517 ret->dw_loc_oprnd2.val_class = dw_val_class_const;
13520 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13521 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
13522 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
13526 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
13527 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl);
13532 /* Output a proper Dwarf location descriptor for a variable or parameter
13533 which is either allocated in a register or in a memory location. For a
13534 register, we just generate an OP_REG and the register number. For a
13535 memory location we provide a Dwarf postfix expression describing how to
13536 generate the (dynamic) address of the object onto the address stack.
13538 MODE is mode of the decl if this loc_descriptor is going to be used in
13539 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13540 allowed, VOIDmode otherwise.
13542 If we don't know how to describe it, return 0. */
13544 static dw_loc_descr_ref
13545 loc_descriptor (rtx rtl, machine_mode mode,
13546 enum var_init_status initialized)
13548 dw_loc_descr_ref loc_result = NULL;
13550 switch (GET_CODE (rtl))
13553 /* The case of a subreg may arise when we have a local (register)
13554 variable or a formal (register) parameter which doesn't quite fill
13555 up an entire register. For now, just assume that it is
13556 legitimate to make the Dwarf info refer to the whole register which
13557 contains the given subreg. */
13558 if (REG_P (SUBREG_REG (rtl)) && subreg_lowpart_p (rtl))
13559 loc_result = loc_descriptor (SUBREG_REG (rtl),
13560 GET_MODE (SUBREG_REG (rtl)), initialized);
13566 loc_result = reg_loc_descriptor (rtl, initialized);
13570 loc_result = mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
13571 GET_MODE (rtl), initialized);
13572 if (loc_result == NULL)
13573 loc_result = tls_mem_loc_descriptor (rtl);
13574 if (loc_result == NULL)
13576 rtx new_rtl = avoid_constant_pool_reference (rtl);
13577 if (new_rtl != rtl)
13578 loc_result = loc_descriptor (new_rtl, mode, initialized);
13583 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
13588 loc_result = concatn_loc_descriptor (rtl, initialized);
13593 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
13595 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
13596 if (GET_CODE (loc) == EXPR_LIST)
13597 loc = XEXP (loc, 0);
13598 loc_result = loc_descriptor (loc, mode, initialized);
13602 rtl = XEXP (rtl, 1);
13607 rtvec par_elems = XVEC (rtl, 0);
13608 int num_elem = GET_NUM_ELEM (par_elems);
13612 /* Create the first one, so we have something to add to. */
13613 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
13614 VOIDmode, initialized);
13615 if (loc_result == NULL)
13617 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
13618 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13619 for (i = 1; i < num_elem; i++)
13621 dw_loc_descr_ref temp;
13623 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
13624 VOIDmode, initialized);
13627 add_loc_descr (&loc_result, temp);
13628 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
13629 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13635 if (mode != VOIDmode && mode != BLKmode)
13636 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
13641 if (mode == VOIDmode)
13642 mode = GET_MODE (rtl);
13644 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13646 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13648 /* Note that a CONST_DOUBLE rtx could represent either an integer
13649 or a floating-point constant. A CONST_DOUBLE is used whenever
13650 the constant requires more than one word in order to be
13651 adequately represented. We output CONST_DOUBLEs as blocks. */
13652 loc_result = new_loc_descr (DW_OP_implicit_value,
13653 GET_MODE_SIZE (mode), 0);
13654 #if TARGET_SUPPORTS_WIDE_INT == 0
13655 if (!SCALAR_FLOAT_MODE_P (mode))
13657 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
13658 loc_result->dw_loc_oprnd2.v.val_double
13659 = rtx_to_double_int (rtl);
13664 unsigned int length = GET_MODE_SIZE (mode);
13665 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
13667 insert_float (rtl, array);
13668 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13669 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
13670 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
13671 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13676 case CONST_WIDE_INT:
13677 if (mode == VOIDmode)
13678 mode = GET_MODE (rtl);
13680 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13682 loc_result = new_loc_descr (DW_OP_implicit_value,
13683 GET_MODE_SIZE (mode), 0);
13684 loc_result->dw_loc_oprnd2.val_class = dw_val_class_wide_int;
13685 loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
13686 *loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode);
13691 if (mode == VOIDmode)
13692 mode = GET_MODE (rtl);
13694 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13696 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
13697 unsigned int length = CONST_VECTOR_NUNITS (rtl);
13698 unsigned char *array
13699 = ggc_vec_alloc<unsigned char> (length * elt_size);
13702 machine_mode imode = GET_MODE_INNER (mode);
13704 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13705 switch (GET_MODE_CLASS (mode))
13707 case MODE_VECTOR_INT:
13708 for (i = 0, p = array; i < length; i++, p += elt_size)
13710 rtx elt = CONST_VECTOR_ELT (rtl, i);
13711 insert_wide_int (std::make_pair (elt, imode), p, elt_size);
13715 case MODE_VECTOR_FLOAT:
13716 for (i = 0, p = array; i < length; i++, p += elt_size)
13718 rtx elt = CONST_VECTOR_ELT (rtl, i);
13719 insert_float (elt, p);
13724 gcc_unreachable ();
13727 loc_result = new_loc_descr (DW_OP_implicit_value,
13728 length * elt_size, 0);
13729 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13730 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
13731 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
13732 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13737 if (mode == VOIDmode
13738 || CONST_SCALAR_INT_P (XEXP (rtl, 0))
13739 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl, 0))
13740 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
13742 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
13747 if (!const_ok_for_output (rtl))
13750 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
13751 && (dwarf_version >= 4 || !dwarf_strict))
13753 loc_result = new_addr_loc_descr (rtl, dtprel_false);
13754 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
13755 vec_safe_push (used_rtx_array, rtl);
13759 case DEBUG_IMPLICIT_PTR:
13760 loc_result = implicit_ptr_descriptor (rtl, 0);
13764 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR
13765 && CONST_INT_P (XEXP (rtl, 1)))
13768 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1)));
13774 if ((GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
13775 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
13776 && dwarf_version >= 4)
13777 || (!dwarf_strict && mode != VOIDmode && mode != BLKmode))
13779 /* Value expression. */
13780 loc_result = mem_loc_descriptor (rtl, mode, VOIDmode, initialized);
13782 add_loc_descr (&loc_result,
13783 new_loc_descr (DW_OP_stack_value, 0, 0));
13791 /* We need to figure out what section we should use as the base for the
13792 address ranges where a given location is valid.
13793 1. If this particular DECL has a section associated with it, use that.
13794 2. If this function has a section associated with it, use that.
13795 3. Otherwise, use the text section.
13796 XXX: If you split a variable across multiple sections, we won't notice. */
13798 static const char *
13799 secname_for_decl (const_tree decl)
13801 const char *secname;
13803 if (VAR_OR_FUNCTION_DECL_P (decl)
13804 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl) || TREE_STATIC (decl))
13805 && DECL_SECTION_NAME (decl))
13806 secname = DECL_SECTION_NAME (decl);
13807 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
13808 secname = DECL_SECTION_NAME (current_function_decl);
13809 else if (cfun && in_cold_section_p)
13810 secname = crtl->subsections.cold_section_label;
13812 secname = text_section_label;
13817 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13820 decl_by_reference_p (tree decl)
13822 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
13823 || TREE_CODE (decl) == VAR_DECL)
13824 && DECL_BY_REFERENCE (decl));
13827 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13830 static dw_loc_descr_ref
13831 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
13832 enum var_init_status initialized)
13834 int have_address = 0;
13835 dw_loc_descr_ref descr;
13838 if (want_address != 2)
13840 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
13842 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
13844 varloc = PAT_VAR_LOCATION_LOC (varloc);
13845 if (GET_CODE (varloc) == EXPR_LIST)
13846 varloc = XEXP (varloc, 0);
13847 mode = GET_MODE (varloc);
13848 if (MEM_P (varloc))
13850 rtx addr = XEXP (varloc, 0);
13851 descr = mem_loc_descriptor (addr, get_address_mode (varloc),
13852 mode, initialized);
13857 rtx x = avoid_constant_pool_reference (varloc);
13859 descr = mem_loc_descriptor (x, mode, VOIDmode,
13864 descr = mem_loc_descriptor (varloc, mode, VOIDmode, initialized);
13871 if (GET_CODE (varloc) == VAR_LOCATION)
13872 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
13874 mode = DECL_MODE (loc);
13875 descr = loc_descriptor (varloc, mode, initialized);
13882 if (want_address == 2 && !have_address
13883 && (dwarf_version >= 4 || !dwarf_strict))
13885 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
13887 expansion_failed (loc, NULL_RTX,
13888 "DWARF address size mismatch");
13891 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
13894 /* Show if we can't fill the request for an address. */
13895 if (want_address && !have_address)
13897 expansion_failed (loc, NULL_RTX,
13898 "Want address and only have value");
13902 /* If we've got an address and don't want one, dereference. */
13903 if (!want_address && have_address)
13905 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
13906 enum dwarf_location_atom op;
13908 if (size > DWARF2_ADDR_SIZE || size == -1)
13910 expansion_failed (loc, NULL_RTX,
13911 "DWARF address size mismatch");
13914 else if (size == DWARF2_ADDR_SIZE)
13917 op = DW_OP_deref_size;
13919 add_loc_descr (&descr, new_loc_descr (op, size, 0));
13925 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13926 if it is not possible. */
13928 static dw_loc_descr_ref
13929 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
13931 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
13932 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
13933 else if (dwarf_version >= 3 || !dwarf_strict)
13934 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
13939 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13940 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13942 static dw_loc_descr_ref
13943 dw_sra_loc_expr (tree decl, rtx loc)
13946 unsigned HOST_WIDE_INT padsize = 0;
13947 dw_loc_descr_ref descr, *descr_tail;
13948 unsigned HOST_WIDE_INT decl_size;
13950 enum var_init_status initialized;
13952 if (DECL_SIZE (decl) == NULL
13953 || !tree_fits_uhwi_p (DECL_SIZE (decl)))
13956 decl_size = tree_to_uhwi (DECL_SIZE (decl));
13958 descr_tail = &descr;
13960 for (p = loc; p; p = XEXP (p, 1))
13962 unsigned HOST_WIDE_INT bitsize = decl_piece_bitsize (p);
13963 rtx loc_note = *decl_piece_varloc_ptr (p);
13964 dw_loc_descr_ref cur_descr;
13965 dw_loc_descr_ref *tail, last = NULL;
13966 unsigned HOST_WIDE_INT opsize = 0;
13968 if (loc_note == NULL_RTX
13969 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
13971 padsize += bitsize;
13974 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
13975 varloc = NOTE_VAR_LOCATION (loc_note);
13976 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
13977 if (cur_descr == NULL)
13979 padsize += bitsize;
13983 /* Check that cur_descr either doesn't use
13984 DW_OP_*piece operations, or their sum is equal
13985 to bitsize. Otherwise we can't embed it. */
13986 for (tail = &cur_descr; *tail != NULL;
13987 tail = &(*tail)->dw_loc_next)
13988 if ((*tail)->dw_loc_opc == DW_OP_piece)
13990 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
13994 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
13996 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
14000 if (last != NULL && opsize != bitsize)
14002 padsize += bitsize;
14003 /* Discard the current piece of the descriptor and release any
14004 addr_table entries it uses. */
14005 remove_loc_list_addr_table_entries (cur_descr);
14009 /* If there is a hole, add DW_OP_*piece after empty DWARF
14010 expression, which means that those bits are optimized out. */
14013 if (padsize > decl_size)
14015 remove_loc_list_addr_table_entries (cur_descr);
14016 goto discard_descr;
14018 decl_size -= padsize;
14019 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
14020 if (*descr_tail == NULL)
14022 remove_loc_list_addr_table_entries (cur_descr);
14023 goto discard_descr;
14025 descr_tail = &(*descr_tail)->dw_loc_next;
14028 *descr_tail = cur_descr;
14030 if (bitsize > decl_size)
14031 goto discard_descr;
14032 decl_size -= bitsize;
14035 HOST_WIDE_INT offset = 0;
14036 if (GET_CODE (varloc) == VAR_LOCATION
14037 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
14039 varloc = PAT_VAR_LOCATION_LOC (varloc);
14040 if (GET_CODE (varloc) == EXPR_LIST)
14041 varloc = XEXP (varloc, 0);
14045 if (GET_CODE (varloc) == CONST
14046 || GET_CODE (varloc) == SIGN_EXTEND
14047 || GET_CODE (varloc) == ZERO_EXTEND)
14048 varloc = XEXP (varloc, 0);
14049 else if (GET_CODE (varloc) == SUBREG)
14050 varloc = SUBREG_REG (varloc);
14055 /* DW_OP_bit_size offset should be zero for register
14056 or implicit location descriptions and empty location
14057 descriptions, but for memory addresses needs big endian
14059 if (MEM_P (varloc))
14061 unsigned HOST_WIDE_INT memsize
14062 = MEM_SIZE (varloc) * BITS_PER_UNIT;
14063 if (memsize != bitsize)
14065 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
14066 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
14067 goto discard_descr;
14068 if (memsize < bitsize)
14069 goto discard_descr;
14070 if (BITS_BIG_ENDIAN)
14071 offset = memsize - bitsize;
14075 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
14076 if (*descr_tail == NULL)
14077 goto discard_descr;
14078 descr_tail = &(*descr_tail)->dw_loc_next;
14082 /* If there were any non-empty expressions, add padding till the end of
14084 if (descr != NULL && decl_size != 0)
14086 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
14087 if (*descr_tail == NULL)
14088 goto discard_descr;
14093 /* Discard the descriptor and release any addr_table entries it uses. */
14094 remove_loc_list_addr_table_entries (descr);
14098 /* Return the dwarf representation of the location list LOC_LIST of
14099 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14102 static dw_loc_list_ref
14103 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
14105 const char *endname, *secname;
14107 enum var_init_status initialized;
14108 struct var_loc_node *node;
14109 dw_loc_descr_ref descr;
14110 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
14111 dw_loc_list_ref list = NULL;
14112 dw_loc_list_ref *listp = &list;
14114 /* Now that we know what section we are using for a base,
14115 actually construct the list of locations.
14116 The first location information is what is passed to the
14117 function that creates the location list, and the remaining
14118 locations just get added on to that list.
14119 Note that we only know the start address for a location
14120 (IE location changes), so to build the range, we use
14121 the range [current location start, next location start].
14122 This means we have to special case the last node, and generate
14123 a range of [last location start, end of function label]. */
14125 secname = secname_for_decl (decl);
14127 for (node = loc_list->first; node; node = node->next)
14128 if (GET_CODE (node->loc) == EXPR_LIST
14129 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
14131 if (GET_CODE (node->loc) == EXPR_LIST)
14133 /* This requires DW_OP_{,bit_}piece, which is not usable
14134 inside DWARF expressions. */
14135 if (want_address != 2)
14137 descr = dw_sra_loc_expr (decl, node->loc);
14143 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14144 varloc = NOTE_VAR_LOCATION (node->loc);
14145 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
14149 bool range_across_switch = false;
14150 /* If section switch happens in between node->label
14151 and node->next->label (or end of function) and
14152 we can't emit it as a single entry list,
14153 emit two ranges, first one ending at the end
14154 of first partition and second one starting at the
14155 beginning of second partition. */
14156 if (node == loc_list->last_before_switch
14157 && (node != loc_list->first || loc_list->first->next)
14158 && current_function_decl)
14160 endname = cfun->fde->dw_fde_end;
14161 range_across_switch = true;
14163 /* The variable has a location between NODE->LABEL and
14164 NODE->NEXT->LABEL. */
14165 else if (node->next)
14166 endname = node->next->label;
14167 /* If the variable has a location at the last label
14168 it keeps its location until the end of function. */
14169 else if (!current_function_decl)
14170 endname = text_end_label;
14173 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
14174 current_function_funcdef_no);
14175 endname = ggc_strdup (label_id);
14178 *listp = new_loc_list (descr, node->label, endname, secname);
14179 if (TREE_CODE (decl) == PARM_DECL
14180 && node == loc_list->first
14181 && NOTE_P (node->loc)
14182 && strcmp (node->label, endname) == 0)
14183 (*listp)->force = true;
14184 listp = &(*listp)->dw_loc_next;
14186 if (range_across_switch)
14188 if (GET_CODE (node->loc) == EXPR_LIST)
14189 descr = dw_sra_loc_expr (decl, node->loc);
14192 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14193 varloc = NOTE_VAR_LOCATION (node->loc);
14194 descr = dw_loc_list_1 (decl, varloc, want_address,
14197 gcc_assert (descr);
14198 /* The variable has a location between NODE->LABEL and
14199 NODE->NEXT->LABEL. */
14201 endname = node->next->label;
14203 endname = cfun->fde->dw_fde_second_end;
14204 *listp = new_loc_list (descr,
14205 cfun->fde->dw_fde_second_begin,
14207 listp = &(*listp)->dw_loc_next;
14212 /* Try to avoid the overhead of a location list emitting a location
14213 expression instead, but only if we didn't have more than one
14214 location entry in the first place. If some entries were not
14215 representable, we don't want to pretend a single entry that was
14216 applies to the entire scope in which the variable is
14218 if (list && loc_list->first->next)
14224 /* Return if the loc_list has only single element and thus can be represented
14225 as location description. */
14228 single_element_loc_list_p (dw_loc_list_ref list)
14230 gcc_assert (!list->dw_loc_next || list->ll_symbol);
14231 return !list->ll_symbol;
14234 /* To each location in list LIST add loc descr REF. */
14237 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
14239 dw_loc_descr_ref copy;
14240 add_loc_descr (&list->expr, ref);
14241 list = list->dw_loc_next;
14244 copy = ggc_alloc<dw_loc_descr_node> ();
14245 memcpy (copy, ref, sizeof (dw_loc_descr_node));
14246 add_loc_descr (&list->expr, copy);
14247 while (copy->dw_loc_next)
14249 dw_loc_descr_ref new_copy = ggc_alloc<dw_loc_descr_node> ();
14250 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
14251 copy->dw_loc_next = new_copy;
14254 list = list->dw_loc_next;
14258 /* Given two lists RET and LIST
14259 produce location list that is result of adding expression in LIST
14260 to expression in RET on each position in program.
14261 Might be destructive on both RET and LIST.
14263 TODO: We handle only simple cases of RET or LIST having at most one
14264 element. General case would inolve sorting the lists in program order
14265 and merging them that will need some additional work.
14266 Adding that will improve quality of debug info especially for SRA-ed
14270 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
14279 if (!list->dw_loc_next)
14281 add_loc_descr_to_each (*ret, list->expr);
14284 if (!(*ret)->dw_loc_next)
14286 add_loc_descr_to_each (list, (*ret)->expr);
14290 expansion_failed (NULL_TREE, NULL_RTX,
14291 "Don't know how to merge two non-trivial"
14292 " location lists.\n");
14297 /* LOC is constant expression. Try a luck, look it up in constant
14298 pool and return its loc_descr of its address. */
14300 static dw_loc_descr_ref
14301 cst_pool_loc_descr (tree loc)
14303 /* Get an RTL for this, if something has been emitted. */
14304 rtx rtl = lookup_constant_def (loc);
14306 if (!rtl || !MEM_P (rtl))
14311 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
14313 /* TODO: We might get more coverage if we was actually delaying expansion
14314 of all expressions till end of compilation when constant pools are fully
14316 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
14318 expansion_failed (loc, NULL_RTX,
14319 "CST value in contant pool but not marked.");
14322 return mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
14323 GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED);
14326 /* Return dw_loc_list representing address of addr_expr LOC
14327 by looking for inner INDIRECT_REF expression and turning
14328 it into simple arithmetics.
14330 See loc_list_from_tree for the meaning of CONTEXT. */
14332 static dw_loc_list_ref
14333 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev,
14334 const loc_descr_context *context)
14337 HOST_WIDE_INT bitsize, bitpos, bytepos;
14339 int unsignedp, volatilep = 0;
14340 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14342 obj = get_inner_reference (TREE_OPERAND (loc, 0),
14343 &bitsize, &bitpos, &offset, &mode,
14344 &unsignedp, &volatilep, false);
14346 if (bitpos % BITS_PER_UNIT)
14348 expansion_failed (loc, NULL_RTX, "bitfield access");
14351 if (!INDIRECT_REF_P (obj))
14353 expansion_failed (obj,
14354 NULL_RTX, "no indirect ref in inner refrence");
14357 if (!offset && !bitpos)
14358 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1,
14361 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
14362 && (dwarf_version >= 4 || !dwarf_strict))
14364 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0, context);
14369 /* Variable offset. */
14370 list_ret1 = loc_list_from_tree (offset, 0, context);
14371 if (list_ret1 == 0)
14373 add_loc_list (&list_ret, list_ret1);
14376 add_loc_descr_to_each (list_ret,
14377 new_loc_descr (DW_OP_plus, 0, 0));
14379 bytepos = bitpos / BITS_PER_UNIT;
14381 add_loc_descr_to_each (list_ret,
14382 new_loc_descr (DW_OP_plus_uconst,
14384 else if (bytepos < 0)
14385 loc_list_plus_const (list_ret, bytepos);
14386 add_loc_descr_to_each (list_ret,
14387 new_loc_descr (DW_OP_stack_value, 0, 0));
14393 /* Helper structure for location descriptions generation. */
14394 struct loc_descr_context
14396 /* The type that is implicitly referenced by DW_OP_push_object_address, or
14397 NULL_TREE if DW_OP_push_object_address in invalid for this location
14398 description. This is used when processing PLACEHOLDER_EXPR nodes. */
14400 /* The ..._DECL node that should be translated as a
14401 DW_OP_push_object_address operation. */
14405 /* Generate Dwarf location list representing LOC.
14406 If WANT_ADDRESS is false, expression computing LOC will be computed
14407 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14408 if WANT_ADDRESS is 2, expression computing address useable in location
14409 will be returned (i.e. DW_OP_reg can be used
14410 to refer to register values).
14412 CONTEXT provides information to customize the location descriptions
14413 generation. Its context_type field specifies what type is implicitly
14414 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
14415 will not be generated.
14417 If CONTEXT is NULL, the behavior is the same as if both context_type and
14418 base_decl fields were NULL_TREE. */
14420 static dw_loc_list_ref
14421 loc_list_from_tree (tree loc, int want_address,
14422 const struct loc_descr_context *context)
14424 dw_loc_descr_ref ret = NULL, ret1 = NULL;
14425 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14426 int have_address = 0;
14427 enum dwarf_location_atom op;
14429 /* ??? Most of the time we do not take proper care for sign/zero
14430 extending the values properly. Hopefully this won't be a real
14433 if (context != NULL
14434 && context->base_decl == loc
14435 && want_address == 0)
14437 if (dwarf_version >= 3 || !dwarf_strict)
14438 return new_loc_list (new_loc_descr (DW_OP_push_object_address, 0, 0),
14444 switch (TREE_CODE (loc))
14447 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
14450 case PLACEHOLDER_EXPR:
14451 /* This case involves extracting fields from an object to determine the
14452 position of other fields. It is supposed to appear only as the first
14453 operand of COMPONENT_REF nodes and to reference precisely the type
14454 that the context allows. */
14455 if (context != NULL
14456 && TREE_TYPE (loc) == context->context_type
14457 && want_address >= 1)
14459 if (dwarf_version >= 3 || !dwarf_strict)
14461 ret = new_loc_descr (DW_OP_push_object_address, 0, 0);
14469 expansion_failed (loc, NULL_RTX,
14470 "PLACEHOLDER_EXPR for an unexpected type");
14474 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
14475 /* There are no opcodes for these operations. */
14478 case PREINCREMENT_EXPR:
14479 case PREDECREMENT_EXPR:
14480 case POSTINCREMENT_EXPR:
14481 case POSTDECREMENT_EXPR:
14482 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
14483 /* There are no opcodes for these operations. */
14487 /* If we already want an address, see if there is INDIRECT_REF inside
14488 e.g. for &this->field. */
14491 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
14492 (loc, want_address == 2, context);
14495 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
14496 && (ret = cst_pool_loc_descr (loc)))
14499 /* Otherwise, process the argument and look for the address. */
14500 if (!list_ret && !ret)
14501 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1, context);
14505 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
14511 if (DECL_THREAD_LOCAL_P (loc))
14514 enum dwarf_location_atom tls_op;
14515 enum dtprel_bool dtprel = dtprel_false;
14517 if (targetm.have_tls)
14519 /* If this is not defined, we have no way to emit the
14521 if (!targetm.asm_out.output_dwarf_dtprel)
14524 /* The way DW_OP_GNU_push_tls_address is specified, we
14525 can only look up addresses of objects in the current
14526 module. We used DW_OP_addr as first op, but that's
14527 wrong, because DW_OP_addr is relocated by the debug
14528 info consumer, while DW_OP_GNU_push_tls_address
14529 operand shouldn't be. */
14530 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
14532 dtprel = dtprel_true;
14533 tls_op = DW_OP_GNU_push_tls_address;
14537 if (!targetm.emutls.debug_form_tls_address
14538 || !(dwarf_version >= 3 || !dwarf_strict))
14540 /* We stuffed the control variable into the DECL_VALUE_EXPR
14541 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14542 no longer appear in gimple code. We used the control
14543 variable in specific so that we could pick it up here. */
14544 loc = DECL_VALUE_EXPR (loc);
14545 tls_op = DW_OP_form_tls_address;
14548 rtl = rtl_for_decl_location (loc);
14549 if (rtl == NULL_RTX)
14554 rtl = XEXP (rtl, 0);
14555 if (! CONSTANT_P (rtl))
14558 ret = new_addr_loc_descr (rtl, dtprel);
14559 ret1 = new_loc_descr (tls_op, 0, 0);
14560 add_loc_descr (&ret, ret1);
14569 if (DECL_HAS_VALUE_EXPR_P (loc))
14570 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
14571 want_address, context);
14574 case FUNCTION_DECL:
14577 var_loc_list *loc_list = lookup_decl_loc (loc);
14579 if (loc_list && loc_list->first)
14581 list_ret = dw_loc_list (loc_list, loc, want_address);
14582 have_address = want_address != 0;
14585 rtl = rtl_for_decl_location (loc);
14586 if (rtl == NULL_RTX)
14588 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
14591 else if (CONST_INT_P (rtl))
14593 HOST_WIDE_INT val = INTVAL (rtl);
14594 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14595 val &= GET_MODE_MASK (DECL_MODE (loc));
14596 ret = int_loc_descriptor (val);
14598 else if (GET_CODE (rtl) == CONST_STRING)
14600 expansion_failed (loc, NULL_RTX, "CONST_STRING");
14603 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
14604 ret = new_addr_loc_descr (rtl, dtprel_false);
14607 machine_mode mode, mem_mode;
14609 /* Certain constructs can only be represented at top-level. */
14610 if (want_address == 2)
14612 ret = loc_descriptor (rtl, VOIDmode,
14613 VAR_INIT_STATUS_INITIALIZED);
14618 mode = GET_MODE (rtl);
14619 mem_mode = VOIDmode;
14623 mode = get_address_mode (rtl);
14624 rtl = XEXP (rtl, 0);
14627 ret = mem_loc_descriptor (rtl, mode, mem_mode,
14628 VAR_INIT_STATUS_INITIALIZED);
14631 expansion_failed (loc, rtl,
14632 "failed to produce loc descriptor for rtl");
14638 if (!integer_zerop (TREE_OPERAND (loc, 1)))
14645 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14649 case TARGET_MEM_REF:
14651 case DEBUG_EXPR_DECL:
14654 case COMPOUND_EXPR:
14655 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address, context);
14658 case VIEW_CONVERT_EXPR:
14661 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address, context);
14663 case COMPONENT_REF:
14664 case BIT_FIELD_REF:
14666 case ARRAY_RANGE_REF:
14667 case REALPART_EXPR:
14668 case IMAGPART_EXPR:
14671 HOST_WIDE_INT bitsize, bitpos, bytepos;
14673 int unsignedp, volatilep = 0;
14675 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
14676 &unsignedp, &volatilep, false);
14678 gcc_assert (obj != loc);
14680 list_ret = loc_list_from_tree (obj,
14682 && !bitpos && !offset ? 2 : 1,
14684 /* TODO: We can extract value of the small expression via shifting even
14685 for nonzero bitpos. */
14688 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
14690 expansion_failed (loc, NULL_RTX,
14691 "bitfield access");
14695 if (offset != NULL_TREE)
14697 /* Variable offset. */
14698 list_ret1 = loc_list_from_tree (offset, 0, context);
14699 if (list_ret1 == 0)
14701 add_loc_list (&list_ret, list_ret1);
14704 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
14707 bytepos = bitpos / BITS_PER_UNIT;
14709 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
14710 else if (bytepos < 0)
14711 loc_list_plus_const (list_ret, bytepos);
14718 if ((want_address || !tree_fits_shwi_p (loc))
14719 && (ret = cst_pool_loc_descr (loc)))
14721 else if (want_address == 2
14722 && tree_fits_shwi_p (loc)
14723 && (ret = address_of_int_loc_descriptor
14724 (int_size_in_bytes (TREE_TYPE (loc)),
14725 tree_to_shwi (loc))))
14727 else if (tree_fits_shwi_p (loc))
14728 ret = int_loc_descriptor (tree_to_shwi (loc));
14731 expansion_failed (loc, NULL_RTX,
14732 "Integer operand is not host integer");
14741 if ((ret = cst_pool_loc_descr (loc)))
14744 /* We can construct small constants here using int_loc_descriptor. */
14745 expansion_failed (loc, NULL_RTX,
14746 "constructor or constant not in constant pool");
14749 case TRUTH_AND_EXPR:
14750 case TRUTH_ANDIF_EXPR:
14755 case TRUTH_XOR_EXPR:
14760 case TRUTH_OR_EXPR:
14761 case TRUTH_ORIF_EXPR:
14766 case FLOOR_DIV_EXPR:
14767 case CEIL_DIV_EXPR:
14768 case ROUND_DIV_EXPR:
14769 case TRUNC_DIV_EXPR:
14770 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14779 case FLOOR_MOD_EXPR:
14780 case CEIL_MOD_EXPR:
14781 case ROUND_MOD_EXPR:
14782 case TRUNC_MOD_EXPR:
14783 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14788 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14789 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context);
14790 if (list_ret == 0 || list_ret1 == 0)
14793 add_loc_list (&list_ret, list_ret1);
14796 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
14797 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
14798 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
14799 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
14800 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
14812 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
14815 case POINTER_PLUS_EXPR:
14818 if (tree_fits_shwi_p (TREE_OPERAND (loc, 1)))
14820 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14824 loc_list_plus_const (list_ret, tree_to_shwi (TREE_OPERAND (loc, 1)));
14832 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14839 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14846 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14853 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14868 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14869 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context);
14870 if (list_ret == 0 || list_ret1 == 0)
14873 add_loc_list (&list_ret, list_ret1);
14876 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14879 case TRUTH_NOT_EXPR:
14893 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14897 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14903 const enum tree_code code =
14904 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
14906 loc = build3 (COND_EXPR, TREE_TYPE (loc),
14907 build2 (code, integer_type_node,
14908 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
14909 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
14912 /* ... fall through ... */
14916 dw_loc_descr_ref lhs
14917 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0, context);
14918 dw_loc_list_ref rhs
14919 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0, context);
14920 dw_loc_descr_ref bra_node, jump_node, tmp;
14922 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14923 if (list_ret == 0 || lhs == 0 || rhs == 0)
14926 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14927 add_loc_descr_to_each (list_ret, bra_node);
14929 add_loc_list (&list_ret, rhs);
14930 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
14931 add_loc_descr_to_each (list_ret, jump_node);
14933 add_loc_descr_to_each (list_ret, lhs);
14934 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14935 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
14937 /* ??? Need a node to point the skip at. Use a nop. */
14938 tmp = new_loc_descr (DW_OP_nop, 0, 0);
14939 add_loc_descr_to_each (list_ret, tmp);
14940 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14941 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
14945 case FIX_TRUNC_EXPR:
14949 /* Leave front-end specific codes as simply unknown. This comes
14950 up, for instance, with the C STMT_EXPR. */
14951 if ((unsigned int) TREE_CODE (loc)
14952 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
14954 expansion_failed (loc, NULL_RTX,
14955 "language specific tree node");
14959 #ifdef ENABLE_CHECKING
14960 /* Otherwise this is a generic code; we should just lists all of
14961 these explicitly. We forgot one. */
14962 gcc_unreachable ();
14964 /* In a release build, we want to degrade gracefully: better to
14965 generate incomplete debugging information than to crash. */
14970 if (!ret && !list_ret)
14973 if (want_address == 2 && !have_address
14974 && (dwarf_version >= 4 || !dwarf_strict))
14976 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
14978 expansion_failed (loc, NULL_RTX,
14979 "DWARF address size mismatch");
14983 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
14985 add_loc_descr_to_each (list_ret,
14986 new_loc_descr (DW_OP_stack_value, 0, 0));
14989 /* Show if we can't fill the request for an address. */
14990 if (want_address && !have_address)
14992 expansion_failed (loc, NULL_RTX,
14993 "Want address and only have value");
14997 gcc_assert (!ret || !list_ret);
14999 /* If we've got an address and don't want one, dereference. */
15000 if (!want_address && have_address)
15002 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
15004 if (size > DWARF2_ADDR_SIZE || size == -1)
15006 expansion_failed (loc, NULL_RTX,
15007 "DWARF address size mismatch");
15010 else if (size == DWARF2_ADDR_SIZE)
15013 op = DW_OP_deref_size;
15016 add_loc_descr (&ret, new_loc_descr (op, size, 0));
15018 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
15021 list_ret = new_loc_list (ret, NULL, NULL, NULL);
15026 /* Same as above but return only single location expression. */
15027 static dw_loc_descr_ref
15028 loc_descriptor_from_tree (tree loc, int want_address,
15029 const struct loc_descr_context *context)
15031 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address, context);
15034 if (ret->dw_loc_next)
15036 expansion_failed (loc, NULL_RTX,
15037 "Location list where only loc descriptor needed");
15043 /* Given a value, round it up to the lowest multiple of `boundary'
15044 which is not less than the value itself. */
15046 static inline HOST_WIDE_INT
15047 ceiling (HOST_WIDE_INT value, unsigned int boundary)
15049 return (((value + boundary - 1) / boundary) * boundary);
15052 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
15053 pointer to the declared type for the relevant field variable, or return
15054 `integer_type_node' if the given node turns out to be an
15055 ERROR_MARK node. */
15058 field_type (const_tree decl)
15062 if (TREE_CODE (decl) == ERROR_MARK)
15063 return integer_type_node;
15065 type = DECL_BIT_FIELD_TYPE (decl);
15066 if (type == NULL_TREE)
15067 type = TREE_TYPE (decl);
15072 /* Given a pointer to a tree node, return the alignment in bits for
15073 it, or else return BITS_PER_WORD if the node actually turns out to
15074 be an ERROR_MARK node. */
15076 static inline unsigned
15077 simple_type_align_in_bits (const_tree type)
15079 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
15082 static inline unsigned
15083 simple_decl_align_in_bits (const_tree decl)
15085 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
15088 /* Return the result of rounding T up to ALIGN. */
15090 static inline offset_int
15091 round_up_to_align (const offset_int &t, unsigned int align)
15093 return wi::udiv_trunc (t + align - 1, align) * align;
15096 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
15097 lowest addressed byte of the "containing object" for the given FIELD_DECL,
15098 or return 0 if we are unable to determine what that offset is, either
15099 because the argument turns out to be a pointer to an ERROR_MARK node, or
15100 because the offset is actually variable. (We can't handle the latter case
15103 static HOST_WIDE_INT
15104 field_byte_offset (const_tree decl)
15106 offset_int object_offset_in_bits;
15107 offset_int object_offset_in_bytes;
15108 offset_int bitpos_int;
15110 if (TREE_CODE (decl) == ERROR_MARK)
15113 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
15115 /* We cannot yet cope with fields whose positions are variable, so
15116 for now, when we see such things, we simply return 0. Someday, we may
15117 be able to handle such cases, but it will be damn difficult. */
15118 if (TREE_CODE (bit_position (decl)) != INTEGER_CST)
15121 bitpos_int = wi::to_offset (bit_position (decl));
15123 #ifdef PCC_BITFIELD_TYPE_MATTERS
15124 if (PCC_BITFIELD_TYPE_MATTERS)
15127 tree field_size_tree;
15128 offset_int deepest_bitpos;
15129 offset_int field_size_in_bits;
15130 unsigned int type_align_in_bits;
15131 unsigned int decl_align_in_bits;
15132 offset_int type_size_in_bits;
15134 type = field_type (decl);
15135 type_size_in_bits = offset_int_type_size_in_bits (type);
15136 type_align_in_bits = simple_type_align_in_bits (type);
15138 field_size_tree = DECL_SIZE (decl);
15140 /* The size could be unspecified if there was an error, or for
15141 a flexible array member. */
15142 if (!field_size_tree)
15143 field_size_tree = bitsize_zero_node;
15145 /* If the size of the field is not constant, use the type size. */
15146 if (TREE_CODE (field_size_tree) == INTEGER_CST)
15147 field_size_in_bits = wi::to_offset (field_size_tree);
15149 field_size_in_bits = type_size_in_bits;
15151 decl_align_in_bits = simple_decl_align_in_bits (decl);
15153 /* The GCC front-end doesn't make any attempt to keep track of the
15154 starting bit offset (relative to the start of the containing
15155 structure type) of the hypothetical "containing object" for a
15156 bit-field. Thus, when computing the byte offset value for the
15157 start of the "containing object" of a bit-field, we must deduce
15158 this information on our own. This can be rather tricky to do in
15159 some cases. For example, handling the following structure type
15160 definition when compiling for an i386/i486 target (which only
15161 aligns long long's to 32-bit boundaries) can be very tricky:
15163 struct S { int field1; long long field2:31; };
15165 Fortunately, there is a simple rule-of-thumb which can be used
15166 in such cases. When compiling for an i386/i486, GCC will
15167 allocate 8 bytes for the structure shown above. It decides to
15168 do this based upon one simple rule for bit-field allocation.
15169 GCC allocates each "containing object" for each bit-field at
15170 the first (i.e. lowest addressed) legitimate alignment boundary
15171 (based upon the required minimum alignment for the declared
15172 type of the field) which it can possibly use, subject to the
15173 condition that there is still enough available space remaining
15174 in the containing object (when allocated at the selected point)
15175 to fully accommodate all of the bits of the bit-field itself.
15177 This simple rule makes it obvious why GCC allocates 8 bytes for
15178 each object of the structure type shown above. When looking
15179 for a place to allocate the "containing object" for `field2',
15180 the compiler simply tries to allocate a 64-bit "containing
15181 object" at each successive 32-bit boundary (starting at zero)
15182 until it finds a place to allocate that 64- bit field such that
15183 at least 31 contiguous (and previously unallocated) bits remain
15184 within that selected 64 bit field. (As it turns out, for the
15185 example above, the compiler finds it is OK to allocate the
15186 "containing object" 64-bit field at bit-offset zero within the
15189 Here we attempt to work backwards from the limited set of facts
15190 we're given, and we try to deduce from those facts, where GCC
15191 must have believed that the containing object started (within
15192 the structure type). The value we deduce is then used (by the
15193 callers of this routine) to generate DW_AT_location and
15194 DW_AT_bit_offset attributes for fields (both bit-fields and, in
15195 the case of DW_AT_location, regular fields as well). */
15197 /* Figure out the bit-distance from the start of the structure to
15198 the "deepest" bit of the bit-field. */
15199 deepest_bitpos = bitpos_int + field_size_in_bits;
15201 /* This is the tricky part. Use some fancy footwork to deduce
15202 where the lowest addressed bit of the containing object must
15204 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15206 /* Round up to type_align by default. This works best for
15208 object_offset_in_bits
15209 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
15211 if (wi::gtu_p (object_offset_in_bits, bitpos_int))
15213 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15215 /* Round up to decl_align instead. */
15216 object_offset_in_bits
15217 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
15221 #endif /* PCC_BITFIELD_TYPE_MATTERS */
15222 object_offset_in_bits = bitpos_int;
15224 object_offset_in_bytes
15225 = wi::lrshift (object_offset_in_bits, LOG2_BITS_PER_UNIT);
15226 return object_offset_in_bytes.to_shwi ();
15229 /* The following routines define various Dwarf attributes and any data
15230 associated with them. */
15232 /* Add a location description attribute value to a DIE.
15234 This emits location attributes suitable for whole variables and
15235 whole parameters. Note that the location attributes for struct fields are
15236 generated by the routine `data_member_location_attribute' below. */
15239 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
15240 dw_loc_list_ref descr)
15244 if (single_element_loc_list_p (descr))
15245 add_AT_loc (die, attr_kind, descr->expr);
15247 add_AT_loc_list (die, attr_kind, descr);
15250 /* Add DW_AT_accessibility attribute to DIE if needed. */
15253 add_accessibility_attribute (dw_die_ref die, tree decl)
15255 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
15256 children, otherwise the default is DW_ACCESS_public. In DWARF2
15257 the default has always been DW_ACCESS_public. */
15258 if (TREE_PROTECTED (decl))
15259 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
15260 else if (TREE_PRIVATE (decl))
15262 if (dwarf_version == 2
15263 || die->die_parent == NULL
15264 || die->die_parent->die_tag != DW_TAG_class_type)
15265 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
15267 else if (dwarf_version > 2
15269 && die->die_parent->die_tag == DW_TAG_class_type)
15270 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
15273 /* Attach the specialized form of location attribute used for data members of
15274 struct and union types. In the special case of a FIELD_DECL node which
15275 represents a bit-field, the "offset" part of this special location
15276 descriptor must indicate the distance in bytes from the lowest-addressed
15277 byte of the containing struct or union type to the lowest-addressed byte of
15278 the "containing object" for the bit-field. (See the `field_byte_offset'
15281 For any given bit-field, the "containing object" is a hypothetical object
15282 (of some integral or enum type) within which the given bit-field lives. The
15283 type of this hypothetical "containing object" is always the same as the
15284 declared type of the individual bit-field itself (for GCC anyway... the
15285 DWARF spec doesn't actually mandate this). Note that it is the size (in
15286 bytes) of the hypothetical "containing object" which will be given in the
15287 DW_AT_byte_size attribute for this bit-field. (See the
15288 `byte_size_attribute' function below.) It is also used when calculating the
15289 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15290 function below.) */
15293 add_data_member_location_attribute (dw_die_ref die, tree decl)
15295 HOST_WIDE_INT offset;
15296 dw_loc_descr_ref loc_descr = 0;
15298 if (TREE_CODE (decl) == TREE_BINFO)
15300 /* We're working on the TAG_inheritance for a base class. */
15301 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
15303 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15304 aren't at a fixed offset from all (sub)objects of the same
15305 type. We need to extract the appropriate offset from our
15306 vtable. The following dwarf expression means
15308 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15310 This is specific to the V3 ABI, of course. */
15312 dw_loc_descr_ref tmp;
15314 /* Make a copy of the object address. */
15315 tmp = new_loc_descr (DW_OP_dup, 0, 0);
15316 add_loc_descr (&loc_descr, tmp);
15318 /* Extract the vtable address. */
15319 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15320 add_loc_descr (&loc_descr, tmp);
15322 /* Calculate the address of the offset. */
15323 offset = tree_to_shwi (BINFO_VPTR_FIELD (decl));
15324 gcc_assert (offset < 0);
15326 tmp = int_loc_descriptor (-offset);
15327 add_loc_descr (&loc_descr, tmp);
15328 tmp = new_loc_descr (DW_OP_minus, 0, 0);
15329 add_loc_descr (&loc_descr, tmp);
15331 /* Extract the offset. */
15332 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15333 add_loc_descr (&loc_descr, tmp);
15335 /* Add it to the object address. */
15336 tmp = new_loc_descr (DW_OP_plus, 0, 0);
15337 add_loc_descr (&loc_descr, tmp);
15340 offset = tree_to_shwi (BINFO_OFFSET (decl));
15343 offset = field_byte_offset (decl);
15347 if (dwarf_version > 2)
15349 /* Don't need to output a location expression, just the constant. */
15351 add_AT_int (die, DW_AT_data_member_location, offset);
15353 add_AT_unsigned (die, DW_AT_data_member_location, offset);
15358 enum dwarf_location_atom op;
15360 /* The DWARF2 standard says that we should assume that the structure
15361 address is already on the stack, so we can specify a structure
15362 field address by using DW_OP_plus_uconst. */
15363 op = DW_OP_plus_uconst;
15364 loc_descr = new_loc_descr (op, offset, 0);
15368 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
15371 /* Writes integer values to dw_vec_const array. */
15374 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
15378 *dest++ = val & 0xff;
15384 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15386 static HOST_WIDE_INT
15387 extract_int (const unsigned char *src, unsigned int size)
15389 HOST_WIDE_INT val = 0;
15395 val |= *--src & 0xff;
15401 /* Writes wide_int values to dw_vec_const array. */
15404 insert_wide_int (const wide_int &val, unsigned char *dest, int elt_size)
15408 if (elt_size <= HOST_BITS_PER_WIDE_INT/BITS_PER_UNIT)
15410 insert_int ((HOST_WIDE_INT) val.elt (0), elt_size, dest);
15414 /* We'd have to extend this code to support odd sizes. */
15415 gcc_assert (elt_size % (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT) == 0);
15417 int n = elt_size / (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
15419 if (WORDS_BIG_ENDIAN)
15420 for (i = n - 1; i >= 0; i--)
15422 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
15423 dest += sizeof (HOST_WIDE_INT);
15426 for (i = 0; i < n; i++)
15428 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
15429 dest += sizeof (HOST_WIDE_INT);
15433 /* Writes floating point values to dw_vec_const array. */
15436 insert_float (const_rtx rtl, unsigned char *array)
15438 REAL_VALUE_TYPE rv;
15442 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
15443 real_to_target (val, &rv, GET_MODE (rtl));
15445 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15446 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
15448 insert_int (val[i], 4, array);
15453 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15454 does not have a "location" either in memory or in a register. These
15455 things can arise in GNU C when a constant is passed as an actual parameter
15456 to an inlined function. They can also arise in C++ where declared
15457 constants do not necessarily get memory "homes". */
15460 add_const_value_attribute (dw_die_ref die, rtx rtl)
15462 switch (GET_CODE (rtl))
15466 HOST_WIDE_INT val = INTVAL (rtl);
15469 add_AT_int (die, DW_AT_const_value, val);
15471 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
15475 case CONST_WIDE_INT:
15476 add_AT_wide (die, DW_AT_const_value,
15477 std::make_pair (rtl, GET_MODE (rtl)));
15481 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15482 floating-point constant. A CONST_DOUBLE is used whenever the
15483 constant requires more than one word in order to be adequately
15486 machine_mode mode = GET_MODE (rtl);
15488 if (TARGET_SUPPORTS_WIDE_INT == 0 && !SCALAR_FLOAT_MODE_P (mode))
15489 add_AT_double (die, DW_AT_const_value,
15490 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
15493 unsigned int length = GET_MODE_SIZE (mode);
15494 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
15496 insert_float (rtl, array);
15497 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
15504 machine_mode mode = GET_MODE (rtl);
15505 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
15506 unsigned int length = CONST_VECTOR_NUNITS (rtl);
15507 unsigned char *array
15508 = ggc_vec_alloc<unsigned char> (length * elt_size);
15511 machine_mode imode = GET_MODE_INNER (mode);
15513 switch (GET_MODE_CLASS (mode))
15515 case MODE_VECTOR_INT:
15516 for (i = 0, p = array; i < length; i++, p += elt_size)
15518 rtx elt = CONST_VECTOR_ELT (rtl, i);
15519 insert_wide_int (std::make_pair (elt, imode), p, elt_size);
15523 case MODE_VECTOR_FLOAT:
15524 for (i = 0, p = array; i < length; i++, p += elt_size)
15526 rtx elt = CONST_VECTOR_ELT (rtl, i);
15527 insert_float (elt, p);
15532 gcc_unreachable ();
15535 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
15540 if (dwarf_version >= 4 || !dwarf_strict)
15542 dw_loc_descr_ref loc_result;
15543 resolve_one_addr (&rtl);
15545 loc_result = new_addr_loc_descr (rtl, dtprel_false);
15546 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
15547 add_AT_loc (die, DW_AT_location, loc_result);
15548 vec_safe_push (used_rtx_array, rtl);
15554 if (CONSTANT_P (XEXP (rtl, 0)))
15555 return add_const_value_attribute (die, XEXP (rtl, 0));
15558 if (!const_ok_for_output (rtl))
15561 if (dwarf_version >= 4 || !dwarf_strict)
15566 /* In cases where an inlined instance of an inline function is passed
15567 the address of an `auto' variable (which is local to the caller) we
15568 can get a situation where the DECL_RTL of the artificial local
15569 variable (for the inlining) which acts as a stand-in for the
15570 corresponding formal parameter (of the inline function) will look
15571 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15572 exactly a compile-time constant expression, but it isn't the address
15573 of the (artificial) local variable either. Rather, it represents the
15574 *value* which the artificial local variable always has during its
15575 lifetime. We currently have no way to represent such quasi-constant
15576 values in Dwarf, so for now we just punt and generate nothing. */
15584 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
15585 && MEM_READONLY_P (rtl)
15586 && GET_MODE (rtl) == BLKmode)
15588 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
15594 /* No other kinds of rtx should be possible here. */
15595 gcc_unreachable ();
15600 /* Determine whether the evaluation of EXPR references any variables
15601 or functions which aren't otherwise used (and therefore may not be
15604 reference_to_unused (tree * tp, int * walk_subtrees,
15605 void * data ATTRIBUTE_UNUSED)
15607 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
15608 *walk_subtrees = 0;
15610 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
15611 && ! TREE_ASM_WRITTEN (*tp))
15613 /* ??? The C++ FE emits debug information for using decls, so
15614 putting gcc_unreachable here falls over. See PR31899. For now
15615 be conservative. */
15616 else if (!symtab->global_info_ready
15617 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
15619 else if (TREE_CODE (*tp) == VAR_DECL)
15621 varpool_node *node = varpool_node::get (*tp);
15622 if (!node || !node->definition)
15625 else if (TREE_CODE (*tp) == FUNCTION_DECL
15626 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
15628 /* The call graph machinery must have finished analyzing,
15629 optimizing and gimplifying the CU by now.
15630 So if *TP has no call graph node associated
15631 to it, it means *TP will not be emitted. */
15632 if (!cgraph_node::get (*tp))
15635 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
15641 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15642 for use in a later add_const_value_attribute call. */
15645 rtl_for_decl_init (tree init, tree type)
15647 rtx rtl = NULL_RTX;
15651 /* If a variable is initialized with a string constant without embedded
15652 zeros, build CONST_STRING. */
15653 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
15655 tree enttype = TREE_TYPE (type);
15656 tree domain = TYPE_DOMAIN (type);
15657 machine_mode mode = TYPE_MODE (enttype);
15659 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
15661 && integer_zerop (TYPE_MIN_VALUE (domain))
15662 && compare_tree_int (TYPE_MAX_VALUE (domain),
15663 TREE_STRING_LENGTH (init) - 1) == 0
15664 && ((size_t) TREE_STRING_LENGTH (init)
15665 == strlen (TREE_STRING_POINTER (init)) + 1))
15667 rtl = gen_rtx_CONST_STRING (VOIDmode,
15668 ggc_strdup (TREE_STRING_POINTER (init)));
15669 rtl = gen_rtx_MEM (BLKmode, rtl);
15670 MEM_READONLY_P (rtl) = 1;
15673 /* Other aggregates, and complex values, could be represented using
15675 else if (AGGREGATE_TYPE_P (type)
15676 || (TREE_CODE (init) == VIEW_CONVERT_EXPR
15677 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init, 0))))
15678 || TREE_CODE (type) == COMPLEX_TYPE)
15680 /* Vectors only work if their mode is supported by the target.
15681 FIXME: generic vectors ought to work too. */
15682 else if (TREE_CODE (type) == VECTOR_TYPE
15683 && !VECTOR_MODE_P (TYPE_MODE (type)))
15685 /* If the initializer is something that we know will expand into an
15686 immediate RTL constant, expand it now. We must be careful not to
15687 reference variables which won't be output. */
15688 else if (initializer_constant_valid_p (init, type)
15689 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
15691 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15693 if (TREE_CODE (type) == VECTOR_TYPE)
15694 switch (TREE_CODE (init))
15699 if (TREE_CONSTANT (init))
15701 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (init);
15702 bool constant_p = true;
15704 unsigned HOST_WIDE_INT ix;
15706 /* Even when ctor is constant, it might contain non-*_CST
15707 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15708 belong into VECTOR_CST nodes. */
15709 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
15710 if (!CONSTANT_CLASS_P (value))
15712 constant_p = false;
15718 init = build_vector_from_ctor (type, elts);
15728 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
15730 /* If expand_expr returns a MEM, it wasn't immediate. */
15731 gcc_assert (!rtl || !MEM_P (rtl));
15737 /* Generate RTL for the variable DECL to represent its location. */
15740 rtl_for_decl_location (tree decl)
15744 /* Here we have to decide where we are going to say the parameter "lives"
15745 (as far as the debugger is concerned). We only have a couple of
15746 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15748 DECL_RTL normally indicates where the parameter lives during most of the
15749 activation of the function. If optimization is enabled however, this
15750 could be either NULL or else a pseudo-reg. Both of those cases indicate
15751 that the parameter doesn't really live anywhere (as far as the code
15752 generation parts of GCC are concerned) during most of the function's
15753 activation. That will happen (for example) if the parameter is never
15754 referenced within the function.
15756 We could just generate a location descriptor here for all non-NULL
15757 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15758 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15759 where DECL_RTL is NULL or is a pseudo-reg.
15761 Note however that we can only get away with using DECL_INCOMING_RTL as
15762 a backup substitute for DECL_RTL in certain limited cases. In cases
15763 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15764 we can be sure that the parameter was passed using the same type as it is
15765 declared to have within the function, and that its DECL_INCOMING_RTL
15766 points us to a place where a value of that type is passed.
15768 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15769 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15770 because in these cases DECL_INCOMING_RTL points us to a value of some
15771 type which is *different* from the type of the parameter itself. Thus,
15772 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15773 such cases, the debugger would end up (for example) trying to fetch a
15774 `float' from a place which actually contains the first part of a
15775 `double'. That would lead to really incorrect and confusing
15776 output at debug-time.
15778 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15779 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15780 are a couple of exceptions however. On little-endian machines we can
15781 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15782 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15783 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15784 when (on a little-endian machine) a non-prototyped function has a
15785 parameter declared to be of type `short' or `char'. In such cases,
15786 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15787 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15788 passed `int' value. If the debugger then uses that address to fetch
15789 a `short' or a `char' (on a little-endian machine) the result will be
15790 the correct data, so we allow for such exceptional cases below.
15792 Note that our goal here is to describe the place where the given formal
15793 parameter lives during most of the function's activation (i.e. between the
15794 end of the prologue and the start of the epilogue). We'll do that as best
15795 as we can. Note however that if the given formal parameter is modified
15796 sometime during the execution of the function, then a stack backtrace (at
15797 debug-time) will show the function as having been called with the *new*
15798 value rather than the value which was originally passed in. This happens
15799 rarely enough that it is not a major problem, but it *is* a problem, and
15800 I'd like to fix it.
15802 A future version of dwarf2out.c may generate two additional attributes for
15803 any given DW_TAG_formal_parameter DIE which will describe the "passed
15804 type" and the "passed location" for the given formal parameter in addition
15805 to the attributes we now generate to indicate the "declared type" and the
15806 "active location" for each parameter. This additional set of attributes
15807 could be used by debuggers for stack backtraces. Separately, note that
15808 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15809 This happens (for example) for inlined-instances of inline function formal
15810 parameters which are never referenced. This really shouldn't be
15811 happening. All PARM_DECL nodes should get valid non-NULL
15812 DECL_INCOMING_RTL values. FIXME. */
15814 /* Use DECL_RTL as the "location" unless we find something better. */
15815 rtl = DECL_RTL_IF_SET (decl);
15817 /* When generating abstract instances, ignore everything except
15818 constants, symbols living in memory, and symbols living in
15819 fixed registers. */
15820 if (! reload_completed)
15823 && (CONSTANT_P (rtl)
15825 && CONSTANT_P (XEXP (rtl, 0)))
15827 && TREE_CODE (decl) == VAR_DECL
15828 && TREE_STATIC (decl))))
15830 rtl = targetm.delegitimize_address (rtl);
15835 else if (TREE_CODE (decl) == PARM_DECL)
15837 if (rtl == NULL_RTX
15838 || is_pseudo_reg (rtl)
15840 && is_pseudo_reg (XEXP (rtl, 0))
15841 && DECL_INCOMING_RTL (decl)
15842 && MEM_P (DECL_INCOMING_RTL (decl))
15843 && GET_MODE (rtl) == GET_MODE (DECL_INCOMING_RTL (decl))))
15845 tree declared_type = TREE_TYPE (decl);
15846 tree passed_type = DECL_ARG_TYPE (decl);
15847 machine_mode dmode = TYPE_MODE (declared_type);
15848 machine_mode pmode = TYPE_MODE (passed_type);
15850 /* This decl represents a formal parameter which was optimized out.
15851 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15852 all cases where (rtl == NULL_RTX) just below. */
15853 if (dmode == pmode)
15854 rtl = DECL_INCOMING_RTL (decl);
15855 else if ((rtl == NULL_RTX || is_pseudo_reg (rtl))
15856 && SCALAR_INT_MODE_P (dmode)
15857 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
15858 && DECL_INCOMING_RTL (decl))
15860 rtx inc = DECL_INCOMING_RTL (decl);
15863 else if (MEM_P (inc))
15865 if (BYTES_BIG_ENDIAN)
15866 rtl = adjust_address_nv (inc, dmode,
15867 GET_MODE_SIZE (pmode)
15868 - GET_MODE_SIZE (dmode));
15875 /* If the parm was passed in registers, but lives on the stack, then
15876 make a big endian correction if the mode of the type of the
15877 parameter is not the same as the mode of the rtl. */
15878 /* ??? This is the same series of checks that are made in dbxout.c before
15879 we reach the big endian correction code there. It isn't clear if all
15880 of these checks are necessary here, but keeping them all is the safe
15882 else if (MEM_P (rtl)
15883 && XEXP (rtl, 0) != const0_rtx
15884 && ! CONSTANT_P (XEXP (rtl, 0))
15885 /* Not passed in memory. */
15886 && !MEM_P (DECL_INCOMING_RTL (decl))
15887 /* Not passed by invisible reference. */
15888 && (!REG_P (XEXP (rtl, 0))
15889 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
15890 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
15891 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15892 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
15895 /* Big endian correction check. */
15896 && BYTES_BIG_ENDIAN
15897 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
15898 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
15901 machine_mode addr_mode = get_address_mode (rtl);
15902 int offset = (UNITS_PER_WORD
15903 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
15905 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15906 plus_constant (addr_mode, XEXP (rtl, 0), offset));
15909 else if (TREE_CODE (decl) == VAR_DECL
15912 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
15913 && BYTES_BIG_ENDIAN)
15915 machine_mode addr_mode = get_address_mode (rtl);
15916 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
15917 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
15919 /* If a variable is declared "register" yet is smaller than
15920 a register, then if we store the variable to memory, it
15921 looks like we're storing a register-sized value, when in
15922 fact we are not. We need to adjust the offset of the
15923 storage location to reflect the actual value's bytes,
15924 else gdb will not be able to display it. */
15926 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15927 plus_constant (addr_mode, XEXP (rtl, 0),
15931 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15932 and will have been substituted directly into all expressions that use it.
15933 C does not have such a concept, but C++ and other languages do. */
15934 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
15935 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
15938 rtl = targetm.delegitimize_address (rtl);
15940 /* If we don't look past the constant pool, we risk emitting a
15941 reference to a constant pool entry that isn't referenced from
15942 code, and thus is not emitted. */
15944 rtl = avoid_constant_pool_reference (rtl);
15946 /* Try harder to get a rtl. If this symbol ends up not being emitted
15947 in the current CU, resolve_addr will remove the expression referencing
15949 if (rtl == NULL_RTX
15950 && TREE_CODE (decl) == VAR_DECL
15951 && !DECL_EXTERNAL (decl)
15952 && TREE_STATIC (decl)
15953 && DECL_NAME (decl)
15954 && !DECL_HARD_REGISTER (decl)
15955 && DECL_MODE (decl) != VOIDmode)
15957 rtl = make_decl_rtl_for_debug (decl);
15959 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
15960 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
15967 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15968 returned. If so, the decl for the COMMON block is returned, and the
15969 value is the offset into the common block for the symbol. */
15972 fortran_common (tree decl, HOST_WIDE_INT *value)
15974 tree val_expr, cvar;
15976 HOST_WIDE_INT bitsize, bitpos;
15978 int unsignedp, volatilep = 0;
15980 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15981 it does not have a value (the offset into the common area), or if it
15982 is thread local (as opposed to global) then it isn't common, and shouldn't
15983 be handled as such. */
15984 if (TREE_CODE (decl) != VAR_DECL
15985 || !TREE_STATIC (decl)
15986 || !DECL_HAS_VALUE_EXPR_P (decl)
15990 val_expr = DECL_VALUE_EXPR (decl);
15991 if (TREE_CODE (val_expr) != COMPONENT_REF)
15994 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
15995 &mode, &unsignedp, &volatilep, true);
15997 if (cvar == NULL_TREE
15998 || TREE_CODE (cvar) != VAR_DECL
15999 || DECL_ARTIFICIAL (cvar)
16000 || !TREE_PUBLIC (cvar))
16004 if (offset != NULL)
16006 if (!tree_fits_shwi_p (offset))
16008 *value = tree_to_shwi (offset);
16011 *value += bitpos / BITS_PER_UNIT;
16016 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
16017 data attribute for a variable or a parameter. We generate the
16018 DW_AT_const_value attribute only in those cases where the given variable
16019 or parameter does not have a true "location" either in memory or in a
16020 register. This can happen (for example) when a constant is passed as an
16021 actual argument in a call to an inline function. (It's possible that
16022 these things can crop up in other ways also.) Note that one type of
16023 constant value which can be passed into an inlined function is a constant
16024 pointer. This can happen for example if an actual argument in an inlined
16025 function call evaluates to a compile-time constant address.
16027 CACHE_P is true if it is worth caching the location list for DECL,
16028 so that future calls can reuse it rather than regenerate it from scratch.
16029 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
16030 since we will need to refer to them each time the function is inlined. */
16033 add_location_or_const_value_attribute (dw_die_ref die, tree decl, bool cache_p,
16034 enum dwarf_attribute attr)
16037 dw_loc_list_ref list;
16038 var_loc_list *loc_list;
16039 cached_dw_loc_list *cache;
16041 if (TREE_CODE (decl) == ERROR_MARK)
16044 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
16045 || TREE_CODE (decl) == RESULT_DECL);
16047 /* Try to get some constant RTL for this decl, and use that as the value of
16050 rtl = rtl_for_decl_location (decl);
16051 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16052 && add_const_value_attribute (die, rtl))
16055 /* See if we have single element location list that is equivalent to
16056 a constant value. That way we are better to use add_const_value_attribute
16057 rather than expanding constant value equivalent. */
16058 loc_list = lookup_decl_loc (decl);
16061 && loc_list->first->next == NULL
16062 && NOTE_P (loc_list->first->loc)
16063 && NOTE_VAR_LOCATION (loc_list->first->loc)
16064 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
16066 struct var_loc_node *node;
16068 node = loc_list->first;
16069 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
16070 if (GET_CODE (rtl) == EXPR_LIST)
16071 rtl = XEXP (rtl, 0);
16072 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16073 && add_const_value_attribute (die, rtl))
16076 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
16077 list several times. See if we've already cached the contents. */
16079 if (loc_list == NULL || cached_dw_loc_list_table == NULL)
16083 cache = cached_dw_loc_list_table->find_with_hash (decl, DECL_UID (decl));
16085 list = cache->loc_list;
16089 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2,
16091 /* It is usually worth caching this result if the decl is from
16092 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
16093 if (cache_p && list && list->dw_loc_next)
16095 cached_dw_loc_list **slot
16096 = cached_dw_loc_list_table->find_slot_with_hash (decl,
16099 cache = ggc_cleared_alloc<cached_dw_loc_list> ();
16100 cache->decl_id = DECL_UID (decl);
16101 cache->loc_list = list;
16107 add_AT_location_description (die, attr, list);
16110 /* None of that worked, so it must not really have a location;
16111 try adding a constant value attribute from the DECL_INITIAL. */
16112 return tree_add_const_value_attribute_for_decl (die, decl);
16115 /* Add VARIABLE and DIE into deferred locations list. */
16118 defer_location (tree variable, dw_die_ref die)
16120 deferred_locations entry;
16121 entry.variable = variable;
16123 vec_safe_push (deferred_locations_list, entry);
16126 /* Helper function for tree_add_const_value_attribute. Natively encode
16127 initializer INIT into an array. Return true if successful. */
16130 native_encode_initializer (tree init, unsigned char *array, int size)
16134 if (init == NULL_TREE)
16138 switch (TREE_CODE (init))
16141 type = TREE_TYPE (init);
16142 if (TREE_CODE (type) == ARRAY_TYPE)
16144 tree enttype = TREE_TYPE (type);
16145 machine_mode mode = TYPE_MODE (enttype);
16147 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
16149 if (int_size_in_bytes (type) != size)
16151 if (size > TREE_STRING_LENGTH (init))
16153 memcpy (array, TREE_STRING_POINTER (init),
16154 TREE_STRING_LENGTH (init));
16155 memset (array + TREE_STRING_LENGTH (init),
16156 '\0', size - TREE_STRING_LENGTH (init));
16159 memcpy (array, TREE_STRING_POINTER (init), size);
16164 type = TREE_TYPE (init);
16165 if (int_size_in_bytes (type) != size)
16167 if (TREE_CODE (type) == ARRAY_TYPE)
16169 HOST_WIDE_INT min_index;
16170 unsigned HOST_WIDE_INT cnt;
16171 int curpos = 0, fieldsize;
16172 constructor_elt *ce;
16174 if (TYPE_DOMAIN (type) == NULL_TREE
16175 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type))))
16178 fieldsize = int_size_in_bytes (TREE_TYPE (type));
16179 if (fieldsize <= 0)
16182 min_index = tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type)));
16183 memset (array, '\0', size);
16184 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce)
16186 tree val = ce->value;
16187 tree index = ce->index;
16189 if (index && TREE_CODE (index) == RANGE_EXPR)
16190 pos = (tree_to_shwi (TREE_OPERAND (index, 0)) - min_index)
16193 pos = (tree_to_shwi (index) - min_index) * fieldsize;
16198 if (!native_encode_initializer (val, array + pos, fieldsize))
16201 curpos = pos + fieldsize;
16202 if (index && TREE_CODE (index) == RANGE_EXPR)
16204 int count = tree_to_shwi (TREE_OPERAND (index, 1))
16205 - tree_to_shwi (TREE_OPERAND (index, 0));
16206 while (count-- > 0)
16209 memcpy (array + curpos, array + pos, fieldsize);
16210 curpos += fieldsize;
16213 gcc_assert (curpos <= size);
16217 else if (TREE_CODE (type) == RECORD_TYPE
16218 || TREE_CODE (type) == UNION_TYPE)
16220 tree field = NULL_TREE;
16221 unsigned HOST_WIDE_INT cnt;
16222 constructor_elt *ce;
16224 if (int_size_in_bytes (type) != size)
16227 if (TREE_CODE (type) == RECORD_TYPE)
16228 field = TYPE_FIELDS (type);
16230 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce)
16232 tree val = ce->value;
16233 int pos, fieldsize;
16235 if (ce->index != 0)
16241 if (field == NULL_TREE || DECL_BIT_FIELD (field))
16244 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
16245 && TYPE_DOMAIN (TREE_TYPE (field))
16246 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
16248 else if (DECL_SIZE_UNIT (field) == NULL_TREE
16249 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field)))
16251 fieldsize = tree_to_shwi (DECL_SIZE_UNIT (field));
16252 pos = int_byte_position (field);
16253 gcc_assert (pos + fieldsize <= size);
16255 && !native_encode_initializer (val, array + pos, fieldsize))
16261 case VIEW_CONVERT_EXPR:
16262 case NON_LVALUE_EXPR:
16263 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
16265 return native_encode_expr (init, array, size) == size;
16269 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16270 attribute is the const value T. */
16273 tree_add_const_value_attribute (dw_die_ref die, tree t)
16276 tree type = TREE_TYPE (t);
16279 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
16283 gcc_assert (!DECL_P (init));
16285 rtl = rtl_for_decl_init (init, type);
16287 return add_const_value_attribute (die, rtl);
16288 /* If the host and target are sane, try harder. */
16289 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
16290 && initializer_constant_valid_p (init, type))
16292 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
16293 if (size > 0 && (int) size == size)
16295 unsigned char *array = ggc_cleared_vec_alloc<unsigned char> (size);
16297 if (native_encode_initializer (init, array, size))
16299 add_AT_vec (die, DW_AT_const_value, size, 1, array);
16308 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16309 attribute is the const value of T, where T is an integral constant
16310 variable with static storage duration
16311 (so it can't be a PARM_DECL or a RESULT_DECL). */
16314 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
16318 || (TREE_CODE (decl) != VAR_DECL
16319 && TREE_CODE (decl) != CONST_DECL)
16320 || (TREE_CODE (decl) == VAR_DECL
16321 && !TREE_STATIC (decl)))
16324 if (TREE_READONLY (decl)
16325 && ! TREE_THIS_VOLATILE (decl)
16326 && DECL_INITIAL (decl))
16331 /* Don't add DW_AT_const_value if abstract origin already has one. */
16332 if (get_AT (var_die, DW_AT_const_value))
16335 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
16338 /* Convert the CFI instructions for the current function into a
16339 location list. This is used for DW_AT_frame_base when we targeting
16340 a dwarf2 consumer that does not support the dwarf3
16341 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16344 static dw_loc_list_ref
16345 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
16349 dw_loc_list_ref list, *list_tail;
16351 dw_cfa_location last_cfa, next_cfa;
16352 const char *start_label, *last_label, *section;
16353 dw_cfa_location remember;
16356 gcc_assert (fde != NULL);
16358 section = secname_for_decl (current_function_decl);
16362 memset (&next_cfa, 0, sizeof (next_cfa));
16363 next_cfa.reg = INVALID_REGNUM;
16364 remember = next_cfa;
16366 start_label = fde->dw_fde_begin;
16368 /* ??? Bald assumption that the CIE opcode list does not contain
16369 advance opcodes. */
16370 FOR_EACH_VEC_ELT (*cie_cfi_vec, ix, cfi)
16371 lookup_cfa_1 (cfi, &next_cfa, &remember);
16373 last_cfa = next_cfa;
16374 last_label = start_label;
16376 if (fde->dw_fde_second_begin && fde->dw_fde_switch_cfi_index == 0)
16378 /* If the first partition contained no CFI adjustments, the
16379 CIE opcodes apply to the whole first partition. */
16380 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16381 fde->dw_fde_begin, fde->dw_fde_end, section);
16382 list_tail =&(*list_tail)->dw_loc_next;
16383 start_label = last_label = fde->dw_fde_second_begin;
16386 FOR_EACH_VEC_SAFE_ELT (fde->dw_fde_cfi, ix, cfi)
16388 switch (cfi->dw_cfi_opc)
16390 case DW_CFA_set_loc:
16391 case DW_CFA_advance_loc1:
16392 case DW_CFA_advance_loc2:
16393 case DW_CFA_advance_loc4:
16394 if (!cfa_equal_p (&last_cfa, &next_cfa))
16396 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16397 start_label, last_label, section);
16399 list_tail = &(*list_tail)->dw_loc_next;
16400 last_cfa = next_cfa;
16401 start_label = last_label;
16403 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
16406 case DW_CFA_advance_loc:
16407 /* The encoding is complex enough that we should never emit this. */
16408 gcc_unreachable ();
16411 lookup_cfa_1 (cfi, &next_cfa, &remember);
16414 if (ix + 1 == fde->dw_fde_switch_cfi_index)
16416 if (!cfa_equal_p (&last_cfa, &next_cfa))
16418 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16419 start_label, last_label, section);
16421 list_tail = &(*list_tail)->dw_loc_next;
16422 last_cfa = next_cfa;
16423 start_label = last_label;
16425 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16426 start_label, fde->dw_fde_end, section);
16427 list_tail = &(*list_tail)->dw_loc_next;
16428 start_label = last_label = fde->dw_fde_second_begin;
16432 if (!cfa_equal_p (&last_cfa, &next_cfa))
16434 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16435 start_label, last_label, section);
16436 list_tail = &(*list_tail)->dw_loc_next;
16437 start_label = last_label;
16440 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
16442 fde->dw_fde_second_begin
16443 ? fde->dw_fde_second_end : fde->dw_fde_end,
16446 if (list && list->dw_loc_next)
16452 /* Compute a displacement from the "steady-state frame pointer" to the
16453 frame base (often the same as the CFA), and store it in
16454 frame_pointer_fb_offset. OFFSET is added to the displacement
16455 before the latter is negated. */
16458 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
16462 #ifdef FRAME_POINTER_CFA_OFFSET
16463 reg = frame_pointer_rtx;
16464 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
16466 reg = arg_pointer_rtx;
16467 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
16470 elim = (ira_use_lra_p
16471 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
16472 : eliminate_regs (reg, VOIDmode, NULL_RTX));
16473 if (GET_CODE (elim) == PLUS)
16475 offset += INTVAL (XEXP (elim, 1));
16476 elim = XEXP (elim, 0);
16479 frame_pointer_fb_offset = -offset;
16481 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16482 in which to eliminate. This is because it's stack pointer isn't
16483 directly accessible as a register within the ISA. To work around
16484 this, assume that while we cannot provide a proper value for
16485 frame_pointer_fb_offset, we won't need one either. */
16486 frame_pointer_fb_offset_valid
16487 = ((SUPPORTS_STACK_ALIGNMENT
16488 && (elim == hard_frame_pointer_rtx
16489 || elim == stack_pointer_rtx))
16490 || elim == (frame_pointer_needed
16491 ? hard_frame_pointer_rtx
16492 : stack_pointer_rtx));
16495 /* Generate a DW_AT_name attribute given some string value to be included as
16496 the value of the attribute. */
16499 add_name_attribute (dw_die_ref die, const char *name_string)
16501 if (name_string != NULL && *name_string != 0)
16503 if (demangle_name_func)
16504 name_string = (*demangle_name_func) (name_string);
16506 add_AT_string (die, DW_AT_name, name_string);
16510 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16511 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16512 of TYPE accordingly.
16514 ??? This is a temporary measure until after we're able to generate
16515 regular DWARF for the complex Ada type system. */
16518 add_gnat_descriptive_type_attribute (dw_die_ref die, tree type,
16519 dw_die_ref context_die)
16522 dw_die_ref dtype_die;
16524 if (!lang_hooks.types.descriptive_type)
16527 dtype = lang_hooks.types.descriptive_type (type);
16531 dtype_die = lookup_type_die (dtype);
16534 gen_type_die (dtype, context_die);
16535 dtype_die = lookup_type_die (dtype);
16536 gcc_assert (dtype_die);
16539 add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die);
16542 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16544 static const char *
16545 comp_dir_string (void)
16549 static const char *cached_wd = NULL;
16551 if (cached_wd != NULL)
16554 wd = get_src_pwd ();
16558 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
16562 wdlen = strlen (wd);
16563 wd1 = ggc_vec_alloc<char> (wdlen + 2);
16565 wd1 [wdlen] = DIR_SEPARATOR;
16566 wd1 [wdlen + 1] = 0;
16570 cached_wd = remap_debug_filename (wd);
16574 /* Generate a DW_AT_comp_dir attribute for DIE. */
16577 add_comp_dir_attribute (dw_die_ref die)
16579 const char * wd = comp_dir_string ();
16581 add_AT_string (die, DW_AT_comp_dir, wd);
16584 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
16585 pointer computation, ...), output a representation for that bound according
16586 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
16587 loc_list_from_tree for the meaning of CONTEXT. */
16590 add_scalar_info (dw_die_ref die, enum dwarf_attribute attr, tree value,
16591 int forms, const struct loc_descr_context *context)
16593 dw_die_ref ctx, decl_die;
16594 dw_loc_list_ref list;
16596 bool strip_conversions = true;
16598 while (strip_conversions)
16599 switch (TREE_CODE (value))
16606 case VIEW_CONVERT_EXPR:
16607 value = TREE_OPERAND (value, 0);
16611 strip_conversions = false;
16615 /* If possible and permitted, output the attribute as a constant. */
16616 if ((forms & dw_scalar_form_constant) != 0
16617 && TREE_CODE (value) == INTEGER_CST)
16619 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (value));
16621 /* If HOST_WIDE_INT is big enough then represent the bound as
16622 a constant value. We need to choose a form based on
16623 whether the type is signed or unsigned. We cannot just
16624 call add_AT_unsigned if the value itself is positive
16625 (add_AT_unsigned might add the unsigned value encoded as
16626 DW_FORM_data[1248]). Some DWARF consumers will lookup the
16627 bounds type and then sign extend any unsigned values found
16628 for signed types. This is needed only for
16629 DW_AT_{lower,upper}_bound, since for most other attributes,
16630 consumers will treat DW_FORM_data[1248] as unsigned values,
16631 regardless of the underlying type. */
16632 if (prec <= HOST_BITS_PER_WIDE_INT
16633 || tree_fits_uhwi_p (value))
16635 if (TYPE_UNSIGNED (TREE_TYPE (value)))
16636 add_AT_unsigned (die, attr, TREE_INT_CST_LOW (value));
16638 add_AT_int (die, attr, TREE_INT_CST_LOW (value));
16641 /* Otherwise represent the bound as an unsigned value with
16642 the precision of its type. The precision and signedness
16643 of the type will be necessary to re-interpret it
16645 add_AT_wide (die, attr, value);
16649 /* Otherwise, if it's possible and permitted too, output a reference to
16651 if ((forms & dw_scalar_form_reference) != 0)
16653 tree decl = NULL_TREE;
16655 /* Some type attributes reference an outer type. For instance, the upper
16656 bound of an array may reference an embedding record (this happens in
16658 if (TREE_CODE (value) == COMPONENT_REF
16659 && TREE_CODE (TREE_OPERAND (value, 0)) == PLACEHOLDER_EXPR
16660 && TREE_CODE (TREE_OPERAND (value, 1)) == FIELD_DECL)
16661 decl = TREE_OPERAND (value, 1);
16663 else if (TREE_CODE (value) == VAR_DECL
16664 || TREE_CODE (value) == PARM_DECL
16665 || TREE_CODE (value) == RESULT_DECL)
16668 if (decl != NULL_TREE)
16670 dw_die_ref decl_die = lookup_decl_die (decl);
16672 /* ??? Can this happen, or should the variable have been bound
16673 first? Probably it can, since I imagine that we try to create
16674 the types of parameters in the order in which they exist in
16675 the list, and won't have created a forward reference to a
16676 later parameter. */
16677 if (decl_die != NULL)
16679 add_AT_die_ref (die, attr, decl_die);
16685 /* Last chance: try to create a stack operation procedure to evaluate the
16686 value. Do nothing if even that is not possible or permitted. */
16687 if ((forms & dw_scalar_form_exprloc) == 0)
16690 list = loc_list_from_tree (value, 2, context);
16691 if (list == NULL || single_element_loc_list_p (list))
16693 /* If this attribute is not a reference nor constant, it is
16694 a DWARF expression rather than location description. For that
16695 loc_list_from_tree (value, 0, &context) is needed. */
16696 dw_loc_list_ref list2 = loc_list_from_tree (value, 0, context);
16697 if (list2 && single_element_loc_list_p (list2))
16699 add_AT_loc (die, attr, list2->expr);
16704 /* If that failed to give a single element location list, fall back to
16705 outputting this as a reference... still if permitted. */
16706 if (list == NULL || (forms & dw_scalar_form_reference) == 0)
16709 if (current_function_decl == 0)
16710 ctx = comp_unit_die ();
16712 ctx = lookup_decl_die (current_function_decl);
16714 decl_die = new_die (DW_TAG_variable, ctx, value);
16715 add_AT_flag (decl_die, DW_AT_artificial, 1);
16716 add_type_attribute (decl_die, TREE_TYPE (value), TYPE_QUAL_CONST, ctx);
16717 add_AT_location_description (decl_die, DW_AT_location, list);
16718 add_AT_die_ref (die, attr, decl_die);
16721 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16725 lower_bound_default (void)
16727 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
16733 case DW_LANG_C_plus_plus:
16734 case DW_LANG_C_plus_plus_11:
16735 case DW_LANG_C_plus_plus_14:
16737 case DW_LANG_ObjC_plus_plus:
16740 case DW_LANG_Fortran77:
16741 case DW_LANG_Fortran90:
16742 case DW_LANG_Fortran95:
16743 case DW_LANG_Fortran03:
16744 case DW_LANG_Fortran08:
16748 case DW_LANG_Python:
16749 return dwarf_version >= 4 ? 0 : -1;
16750 case DW_LANG_Ada95:
16751 case DW_LANG_Ada83:
16752 case DW_LANG_Cobol74:
16753 case DW_LANG_Cobol85:
16754 case DW_LANG_Pascal83:
16755 case DW_LANG_Modula2:
16757 return dwarf_version >= 4 ? 1 : -1;
16763 /* Given a tree node describing an array bound (either lower or upper) output
16764 a representation for that bound. */
16767 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr,
16768 tree bound, const struct loc_descr_context *context)
16773 switch (TREE_CODE (bound))
16775 /* Strip all conversions. */
16777 case VIEW_CONVERT_EXPR:
16778 bound = TREE_OPERAND (bound, 0);
16781 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
16782 are even omitted when they are the default. */
16784 /* If the value for this bound is the default one, we can even omit the
16786 if (bound_attr == DW_AT_lower_bound
16787 && tree_fits_shwi_p (bound)
16788 && (dflt = lower_bound_default ()) != -1
16789 && tree_to_shwi (bound) == dflt)
16795 add_scalar_info (subrange_die, bound_attr, bound,
16796 dw_scalar_form_constant
16797 | dw_scalar_form_exprloc
16798 | dw_scalar_form_reference,
16804 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16805 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16806 Note that the block of subscript information for an array type also
16807 includes information about the element type of the given array type. */
16810 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
16812 unsigned dimension_number;
16814 dw_die_ref subrange_die;
16816 for (dimension_number = 0;
16817 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
16818 type = TREE_TYPE (type), dimension_number++)
16820 tree domain = TYPE_DOMAIN (type);
16822 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
16825 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16826 and (in GNU C only) variable bounds. Handle all three forms
16828 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
16831 /* We have an array type with specified bounds. */
16832 lower = TYPE_MIN_VALUE (domain);
16833 upper = TYPE_MAX_VALUE (domain);
16835 /* Define the index type. */
16836 if (TREE_TYPE (domain))
16838 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16839 TREE_TYPE field. We can't emit debug info for this
16840 because it is an unnamed integral type. */
16841 if (TREE_CODE (domain) == INTEGER_TYPE
16842 && TYPE_NAME (domain) == NULL_TREE
16843 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
16844 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
16847 add_type_attribute (subrange_die, TREE_TYPE (domain),
16848 TYPE_UNQUALIFIED, type_die);
16851 /* ??? If upper is NULL, the array has unspecified length,
16852 but it does have a lower bound. This happens with Fortran
16854 Since the debugger is definitely going to need to know N
16855 to produce useful results, go ahead and output the lower
16856 bound solo, and hope the debugger can cope. */
16858 add_bound_info (subrange_die, DW_AT_lower_bound, lower, NULL);
16860 add_bound_info (subrange_die, DW_AT_upper_bound, upper, NULL);
16863 /* Otherwise we have an array type with an unspecified length. The
16864 DWARF-2 spec does not say how to handle this; let's just leave out the
16869 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16872 add_byte_size_attribute (dw_die_ref die, tree tree_node)
16874 dw_die_ref decl_die;
16875 HOST_WIDE_INT size;
16877 switch (TREE_CODE (tree_node))
16882 case ENUMERAL_TYPE:
16885 case QUAL_UNION_TYPE:
16886 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node)) == VAR_DECL
16887 && (decl_die = lookup_decl_die (TYPE_SIZE_UNIT (tree_node))))
16889 add_AT_die_ref (die, DW_AT_byte_size, decl_die);
16892 size = int_size_in_bytes (tree_node);
16895 /* For a data member of a struct or union, the DW_AT_byte_size is
16896 generally given as the number of bytes normally allocated for an
16897 object of the *declared* type of the member itself. This is true
16898 even for bit-fields. */
16899 size = int_size_in_bytes (field_type (tree_node));
16902 gcc_unreachable ();
16905 /* Note that `size' might be -1 when we get to this point. If it is, that
16906 indicates that the byte size of the entity in question is variable. We
16907 have no good way of expressing this fact in Dwarf at the present time,
16908 when location description was not used by the caller code instead. */
16910 add_AT_unsigned (die, DW_AT_byte_size, size);
16913 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16914 which specifies the distance in bits from the highest order bit of the
16915 "containing object" for the bit-field to the highest order bit of the
16918 For any given bit-field, the "containing object" is a hypothetical object
16919 (of some integral or enum type) within which the given bit-field lives. The
16920 type of this hypothetical "containing object" is always the same as the
16921 declared type of the individual bit-field itself. The determination of the
16922 exact location of the "containing object" for a bit-field is rather
16923 complicated. It's handled by the `field_byte_offset' function (above).
16925 Note that it is the size (in bytes) of the hypothetical "containing object"
16926 which will be given in the DW_AT_byte_size attribute for this bit-field.
16927 (See `byte_size_attribute' above). */
16930 add_bit_offset_attribute (dw_die_ref die, tree decl)
16932 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
16933 tree type = DECL_BIT_FIELD_TYPE (decl);
16934 HOST_WIDE_INT bitpos_int;
16935 HOST_WIDE_INT highest_order_object_bit_offset;
16936 HOST_WIDE_INT highest_order_field_bit_offset;
16937 HOST_WIDE_INT bit_offset;
16939 /* Must be a field and a bit field. */
16940 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
16942 /* We can't yet handle bit-fields whose offsets are variable, so if we
16943 encounter such things, just return without generating any attribute
16944 whatsoever. Likewise for variable or too large size. */
16945 if (! tree_fits_shwi_p (bit_position (decl))
16946 || ! tree_fits_uhwi_p (DECL_SIZE (decl)))
16949 bitpos_int = int_bit_position (decl);
16951 /* Note that the bit offset is always the distance (in bits) from the
16952 highest-order bit of the "containing object" to the highest-order bit of
16953 the bit-field itself. Since the "high-order end" of any object or field
16954 is different on big-endian and little-endian machines, the computation
16955 below must take account of these differences. */
16956 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
16957 highest_order_field_bit_offset = bitpos_int;
16959 if (! BYTES_BIG_ENDIAN)
16961 highest_order_field_bit_offset += tree_to_shwi (DECL_SIZE (decl));
16962 highest_order_object_bit_offset += simple_type_size_in_bits (type);
16966 = (! BYTES_BIG_ENDIAN
16967 ? highest_order_object_bit_offset - highest_order_field_bit_offset
16968 : highest_order_field_bit_offset - highest_order_object_bit_offset);
16970 if (bit_offset < 0)
16971 add_AT_int (die, DW_AT_bit_offset, bit_offset);
16973 add_AT_unsigned (die, DW_AT_bit_offset, (unsigned HOST_WIDE_INT) bit_offset);
16976 /* For a FIELD_DECL node which represents a bit field, output an attribute
16977 which specifies the length in bits of the given field. */
16980 add_bit_size_attribute (dw_die_ref die, tree decl)
16982 /* Must be a field and a bit field. */
16983 gcc_assert (TREE_CODE (decl) == FIELD_DECL
16984 && DECL_BIT_FIELD_TYPE (decl));
16986 if (tree_fits_uhwi_p (DECL_SIZE (decl)))
16987 add_AT_unsigned (die, DW_AT_bit_size, tree_to_uhwi (DECL_SIZE (decl)));
16990 /* If the compiled language is ANSI C, then add a 'prototyped'
16991 attribute, if arg types are given for the parameters of a function. */
16994 add_prototyped_attribute (dw_die_ref die, tree func_type)
16996 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
17003 if (prototype_p (func_type))
17004 add_AT_flag (die, DW_AT_prototyped, 1);
17011 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
17012 by looking in either the type declaration or object declaration
17015 static inline dw_die_ref
17016 add_abstract_origin_attribute (dw_die_ref die, tree origin)
17018 dw_die_ref origin_die = NULL;
17020 if (TREE_CODE (origin) != FUNCTION_DECL)
17022 /* We may have gotten separated from the block for the inlined
17023 function, if we're in an exception handler or some such; make
17024 sure that the abstract function has been written out.
17026 Doing this for nested functions is wrong, however; functions are
17027 distinct units, and our context might not even be inline. */
17031 fn = TYPE_STUB_DECL (fn);
17033 fn = decl_function_context (fn);
17035 dwarf2out_abstract_function (fn);
17038 if (DECL_P (origin))
17039 origin_die = lookup_decl_die (origin);
17040 else if (TYPE_P (origin))
17041 origin_die = lookup_type_die (origin);
17043 /* XXX: Functions that are never lowered don't always have correct block
17044 trees (in the case of java, they simply have no block tree, in some other
17045 languages). For these functions, there is nothing we can really do to
17046 output correct debug info for inlined functions in all cases. Rather
17047 than die, we'll just produce deficient debug info now, in that we will
17048 have variables without a proper abstract origin. In the future, when all
17049 functions are lowered, we should re-add a gcc_assert (origin_die)
17053 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
17057 /* We do not currently support the pure_virtual attribute. */
17060 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
17062 if (DECL_VINDEX (func_decl))
17064 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
17066 if (tree_fits_shwi_p (DECL_VINDEX (func_decl)))
17067 add_AT_loc (die, DW_AT_vtable_elem_location,
17068 new_loc_descr (DW_OP_constu,
17069 tree_to_shwi (DECL_VINDEX (func_decl)),
17072 /* GNU extension: Record what type this method came from originally. */
17073 if (debug_info_level > DINFO_LEVEL_TERSE
17074 && DECL_CONTEXT (func_decl))
17075 add_AT_die_ref (die, DW_AT_containing_type,
17076 lookup_type_die (DECL_CONTEXT (func_decl)));
17080 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
17081 given decl. This used to be a vendor extension until after DWARF 4
17082 standardized it. */
17085 add_linkage_attr (dw_die_ref die, tree decl)
17087 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
17089 /* Mimic what assemble_name_raw does with a leading '*'. */
17090 if (name[0] == '*')
17093 if (dwarf_version >= 4)
17094 add_AT_string (die, DW_AT_linkage_name, name);
17096 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
17099 /* Add source coordinate attributes for the given decl. */
17102 add_src_coords_attributes (dw_die_ref die, tree decl)
17104 expanded_location s;
17106 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl)) == UNKNOWN_LOCATION)
17108 s = expand_location (DECL_SOURCE_LOCATION (decl));
17109 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
17110 add_AT_unsigned (die, DW_AT_decl_line, s.line);
17113 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
17116 add_linkage_name (dw_die_ref die, tree decl)
17118 if (debug_info_level > DINFO_LEVEL_NONE
17119 && (TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
17120 && TREE_PUBLIC (decl)
17121 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
17122 && die->die_tag != DW_TAG_member)
17124 /* Defer until we have an assembler name set. */
17125 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
17127 limbo_die_node *asm_name;
17129 asm_name = ggc_cleared_alloc<limbo_die_node> ();
17130 asm_name->die = die;
17131 asm_name->created_for = decl;
17132 asm_name->next = deferred_asm_name;
17133 deferred_asm_name = asm_name;
17135 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
17136 add_linkage_attr (die, decl);
17140 /* Add a DW_AT_name attribute and source coordinate attribute for the
17141 given decl, but only if it actually has a name. */
17144 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
17148 decl_name = DECL_NAME (decl);
17149 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
17151 const char *name = dwarf2_name (decl, 0);
17153 add_name_attribute (die, name);
17154 if (! DECL_ARTIFICIAL (decl))
17155 add_src_coords_attributes (die, decl);
17157 add_linkage_name (die, decl);
17160 #ifdef VMS_DEBUGGING_INFO
17161 /* Get the function's name, as described by its RTL. This may be different
17162 from the DECL_NAME name used in the source file. */
17163 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
17165 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
17166 XEXP (DECL_RTL (decl), 0), false);
17167 vec_safe_push (used_rtx_array, XEXP (DECL_RTL (decl), 0));
17169 #endif /* VMS_DEBUGGING_INFO */
17172 #ifdef VMS_DEBUGGING_INFO
17173 /* Output the debug main pointer die for VMS */
17176 dwarf2out_vms_debug_main_pointer (void)
17178 char label[MAX_ARTIFICIAL_LABEL_BYTES];
17181 /* Allocate the VMS debug main subprogram die. */
17182 die = ggc_cleared_alloc<die_node> ();
17183 die->die_tag = DW_TAG_subprogram;
17184 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
17185 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
17186 current_function_funcdef_no);
17187 add_AT_lbl_id (die, DW_AT_entry_pc, label);
17189 /* Make it the first child of comp_unit_die (). */
17190 die->die_parent = comp_unit_die ();
17191 if (comp_unit_die ()->die_child)
17193 die->die_sib = comp_unit_die ()->die_child->die_sib;
17194 comp_unit_die ()->die_child->die_sib = die;
17198 die->die_sib = die;
17199 comp_unit_die ()->die_child = die;
17202 #endif /* VMS_DEBUGGING_INFO */
17204 /* Push a new declaration scope. */
17207 push_decl_scope (tree scope)
17209 vec_safe_push (decl_scope_table, scope);
17212 /* Pop a declaration scope. */
17215 pop_decl_scope (void)
17217 decl_scope_table->pop ();
17220 /* walk_tree helper function for uses_local_type, below. */
17223 uses_local_type_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
17226 *walk_subtrees = 0;
17229 tree name = TYPE_NAME (*tp);
17230 if (name && DECL_P (name) && decl_function_context (name))
17236 /* If TYPE involves a function-local type (including a local typedef to a
17237 non-local type), returns that type; otherwise returns NULL_TREE. */
17240 uses_local_type (tree type)
17242 tree used = walk_tree_without_duplicates (&type, uses_local_type_r, NULL);
17246 /* Return the DIE for the scope that immediately contains this type.
17247 Non-named types that do not involve a function-local type get global
17248 scope. Named types nested in namespaces or other types get their
17249 containing scope. All other types (i.e. function-local named types) get
17250 the current active scope. */
17253 scope_die_for (tree t, dw_die_ref context_die)
17255 dw_die_ref scope_die = NULL;
17256 tree containing_scope;
17258 /* Non-types always go in the current scope. */
17259 gcc_assert (TYPE_P (t));
17261 /* Use the scope of the typedef, rather than the scope of the type
17263 if (TYPE_NAME (t) && DECL_P (TYPE_NAME (t)))
17264 containing_scope = DECL_CONTEXT (TYPE_NAME (t));
17266 containing_scope = TYPE_CONTEXT (t);
17268 /* Use the containing namespace if there is one. */
17269 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
17271 if (context_die == lookup_decl_die (containing_scope))
17273 else if (debug_info_level > DINFO_LEVEL_TERSE)
17274 context_die = get_context_die (containing_scope);
17276 containing_scope = NULL_TREE;
17279 /* Ignore function type "scopes" from the C frontend. They mean that
17280 a tagged type is local to a parmlist of a function declarator, but
17281 that isn't useful to DWARF. */
17282 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
17283 containing_scope = NULL_TREE;
17285 if (SCOPE_FILE_SCOPE_P (containing_scope))
17287 /* If T uses a local type keep it local as well, to avoid references
17288 to function-local DIEs from outside the function. */
17289 if (current_function_decl && uses_local_type (t))
17290 scope_die = context_die;
17292 scope_die = comp_unit_die ();
17294 else if (TYPE_P (containing_scope))
17296 /* For types, we can just look up the appropriate DIE. */
17297 if (debug_info_level > DINFO_LEVEL_TERSE)
17298 scope_die = get_context_die (containing_scope);
17301 scope_die = lookup_type_die_strip_naming_typedef (containing_scope);
17302 if (scope_die == NULL)
17303 scope_die = comp_unit_die ();
17307 scope_die = context_die;
17312 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17315 local_scope_p (dw_die_ref context_die)
17317 for (; context_die; context_die = context_die->die_parent)
17318 if (context_die->die_tag == DW_TAG_inlined_subroutine
17319 || context_die->die_tag == DW_TAG_subprogram)
17325 /* Returns nonzero if CONTEXT_DIE is a class. */
17328 class_scope_p (dw_die_ref context_die)
17330 return (context_die
17331 && (context_die->die_tag == DW_TAG_structure_type
17332 || context_die->die_tag == DW_TAG_class_type
17333 || context_die->die_tag == DW_TAG_interface_type
17334 || context_die->die_tag == DW_TAG_union_type));
17337 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17338 whether or not to treat a DIE in this context as a declaration. */
17341 class_or_namespace_scope_p (dw_die_ref context_die)
17343 return (class_scope_p (context_die)
17344 || (context_die && context_die->die_tag == DW_TAG_namespace));
17347 /* Many forms of DIEs require a "type description" attribute. This
17348 routine locates the proper "type descriptor" die for the type given
17349 by 'type' plus any additional qualifiers given by 'cv_quals', and
17350 adds a DW_AT_type attribute below the given die. */
17353 add_type_attribute (dw_die_ref object_die, tree type, int cv_quals,
17354 dw_die_ref context_die)
17356 enum tree_code code = TREE_CODE (type);
17357 dw_die_ref type_die = NULL;
17359 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17360 or fixed-point type, use the inner type. This is because we have no
17361 support for unnamed types in base_type_die. This can happen if this is
17362 an Ada subrange type. Correct solution is emit a subrange type die. */
17363 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
17364 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
17365 type = TREE_TYPE (type), code = TREE_CODE (type);
17367 if (code == ERROR_MARK
17368 /* Handle a special case. For functions whose return type is void, we
17369 generate *no* type attribute. (Note that no object may have type
17370 `void', so this only applies to function return types). */
17371 || code == VOID_TYPE)
17374 type_die = modified_type_die (type,
17375 cv_quals | TYPE_QUALS_NO_ADDR_SPACE (type),
17378 if (type_die != NULL)
17379 add_AT_die_ref (object_die, DW_AT_type, type_die);
17382 /* Given an object die, add the calling convention attribute for the
17383 function call type. */
17385 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
17387 enum dwarf_calling_convention value = DW_CC_normal;
17389 value = ((enum dwarf_calling_convention)
17390 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
17393 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
17395 /* DWARF 2 doesn't provide a way to identify a program's source-level
17396 entry point. DW_AT_calling_convention attributes are only meant
17397 to describe functions' calling conventions. However, lacking a
17398 better way to signal the Fortran main program, we used this for
17399 a long time, following existing custom. Now, DWARF 4 has
17400 DW_AT_main_subprogram, which we add below, but some tools still
17401 rely on the old way, which we thus keep. */
17402 value = DW_CC_program;
17404 if (dwarf_version >= 4 || !dwarf_strict)
17405 add_AT_flag (subr_die, DW_AT_main_subprogram, 1);
17408 /* Only add the attribute if the backend requests it, and
17409 is not DW_CC_normal. */
17410 if (value && (value != DW_CC_normal))
17411 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
17414 /* Given a tree pointer to a struct, class, union, or enum type node, return
17415 a pointer to the (string) tag name for the given type, or zero if the type
17416 was declared without a tag. */
17418 static const char *
17419 type_tag (const_tree type)
17421 const char *name = 0;
17423 if (TYPE_NAME (type) != 0)
17427 /* Find the IDENTIFIER_NODE for the type name. */
17428 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
17429 && !TYPE_NAMELESS (type))
17430 t = TYPE_NAME (type);
17432 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17433 a TYPE_DECL node, regardless of whether or not a `typedef' was
17435 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
17436 && ! DECL_IGNORED_P (TYPE_NAME (type)))
17438 /* We want to be extra verbose. Don't call dwarf_name if
17439 DECL_NAME isn't set. The default hook for decl_printable_name
17440 doesn't like that, and in this context it's correct to return
17441 0, instead of "<anonymous>" or the like. */
17442 if (DECL_NAME (TYPE_NAME (type))
17443 && !DECL_NAMELESS (TYPE_NAME (type)))
17444 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
17447 /* Now get the name as a string, or invent one. */
17448 if (!name && t != 0)
17449 name = IDENTIFIER_POINTER (t);
17452 return (name == 0 || *name == '\0') ? 0 : name;
17455 /* Return the type associated with a data member, make a special check
17456 for bit field types. */
17459 member_declared_type (const_tree member)
17461 return (DECL_BIT_FIELD_TYPE (member)
17462 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
17465 /* Get the decl's label, as described by its RTL. This may be different
17466 from the DECL_NAME name used in the source file. */
17469 static const char *
17470 decl_start_label (tree decl)
17473 const char *fnname;
17475 x = DECL_RTL (decl);
17476 gcc_assert (MEM_P (x));
17479 gcc_assert (GET_CODE (x) == SYMBOL_REF);
17481 fnname = XSTR (x, 0);
17486 /* These routines generate the internal representation of the DIE's for
17487 the compilation unit. Debugging information is collected by walking
17488 the declaration trees passed in from dwarf2out_decl(). */
17491 gen_array_type_die (tree type, dw_die_ref context_die)
17493 dw_die_ref scope_die = scope_die_for (type, context_die);
17494 dw_die_ref array_die;
17496 /* GNU compilers represent multidimensional array types as sequences of one
17497 dimensional array types whose element types are themselves array types.
17498 We sometimes squish that down to a single array_type DIE with multiple
17499 subscripts in the Dwarf debugging info. The draft Dwarf specification
17500 say that we are allowed to do this kind of compression in C, because
17501 there is no difference between an array of arrays and a multidimensional
17502 array. We don't do this for Ada to remain as close as possible to the
17503 actual representation, which is especially important against the language
17504 flexibilty wrt arrays of variable size. */
17506 bool collapse_nested_arrays = !is_ada ();
17509 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17510 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17511 if (TYPE_STRING_FLAG (type)
17512 && TREE_CODE (type) == ARRAY_TYPE
17514 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
17516 HOST_WIDE_INT size;
17518 array_die = new_die (DW_TAG_string_type, scope_die, type);
17519 add_name_attribute (array_die, type_tag (type));
17520 equate_type_number_to_die (type, array_die);
17521 size = int_size_in_bytes (type);
17523 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17524 else if (TYPE_DOMAIN (type) != NULL_TREE
17525 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
17526 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
17528 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
17529 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2, NULL);
17531 size = int_size_in_bytes (TREE_TYPE (szdecl));
17532 if (loc && size > 0)
17534 add_AT_location_description (array_die, DW_AT_string_length, loc);
17535 if (size != DWARF2_ADDR_SIZE)
17536 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17542 array_die = new_die (DW_TAG_array_type, scope_die, type);
17543 add_name_attribute (array_die, type_tag (type));
17544 equate_type_number_to_die (type, array_die);
17546 if (TREE_CODE (type) == VECTOR_TYPE)
17547 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
17549 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17551 && TREE_CODE (type) == ARRAY_TYPE
17552 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
17553 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
17554 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17557 /* We default the array ordering. SDB will probably do
17558 the right things even if DW_AT_ordering is not present. It's not even
17559 an issue until we start to get into multidimensional arrays anyway. If
17560 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17561 then we'll have to put the DW_AT_ordering attribute back in. (But if
17562 and when we find out that we need to put these in, we will only do so
17563 for multidimensional arrays. */
17564 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17567 if (TREE_CODE (type) == VECTOR_TYPE)
17569 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17570 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
17571 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node, NULL);
17572 add_bound_info (subrange_die, DW_AT_upper_bound,
17573 size_int (TYPE_VECTOR_SUBPARTS (type) - 1), NULL);
17576 add_subscript_info (array_die, type, collapse_nested_arrays);
17578 /* Add representation of the type of the elements of this array type and
17579 emit the corresponding DIE if we haven't done it already. */
17580 element_type = TREE_TYPE (type);
17581 if (collapse_nested_arrays)
17582 while (TREE_CODE (element_type) == ARRAY_TYPE)
17584 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
17586 element_type = TREE_TYPE (element_type);
17589 add_type_attribute (array_die, element_type, TYPE_UNQUALIFIED, context_die);
17591 add_gnat_descriptive_type_attribute (array_die, type, context_die);
17592 if (TYPE_ARTIFICIAL (type))
17593 add_AT_flag (array_die, DW_AT_artificial, 1);
17595 if (get_AT (array_die, DW_AT_name))
17596 add_pubtype (type, array_die);
17599 /* This routine generates DIE for array with hidden descriptor, details
17600 are filled into *info by a langhook. */
17603 gen_descr_array_type_die (tree type, struct array_descr_info *info,
17604 dw_die_ref context_die)
17606 const dw_die_ref scope_die = scope_die_for (type, context_die);
17607 const dw_die_ref array_die = new_die (DW_TAG_array_type, scope_die, type);
17608 const struct loc_descr_context context = { type, info->base_decl };
17611 add_name_attribute (array_die, type_tag (type));
17612 equate_type_number_to_die (type, array_die);
17614 if (info->ndimensions > 1)
17615 switch (info->ordering)
17617 case array_descr_ordering_row_major:
17618 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17620 case array_descr_ordering_column_major:
17621 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17627 if (dwarf_version >= 3 || !dwarf_strict)
17629 if (info->data_location)
17630 add_scalar_info (array_die, DW_AT_data_location, info->data_location,
17631 dw_scalar_form_exprloc, &context);
17632 if (info->associated)
17633 add_scalar_info (array_die, DW_AT_associated, info->associated,
17634 dw_scalar_form_constant
17635 | dw_scalar_form_exprloc
17636 | dw_scalar_form_reference, &context);
17637 if (info->allocated)
17638 add_scalar_info (array_die, DW_AT_allocated, info->allocated,
17639 dw_scalar_form_constant
17640 | dw_scalar_form_exprloc
17641 | dw_scalar_form_reference, &context);
17644 add_gnat_descriptive_type_attribute (array_die, type, context_die);
17646 for (dim = 0; dim < info->ndimensions; dim++)
17648 dw_die_ref subrange_die
17649 = new_die (DW_TAG_subrange_type, array_die, NULL);
17651 if (info->dimen[dim].bounds_type)
17652 add_type_attribute (subrange_die,
17653 info->dimen[dim].bounds_type, 0,
17655 if (info->dimen[dim].lower_bound)
17656 add_bound_info (subrange_die, DW_AT_lower_bound,
17657 info->dimen[dim].lower_bound, &context);
17658 if (info->dimen[dim].upper_bound)
17659 add_bound_info (subrange_die, DW_AT_upper_bound,
17660 info->dimen[dim].upper_bound, &context);
17661 if ((dwarf_version >= 3 || !dwarf_strict) && info->dimen[dim].stride)
17662 add_scalar_info (subrange_die, DW_AT_byte_stride,
17663 info->dimen[dim].stride,
17664 dw_scalar_form_constant
17665 | dw_scalar_form_exprloc
17666 | dw_scalar_form_reference,
17670 gen_type_die (info->element_type, context_die);
17671 add_type_attribute (array_die, info->element_type, TYPE_UNQUALIFIED,
17674 if (get_AT (array_die, DW_AT_name))
17675 add_pubtype (type, array_die);
17680 gen_entry_point_die (tree decl, dw_die_ref context_die)
17682 tree origin = decl_ultimate_origin (decl);
17683 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
17685 if (origin != NULL)
17686 add_abstract_origin_attribute (decl_die, origin);
17689 add_name_and_src_coords_attributes (decl_die, decl);
17690 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
17691 TYPE_UNQUALIFIED, context_die);
17694 if (DECL_ABSTRACT_P (decl))
17695 equate_decl_number_to_die (decl, decl_die);
17697 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
17701 /* Walk through the list of incomplete types again, trying once more to
17702 emit full debugging info for them. */
17705 retry_incomplete_types (void)
17709 for (i = vec_safe_length (incomplete_types) - 1; i >= 0; i--)
17710 if (should_emit_struct_debug ((*incomplete_types)[i], DINFO_USAGE_DIR_USE))
17711 gen_type_die ((*incomplete_types)[i], comp_unit_die ());
17714 /* Determine what tag to use for a record type. */
17716 static enum dwarf_tag
17717 record_type_tag (tree type)
17719 if (! lang_hooks.types.classify_record)
17720 return DW_TAG_structure_type;
17722 switch (lang_hooks.types.classify_record (type))
17724 case RECORD_IS_STRUCT:
17725 return DW_TAG_structure_type;
17727 case RECORD_IS_CLASS:
17728 return DW_TAG_class_type;
17730 case RECORD_IS_INTERFACE:
17731 if (dwarf_version >= 3 || !dwarf_strict)
17732 return DW_TAG_interface_type;
17733 return DW_TAG_structure_type;
17736 gcc_unreachable ();
17740 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17741 include all of the information about the enumeration values also. Each
17742 enumerated type name/value is listed as a child of the enumerated type
17746 gen_enumeration_type_die (tree type, dw_die_ref context_die)
17748 dw_die_ref type_die = lookup_type_die (type);
17750 if (type_die == NULL)
17752 type_die = new_die (DW_TAG_enumeration_type,
17753 scope_die_for (type, context_die), type);
17754 equate_type_number_to_die (type, type_die);
17755 add_name_attribute (type_die, type_tag (type));
17756 if (dwarf_version >= 4 || !dwarf_strict)
17758 if (ENUM_IS_SCOPED (type))
17759 add_AT_flag (type_die, DW_AT_enum_class, 1);
17760 if (ENUM_IS_OPAQUE (type))
17761 add_AT_flag (type_die, DW_AT_declaration, 1);
17764 else if (! TYPE_SIZE (type))
17767 remove_AT (type_die, DW_AT_declaration);
17769 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17770 given enum type is incomplete, do not generate the DW_AT_byte_size
17771 attribute or the DW_AT_element_list attribute. */
17772 if (TYPE_SIZE (type))
17776 TREE_ASM_WRITTEN (type) = 1;
17777 add_byte_size_attribute (type_die, type);
17778 if (dwarf_version >= 3 || !dwarf_strict)
17780 tree underlying = lang_hooks.types.enum_underlying_base_type (type);
17781 add_type_attribute (type_die, underlying, TYPE_UNQUALIFIED,
17784 if (TYPE_STUB_DECL (type) != NULL_TREE)
17786 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
17787 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
17790 /* If the first reference to this type was as the return type of an
17791 inline function, then it may not have a parent. Fix this now. */
17792 if (type_die->die_parent == NULL)
17793 add_child_die (scope_die_for (type, context_die), type_die);
17795 for (link = TYPE_VALUES (type);
17796 link != NULL; link = TREE_CHAIN (link))
17798 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
17799 tree value = TREE_VALUE (link);
17801 add_name_attribute (enum_die,
17802 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
17804 if (TREE_CODE (value) == CONST_DECL)
17805 value = DECL_INITIAL (value);
17807 if (simple_type_size_in_bits (TREE_TYPE (value))
17808 <= HOST_BITS_PER_WIDE_INT || tree_fits_shwi_p (value))
17810 /* For constant forms created by add_AT_unsigned DWARF
17811 consumers (GDB, elfutils, etc.) always zero extend
17812 the value. Only when the actual value is negative
17813 do we need to use add_AT_int to generate a constant
17814 form that can represent negative values. */
17815 HOST_WIDE_INT val = TREE_INT_CST_LOW (value);
17816 if (TYPE_UNSIGNED (TREE_TYPE (value)) || val >= 0)
17817 add_AT_unsigned (enum_die, DW_AT_const_value,
17818 (unsigned HOST_WIDE_INT) val);
17820 add_AT_int (enum_die, DW_AT_const_value, val);
17823 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17824 that here. TODO: This should be re-worked to use correct
17825 signed/unsigned double tags for all cases. */
17826 add_AT_wide (enum_die, DW_AT_const_value, value);
17829 add_gnat_descriptive_type_attribute (type_die, type, context_die);
17830 if (TYPE_ARTIFICIAL (type))
17831 add_AT_flag (type_die, DW_AT_artificial, 1);
17834 add_AT_flag (type_die, DW_AT_declaration, 1);
17836 add_pubtype (type, type_die);
17841 /* Generate a DIE to represent either a real live formal parameter decl or to
17842 represent just the type of some formal parameter position in some function
17845 Note that this routine is a bit unusual because its argument may be a
17846 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17847 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17848 node. If it's the former then this function is being called to output a
17849 DIE to represent a formal parameter object (or some inlining thereof). If
17850 it's the latter, then this function is only being called to output a
17851 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17852 argument type of some subprogram type.
17853 If EMIT_NAME_P is true, name and source coordinate attributes
17857 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
17858 dw_die_ref context_die)
17860 tree node_or_origin = node ? node : origin;
17861 tree ultimate_origin;
17862 dw_die_ref parm_die
17863 = new_die (DW_TAG_formal_parameter, context_die, node);
17865 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
17867 case tcc_declaration:
17868 ultimate_origin = decl_ultimate_origin (node_or_origin);
17869 if (node || ultimate_origin)
17870 origin = ultimate_origin;
17871 if (origin != NULL)
17872 add_abstract_origin_attribute (parm_die, origin);
17873 else if (emit_name_p)
17874 add_name_and_src_coords_attributes (parm_die, node);
17876 || (! DECL_ABSTRACT_P (node_or_origin)
17877 && variably_modified_type_p (TREE_TYPE (node_or_origin),
17878 decl_function_context
17879 (node_or_origin))))
17881 tree type = TREE_TYPE (node_or_origin);
17882 if (decl_by_reference_p (node_or_origin))
17883 add_type_attribute (parm_die, TREE_TYPE (type),
17884 TYPE_UNQUALIFIED, context_die);
17886 add_type_attribute (parm_die, type,
17887 decl_quals (node_or_origin),
17890 if (origin == NULL && DECL_ARTIFICIAL (node))
17891 add_AT_flag (parm_die, DW_AT_artificial, 1);
17893 if (node && node != origin)
17894 equate_decl_number_to_die (node, parm_die);
17895 if (! DECL_ABSTRACT_P (node_or_origin))
17896 add_location_or_const_value_attribute (parm_die, node_or_origin,
17897 node == NULL, DW_AT_location);
17902 /* We were called with some kind of a ..._TYPE node. */
17903 add_type_attribute (parm_die, node_or_origin, TYPE_UNQUALIFIED,
17908 gcc_unreachable ();
17914 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17915 children DW_TAG_formal_parameter DIEs representing the arguments of the
17918 PARM_PACK must be a function parameter pack.
17919 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17920 must point to the subsequent arguments of the function PACK_ARG belongs to.
17921 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17922 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17923 following the last one for which a DIE was generated. */
17926 gen_formal_parameter_pack_die (tree parm_pack,
17928 dw_die_ref subr_die,
17932 dw_die_ref parm_pack_die;
17934 gcc_assert (parm_pack
17935 && lang_hooks.function_parameter_pack_p (parm_pack)
17938 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
17939 add_src_coords_attributes (parm_pack_die, parm_pack);
17941 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg))
17943 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
17946 gen_formal_parameter_die (arg, NULL,
17947 false /* Don't emit name attribute. */,
17952 return parm_pack_die;
17955 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17956 at the end of an (ANSI prototyped) formal parameters list. */
17959 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
17961 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
17964 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17965 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17966 parameters as specified in some function type specification (except for
17967 those which appear as part of a function *definition*). */
17970 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
17973 tree formal_type = NULL;
17974 tree first_parm_type;
17977 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
17979 arg = DECL_ARGUMENTS (function_or_method_type);
17980 function_or_method_type = TREE_TYPE (function_or_method_type);
17985 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
17987 /* Make our first pass over the list of formal parameter types and output a
17988 DW_TAG_formal_parameter DIE for each one. */
17989 for (link = first_parm_type; link; )
17991 dw_die_ref parm_die;
17993 formal_type = TREE_VALUE (link);
17994 if (formal_type == void_type_node)
17997 /* Output a (nameless) DIE to represent the formal parameter itself. */
17998 if (!POINTER_BOUNDS_TYPE_P (formal_type))
18000 parm_die = gen_formal_parameter_die (formal_type, NULL,
18001 true /* Emit name attribute. */,
18003 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
18004 && link == first_parm_type)
18006 add_AT_flag (parm_die, DW_AT_artificial, 1);
18007 if (dwarf_version >= 3 || !dwarf_strict)
18008 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die);
18010 else if (arg && DECL_ARTIFICIAL (arg))
18011 add_AT_flag (parm_die, DW_AT_artificial, 1);
18014 link = TREE_CHAIN (link);
18016 arg = DECL_CHAIN (arg);
18019 /* If this function type has an ellipsis, add a
18020 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
18021 if (formal_type != void_type_node)
18022 gen_unspecified_parameters_die (function_or_method_type, context_die);
18024 /* Make our second (and final) pass over the list of formal parameter types
18025 and output DIEs to represent those types (as necessary). */
18026 for (link = TYPE_ARG_TYPES (function_or_method_type);
18027 link && TREE_VALUE (link);
18028 link = TREE_CHAIN (link))
18029 gen_type_die (TREE_VALUE (link), context_die);
18032 /* We want to generate the DIE for TYPE so that we can generate the
18033 die for MEMBER, which has been defined; we will need to refer back
18034 to the member declaration nested within TYPE. If we're trying to
18035 generate minimal debug info for TYPE, processing TYPE won't do the
18036 trick; we need to attach the member declaration by hand. */
18039 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
18041 gen_type_die (type, context_die);
18043 /* If we're trying to avoid duplicate debug info, we may not have
18044 emitted the member decl for this function. Emit it now. */
18045 if (TYPE_STUB_DECL (type)
18046 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
18047 && ! lookup_decl_die (member))
18049 dw_die_ref type_die;
18050 gcc_assert (!decl_ultimate_origin (member));
18052 push_decl_scope (type);
18053 type_die = lookup_type_die_strip_naming_typedef (type);
18054 if (TREE_CODE (member) == FUNCTION_DECL)
18055 gen_subprogram_die (member, type_die);
18056 else if (TREE_CODE (member) == FIELD_DECL)
18058 /* Ignore the nameless fields that are used to skip bits but handle
18059 C++ anonymous unions and structs. */
18060 if (DECL_NAME (member) != NULL_TREE
18061 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
18062 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
18064 gen_type_die (member_declared_type (member), type_die);
18065 gen_field_die (member, type_die);
18069 gen_variable_die (member, NULL_TREE, type_die);
18075 /* Forward declare these functions, because they are mutually recursive
18076 with their set_block_* pairing functions. */
18077 static void set_decl_origin_self (tree);
18078 static void set_decl_abstract_flags (tree, vec<tree> &);
18080 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
18081 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
18082 that it points to the node itself, thus indicating that the node is its
18083 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
18084 the given node is NULL, recursively descend the decl/block tree which
18085 it is the root of, and for each other ..._DECL or BLOCK node contained
18086 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
18087 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
18088 values to point to themselves. */
18091 set_block_origin_self (tree stmt)
18093 if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
18095 BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
18100 for (local_decl = BLOCK_VARS (stmt);
18101 local_decl != NULL_TREE;
18102 local_decl = DECL_CHAIN (local_decl))
18103 /* Do not recurse on nested functions since the inlining status
18104 of parent and child can be different as per the DWARF spec. */
18105 if (TREE_CODE (local_decl) != FUNCTION_DECL
18106 && !DECL_EXTERNAL (local_decl))
18107 set_decl_origin_self (local_decl);
18113 for (subblock = BLOCK_SUBBLOCKS (stmt);
18114 subblock != NULL_TREE;
18115 subblock = BLOCK_CHAIN (subblock))
18116 set_block_origin_self (subblock); /* Recurse. */
18121 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
18122 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
18123 node to so that it points to the node itself, thus indicating that the
18124 node represents its own (abstract) origin. Additionally, if the
18125 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
18126 the decl/block tree of which the given node is the root of, and for
18127 each other ..._DECL or BLOCK node contained therein whose
18128 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
18129 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
18130 point to themselves. */
18133 set_decl_origin_self (tree decl)
18135 if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
18137 DECL_ABSTRACT_ORIGIN (decl) = decl;
18138 if (TREE_CODE (decl) == FUNCTION_DECL)
18142 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
18143 DECL_ABSTRACT_ORIGIN (arg) = arg;
18144 if (DECL_INITIAL (decl) != NULL_TREE
18145 && DECL_INITIAL (decl) != error_mark_node)
18146 set_block_origin_self (DECL_INITIAL (decl));
18151 /* Given a pointer to some BLOCK node, set the BLOCK_ABSTRACT flag to 1
18152 and if it wasn't 1 before, push it to abstract_vec vector.
18153 For all local decls and all local sub-blocks (recursively) do it
18157 set_block_abstract_flags (tree stmt, vec<tree> &abstract_vec)
18163 if (!BLOCK_ABSTRACT (stmt))
18165 abstract_vec.safe_push (stmt);
18166 BLOCK_ABSTRACT (stmt) = 1;
18169 for (local_decl = BLOCK_VARS (stmt);
18170 local_decl != NULL_TREE;
18171 local_decl = DECL_CHAIN (local_decl))
18172 if (! DECL_EXTERNAL (local_decl))
18173 set_decl_abstract_flags (local_decl, abstract_vec);
18175 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
18177 local_decl = BLOCK_NONLOCALIZED_VAR (stmt, i);
18178 if ((TREE_CODE (local_decl) == VAR_DECL && !TREE_STATIC (local_decl))
18179 || TREE_CODE (local_decl) == PARM_DECL)
18180 set_decl_abstract_flags (local_decl, abstract_vec);
18183 for (subblock = BLOCK_SUBBLOCKS (stmt);
18184 subblock != NULL_TREE;
18185 subblock = BLOCK_CHAIN (subblock))
18186 set_block_abstract_flags (subblock, abstract_vec);
18189 /* Given a pointer to some ..._DECL node, set DECL_ABSTRACT_P flag on it
18190 to 1 and if it wasn't 1 before, push to abstract_vec vector.
18191 In the case where the decl is a FUNCTION_DECL also set the abstract
18192 flags for all of the parameters, local vars, local
18193 blocks and sub-blocks (recursively). */
18196 set_decl_abstract_flags (tree decl, vec<tree> &abstract_vec)
18198 if (!DECL_ABSTRACT_P (decl))
18200 abstract_vec.safe_push (decl);
18201 DECL_ABSTRACT_P (decl) = 1;
18204 if (TREE_CODE (decl) == FUNCTION_DECL)
18208 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
18209 if (!DECL_ABSTRACT_P (arg))
18211 abstract_vec.safe_push (arg);
18212 DECL_ABSTRACT_P (arg) = 1;
18214 if (DECL_INITIAL (decl) != NULL_TREE
18215 && DECL_INITIAL (decl) != error_mark_node)
18216 set_block_abstract_flags (DECL_INITIAL (decl), abstract_vec);
18220 /* Generate the DWARF2 info for the "abstract" instance of a function which we
18221 may later generate inlined and/or out-of-line instances of. */
18224 dwarf2out_abstract_function (tree decl)
18226 dw_die_ref old_die;
18229 hash_table<decl_loc_hasher> *old_decl_loc_table;
18230 hash_table<dw_loc_list_hasher> *old_cached_dw_loc_list_table;
18231 int old_call_site_count, old_tail_call_site_count;
18232 struct call_arg_loc_node *old_call_arg_locations;
18234 /* Make sure we have the actual abstract inline, not a clone. */
18235 decl = DECL_ORIGIN (decl);
18237 old_die = lookup_decl_die (decl);
18238 if (old_die && get_AT (old_die, DW_AT_inline))
18239 /* We've already generated the abstract instance. */
18242 /* We can be called while recursively when seeing block defining inlined subroutine
18243 DIE. Be sure to not clobber the outer location table nor use it or we would
18244 get locations in abstract instantces. */
18245 old_decl_loc_table = decl_loc_table;
18246 decl_loc_table = NULL;
18247 old_cached_dw_loc_list_table = cached_dw_loc_list_table;
18248 cached_dw_loc_list_table = NULL;
18249 old_call_arg_locations = call_arg_locations;
18250 call_arg_locations = NULL;
18251 old_call_site_count = call_site_count;
18252 call_site_count = -1;
18253 old_tail_call_site_count = tail_call_site_count;
18254 tail_call_site_count = -1;
18256 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
18257 we don't get confused by DECL_ABSTRACT_P. */
18258 if (debug_info_level > DINFO_LEVEL_TERSE)
18260 context = decl_class_context (decl);
18262 gen_type_die_for_member
18263 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ());
18266 /* Pretend we've just finished compiling this function. */
18267 save_fn = current_function_decl;
18268 current_function_decl = decl;
18270 auto_vec<tree, 64> abstract_vec;
18271 set_decl_abstract_flags (decl, abstract_vec);
18272 dwarf2out_decl (decl);
18275 FOR_EACH_VEC_ELT (abstract_vec, i, t)
18276 if (TREE_CODE (t) == BLOCK)
18277 BLOCK_ABSTRACT (t) = 0;
18279 DECL_ABSTRACT_P (t) = 0;
18281 current_function_decl = save_fn;
18282 decl_loc_table = old_decl_loc_table;
18283 cached_dw_loc_list_table = old_cached_dw_loc_list_table;
18284 call_arg_locations = old_call_arg_locations;
18285 call_site_count = old_call_site_count;
18286 tail_call_site_count = old_tail_call_site_count;
18289 /* Helper function of premark_used_types() which gets called through
18292 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18293 marked as unused by prune_unused_types. */
18296 premark_used_types_helper (tree const &type, void *)
18300 die = lookup_type_die (type);
18302 die->die_perennial_p = 1;
18306 /* Helper function of premark_types_used_by_global_vars which gets called
18307 through htab_traverse.
18309 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18310 marked as unused by prune_unused_types. The DIE of the type is marked
18311 only if the global variable using the type will actually be emitted. */
18314 premark_types_used_by_global_vars_helper (types_used_by_vars_entry **slot,
18317 struct types_used_by_vars_entry *entry;
18320 entry = (struct types_used_by_vars_entry *) *slot;
18321 gcc_assert (entry->type != NULL
18322 && entry->var_decl != NULL);
18323 die = lookup_type_die (entry->type);
18326 /* Ask cgraph if the global variable really is to be emitted.
18327 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18328 varpool_node *node = varpool_node::get (entry->var_decl);
18329 if (node && node->definition)
18331 die->die_perennial_p = 1;
18332 /* Keep the parent DIEs as well. */
18333 while ((die = die->die_parent) && die->die_perennial_p == 0)
18334 die->die_perennial_p = 1;
18340 /* Mark all members of used_types_hash as perennial. */
18343 premark_used_types (struct function *fun)
18345 if (fun && fun->used_types_hash)
18346 fun->used_types_hash->traverse<void *, premark_used_types_helper> (NULL);
18349 /* Mark all members of types_used_by_vars_entry as perennial. */
18352 premark_types_used_by_global_vars (void)
18354 if (types_used_by_vars_hash)
18355 types_used_by_vars_hash
18356 ->traverse<void *, premark_types_used_by_global_vars_helper> (NULL);
18359 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
18360 for CA_LOC call arg loc node. */
18363 gen_call_site_die (tree decl, dw_die_ref subr_die,
18364 struct call_arg_loc_node *ca_loc)
18366 dw_die_ref stmt_die = NULL, die;
18367 tree block = ca_loc->block;
18370 && block != DECL_INITIAL (decl)
18371 && TREE_CODE (block) == BLOCK)
18373 if (block_map.length () > BLOCK_NUMBER (block))
18374 stmt_die = block_map[BLOCK_NUMBER (block)];
18377 block = BLOCK_SUPERCONTEXT (block);
18379 if (stmt_die == NULL)
18380 stmt_die = subr_die;
18381 die = new_die (DW_TAG_GNU_call_site, stmt_die, NULL_TREE);
18382 add_AT_lbl_id (die, DW_AT_low_pc, ca_loc->label);
18383 if (ca_loc->tail_call_p)
18384 add_AT_flag (die, DW_AT_GNU_tail_call, 1);
18385 if (ca_loc->symbol_ref)
18387 dw_die_ref tdie = lookup_decl_die (SYMBOL_REF_DECL (ca_loc->symbol_ref));
18389 add_AT_die_ref (die, DW_AT_abstract_origin, tdie);
18391 add_AT_addr (die, DW_AT_abstract_origin, ca_loc->symbol_ref, false);
18396 /* Generate a DIE to represent a declared function (either file-scope or
18400 gen_subprogram_die (tree decl, dw_die_ref context_die)
18402 tree origin = decl_ultimate_origin (decl);
18403 dw_die_ref subr_die;
18405 dw_die_ref old_die = lookup_decl_die (decl);
18406 int declaration = (current_function_decl != decl
18407 || class_or_namespace_scope_p (context_die));
18409 premark_used_types (DECL_STRUCT_FUNCTION (decl));
18411 /* It is possible to have both DECL_ABSTRACT_P and DECLARATION be true if we
18412 started to generate the abstract instance of an inline, decided to output
18413 its containing class, and proceeded to emit the declaration of the inline
18414 from the member list for the class. If so, DECLARATION takes priority;
18415 we'll get back to the abstract instance when done with the class. */
18417 /* The class-scope declaration DIE must be the primary DIE. */
18418 if (origin && declaration && class_or_namespace_scope_p (context_die))
18421 gcc_assert (!old_die);
18424 /* Now that the C++ front end lazily declares artificial member fns, we
18425 might need to retrofit the declaration into its class. */
18426 if (!declaration && !origin && !old_die
18427 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
18428 && !class_or_namespace_scope_p (context_die)
18429 && debug_info_level > DINFO_LEVEL_TERSE)
18430 old_die = force_decl_die (decl);
18432 if (origin != NULL)
18434 gcc_assert (!declaration || local_scope_p (context_die));
18436 /* Fixup die_parent for the abstract instance of a nested
18437 inline function. */
18438 if (old_die && old_die->die_parent == NULL)
18439 add_child_die (context_die, old_die);
18441 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18442 add_abstract_origin_attribute (subr_die, origin);
18443 /* This is where the actual code for a cloned function is.
18444 Let's emit linkage name attribute for it. This helps
18445 debuggers to e.g, set breakpoints into
18446 constructors/destructors when the user asks "break
18448 add_linkage_name (subr_die, decl);
18452 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
18453 struct dwarf_file_data * file_index = lookup_filename (s.file);
18455 if (!get_AT_flag (old_die, DW_AT_declaration)
18456 /* We can have a normal definition following an inline one in the
18457 case of redefinition of GNU C extern inlines.
18458 It seems reasonable to use AT_specification in this case. */
18459 && !get_AT (old_die, DW_AT_inline))
18461 /* Detect and ignore this case, where we are trying to output
18462 something we have already output. */
18466 /* If the definition comes from the same place as the declaration,
18467 maybe use the old DIE. We always want the DIE for this function
18468 that has the *_pc attributes to be under comp_unit_die so the
18469 debugger can find it. We also need to do this for abstract
18470 instances of inlines, since the spec requires the out-of-line copy
18471 to have the same parent. For local class methods, this doesn't
18472 apply; we just use the old DIE. */
18473 if ((is_cu_die (old_die->die_parent) || context_die == NULL)
18474 && (DECL_ARTIFICIAL (decl)
18475 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
18476 && (get_AT_unsigned (old_die, DW_AT_decl_line)
18477 == (unsigned) s.line))))
18479 subr_die = old_die;
18481 /* Clear out the declaration attribute and the formal parameters.
18482 Do not remove all children, because it is possible that this
18483 declaration die was forced using force_decl_die(). In such
18484 cases die that forced declaration die (e.g. TAG_imported_module)
18485 is one of the children that we do not want to remove. */
18486 remove_AT (subr_die, DW_AT_declaration);
18487 remove_AT (subr_die, DW_AT_object_pointer);
18488 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
18492 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18493 add_AT_specification (subr_die, old_die);
18494 add_pubname (decl, subr_die);
18495 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
18496 add_AT_file (subr_die, DW_AT_decl_file, file_index);
18497 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
18498 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
18500 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18501 emit the real type on the definition die. */
18502 if (is_cxx() && debug_info_level > DINFO_LEVEL_TERSE)
18504 dw_die_ref die = get_AT_ref (old_die, DW_AT_type);
18505 if (die == auto_die || die == decltype_auto_die)
18506 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18507 TYPE_UNQUALIFIED, context_die);
18513 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18515 if (TREE_PUBLIC (decl))
18516 add_AT_flag (subr_die, DW_AT_external, 1);
18518 add_name_and_src_coords_attributes (subr_die, decl);
18519 add_pubname (decl, subr_die);
18520 if (debug_info_level > DINFO_LEVEL_TERSE)
18522 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
18523 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18524 TYPE_UNQUALIFIED, context_die);
18527 add_pure_or_virtual_attribute (subr_die, decl);
18528 if (DECL_ARTIFICIAL (decl))
18529 add_AT_flag (subr_die, DW_AT_artificial, 1);
18531 if (TREE_THIS_VOLATILE (decl) && (dwarf_version >= 5 || !dwarf_strict))
18532 add_AT_flag (subr_die, DW_AT_noreturn, 1);
18534 add_accessibility_attribute (subr_die, decl);
18539 if (!old_die || !get_AT (old_die, DW_AT_inline))
18541 add_AT_flag (subr_die, DW_AT_declaration, 1);
18543 /* If this is an explicit function declaration then generate
18544 a DW_AT_explicit attribute. */
18545 if (lang_hooks.decls.function_decl_explicit_p (decl)
18546 && (dwarf_version >= 3 || !dwarf_strict))
18547 add_AT_flag (subr_die, DW_AT_explicit, 1);
18549 /* If this is a C++11 deleted special function member then generate
18550 a DW_AT_GNU_deleted attribute. */
18551 if (lang_hooks.decls.function_decl_deleted_p (decl)
18552 && (! dwarf_strict))
18553 add_AT_flag (subr_die, DW_AT_GNU_deleted, 1);
18555 /* The first time we see a member function, it is in the context of
18556 the class to which it belongs. We make sure of this by emitting
18557 the class first. The next time is the definition, which is
18558 handled above. The two may come from the same source text.
18560 Note that force_decl_die() forces function declaration die. It is
18561 later reused to represent definition. */
18562 equate_decl_number_to_die (decl, subr_die);
18565 else if (DECL_ABSTRACT_P (decl))
18567 if (DECL_DECLARED_INLINE_P (decl))
18569 if (cgraph_function_possibly_inlined_p (decl))
18570 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
18572 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
18576 if (cgraph_function_possibly_inlined_p (decl))
18577 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
18579 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
18582 if (DECL_DECLARED_INLINE_P (decl)
18583 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
18584 add_AT_flag (subr_die, DW_AT_artificial, 1);
18586 equate_decl_number_to_die (decl, subr_die);
18588 else if (!DECL_EXTERNAL (decl))
18590 HOST_WIDE_INT cfa_fb_offset;
18591 struct function *fun = DECL_STRUCT_FUNCTION (decl);
18593 if (!old_die || !get_AT (old_die, DW_AT_inline))
18594 equate_decl_number_to_die (decl, subr_die);
18596 gcc_checking_assert (fun);
18597 if (!flag_reorder_blocks_and_partition)
18599 dw_fde_ref fde = fun->fde;
18600 if (fde->dw_fde_begin)
18602 /* We have already generated the labels. */
18603 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
18604 fde->dw_fde_end, false);
18608 /* Create start/end labels and add the range. */
18609 char label_id_low[MAX_ARTIFICIAL_LABEL_BYTES];
18610 char label_id_high[MAX_ARTIFICIAL_LABEL_BYTES];
18611 ASM_GENERATE_INTERNAL_LABEL (label_id_low, FUNC_BEGIN_LABEL,
18612 current_function_funcdef_no);
18613 ASM_GENERATE_INTERNAL_LABEL (label_id_high, FUNC_END_LABEL,
18614 current_function_funcdef_no);
18615 add_AT_low_high_pc (subr_die, label_id_low, label_id_high,
18619 #if VMS_DEBUGGING_INFO
18620 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18621 Section 2.3 Prologue and Epilogue Attributes:
18622 When a breakpoint is set on entry to a function, it is generally
18623 desirable for execution to be suspended, not on the very first
18624 instruction of the function, but rather at a point after the
18625 function's frame has been set up, after any language defined local
18626 declaration processing has been completed, and before execution of
18627 the first statement of the function begins. Debuggers generally
18628 cannot properly determine where this point is. Similarly for a
18629 breakpoint set on exit from a function. The prologue and epilogue
18630 attributes allow a compiler to communicate the location(s) to use. */
18633 if (fde->dw_fde_vms_end_prologue)
18634 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
18635 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
18637 if (fde->dw_fde_vms_begin_epilogue)
18638 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
18639 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
18646 /* Generate pubnames entries for the split function code ranges. */
18647 dw_fde_ref fde = fun->fde;
18649 if (fde->dw_fde_second_begin)
18651 if (dwarf_version >= 3 || !dwarf_strict)
18653 /* We should use ranges for non-contiguous code section
18654 addresses. Use the actual code range for the initial
18655 section, since the HOT/COLD labels might precede an
18656 alignment offset. */
18657 bool range_list_added = false;
18658 add_ranges_by_labels (subr_die, fde->dw_fde_begin,
18659 fde->dw_fde_end, &range_list_added,
18661 add_ranges_by_labels (subr_die, fde->dw_fde_second_begin,
18662 fde->dw_fde_second_end,
18663 &range_list_added, false);
18664 if (range_list_added)
18669 /* There is no real support in DW2 for this .. so we make
18670 a work-around. First, emit the pub name for the segment
18671 containing the function label. Then make and emit a
18672 simplified subprogram DIE for the second segment with the
18673 name pre-fixed by __hot/cold_sect_of_. We use the same
18674 linkage name for the second die so that gdb will find both
18675 sections when given "b foo". */
18676 const char *name = NULL;
18677 tree decl_name = DECL_NAME (decl);
18678 dw_die_ref seg_die;
18680 /* Do the 'primary' section. */
18681 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
18682 fde->dw_fde_end, false);
18684 /* Build a minimal DIE for the secondary section. */
18685 seg_die = new_die (DW_TAG_subprogram,
18686 subr_die->die_parent, decl);
18688 if (TREE_PUBLIC (decl))
18689 add_AT_flag (seg_die, DW_AT_external, 1);
18691 if (decl_name != NULL
18692 && IDENTIFIER_POINTER (decl_name) != NULL)
18694 name = dwarf2_name (decl, 1);
18695 if (! DECL_ARTIFICIAL (decl))
18696 add_src_coords_attributes (seg_die, decl);
18698 add_linkage_name (seg_die, decl);
18700 gcc_assert (name != NULL);
18701 add_pure_or_virtual_attribute (seg_die, decl);
18702 if (DECL_ARTIFICIAL (decl))
18703 add_AT_flag (seg_die, DW_AT_artificial, 1);
18705 name = concat ("__second_sect_of_", name, NULL);
18706 add_AT_low_high_pc (seg_die, fde->dw_fde_second_begin,
18707 fde->dw_fde_second_end, false);
18708 add_name_attribute (seg_die, name);
18709 if (want_pubnames ())
18710 add_pubname_string (name, seg_die);
18714 add_AT_low_high_pc (subr_die, fde->dw_fde_begin, fde->dw_fde_end,
18718 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
18720 /* We define the "frame base" as the function's CFA. This is more
18721 convenient for several reasons: (1) It's stable across the prologue
18722 and epilogue, which makes it better than just a frame pointer,
18723 (2) With dwarf3, there exists a one-byte encoding that allows us
18724 to reference the .debug_frame data by proxy, but failing that,
18725 (3) We can at least reuse the code inspection and interpretation
18726 code that determines the CFA position at various points in the
18728 if (dwarf_version >= 3 && targetm.debug_unwind_info () == UI_DWARF2)
18730 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
18731 add_AT_loc (subr_die, DW_AT_frame_base, op);
18735 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
18736 if (list->dw_loc_next)
18737 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
18739 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
18742 /* Compute a displacement from the "steady-state frame pointer" to
18743 the CFA. The former is what all stack slots and argument slots
18744 will reference in the rtl; the latter is what we've told the
18745 debugger about. We'll need to adjust all frame_base references
18746 by this displacement. */
18747 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
18749 if (fun->static_chain_decl)
18750 add_AT_location_description (subr_die, DW_AT_static_link,
18751 loc_list_from_tree (fun->static_chain_decl, 2, NULL));
18754 /* Generate child dies for template paramaters. */
18755 if (debug_info_level > DINFO_LEVEL_TERSE)
18756 gen_generic_params_dies (decl);
18758 /* Now output descriptions of the arguments for this function. This gets
18759 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18760 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18761 `...' at the end of the formal parameter list. In order to find out if
18762 there was a trailing ellipsis or not, we must instead look at the type
18763 associated with the FUNCTION_DECL. This will be a node of type
18764 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18765 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18766 an ellipsis at the end. */
18768 /* In the case where we are describing a mere function declaration, all we
18769 need to do here (and all we *can* do here) is to describe the *types* of
18770 its formal parameters. */
18771 if (debug_info_level <= DINFO_LEVEL_TERSE)
18773 else if (declaration)
18774 gen_formal_types_die (decl, subr_die);
18777 /* Generate DIEs to represent all known formal parameters. */
18778 tree parm = DECL_ARGUMENTS (decl);
18779 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
18780 tree generic_decl_parm = generic_decl
18781 ? DECL_ARGUMENTS (generic_decl)
18784 /* Now we want to walk the list of parameters of the function and
18785 emit their relevant DIEs.
18787 We consider the case of DECL being an instance of a generic function
18788 as well as it being a normal function.
18790 If DECL is an instance of a generic function we walk the
18791 parameters of the generic function declaration _and_ the parameters of
18792 DECL itself. This is useful because we want to emit specific DIEs for
18793 function parameter packs and those are declared as part of the
18794 generic function declaration. In that particular case,
18795 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18796 That DIE has children DIEs representing the set of arguments
18797 of the pack. Note that the set of pack arguments can be empty.
18798 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18801 Otherwise, we just consider the parameters of DECL. */
18802 while (generic_decl_parm || parm)
18804 if (generic_decl_parm
18805 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
18806 gen_formal_parameter_pack_die (generic_decl_parm,
18809 else if (parm && !POINTER_BOUNDS_P (parm))
18811 dw_die_ref parm_die = gen_decl_die (parm, NULL, subr_die);
18813 if (parm == DECL_ARGUMENTS (decl)
18814 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
18816 && (dwarf_version >= 3 || !dwarf_strict))
18817 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die);
18819 parm = DECL_CHAIN (parm);
18822 parm = DECL_CHAIN (parm);
18824 if (generic_decl_parm)
18825 generic_decl_parm = DECL_CHAIN (generic_decl_parm);
18828 /* Decide whether we need an unspecified_parameters DIE at the end.
18829 There are 2 more cases to do this for: 1) the ansi ... declaration -
18830 this is detectable when the end of the arg list is not a
18831 void_type_node 2) an unprototyped function declaration (not a
18832 definition). This just means that we have no info about the
18833 parameters at all. */
18834 if (prototype_p (TREE_TYPE (decl)))
18836 /* This is the prototyped case, check for.... */
18837 if (stdarg_p (TREE_TYPE (decl)))
18838 gen_unspecified_parameters_die (decl, subr_die);
18840 else if (DECL_INITIAL (decl) == NULL_TREE)
18841 gen_unspecified_parameters_die (decl, subr_die);
18844 /* Output Dwarf info for all of the stuff within the body of the function
18845 (if it has one - it may be just a declaration). */
18846 outer_scope = DECL_INITIAL (decl);
18848 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18849 a function. This BLOCK actually represents the outermost binding contour
18850 for the function, i.e. the contour in which the function's formal
18851 parameters and labels get declared. Curiously, it appears that the front
18852 end doesn't actually put the PARM_DECL nodes for the current function onto
18853 the BLOCK_VARS list for this outer scope, but are strung off of the
18854 DECL_ARGUMENTS list for the function instead.
18856 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18857 the LABEL_DECL nodes for the function however, and we output DWARF info
18858 for those in decls_for_scope. Just within the `outer_scope' there will be
18859 a BLOCK node representing the function's outermost pair of curly braces,
18860 and any blocks used for the base and member initializers of a C++
18861 constructor function. */
18862 if (! declaration && outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
18864 int call_site_note_count = 0;
18865 int tail_call_site_note_count = 0;
18867 /* Emit a DW_TAG_variable DIE for a named return value. */
18868 if (DECL_NAME (DECL_RESULT (decl)))
18869 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
18871 decls_for_scope (outer_scope, subr_die);
18873 if (call_arg_locations && !dwarf_strict)
18875 struct call_arg_loc_node *ca_loc;
18876 for (ca_loc = call_arg_locations; ca_loc; ca_loc = ca_loc->next)
18878 dw_die_ref die = NULL;
18879 rtx tloc = NULL_RTX, tlocc = NULL_RTX;
18882 for (arg = NOTE_VAR_LOCATION (ca_loc->call_arg_loc_note);
18883 arg; arg = next_arg)
18885 dw_loc_descr_ref reg, val;
18886 machine_mode mode = GET_MODE (XEXP (XEXP (arg, 0), 1));
18887 dw_die_ref cdie, tdie = NULL;
18889 next_arg = XEXP (arg, 1);
18890 if (REG_P (XEXP (XEXP (arg, 0), 0))
18892 && MEM_P (XEXP (XEXP (next_arg, 0), 0))
18893 && REG_P (XEXP (XEXP (XEXP (next_arg, 0), 0), 0))
18894 && REGNO (XEXP (XEXP (arg, 0), 0))
18895 == REGNO (XEXP (XEXP (XEXP (next_arg, 0), 0), 0)))
18896 next_arg = XEXP (next_arg, 1);
18897 if (mode == VOIDmode)
18899 mode = GET_MODE (XEXP (XEXP (arg, 0), 0));
18900 if (mode == VOIDmode)
18901 mode = GET_MODE (XEXP (arg, 0));
18903 if (mode == VOIDmode || mode == BLKmode)
18905 if (XEXP (XEXP (arg, 0), 0) == pc_rtx)
18907 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
18908 tloc = XEXP (XEXP (arg, 0), 1);
18911 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) == CLOBBER
18912 && XEXP (XEXP (XEXP (arg, 0), 0), 0) == pc_rtx)
18914 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
18915 tlocc = XEXP (XEXP (arg, 0), 1);
18919 if (REG_P (XEXP (XEXP (arg, 0), 0)))
18920 reg = reg_loc_descriptor (XEXP (XEXP (arg, 0), 0),
18921 VAR_INIT_STATUS_INITIALIZED);
18922 else if (MEM_P (XEXP (XEXP (arg, 0), 0)))
18924 rtx mem = XEXP (XEXP (arg, 0), 0);
18925 reg = mem_loc_descriptor (XEXP (mem, 0),
18926 get_address_mode (mem),
18928 VAR_INIT_STATUS_INITIALIZED);
18930 else if (GET_CODE (XEXP (XEXP (arg, 0), 0))
18931 == DEBUG_PARAMETER_REF)
18934 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg, 0), 0));
18935 tdie = lookup_decl_die (tdecl);
18942 && GET_CODE (XEXP (XEXP (arg, 0), 0))
18943 != DEBUG_PARAMETER_REF)
18945 val = mem_loc_descriptor (XEXP (XEXP (arg, 0), 1), mode,
18947 VAR_INIT_STATUS_INITIALIZED);
18951 die = gen_call_site_die (decl, subr_die, ca_loc);
18952 cdie = new_die (DW_TAG_GNU_call_site_parameter, die,
18955 add_AT_loc (cdie, DW_AT_location, reg);
18956 else if (tdie != NULL)
18957 add_AT_die_ref (cdie, DW_AT_abstract_origin, tdie);
18958 add_AT_loc (cdie, DW_AT_GNU_call_site_value, val);
18959 if (next_arg != XEXP (arg, 1))
18961 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 1));
18962 if (mode == VOIDmode)
18963 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 0));
18964 val = mem_loc_descriptor (XEXP (XEXP (XEXP (arg, 1),
18967 VAR_INIT_STATUS_INITIALIZED);
18969 add_AT_loc (cdie, DW_AT_GNU_call_site_data_value, val);
18973 && (ca_loc->symbol_ref || tloc))
18974 die = gen_call_site_die (decl, subr_die, ca_loc);
18975 if (die != NULL && (tloc != NULL_RTX || tlocc != NULL_RTX))
18977 dw_loc_descr_ref tval = NULL;
18979 if (tloc != NULL_RTX)
18980 tval = mem_loc_descriptor (tloc,
18981 GET_MODE (tloc) == VOIDmode
18982 ? Pmode : GET_MODE (tloc),
18984 VAR_INIT_STATUS_INITIALIZED);
18986 add_AT_loc (die, DW_AT_GNU_call_site_target, tval);
18987 else if (tlocc != NULL_RTX)
18989 tval = mem_loc_descriptor (tlocc,
18990 GET_MODE (tlocc) == VOIDmode
18991 ? Pmode : GET_MODE (tlocc),
18993 VAR_INIT_STATUS_INITIALIZED);
18995 add_AT_loc (die, DW_AT_GNU_call_site_target_clobbered,
19001 call_site_note_count++;
19002 if (ca_loc->tail_call_p)
19003 tail_call_site_note_count++;
19007 call_arg_locations = NULL;
19008 call_arg_loc_last = NULL;
19009 if (tail_call_site_count >= 0
19010 && tail_call_site_count == tail_call_site_note_count
19013 if (call_site_count >= 0
19014 && call_site_count == call_site_note_count)
19015 add_AT_flag (subr_die, DW_AT_GNU_all_call_sites, 1);
19017 add_AT_flag (subr_die, DW_AT_GNU_all_tail_call_sites, 1);
19019 call_site_count = -1;
19020 tail_call_site_count = -1;
19023 if (subr_die != old_die)
19024 /* Add the calling convention attribute if requested. */
19025 add_calling_convention_attribute (subr_die, decl);
19028 /* Returns a hash value for X (which really is a die_struct). */
19031 block_die_hasher::hash (die_struct *d)
19033 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
19036 /* Return nonzero if decl_id and die_parent of die_struct X is the same
19037 as decl_id and die_parent of die_struct Y. */
19040 block_die_hasher::equal (die_struct *x, die_struct *y)
19042 return x->decl_id == y->decl_id && x->die_parent == y->die_parent;
19045 /* Generate a DIE to represent a declared data object.
19046 Either DECL or ORIGIN must be non-null. */
19049 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
19051 HOST_WIDE_INT off = 0;
19053 tree decl_or_origin = decl ? decl : origin;
19054 tree ultimate_origin;
19055 dw_die_ref var_die;
19056 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
19057 dw_die_ref origin_die;
19058 bool declaration = (DECL_EXTERNAL (decl_or_origin)
19059 || class_or_namespace_scope_p (context_die));
19060 bool specialization_p = false;
19062 ultimate_origin = decl_ultimate_origin (decl_or_origin);
19063 if (decl || ultimate_origin)
19064 origin = ultimate_origin;
19065 com_decl = fortran_common (decl_or_origin, &off);
19067 /* Symbol in common gets emitted as a child of the common block, in the form
19068 of a data member. */
19071 dw_die_ref com_die;
19072 dw_loc_list_ref loc;
19073 die_node com_die_arg;
19075 var_die = lookup_decl_die (decl_or_origin);
19078 if (get_AT (var_die, DW_AT_location) == NULL)
19080 loc = loc_list_from_tree (com_decl, off ? 1 : 2, NULL);
19085 /* Optimize the common case. */
19086 if (single_element_loc_list_p (loc)
19087 && loc->expr->dw_loc_opc == DW_OP_addr
19088 && loc->expr->dw_loc_next == NULL
19089 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
19092 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
19093 loc->expr->dw_loc_oprnd1.v.val_addr
19094 = plus_constant (GET_MODE (x), x , off);
19097 loc_list_plus_const (loc, off);
19099 add_AT_location_description (var_die, DW_AT_location, loc);
19100 remove_AT (var_die, DW_AT_declaration);
19106 if (common_block_die_table == NULL)
19107 common_block_die_table = hash_table<block_die_hasher>::create_ggc (10);
19109 com_die_arg.decl_id = DECL_UID (com_decl);
19110 com_die_arg.die_parent = context_die;
19111 com_die = common_block_die_table->find (&com_die_arg);
19112 loc = loc_list_from_tree (com_decl, 2, NULL);
19113 if (com_die == NULL)
19116 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
19119 com_die = new_die (DW_TAG_common_block, context_die, decl);
19120 add_name_and_src_coords_attributes (com_die, com_decl);
19123 add_AT_location_description (com_die, DW_AT_location, loc);
19124 /* Avoid sharing the same loc descriptor between
19125 DW_TAG_common_block and DW_TAG_variable. */
19126 loc = loc_list_from_tree (com_decl, 2, NULL);
19128 else if (DECL_EXTERNAL (decl))
19129 add_AT_flag (com_die, DW_AT_declaration, 1);
19130 if (want_pubnames ())
19131 add_pubname_string (cnam, com_die); /* ??? needed? */
19132 com_die->decl_id = DECL_UID (com_decl);
19133 slot = common_block_die_table->find_slot (com_die, INSERT);
19136 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
19138 add_AT_location_description (com_die, DW_AT_location, loc);
19139 loc = loc_list_from_tree (com_decl, 2, NULL);
19140 remove_AT (com_die, DW_AT_declaration);
19142 var_die = new_die (DW_TAG_variable, com_die, decl);
19143 add_name_and_src_coords_attributes (var_die, decl);
19144 add_type_attribute (var_die, TREE_TYPE (decl), decl_quals (decl),
19146 add_AT_flag (var_die, DW_AT_external, 1);
19151 /* Optimize the common case. */
19152 if (single_element_loc_list_p (loc)
19153 && loc->expr->dw_loc_opc == DW_OP_addr
19154 && loc->expr->dw_loc_next == NULL
19155 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
19157 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
19158 loc->expr->dw_loc_oprnd1.v.val_addr
19159 = plus_constant (GET_MODE (x), x, off);
19162 loc_list_plus_const (loc, off);
19164 add_AT_location_description (var_die, DW_AT_location, loc);
19166 else if (DECL_EXTERNAL (decl))
19167 add_AT_flag (var_die, DW_AT_declaration, 1);
19168 equate_decl_number_to_die (decl, var_die);
19172 /* If the compiler emitted a definition for the DECL declaration
19173 and if we already emitted a DIE for it, don't emit a second
19174 DIE for it again. Allow re-declarations of DECLs that are
19175 inside functions, though. */
19176 if (old_die && declaration && !local_scope_p (context_die))
19179 /* For static data members, the declaration in the class is supposed
19180 to have DW_TAG_member tag; the specification should still be
19181 DW_TAG_variable referencing the DW_TAG_member DIE. */
19182 if (declaration && class_scope_p (context_die))
19183 var_die = new_die (DW_TAG_member, context_die, decl);
19185 var_die = new_die (DW_TAG_variable, context_die, decl);
19188 if (origin != NULL)
19189 origin_die = add_abstract_origin_attribute (var_die, origin);
19191 /* Loop unrolling can create multiple blocks that refer to the same
19192 static variable, so we must test for the DW_AT_declaration flag.
19194 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
19195 copy decls and set the DECL_ABSTRACT_P flag on them instead of
19198 ??? Duplicated blocks have been rewritten to use .debug_ranges.
19200 ??? The declare_in_namespace support causes us to get two DIEs for one
19201 variable, both of which are declarations. We want to avoid considering
19202 one to be a specification, so we must test that this DIE is not a
19204 else if (old_die && TREE_STATIC (decl) && ! declaration
19205 && get_AT_flag (old_die, DW_AT_declaration) == 1)
19207 /* This is a definition of a C++ class level static. */
19208 add_AT_specification (var_die, old_die);
19209 specialization_p = true;
19210 if (DECL_NAME (decl))
19212 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
19213 struct dwarf_file_data * file_index = lookup_filename (s.file);
19215 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
19216 add_AT_file (var_die, DW_AT_decl_file, file_index);
19218 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
19219 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
19221 if (old_die->die_tag == DW_TAG_member)
19222 add_linkage_name (var_die, decl);
19226 add_name_and_src_coords_attributes (var_die, decl);
19228 if ((origin == NULL && !specialization_p)
19230 && !DECL_ABSTRACT_P (decl_or_origin)
19231 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
19232 decl_function_context
19233 (decl_or_origin))))
19235 tree type = TREE_TYPE (decl_or_origin);
19237 if (decl_by_reference_p (decl_or_origin))
19238 add_type_attribute (var_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19241 add_type_attribute (var_die, type, decl_quals (decl_or_origin),
19245 if (origin == NULL && !specialization_p)
19247 if (TREE_PUBLIC (decl))
19248 add_AT_flag (var_die, DW_AT_external, 1);
19250 if (DECL_ARTIFICIAL (decl))
19251 add_AT_flag (var_die, DW_AT_artificial, 1);
19253 add_accessibility_attribute (var_die, decl);
19257 add_AT_flag (var_die, DW_AT_declaration, 1);
19259 if (decl && (DECL_ABSTRACT_P (decl) || declaration || old_die == NULL))
19260 equate_decl_number_to_die (decl, var_die);
19263 && (! DECL_ABSTRACT_P (decl_or_origin)
19264 /* Local static vars are shared between all clones/inlines,
19265 so emit DW_AT_location on the abstract DIE if DECL_RTL is
19267 || (TREE_CODE (decl_or_origin) == VAR_DECL
19268 && TREE_STATIC (decl_or_origin)
19269 && DECL_RTL_SET_P (decl_or_origin)))
19270 /* When abstract origin already has DW_AT_location attribute, no need
19271 to add it again. */
19272 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
19274 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
19275 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
19276 defer_location (decl_or_origin, var_die);
19278 add_location_or_const_value_attribute (var_die, decl_or_origin,
19279 decl == NULL, DW_AT_location);
19280 add_pubname (decl_or_origin, var_die);
19283 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
19286 /* Generate a DIE to represent a named constant. */
19289 gen_const_die (tree decl, dw_die_ref context_die)
19291 dw_die_ref const_die;
19292 tree type = TREE_TYPE (decl);
19294 const_die = new_die (DW_TAG_constant, context_die, decl);
19295 add_name_and_src_coords_attributes (const_die, decl);
19296 add_type_attribute (const_die, type, TYPE_QUAL_CONST, context_die);
19297 if (TREE_PUBLIC (decl))
19298 add_AT_flag (const_die, DW_AT_external, 1);
19299 if (DECL_ARTIFICIAL (decl))
19300 add_AT_flag (const_die, DW_AT_artificial, 1);
19301 tree_add_const_value_attribute_for_decl (const_die, decl);
19304 /* Generate a DIE to represent a label identifier. */
19307 gen_label_die (tree decl, dw_die_ref context_die)
19309 tree origin = decl_ultimate_origin (decl);
19310 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
19312 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19314 if (origin != NULL)
19315 add_abstract_origin_attribute (lbl_die, origin);
19317 add_name_and_src_coords_attributes (lbl_die, decl);
19319 if (DECL_ABSTRACT_P (decl))
19320 equate_decl_number_to_die (decl, lbl_die);
19323 insn = DECL_RTL_IF_SET (decl);
19325 /* Deleted labels are programmer specified labels which have been
19326 eliminated because of various optimizations. We still emit them
19327 here so that it is possible to put breakpoints on them. */
19331 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
19333 /* When optimization is enabled (via -O) some parts of the compiler
19334 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19335 represent source-level labels which were explicitly declared by
19336 the user. This really shouldn't be happening though, so catch
19337 it if it ever does happen. */
19338 gcc_assert (!as_a<rtx_insn *> (insn)->deleted ());
19340 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
19341 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19345 && NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL
19346 && CODE_LABEL_NUMBER (insn) != -1)
19348 ASM_GENERATE_INTERNAL_LABEL (label, "LDL", CODE_LABEL_NUMBER (insn));
19349 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19354 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19355 attributes to the DIE for a block STMT, to describe where the inlined
19356 function was called from. This is similar to add_src_coords_attributes. */
19359 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
19361 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
19363 if (dwarf_version >= 3 || !dwarf_strict)
19365 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
19366 add_AT_unsigned (die, DW_AT_call_line, s.line);
19371 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19372 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19375 add_high_low_attributes (tree stmt, dw_die_ref die)
19377 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19379 if (BLOCK_FRAGMENT_CHAIN (stmt)
19380 && (dwarf_version >= 3 || !dwarf_strict))
19382 tree chain, superblock = NULL_TREE;
19384 dw_attr_ref attr = NULL;
19386 if (inlined_function_outer_scope_p (stmt))
19388 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19389 BLOCK_NUMBER (stmt));
19390 add_AT_lbl_id (die, DW_AT_entry_pc, label);
19393 /* Optimize duplicate .debug_ranges lists or even tails of
19394 lists. If this BLOCK has same ranges as its supercontext,
19395 lookup DW_AT_ranges attribute in the supercontext (and
19396 recursively so), verify that the ranges_table contains the
19397 right values and use it instead of adding a new .debug_range. */
19398 for (chain = stmt, pdie = die;
19399 BLOCK_SAME_RANGE (chain);
19400 chain = BLOCK_SUPERCONTEXT (chain))
19402 dw_attr_ref new_attr;
19404 pdie = pdie->die_parent;
19407 if (BLOCK_SUPERCONTEXT (chain) == NULL_TREE)
19409 new_attr = get_AT (pdie, DW_AT_ranges);
19410 if (new_attr == NULL
19411 || new_attr->dw_attr_val.val_class != dw_val_class_range_list)
19414 superblock = BLOCK_SUPERCONTEXT (chain);
19417 && (ranges_table[attr->dw_attr_val.v.val_offset
19418 / 2 / DWARF2_ADDR_SIZE].num
19419 == BLOCK_NUMBER (superblock))
19420 && BLOCK_FRAGMENT_CHAIN (superblock))
19422 unsigned long off = attr->dw_attr_val.v.val_offset
19423 / 2 / DWARF2_ADDR_SIZE;
19424 unsigned long supercnt = 0, thiscnt = 0;
19425 for (chain = BLOCK_FRAGMENT_CHAIN (superblock);
19426 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
19429 gcc_checking_assert (ranges_table[off + supercnt].num
19430 == BLOCK_NUMBER (chain));
19432 gcc_checking_assert (ranges_table[off + supercnt + 1].num == 0);
19433 for (chain = BLOCK_FRAGMENT_CHAIN (stmt);
19434 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
19436 gcc_assert (supercnt >= thiscnt);
19437 add_AT_range_list (die, DW_AT_ranges,
19438 ((off + supercnt - thiscnt)
19439 * 2 * DWARF2_ADDR_SIZE),
19444 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt), false);
19446 chain = BLOCK_FRAGMENT_CHAIN (stmt);
19449 add_ranges (chain);
19450 chain = BLOCK_FRAGMENT_CHAIN (chain);
19457 char label_high[MAX_ARTIFICIAL_LABEL_BYTES];
19458 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19459 BLOCK_NUMBER (stmt));
19460 ASM_GENERATE_INTERNAL_LABEL (label_high, BLOCK_END_LABEL,
19461 BLOCK_NUMBER (stmt));
19462 add_AT_low_high_pc (die, label, label_high, false);
19466 /* Generate a DIE for a lexical block. */
19469 gen_lexical_block_die (tree stmt, dw_die_ref context_die)
19471 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
19473 if (call_arg_locations)
19475 if (block_map.length () <= BLOCK_NUMBER (stmt))
19476 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1);
19477 block_map[BLOCK_NUMBER (stmt)] = stmt_die;
19480 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
19481 add_high_low_attributes (stmt, stmt_die);
19483 decls_for_scope (stmt, stmt_die);
19486 /* Generate a DIE for an inlined subprogram. */
19489 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die)
19493 /* The instance of function that is effectively being inlined shall not
19495 gcc_assert (! BLOCK_ABSTRACT (stmt));
19497 decl = block_ultimate_origin (stmt);
19499 /* Emit info for the abstract instance first, if we haven't yet. We
19500 must emit this even if the block is abstract, otherwise when we
19501 emit the block below (or elsewhere), we may end up trying to emit
19502 a die whose origin die hasn't been emitted, and crashing. */
19503 dwarf2out_abstract_function (decl);
19505 if (! BLOCK_ABSTRACT (stmt))
19507 dw_die_ref subr_die
19508 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
19510 if (call_arg_locations)
19512 if (block_map.length () <= BLOCK_NUMBER (stmt))
19513 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1);
19514 block_map[BLOCK_NUMBER (stmt)] = subr_die;
19516 add_abstract_origin_attribute (subr_die, decl);
19517 if (TREE_ASM_WRITTEN (stmt))
19518 add_high_low_attributes (stmt, subr_die);
19519 add_call_src_coords_attributes (stmt, subr_die);
19521 decls_for_scope (stmt, subr_die);
19525 /* Generate a DIE for a field in a record, or structure. */
19528 gen_field_die (tree decl, dw_die_ref context_die)
19530 dw_die_ref decl_die;
19532 if (TREE_TYPE (decl) == error_mark_node)
19535 decl_die = new_die (DW_TAG_member, context_die, decl);
19536 add_name_and_src_coords_attributes (decl_die, decl);
19537 add_type_attribute (decl_die, member_declared_type (decl),
19538 decl_quals (decl), context_die);
19540 if (DECL_BIT_FIELD_TYPE (decl))
19542 add_byte_size_attribute (decl_die, decl);
19543 add_bit_size_attribute (decl_die, decl);
19544 add_bit_offset_attribute (decl_die, decl);
19547 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
19548 add_data_member_location_attribute (decl_die, decl);
19550 if (DECL_ARTIFICIAL (decl))
19551 add_AT_flag (decl_die, DW_AT_artificial, 1);
19553 add_accessibility_attribute (decl_die, decl);
19555 /* Equate decl number to die, so that we can look up this decl later on. */
19556 equate_decl_number_to_die (decl, decl_die);
19560 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19561 Use modified_type_die instead.
19562 We keep this code here just in case these types of DIEs may be needed to
19563 represent certain things in other languages (e.g. Pascal) someday. */
19566 gen_pointer_type_die (tree type, dw_die_ref context_die)
19569 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
19571 equate_type_number_to_die (type, ptr_die);
19572 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19574 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19577 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19578 Use modified_type_die instead.
19579 We keep this code here just in case these types of DIEs may be needed to
19580 represent certain things in other languages (e.g. Pascal) someday. */
19583 gen_reference_type_die (tree type, dw_die_ref context_die)
19585 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die);
19587 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
19588 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type);
19590 ref_die = new_die (DW_TAG_reference_type, scope_die, type);
19592 equate_type_number_to_die (type, ref_die);
19593 add_type_attribute (ref_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19595 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19599 /* Generate a DIE for a pointer to a member type. */
19602 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
19605 = new_die (DW_TAG_ptr_to_member_type,
19606 scope_die_for (type, context_die), type);
19608 equate_type_number_to_die (type, ptr_die);
19609 add_AT_die_ref (ptr_die, DW_AT_containing_type,
19610 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
19611 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19615 typedef const char *dchar_p; /* For DEF_VEC_P. */
19617 static char *producer_string;
19619 /* Return a heap allocated producer string including command line options
19620 if -grecord-gcc-switches. */
19623 gen_producer_string (void)
19626 auto_vec<dchar_p> switches;
19627 const char *language_string = lang_hooks.name;
19628 char *producer, *tail;
19630 size_t len = dwarf_record_gcc_switches ? 0 : 3;
19631 size_t plen = strlen (language_string) + 1 + strlen (version_string);
19633 for (j = 1; dwarf_record_gcc_switches && j < save_decoded_options_count; j++)
19634 switch (save_decoded_options[j].opt_index)
19641 case OPT_auxbase_strip:
19650 case OPT_SPECIAL_unknown:
19651 case OPT_SPECIAL_ignore:
19652 case OPT_SPECIAL_program_name:
19653 case OPT_SPECIAL_input_file:
19654 case OPT_grecord_gcc_switches:
19655 case OPT_gno_record_gcc_switches:
19656 case OPT__output_pch_:
19657 case OPT_fdiagnostics_show_location_:
19658 case OPT_fdiagnostics_show_option:
19659 case OPT_fdiagnostics_show_caret:
19660 case OPT_fdiagnostics_color_:
19661 case OPT_fverbose_asm:
19663 case OPT__sysroot_:
19665 case OPT_nostdinc__:
19666 case OPT_fpreprocessed:
19667 case OPT_fltrans_output_list_:
19668 case OPT_fresolution_:
19669 /* Ignore these. */
19672 if (cl_options[save_decoded_options[j].opt_index].flags
19673 & CL_NO_DWARF_RECORD)
19675 gcc_checking_assert (save_decoded_options[j].canonical_option[0][0]
19677 switch (save_decoded_options[j].canonical_option[0][1])
19684 if (strncmp (save_decoded_options[j].canonical_option[0] + 2,
19691 switches.safe_push (save_decoded_options[j].orig_option_with_args_text);
19692 len += strlen (save_decoded_options[j].orig_option_with_args_text) + 1;
19696 producer = XNEWVEC (char, plen + 1 + len + 1);
19698 sprintf (tail, "%s %s", language_string, version_string);
19701 FOR_EACH_VEC_ELT (switches, j, p)
19705 memcpy (tail + 1, p, len);
19713 /* Given a C and/or C++ language/version string return the "highest".
19714 C++ is assumed to be "higher" than C in this case. Used for merging
19715 LTO translation unit languages. */
19716 static const char *
19717 highest_c_language (const char *lang1, const char *lang2)
19719 if (strcmp ("GNU C++14", lang1) == 0 || strcmp ("GNU C++14", lang2) == 0)
19720 return "GNU C++14";
19721 if (strcmp ("GNU C++11", lang1) == 0 || strcmp ("GNU C++11", lang2) == 0)
19722 return "GNU C++11";
19723 if (strcmp ("GNU C++98", lang1) == 0 || strcmp ("GNU C++98", lang2) == 0)
19724 return "GNU C++98";
19726 if (strcmp ("GNU C11", lang1) == 0 || strcmp ("GNU C11", lang2) == 0)
19728 if (strcmp ("GNU C99", lang1) == 0 || strcmp ("GNU C99", lang2) == 0)
19730 if (strcmp ("GNU C89", lang1) == 0 || strcmp ("GNU C89", lang2) == 0)
19733 gcc_unreachable ();
19737 /* Generate the DIE for the compilation unit. */
19740 gen_compile_unit_die (const char *filename)
19743 const char *language_string = lang_hooks.name;
19746 die = new_die (DW_TAG_compile_unit, NULL, NULL);
19750 add_name_attribute (die, filename);
19751 /* Don't add cwd for <built-in>. */
19752 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
19753 add_comp_dir_attribute (die);
19756 add_AT_string (die, DW_AT_producer, producer_string ? producer_string : "");
19758 /* If our producer is LTO try to figure out a common language to use
19759 from the global list of translation units. */
19760 if (strcmp (language_string, "GNU GIMPLE") == 0)
19764 const char *common_lang = NULL;
19766 FOR_EACH_VEC_SAFE_ELT (all_translation_units, i, t)
19768 if (!TRANSLATION_UNIT_LANGUAGE (t))
19771 common_lang = TRANSLATION_UNIT_LANGUAGE (t);
19772 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
19774 else if (strncmp (common_lang, "GNU C", 5) == 0
19775 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
19776 /* Mixing C and C++ is ok, use C++ in that case. */
19777 common_lang = highest_c_language (common_lang,
19778 TRANSLATION_UNIT_LANGUAGE (t));
19781 /* Fall back to C. */
19782 common_lang = NULL;
19788 language_string = common_lang;
19791 language = DW_LANG_C;
19792 if (strncmp (language_string, "GNU C", 5) == 0
19793 && ISDIGIT (language_string[5]))
19795 language = DW_LANG_C89;
19796 if (dwarf_version >= 3 || !dwarf_strict)
19798 if (strcmp (language_string, "GNU C89") != 0)
19799 language = DW_LANG_C99;
19801 if (dwarf_version >= 5 /* || !dwarf_strict */)
19802 if (strcmp (language_string, "GNU C11") == 0)
19803 language = DW_LANG_C11;
19806 else if (strncmp (language_string, "GNU C++", 7) == 0)
19808 language = DW_LANG_C_plus_plus;
19809 if (dwarf_version >= 5 /* || !dwarf_strict */)
19811 if (strcmp (language_string, "GNU C++11") == 0)
19812 language = DW_LANG_C_plus_plus_11;
19813 else if (strcmp (language_string, "GNU C++14") == 0)
19814 language = DW_LANG_C_plus_plus_14;
19817 else if (strcmp (language_string, "GNU F77") == 0)
19818 language = DW_LANG_Fortran77;
19819 else if (strcmp (language_string, "GNU Pascal") == 0)
19820 language = DW_LANG_Pascal83;
19821 else if (dwarf_version >= 3 || !dwarf_strict)
19823 if (strcmp (language_string, "GNU Ada") == 0)
19824 language = DW_LANG_Ada95;
19825 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
19827 language = DW_LANG_Fortran95;
19828 if (dwarf_version >= 5 /* || !dwarf_strict */)
19830 if (strcmp (language_string, "GNU Fortran2003") == 0)
19831 language = DW_LANG_Fortran03;
19832 else if (strcmp (language_string, "GNU Fortran2008") == 0)
19833 language = DW_LANG_Fortran08;
19836 else if (strcmp (language_string, "GNU Java") == 0)
19837 language = DW_LANG_Java;
19838 else if (strcmp (language_string, "GNU Objective-C") == 0)
19839 language = DW_LANG_ObjC;
19840 else if (strcmp (language_string, "GNU Objective-C++") == 0)
19841 language = DW_LANG_ObjC_plus_plus;
19842 else if (dwarf_version >= 5 || !dwarf_strict)
19844 if (strcmp (language_string, "GNU Go") == 0)
19845 language = DW_LANG_Go;
19848 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19849 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
19850 language = DW_LANG_Fortran90;
19852 add_AT_unsigned (die, DW_AT_language, language);
19856 case DW_LANG_Fortran77:
19857 case DW_LANG_Fortran90:
19858 case DW_LANG_Fortran95:
19859 case DW_LANG_Fortran03:
19860 case DW_LANG_Fortran08:
19861 /* Fortran has case insensitive identifiers and the front-end
19862 lowercases everything. */
19863 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
19866 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19872 /* Generate the DIE for a base class. */
19875 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
19877 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
19879 add_type_attribute (die, BINFO_TYPE (binfo), TYPE_UNQUALIFIED, context_die);
19880 add_data_member_location_attribute (die, binfo);
19882 if (BINFO_VIRTUAL_P (binfo))
19883 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
19885 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19886 children, otherwise the default is DW_ACCESS_public. In DWARF2
19887 the default has always been DW_ACCESS_private. */
19888 if (access == access_public_node)
19890 if (dwarf_version == 2
19891 || context_die->die_tag == DW_TAG_class_type)
19892 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
19894 else if (access == access_protected_node)
19895 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
19896 else if (dwarf_version > 2
19897 && context_die->die_tag != DW_TAG_class_type)
19898 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
19901 /* Generate a DIE for a class member. */
19904 gen_member_die (tree type, dw_die_ref context_die)
19907 tree binfo = TYPE_BINFO (type);
19910 /* If this is not an incomplete type, output descriptions of each of its
19911 members. Note that as we output the DIEs necessary to represent the
19912 members of this record or union type, we will also be trying to output
19913 DIEs to represent the *types* of those members. However the `type'
19914 function (above) will specifically avoid generating type DIEs for member
19915 types *within* the list of member DIEs for this (containing) type except
19916 for those types (of members) which are explicitly marked as also being
19917 members of this (containing) type themselves. The g++ front- end can
19918 force any given type to be treated as a member of some other (containing)
19919 type by setting the TYPE_CONTEXT of the given (member) type to point to
19920 the TREE node representing the appropriate (containing) type. */
19922 /* First output info about the base classes. */
19925 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
19929 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
19930 gen_inheritance_die (base,
19931 (accesses ? (*accesses)[i] : access_public_node),
19935 /* Now output info about the data members and type members. */
19936 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
19938 /* If we thought we were generating minimal debug info for TYPE
19939 and then changed our minds, some of the member declarations
19940 may have already been defined. Don't define them again, but
19941 do put them in the right order. */
19943 child = lookup_decl_die (member);
19945 splice_child_die (context_die, child);
19947 gen_decl_die (member, NULL, context_die);
19950 /* Now output info about the function members (if any). */
19951 for (member = TYPE_METHODS (type); member; member = DECL_CHAIN (member))
19953 /* Don't include clones in the member list. */
19954 if (DECL_ABSTRACT_ORIGIN (member))
19957 child = lookup_decl_die (member);
19959 splice_child_die (context_die, child);
19961 gen_decl_die (member, NULL, context_die);
19965 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19966 is set, we pretend that the type was never defined, so we only get the
19967 member DIEs needed by later specification DIEs. */
19970 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
19971 enum debug_info_usage usage)
19973 dw_die_ref type_die = lookup_type_die (type);
19974 dw_die_ref scope_die = 0;
19976 int complete = (TYPE_SIZE (type)
19977 && (! TYPE_STUB_DECL (type)
19978 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
19979 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
19980 complete = complete && should_emit_struct_debug (type, usage);
19982 if (type_die && ! complete)
19985 if (TYPE_CONTEXT (type) != NULL_TREE
19986 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
19987 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
19990 scope_die = scope_die_for (type, context_die);
19992 /* Generate child dies for template paramaters. */
19993 if (!type_die && debug_info_level > DINFO_LEVEL_TERSE)
19994 schedule_generic_params_dies_gen (type);
19996 if (! type_die || (nested && is_cu_die (scope_die)))
19997 /* First occurrence of type or toplevel definition of nested class. */
19999 dw_die_ref old_die = type_die;
20001 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
20002 ? record_type_tag (type) : DW_TAG_union_type,
20004 equate_type_number_to_die (type, type_die);
20006 add_AT_specification (type_die, old_die);
20008 add_name_attribute (type_die, type_tag (type));
20011 remove_AT (type_die, DW_AT_declaration);
20013 /* If this type has been completed, then give it a byte_size attribute and
20014 then give a list of members. */
20015 if (complete && !ns_decl)
20017 /* Prevent infinite recursion in cases where the type of some member of
20018 this type is expressed in terms of this type itself. */
20019 TREE_ASM_WRITTEN (type) = 1;
20020 add_byte_size_attribute (type_die, type);
20021 if (TYPE_STUB_DECL (type) != NULL_TREE)
20023 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
20024 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
20027 /* If the first reference to this type was as the return type of an
20028 inline function, then it may not have a parent. Fix this now. */
20029 if (type_die->die_parent == NULL)
20030 add_child_die (scope_die, type_die);
20032 push_decl_scope (type);
20033 gen_member_die (type, type_die);
20036 add_gnat_descriptive_type_attribute (type_die, type, context_die);
20037 if (TYPE_ARTIFICIAL (type))
20038 add_AT_flag (type_die, DW_AT_artificial, 1);
20040 /* GNU extension: Record what type our vtable lives in. */
20041 if (TYPE_VFIELD (type))
20043 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
20045 gen_type_die (vtype, context_die);
20046 add_AT_die_ref (type_die, DW_AT_containing_type,
20047 lookup_type_die (vtype));
20052 add_AT_flag (type_die, DW_AT_declaration, 1);
20054 /* We don't need to do this for function-local types. */
20055 if (TYPE_STUB_DECL (type)
20056 && ! decl_function_context (TYPE_STUB_DECL (type)))
20057 vec_safe_push (incomplete_types, type);
20060 if (get_AT (type_die, DW_AT_name))
20061 add_pubtype (type, type_die);
20064 /* Generate a DIE for a subroutine _type_. */
20067 gen_subroutine_type_die (tree type, dw_die_ref context_die)
20069 tree return_type = TREE_TYPE (type);
20070 dw_die_ref subr_die
20071 = new_die (DW_TAG_subroutine_type,
20072 scope_die_for (type, context_die), type);
20074 equate_type_number_to_die (type, subr_die);
20075 add_prototyped_attribute (subr_die, type);
20076 add_type_attribute (subr_die, return_type, TYPE_UNQUALIFIED, context_die);
20077 gen_formal_types_die (type, subr_die);
20079 if (get_AT (subr_die, DW_AT_name))
20080 add_pubtype (type, subr_die);
20083 /* Generate a DIE for a type definition. */
20086 gen_typedef_die (tree decl, dw_die_ref context_die)
20088 dw_die_ref type_die;
20091 if (TREE_ASM_WRITTEN (decl))
20094 TREE_ASM_WRITTEN (decl) = 1;
20095 type_die = new_die (DW_TAG_typedef, context_die, decl);
20096 origin = decl_ultimate_origin (decl);
20097 if (origin != NULL)
20098 add_abstract_origin_attribute (type_die, origin);
20103 add_name_and_src_coords_attributes (type_die, decl);
20104 if (DECL_ORIGINAL_TYPE (decl))
20106 type = DECL_ORIGINAL_TYPE (decl);
20108 gcc_assert (type != TREE_TYPE (decl));
20109 equate_type_number_to_die (TREE_TYPE (decl), type_die);
20113 type = TREE_TYPE (decl);
20115 if (is_naming_typedef_decl (TYPE_NAME (type)))
20117 /* Here, we are in the case of decl being a typedef naming
20118 an anonymous type, e.g:
20119 typedef struct {...} foo;
20120 In that case TREE_TYPE (decl) is not a typedef variant
20121 type and TYPE_NAME of the anonymous type is set to the
20122 TYPE_DECL of the typedef. This construct is emitted by
20125 TYPE is the anonymous struct named by the typedef
20126 DECL. As we need the DW_AT_type attribute of the
20127 DW_TAG_typedef to point to the DIE of TYPE, let's
20128 generate that DIE right away. add_type_attribute
20129 called below will then pick (via lookup_type_die) that
20130 anonymous struct DIE. */
20131 if (!TREE_ASM_WRITTEN (type))
20132 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
20134 /* This is a GNU Extension. We are adding a
20135 DW_AT_linkage_name attribute to the DIE of the
20136 anonymous struct TYPE. The value of that attribute
20137 is the name of the typedef decl naming the anonymous
20138 struct. This greatly eases the work of consumers of
20139 this debug info. */
20140 add_linkage_attr (lookup_type_die (type), decl);
20144 add_type_attribute (type_die, type, decl_quals (decl), context_die);
20146 if (is_naming_typedef_decl (decl))
20147 /* We want that all subsequent calls to lookup_type_die with
20148 TYPE in argument yield the DW_TAG_typedef we have just
20150 equate_type_number_to_die (type, type_die);
20152 add_accessibility_attribute (type_die, decl);
20155 if (DECL_ABSTRACT_P (decl))
20156 equate_decl_number_to_die (decl, type_die);
20158 if (get_AT (type_die, DW_AT_name))
20159 add_pubtype (decl, type_die);
20162 /* Generate a DIE for a struct, class, enum or union type. */
20165 gen_tagged_type_die (tree type,
20166 dw_die_ref context_die,
20167 enum debug_info_usage usage)
20171 if (type == NULL_TREE
20172 || !is_tagged_type (type))
20175 /* If this is a nested type whose containing class hasn't been written
20176 out yet, writing it out will cover this one, too. This does not apply
20177 to instantiations of member class templates; they need to be added to
20178 the containing class as they are generated. FIXME: This hurts the
20179 idea of combining type decls from multiple TUs, since we can't predict
20180 what set of template instantiations we'll get. */
20181 if (TYPE_CONTEXT (type)
20182 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
20183 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
20185 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
20187 if (TREE_ASM_WRITTEN (type))
20190 /* If that failed, attach ourselves to the stub. */
20191 push_decl_scope (TYPE_CONTEXT (type));
20192 context_die = lookup_type_die (TYPE_CONTEXT (type));
20195 else if (TYPE_CONTEXT (type) != NULL_TREE
20196 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
20198 /* If this type is local to a function that hasn't been written
20199 out yet, use a NULL context for now; it will be fixed up in
20200 decls_for_scope. */
20201 context_die = lookup_decl_die (TYPE_CONTEXT (type));
20202 /* A declaration DIE doesn't count; nested types need to go in the
20204 if (context_die && is_declaration_die (context_die))
20205 context_die = NULL;
20210 context_die = declare_in_namespace (type, context_die);
20214 if (TREE_CODE (type) == ENUMERAL_TYPE)
20216 /* This might have been written out by the call to
20217 declare_in_namespace. */
20218 if (!TREE_ASM_WRITTEN (type))
20219 gen_enumeration_type_die (type, context_die);
20222 gen_struct_or_union_type_die (type, context_die, usage);
20227 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
20228 it up if it is ever completed. gen_*_type_die will set it for us
20229 when appropriate. */
20232 /* Generate a type description DIE. */
20235 gen_type_die_with_usage (tree type, dw_die_ref context_die,
20236 enum debug_info_usage usage)
20238 struct array_descr_info info;
20240 if (type == NULL_TREE || type == error_mark_node)
20243 if (TYPE_NAME (type) != NULL_TREE
20244 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
20245 && is_redundant_typedef (TYPE_NAME (type))
20246 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
20247 /* The DECL of this type is a typedef we don't want to emit debug
20248 info for but we want debug info for its underlying typedef.
20249 This can happen for e.g, the injected-class-name of a C++
20251 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
20253 /* If TYPE is a typedef type variant, let's generate debug info
20254 for the parent typedef which TYPE is a type of. */
20255 if (typedef_variant_p (type))
20257 if (TREE_ASM_WRITTEN (type))
20260 /* Prevent broken recursion; we can't hand off to the same type. */
20261 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
20263 /* Give typedefs the right scope. */
20264 context_die = scope_die_for (type, context_die);
20266 TREE_ASM_WRITTEN (type) = 1;
20268 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20272 /* If type is an anonymous tagged type named by a typedef, let's
20273 generate debug info for the typedef. */
20274 if (is_naming_typedef_decl (TYPE_NAME (type)))
20276 /* Use the DIE of the containing namespace as the parent DIE of
20277 the type description DIE we want to generate. */
20278 if (DECL_CONTEXT (TYPE_NAME (type))
20279 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
20280 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
20282 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20286 /* We are going to output a DIE to represent the unqualified version
20287 of this type (i.e. without any const or volatile qualifiers) so
20288 get the main variant (i.e. the unqualified version) of this type
20289 now. (Vectors are special because the debugging info is in the
20290 cloned type itself). */
20291 if (TREE_CODE (type) != VECTOR_TYPE)
20292 type = type_main_variant (type);
20294 /* If this is an array type with hidden descriptor, handle it first. */
20295 if (!TREE_ASM_WRITTEN (type)
20296 && lang_hooks.types.get_array_descr_info)
20298 memset (&info, 0, sizeof (info));
20299 if (lang_hooks.types.get_array_descr_info (type, &info))
20301 gen_descr_array_type_die (type, &info, context_die);
20302 TREE_ASM_WRITTEN (type) = 1;
20307 if (TREE_ASM_WRITTEN (type))
20310 switch (TREE_CODE (type))
20316 case REFERENCE_TYPE:
20317 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
20318 ensures that the gen_type_die recursion will terminate even if the
20319 type is recursive. Recursive types are possible in Ada. */
20320 /* ??? We could perhaps do this for all types before the switch
20322 TREE_ASM_WRITTEN (type) = 1;
20324 /* For these types, all that is required is that we output a DIE (or a
20325 set of DIEs) to represent the "basis" type. */
20326 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20327 DINFO_USAGE_IND_USE);
20331 /* This code is used for C++ pointer-to-data-member types.
20332 Output a description of the relevant class type. */
20333 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
20334 DINFO_USAGE_IND_USE);
20336 /* Output a description of the type of the object pointed to. */
20337 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20338 DINFO_USAGE_IND_USE);
20340 /* Now output a DIE to represent this pointer-to-data-member type
20342 gen_ptr_to_mbr_type_die (type, context_die);
20345 case FUNCTION_TYPE:
20346 /* Force out return type (in case it wasn't forced out already). */
20347 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20348 DINFO_USAGE_DIR_USE);
20349 gen_subroutine_type_die (type, context_die);
20353 /* Force out return type (in case it wasn't forced out already). */
20354 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20355 DINFO_USAGE_DIR_USE);
20356 gen_subroutine_type_die (type, context_die);
20360 gen_array_type_die (type, context_die);
20364 gen_array_type_die (type, context_die);
20367 case ENUMERAL_TYPE:
20370 case QUAL_UNION_TYPE:
20371 gen_tagged_type_die (type, context_die, usage);
20377 case FIXED_POINT_TYPE:
20380 case POINTER_BOUNDS_TYPE:
20381 /* No DIEs needed for fundamental types. */
20386 /* Just use DW_TAG_unspecified_type. */
20388 dw_die_ref type_die = lookup_type_die (type);
20389 if (type_die == NULL)
20391 tree name = TYPE_IDENTIFIER (type);
20392 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (),
20394 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
20395 equate_type_number_to_die (type, type_die);
20401 if (is_cxx_auto (type))
20403 tree name = TYPE_IDENTIFIER (type);
20404 dw_die_ref *die = (name == get_identifier ("auto")
20405 ? &auto_die : &decltype_auto_die);
20408 *die = new_die (DW_TAG_unspecified_type,
20409 comp_unit_die (), NULL_TREE);
20410 add_name_attribute (*die, IDENTIFIER_POINTER (name));
20412 equate_type_number_to_die (type, *die);
20415 gcc_unreachable ();
20418 TREE_ASM_WRITTEN (type) = 1;
20422 gen_type_die (tree type, dw_die_ref context_die)
20424 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
20427 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20428 things which are local to the given block. */
20431 gen_block_die (tree stmt, dw_die_ref context_die)
20433 int must_output_die = 0;
20436 /* Ignore blocks that are NULL. */
20437 if (stmt == NULL_TREE)
20440 inlined_func = inlined_function_outer_scope_p (stmt);
20442 /* If the block is one fragment of a non-contiguous block, do not
20443 process the variables, since they will have been done by the
20444 origin block. Do process subblocks. */
20445 if (BLOCK_FRAGMENT_ORIGIN (stmt))
20449 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
20450 gen_block_die (sub, context_die);
20455 /* Determine if we need to output any Dwarf DIEs at all to represent this
20458 /* The outer scopes for inlinings *must* always be represented. We
20459 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20460 must_output_die = 1;
20463 /* Determine if this block directly contains any "significant"
20464 local declarations which we will need to output DIEs for. */
20465 if (debug_info_level > DINFO_LEVEL_TERSE)
20466 /* We are not in terse mode so *any* local declaration counts
20467 as being a "significant" one. */
20468 must_output_die = ((BLOCK_VARS (stmt) != NULL
20469 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
20470 && (TREE_USED (stmt)
20471 || TREE_ASM_WRITTEN (stmt)
20472 || BLOCK_ABSTRACT (stmt)));
20473 else if ((TREE_USED (stmt)
20474 || TREE_ASM_WRITTEN (stmt)
20475 || BLOCK_ABSTRACT (stmt))
20476 && !dwarf2out_ignore_block (stmt))
20477 must_output_die = 1;
20480 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20481 DIE for any block which contains no significant local declarations at
20482 all. Rather, in such cases we just call `decls_for_scope' so that any
20483 needed Dwarf info for any sub-blocks will get properly generated. Note
20484 that in terse mode, our definition of what constitutes a "significant"
20485 local declaration gets restricted to include only inlined function
20486 instances and local (nested) function definitions. */
20487 if (must_output_die)
20491 /* If STMT block is abstract, that means we have been called
20492 indirectly from dwarf2out_abstract_function.
20493 That function rightfully marks the descendent blocks (of
20494 the abstract function it is dealing with) as being abstract,
20495 precisely to prevent us from emitting any
20496 DW_TAG_inlined_subroutine DIE as a descendent
20497 of an abstract function instance. So in that case, we should
20498 not call gen_inlined_subroutine_die.
20500 Later though, when cgraph asks dwarf2out to emit info
20501 for the concrete instance of the function decl into which
20502 the concrete instance of STMT got inlined, the later will lead
20503 to the generation of a DW_TAG_inlined_subroutine DIE. */
20504 if (! BLOCK_ABSTRACT (stmt))
20505 gen_inlined_subroutine_die (stmt, context_die);
20508 gen_lexical_block_die (stmt, context_die);
20511 decls_for_scope (stmt, context_die);
20514 /* Process variable DECL (or variable with origin ORIGIN) within
20515 block STMT and add it to CONTEXT_DIE. */
20517 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
20520 tree decl_or_origin = decl ? decl : origin;
20522 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
20523 die = lookup_decl_die (decl_or_origin);
20524 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
20525 && TYPE_DECL_IS_STUB (decl_or_origin))
20526 die = lookup_type_die (TREE_TYPE (decl_or_origin));
20530 if (die != NULL && die->die_parent == NULL)
20531 add_child_die (context_die, die);
20532 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
20533 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
20534 stmt, context_die);
20536 gen_decl_die (decl, origin, context_die);
20539 /* Generate all of the decls declared within a given scope and (recursively)
20540 all of its sub-blocks. */
20543 decls_for_scope (tree stmt, dw_die_ref context_die)
20549 /* Ignore NULL blocks. */
20550 if (stmt == NULL_TREE)
20553 /* Output the DIEs to represent all of the data objects and typedefs
20554 declared directly within this block but not within any nested
20555 sub-blocks. Also, nested function and tag DIEs have been
20556 generated with a parent of NULL; fix that up now. We don't
20557 have to do this if we're at -g1. */
20558 if (debug_info_level > DINFO_LEVEL_TERSE)
20560 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl))
20561 process_scope_var (stmt, decl, NULL_TREE, context_die);
20562 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
20563 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
20567 /* Even if we're at -g1, we need to process the subblocks in order to get
20568 inlined call information. */
20570 /* Output the DIEs to represent all sub-blocks (and the items declared
20571 therein) of this block. */
20572 for (subblocks = BLOCK_SUBBLOCKS (stmt);
20574 subblocks = BLOCK_CHAIN (subblocks))
20575 gen_block_die (subblocks, context_die);
20578 /* Is this a typedef we can avoid emitting? */
20581 is_redundant_typedef (const_tree decl)
20583 if (TYPE_DECL_IS_STUB (decl))
20586 if (DECL_ARTIFICIAL (decl)
20587 && DECL_CONTEXT (decl)
20588 && is_tagged_type (DECL_CONTEXT (decl))
20589 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
20590 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
20591 /* Also ignore the artificial member typedef for the class name. */
20597 /* Return TRUE if TYPE is a typedef that names a type for linkage
20598 purposes. This kind of typedefs is produced by the C++ FE for
20601 typedef struct {...} foo;
20603 In that case, there is no typedef variant type produced for foo.
20604 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20608 is_naming_typedef_decl (const_tree decl)
20610 if (decl == NULL_TREE
20611 || TREE_CODE (decl) != TYPE_DECL
20612 || !is_tagged_type (TREE_TYPE (decl))
20613 || DECL_IS_BUILTIN (decl)
20614 || is_redundant_typedef (decl)
20615 /* It looks like Ada produces TYPE_DECLs that are very similar
20616 to C++ naming typedefs but that have different
20617 semantics. Let's be specific to c++ for now. */
20621 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
20622 && TYPE_NAME (TREE_TYPE (decl)) == decl
20623 && (TYPE_STUB_DECL (TREE_TYPE (decl))
20624 != TYPE_NAME (TREE_TYPE (decl))));
20627 /* Returns the DIE for a context. */
20629 static inline dw_die_ref
20630 get_context_die (tree context)
20634 /* Find die that represents this context. */
20635 if (TYPE_P (context))
20637 context = TYPE_MAIN_VARIANT (context);
20638 return strip_naming_typedef (context, force_type_die (context));
20641 return force_decl_die (context);
20643 return comp_unit_die ();
20646 /* Returns the DIE for decl. A DIE will always be returned. */
20649 force_decl_die (tree decl)
20651 dw_die_ref decl_die;
20652 unsigned saved_external_flag;
20653 tree save_fn = NULL_TREE;
20654 decl_die = lookup_decl_die (decl);
20657 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
20659 decl_die = lookup_decl_die (decl);
20663 switch (TREE_CODE (decl))
20665 case FUNCTION_DECL:
20666 /* Clear current_function_decl, so that gen_subprogram_die thinks
20667 that this is a declaration. At this point, we just want to force
20668 declaration die. */
20669 save_fn = current_function_decl;
20670 current_function_decl = NULL_TREE;
20671 gen_subprogram_die (decl, context_die);
20672 current_function_decl = save_fn;
20676 /* Set external flag to force declaration die. Restore it after
20677 gen_decl_die() call. */
20678 saved_external_flag = DECL_EXTERNAL (decl);
20679 DECL_EXTERNAL (decl) = 1;
20680 gen_decl_die (decl, NULL, context_die);
20681 DECL_EXTERNAL (decl) = saved_external_flag;
20684 case NAMESPACE_DECL:
20685 if (dwarf_version >= 3 || !dwarf_strict)
20686 dwarf2out_decl (decl);
20688 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20689 decl_die = comp_unit_die ();
20692 case TRANSLATION_UNIT_DECL:
20693 decl_die = comp_unit_die ();
20697 gcc_unreachable ();
20700 /* We should be able to find the DIE now. */
20702 decl_die = lookup_decl_die (decl);
20703 gcc_assert (decl_die);
20709 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20710 always returned. */
20713 force_type_die (tree type)
20715 dw_die_ref type_die;
20717 type_die = lookup_type_die (type);
20720 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
20722 type_die = modified_type_die (type, TYPE_QUALS_NO_ADDR_SPACE (type),
20724 gcc_assert (type_die);
20729 /* Force out any required namespaces to be able to output DECL,
20730 and return the new context_die for it, if it's changed. */
20733 setup_namespace_context (tree thing, dw_die_ref context_die)
20735 tree context = (DECL_P (thing)
20736 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
20737 if (context && TREE_CODE (context) == NAMESPACE_DECL)
20738 /* Force out the namespace. */
20739 context_die = force_decl_die (context);
20741 return context_die;
20744 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20745 type) within its namespace, if appropriate.
20747 For compatibility with older debuggers, namespace DIEs only contain
20748 declarations; all definitions are emitted at CU scope. */
20751 declare_in_namespace (tree thing, dw_die_ref context_die)
20753 dw_die_ref ns_context;
20755 if (debug_info_level <= DINFO_LEVEL_TERSE)
20756 return context_die;
20758 /* External declarations in the local scope only need to be emitted
20759 once, not once in the namespace and once in the scope.
20761 This avoids declaring the `extern' below in the
20762 namespace DIE as well as in the innermost scope:
20775 if (DECL_P (thing) && DECL_EXTERNAL (thing) && local_scope_p (context_die))
20776 return context_die;
20778 /* If this decl is from an inlined function, then don't try to emit it in its
20779 namespace, as we will get confused. It would have already been emitted
20780 when the abstract instance of the inline function was emitted anyways. */
20781 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
20782 return context_die;
20784 ns_context = setup_namespace_context (thing, context_die);
20786 if (ns_context != context_die)
20790 if (DECL_P (thing))
20791 gen_decl_die (thing, NULL, ns_context);
20793 gen_type_die (thing, ns_context);
20795 return context_die;
20798 /* Generate a DIE for a namespace or namespace alias. */
20801 gen_namespace_die (tree decl, dw_die_ref context_die)
20803 dw_die_ref namespace_die;
20805 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20806 they are an alias of. */
20807 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
20809 /* Output a real namespace or module. */
20810 context_die = setup_namespace_context (decl, comp_unit_die ());
20811 namespace_die = new_die (is_fortran ()
20812 ? DW_TAG_module : DW_TAG_namespace,
20813 context_die, decl);
20814 /* For Fortran modules defined in different CU don't add src coords. */
20815 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
20817 const char *name = dwarf2_name (decl, 0);
20819 add_name_attribute (namespace_die, name);
20822 add_name_and_src_coords_attributes (namespace_die, decl);
20823 if (DECL_EXTERNAL (decl))
20824 add_AT_flag (namespace_die, DW_AT_declaration, 1);
20825 equate_decl_number_to_die (decl, namespace_die);
20829 /* Output a namespace alias. */
20831 /* Force out the namespace we are an alias of, if necessary. */
20832 dw_die_ref origin_die
20833 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
20835 if (DECL_FILE_SCOPE_P (decl)
20836 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
20837 context_die = setup_namespace_context (decl, comp_unit_die ());
20838 /* Now create the namespace alias DIE. */
20839 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
20840 add_name_and_src_coords_attributes (namespace_die, decl);
20841 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
20842 equate_decl_number_to_die (decl, namespace_die);
20844 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20845 if (want_pubnames ())
20846 add_pubname_string (lang_hooks.dwarf_name (decl, 1), namespace_die);
20849 /* Generate Dwarf debug information for a decl described by DECL.
20850 The return value is currently only meaningful for PARM_DECLs,
20851 for all other decls it returns NULL. */
20854 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
20856 tree decl_or_origin = decl ? decl : origin;
20857 tree class_origin = NULL, ultimate_origin;
20859 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
20862 /* Ignore pointer bounds decls. */
20863 if (DECL_P (decl_or_origin)
20864 && TREE_TYPE (decl_or_origin)
20865 && POINTER_BOUNDS_P (decl_or_origin))
20868 switch (TREE_CODE (decl_or_origin))
20874 if (!is_fortran () && !is_ada ())
20876 /* The individual enumerators of an enum type get output when we output
20877 the Dwarf representation of the relevant enum type itself. */
20881 /* Emit its type. */
20882 gen_type_die (TREE_TYPE (decl), context_die);
20884 /* And its containing namespace. */
20885 context_die = declare_in_namespace (decl, context_die);
20887 gen_const_die (decl, context_die);
20890 case FUNCTION_DECL:
20891 /* Don't output any DIEs to represent mere function declarations,
20892 unless they are class members or explicit block externs. */
20893 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
20894 && DECL_FILE_SCOPE_P (decl_or_origin)
20895 && (current_function_decl == NULL_TREE
20896 || DECL_ARTIFICIAL (decl_or_origin)))
20901 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20902 on local redeclarations of global functions. That seems broken. */
20903 if (current_function_decl != decl)
20904 /* This is only a declaration. */;
20907 /* If we're emitting a clone, emit info for the abstract instance. */
20908 if (origin || DECL_ORIGIN (decl) != decl)
20909 dwarf2out_abstract_function (origin
20910 ? DECL_ORIGIN (origin)
20911 : DECL_ABSTRACT_ORIGIN (decl));
20913 /* If we're emitting an out-of-line copy of an inline function,
20914 emit info for the abstract instance and set up to refer to it. */
20915 else if (cgraph_function_possibly_inlined_p (decl)
20916 && ! DECL_ABSTRACT_P (decl)
20917 && ! class_or_namespace_scope_p (context_die)
20918 /* dwarf2out_abstract_function won't emit a die if this is just
20919 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20920 that case, because that works only if we have a die. */
20921 && DECL_INITIAL (decl) != NULL_TREE)
20923 dwarf2out_abstract_function (decl);
20924 set_decl_origin_self (decl);
20927 /* Otherwise we're emitting the primary DIE for this decl. */
20928 else if (debug_info_level > DINFO_LEVEL_TERSE)
20930 /* Before we describe the FUNCTION_DECL itself, make sure that we
20931 have its containing type. */
20933 origin = decl_class_context (decl);
20934 if (origin != NULL_TREE)
20935 gen_type_die (origin, context_die);
20937 /* And its return type. */
20938 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
20940 /* And its virtual context. */
20941 if (DECL_VINDEX (decl) != NULL_TREE)
20942 gen_type_die (DECL_CONTEXT (decl), context_die);
20944 /* Make sure we have a member DIE for decl. */
20945 if (origin != NULL_TREE)
20946 gen_type_die_for_member (origin, decl, context_die);
20948 /* And its containing namespace. */
20949 context_die = declare_in_namespace (decl, context_die);
20952 /* Now output a DIE to represent the function itself. */
20954 gen_subprogram_die (decl, context_die);
20958 /* If we are in terse mode, don't generate any DIEs to represent any
20959 actual typedefs. */
20960 if (debug_info_level <= DINFO_LEVEL_TERSE)
20963 /* In the special case of a TYPE_DECL node representing the declaration
20964 of some type tag, if the given TYPE_DECL is marked as having been
20965 instantiated from some other (original) TYPE_DECL node (e.g. one which
20966 was generated within the original definition of an inline function) we
20967 used to generate a special (abbreviated) DW_TAG_structure_type,
20968 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20969 should be actually referencing those DIEs, as variable DIEs with that
20970 type would be emitted already in the abstract origin, so it was always
20971 removed during unused type prunning. Don't add anything in this
20973 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
20976 if (is_redundant_typedef (decl))
20977 gen_type_die (TREE_TYPE (decl), context_die);
20979 /* Output a DIE to represent the typedef itself. */
20980 gen_typedef_die (decl, context_die);
20984 if (debug_info_level >= DINFO_LEVEL_NORMAL)
20985 gen_label_die (decl, context_die);
20990 /* If we are in terse mode, don't generate any DIEs to represent any
20991 variable declarations or definitions. */
20992 if (debug_info_level <= DINFO_LEVEL_TERSE)
20995 /* Output any DIEs that are needed to specify the type of this data
20997 if (decl_by_reference_p (decl_or_origin))
20998 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
21000 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
21002 /* And its containing type. */
21003 class_origin = decl_class_context (decl_or_origin);
21004 if (class_origin != NULL_TREE)
21005 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
21007 /* And its containing namespace. */
21008 context_die = declare_in_namespace (decl_or_origin, context_die);
21010 /* Now output the DIE to represent the data object itself. This gets
21011 complicated because of the possibility that the VAR_DECL really
21012 represents an inlined instance of a formal parameter for an inline
21014 ultimate_origin = decl_ultimate_origin (decl_or_origin);
21015 if (ultimate_origin != NULL_TREE
21016 && TREE_CODE (ultimate_origin) == PARM_DECL)
21017 gen_formal_parameter_die (decl, origin,
21018 true /* Emit name attribute. */,
21021 gen_variable_die (decl, origin, context_die);
21025 /* Ignore the nameless fields that are used to skip bits but handle C++
21026 anonymous unions and structs. */
21027 if (DECL_NAME (decl) != NULL_TREE
21028 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
21029 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
21031 gen_type_die (member_declared_type (decl), context_die);
21032 gen_field_die (decl, context_die);
21037 if (DECL_BY_REFERENCE (decl_or_origin))
21038 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
21040 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
21041 return gen_formal_parameter_die (decl, origin,
21042 true /* Emit name attribute. */,
21045 case NAMESPACE_DECL:
21046 case IMPORTED_DECL:
21047 if (dwarf_version >= 3 || !dwarf_strict)
21048 gen_namespace_die (decl, context_die);
21051 case NAMELIST_DECL:
21052 gen_namelist_decl (DECL_NAME (decl), context_die,
21053 NAMELIST_DECL_ASSOCIATED_DECL (decl));
21057 /* Probably some frontend-internal decl. Assume we don't care. */
21058 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
21065 /* Output debug information for global decl DECL. Called from toplev.c after
21066 compilation proper has finished. */
21069 dwarf2out_global_decl (tree decl)
21071 /* Output DWARF2 information for file-scope tentative data object
21072 declarations, file-scope (extern) function declarations (which
21073 had no corresponding body) and file-scope tagged type declarations
21074 and definitions which have not yet been forced out. */
21075 if ((TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
21076 && !POINTER_BOUNDS_P (decl))
21077 dwarf2out_decl (decl);
21080 /* Output debug information for type decl DECL. Called from toplev.c
21081 and from language front ends (to record built-in types). */
21083 dwarf2out_type_decl (tree decl, int local)
21086 dwarf2out_decl (decl);
21089 /* Output debug information for imported module or decl DECL.
21090 NAME is non-NULL name in the lexical block if the decl has been renamed.
21091 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
21092 that DECL belongs to.
21093 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
21095 dwarf2out_imported_module_or_decl_1 (tree decl,
21097 tree lexical_block,
21098 dw_die_ref lexical_block_die)
21100 expanded_location xloc;
21101 dw_die_ref imported_die = NULL;
21102 dw_die_ref at_import_die;
21104 if (TREE_CODE (decl) == IMPORTED_DECL)
21106 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
21107 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
21111 xloc = expand_location (input_location);
21113 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
21115 at_import_die = force_type_die (TREE_TYPE (decl));
21116 /* For namespace N { typedef void T; } using N::T; base_type_die
21117 returns NULL, but DW_TAG_imported_declaration requires
21118 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
21119 if (!at_import_die)
21121 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
21122 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
21123 at_import_die = lookup_type_die (TREE_TYPE (decl));
21124 gcc_assert (at_import_die);
21129 at_import_die = lookup_decl_die (decl);
21130 if (!at_import_die)
21132 /* If we're trying to avoid duplicate debug info, we may not have
21133 emitted the member decl for this field. Emit it now. */
21134 if (TREE_CODE (decl) == FIELD_DECL)
21136 tree type = DECL_CONTEXT (decl);
21138 if (TYPE_CONTEXT (type)
21139 && TYPE_P (TYPE_CONTEXT (type))
21140 && !should_emit_struct_debug (TYPE_CONTEXT (type),
21141 DINFO_USAGE_DIR_USE))
21143 gen_type_die_for_member (type, decl,
21144 get_context_die (TYPE_CONTEXT (type)));
21146 if (TREE_CODE (decl) == NAMELIST_DECL)
21147 at_import_die = gen_namelist_decl (DECL_NAME (decl),
21148 get_context_die (DECL_CONTEXT (decl)),
21151 at_import_die = force_decl_die (decl);
21155 if (TREE_CODE (decl) == NAMESPACE_DECL)
21157 if (dwarf_version >= 3 || !dwarf_strict)
21158 imported_die = new_die (DW_TAG_imported_module,
21165 imported_die = new_die (DW_TAG_imported_declaration,
21169 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
21170 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
21172 add_AT_string (imported_die, DW_AT_name,
21173 IDENTIFIER_POINTER (name));
21174 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
21177 /* Output debug information for imported module or decl DECL.
21178 NAME is non-NULL name in context if the decl has been renamed.
21179 CHILD is true if decl is one of the renamed decls as part of
21180 importing whole module. */
21183 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
21186 /* dw_die_ref at_import_die; */
21187 dw_die_ref scope_die;
21189 if (debug_info_level <= DINFO_LEVEL_TERSE)
21194 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
21195 We need decl DIE for reference and scope die. First, get DIE for the decl
21198 /* Get the scope die for decl context. Use comp_unit_die for global module
21199 or decl. If die is not found for non globals, force new die. */
21201 && TYPE_P (context)
21202 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
21205 if (!(dwarf_version >= 3 || !dwarf_strict))
21208 scope_die = get_context_die (context);
21212 gcc_assert (scope_die->die_child);
21213 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
21214 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
21215 scope_die = scope_die->die_child;
21218 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
21219 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
21223 /* Output debug information for namelists. */
21226 gen_namelist_decl (tree name, dw_die_ref scope_die, tree item_decls)
21228 dw_die_ref nml_die, nml_item_die, nml_item_ref_die;
21232 if (debug_info_level <= DINFO_LEVEL_TERSE)
21235 gcc_assert (scope_die != NULL);
21236 nml_die = new_die (DW_TAG_namelist, scope_die, NULL);
21237 add_AT_string (nml_die, DW_AT_name, IDENTIFIER_POINTER (name));
21239 /* If there are no item_decls, we have a nondefining namelist, e.g.
21240 with USE association; hence, set DW_AT_declaration. */
21241 if (item_decls == NULL_TREE)
21243 add_AT_flag (nml_die, DW_AT_declaration, 1);
21247 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls), i, value)
21249 nml_item_ref_die = lookup_decl_die (value);
21250 if (!nml_item_ref_die)
21251 nml_item_ref_die = force_decl_die (value);
21253 nml_item_die = new_die (DW_TAG_namelist_item, nml_die, NULL);
21254 add_AT_die_ref (nml_item_die, DW_AT_namelist_items, nml_item_ref_die);
21260 /* Write the debugging output for DECL. */
21263 dwarf2out_decl (tree decl)
21265 dw_die_ref context_die = comp_unit_die ();
21267 switch (TREE_CODE (decl))
21272 case FUNCTION_DECL:
21273 /* What we would really like to do here is to filter out all mere
21274 file-scope declarations of file-scope functions which are never
21275 referenced later within this translation unit (and keep all of ones
21276 that *are* referenced later on) but we aren't clairvoyant, so we have
21277 no idea which functions will be referenced in the future (i.e. later
21278 on within the current translation unit). So here we just ignore all
21279 file-scope function declarations which are not also definitions. If
21280 and when the debugger needs to know something about these functions,
21281 it will have to hunt around and find the DWARF information associated
21282 with the definition of the function.
21284 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
21285 nodes represent definitions and which ones represent mere
21286 declarations. We have to check DECL_INITIAL instead. That's because
21287 the C front-end supports some weird semantics for "extern inline"
21288 function definitions. These can get inlined within the current
21289 translation unit (and thus, we need to generate Dwarf info for their
21290 abstract instances so that the Dwarf info for the concrete inlined
21291 instances can have something to refer to) but the compiler never
21292 generates any out-of-lines instances of such things (despite the fact
21293 that they *are* definitions).
21295 The important point is that the C front-end marks these "extern
21296 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
21297 them anyway. Note that the C++ front-end also plays some similar games
21298 for inline function definitions appearing within include files which
21299 also contain `#pragma interface' pragmas.
21301 If we are called from dwarf2out_abstract_function output a DIE
21302 anyway. We can end up here this way with early inlining and LTO
21303 where the inlined function is output in a different LTRANS unit
21305 if (DECL_INITIAL (decl) == NULL_TREE
21306 && ! DECL_ABSTRACT_P (decl))
21309 /* If we're a nested function, initially use a parent of NULL; if we're
21310 a plain function, this will be fixed up in decls_for_scope. If
21311 we're a method, it will be ignored, since we already have a DIE. */
21312 if (decl_function_context (decl)
21313 /* But if we're in terse mode, we don't care about scope. */
21314 && debug_info_level > DINFO_LEVEL_TERSE)
21315 context_die = NULL;
21319 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
21320 declaration and if the declaration was never even referenced from
21321 within this entire compilation unit. We suppress these DIEs in
21322 order to save space in the .debug section (by eliminating entries
21323 which are probably useless). Note that we must not suppress
21324 block-local extern declarations (whether used or not) because that
21325 would screw-up the debugger's name lookup mechanism and cause it to
21326 miss things which really ought to be in scope at a given point. */
21327 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
21330 /* For local statics lookup proper context die. */
21331 if (TREE_STATIC (decl)
21332 && DECL_CONTEXT (decl)
21333 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
21334 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21336 /* If we are in terse mode, don't generate any DIEs to represent any
21337 variable declarations or definitions. */
21338 if (debug_info_level <= DINFO_LEVEL_TERSE)
21343 if (debug_info_level <= DINFO_LEVEL_TERSE)
21345 if (!is_fortran () && !is_ada ())
21347 if (TREE_STATIC (decl) && decl_function_context (decl))
21348 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21351 case NAMESPACE_DECL:
21352 case IMPORTED_DECL:
21353 if (debug_info_level <= DINFO_LEVEL_TERSE)
21355 if (lookup_decl_die (decl) != NULL)
21360 /* Don't emit stubs for types unless they are needed by other DIEs. */
21361 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
21364 /* Don't bother trying to generate any DIEs to represent any of the
21365 normal built-in types for the language we are compiling. */
21366 if (DECL_IS_BUILTIN (decl))
21369 /* If we are in terse mode, don't generate any DIEs for types. */
21370 if (debug_info_level <= DINFO_LEVEL_TERSE)
21373 /* If we're a function-scope tag, initially use a parent of NULL;
21374 this will be fixed up in decls_for_scope. */
21375 if (decl_function_context (decl))
21376 context_die = NULL;
21380 case NAMELIST_DECL:
21387 gen_decl_die (decl, NULL, context_die);
21390 /* Write the debugging output for DECL. */
21393 dwarf2out_function_decl (tree decl)
21395 dwarf2out_decl (decl);
21396 call_arg_locations = NULL;
21397 call_arg_loc_last = NULL;
21398 call_site_count = -1;
21399 tail_call_site_count = -1;
21400 block_map.release ();
21401 decl_loc_table->empty ();
21402 cached_dw_loc_list_table->empty ();
21405 /* Output a marker (i.e. a label) for the beginning of the generated code for
21406 a lexical block. */
21409 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
21410 unsigned int blocknum)
21412 switch_to_section (current_function_section ());
21413 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
21416 /* Output a marker (i.e. a label) for the end of the generated code for a
21420 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
21422 switch_to_section (current_function_section ());
21423 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
21426 /* Returns nonzero if it is appropriate not to emit any debugging
21427 information for BLOCK, because it doesn't contain any instructions.
21429 Don't allow this for blocks with nested functions or local classes
21430 as we would end up with orphans, and in the presence of scheduling
21431 we may end up calling them anyway. */
21434 dwarf2out_ignore_block (const_tree block)
21439 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
21440 if (TREE_CODE (decl) == FUNCTION_DECL
21441 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21443 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
21445 decl = BLOCK_NONLOCALIZED_VAR (block, i);
21446 if (TREE_CODE (decl) == FUNCTION_DECL
21447 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21454 /* Hash table routines for file_hash. */
21457 dwarf_file_hasher::equal (dwarf_file_data *p1, const char *p2)
21459 return filename_cmp (p1->filename, p2) == 0;
21463 dwarf_file_hasher::hash (dwarf_file_data *p)
21465 return htab_hash_string (p->filename);
21468 /* Lookup FILE_NAME (in the list of filenames that we know about here in
21469 dwarf2out.c) and return its "index". The index of each (known) filename is
21470 just a unique number which is associated with only that one filename. We
21471 need such numbers for the sake of generating labels (in the .debug_sfnames
21472 section) and references to those files numbers (in the .debug_srcinfo
21473 and.debug_macinfo sections). If the filename given as an argument is not
21474 found in our current list, add it to the list and assign it the next
21475 available unique index number. In order to speed up searches, we remember
21476 the index of the filename was looked up last. This handles the majority of
21479 static struct dwarf_file_data *
21480 lookup_filename (const char *file_name)
21482 struct dwarf_file_data * created;
21484 /* Check to see if the file name that was searched on the previous
21485 call matches this file name. If so, return the index. */
21486 if (file_table_last_lookup
21487 && (file_name == file_table_last_lookup->filename
21488 || filename_cmp (file_table_last_lookup->filename, file_name) == 0))
21489 return file_table_last_lookup;
21491 /* Didn't match the previous lookup, search the table. */
21492 dwarf_file_data **slot
21493 = file_table->find_slot_with_hash (file_name, htab_hash_string (file_name),
21498 created = ggc_alloc<dwarf_file_data> ();
21499 created->filename = file_name;
21500 created->emitted_number = 0;
21505 /* If the assembler will construct the file table, then translate the compiler
21506 internal file table number into the assembler file table number, and emit
21507 a .file directive if we haven't already emitted one yet. The file table
21508 numbers are different because we prune debug info for unused variables and
21509 types, which may include filenames. */
21512 maybe_emit_file (struct dwarf_file_data * fd)
21514 if (! fd->emitted_number)
21516 if (last_emitted_file)
21517 fd->emitted_number = last_emitted_file->emitted_number + 1;
21519 fd->emitted_number = 1;
21520 last_emitted_file = fd;
21522 if (DWARF2_ASM_LINE_DEBUG_INFO)
21524 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
21525 output_quoted_string (asm_out_file,
21526 remap_debug_filename (fd->filename));
21527 fputc ('\n', asm_out_file);
21531 return fd->emitted_number;
21534 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21535 That generation should happen after function debug info has been
21536 generated. The value of the attribute is the constant value of ARG. */
21539 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
21541 die_arg_entry entry;
21546 if (!tmpl_value_parm_die_table)
21547 vec_alloc (tmpl_value_parm_die_table, 32);
21551 vec_safe_push (tmpl_value_parm_die_table, entry);
21554 /* Return TRUE if T is an instance of generic type, FALSE
21558 generic_type_p (tree t)
21560 if (t == NULL_TREE || !TYPE_P (t))
21562 return lang_hooks.get_innermost_generic_parms (t) != NULL_TREE;
21565 /* Schedule the generation of the generic parameter dies for the
21566 instance of generic type T. The proper generation itself is later
21567 done by gen_scheduled_generic_parms_dies. */
21570 schedule_generic_params_dies_gen (tree t)
21572 if (!generic_type_p (t))
21575 if (!generic_type_instances)
21576 vec_alloc (generic_type_instances, 256);
21578 vec_safe_push (generic_type_instances, t);
21581 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21582 by append_entry_to_tmpl_value_parm_die_table. This function must
21583 be called after function DIEs have been generated. */
21586 gen_remaining_tmpl_value_param_die_attribute (void)
21588 if (tmpl_value_parm_die_table)
21593 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table, i, e)
21594 tree_add_const_value_attribute (e->die, e->arg);
21598 /* Generate generic parameters DIEs for instances of generic types
21599 that have been previously scheduled by
21600 schedule_generic_params_dies_gen. This function must be called
21601 after all the types of the CU have been laid out. */
21604 gen_scheduled_generic_parms_dies (void)
21609 if (!generic_type_instances)
21612 FOR_EACH_VEC_ELT (*generic_type_instances, i, t)
21613 if (COMPLETE_TYPE_P (t))
21614 gen_generic_params_dies (t);
21618 /* Replace DW_AT_name for the decl with name. */
21621 dwarf2out_set_name (tree decl, tree name)
21627 die = TYPE_SYMTAB_DIE (decl);
21631 dname = dwarf2_name (name, 0);
21635 attr = get_AT (die, DW_AT_name);
21638 struct indirect_string_node *node;
21640 node = find_AT_string (dname);
21641 /* replace the string. */
21642 attr->dw_attr_val.v.val_str = node;
21646 add_name_attribute (die, dname);
21649 /* True if before or during processing of the first function being emitted. */
21650 static bool in_first_function_p = true;
21651 /* True if loc_note during dwarf2out_var_location call might still be
21652 before first real instruction at address equal to .Ltext0. */
21653 static bool maybe_at_text_label_p = true;
21654 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21655 static unsigned int first_loclabel_num_not_at_text_label;
21657 /* Called by the final INSN scan whenever we see a var location. We
21658 use it to drop labels in the right places, and throw the location in
21659 our lookup table. */
21662 dwarf2out_var_location (rtx_insn *loc_note)
21664 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
21665 struct var_loc_node *newloc;
21666 rtx_insn *next_real, *next_note;
21667 static const char *last_label;
21668 static const char *last_postcall_label;
21669 static bool last_in_cold_section_p;
21670 static rtx_insn *expected_next_loc_note;
21674 if (!NOTE_P (loc_note))
21676 if (CALL_P (loc_note))
21679 if (SIBLING_CALL_P (loc_note))
21680 tail_call_site_count++;
21685 var_loc_p = NOTE_KIND (loc_note) == NOTE_INSN_VAR_LOCATION;
21686 if (var_loc_p && !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
21689 /* Optimize processing a large consecutive sequence of location
21690 notes so we don't spend too much time in next_real_insn. If the
21691 next insn is another location note, remember the next_real_insn
21692 calculation for next time. */
21693 next_real = cached_next_real_insn;
21696 if (expected_next_loc_note != loc_note)
21700 next_note = NEXT_INSN (loc_note);
21702 || next_note->deleted ()
21703 || ! NOTE_P (next_note)
21704 || (NOTE_KIND (next_note) != NOTE_INSN_VAR_LOCATION
21705 && NOTE_KIND (next_note) != NOTE_INSN_CALL_ARG_LOCATION))
21709 next_real = next_real_insn (loc_note);
21713 expected_next_loc_note = next_note;
21714 cached_next_real_insn = next_real;
21717 cached_next_real_insn = NULL;
21719 /* If there are no instructions which would be affected by this note,
21720 don't do anything. */
21722 && next_real == NULL_RTX
21723 && !NOTE_DURING_CALL_P (loc_note))
21726 if (next_real == NULL_RTX)
21727 next_real = get_last_insn ();
21729 /* If there were any real insns between note we processed last time
21730 and this note (or if it is the first note), clear
21731 last_{,postcall_}label so that they are not reused this time. */
21732 if (last_var_location_insn == NULL_RTX
21733 || last_var_location_insn != next_real
21734 || last_in_cold_section_p != in_cold_section_p)
21737 last_postcall_label = NULL;
21742 decl = NOTE_VAR_LOCATION_DECL (loc_note);
21743 newloc = add_var_loc_to_decl (decl, loc_note,
21744 NOTE_DURING_CALL_P (loc_note)
21745 ? last_postcall_label : last_label);
21746 if (newloc == NULL)
21755 /* If there were no real insns between note we processed last time
21756 and this note, use the label we emitted last time. Otherwise
21757 create a new label and emit it. */
21758 if (last_label == NULL)
21760 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
21761 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
21763 last_label = ggc_strdup (loclabel);
21764 /* See if loclabel might be equal to .Ltext0. If yes,
21765 bump first_loclabel_num_not_at_text_label. */
21766 if (!have_multiple_function_sections
21767 && in_first_function_p
21768 && maybe_at_text_label_p)
21770 static rtx_insn *last_start;
21772 for (insn = loc_note; insn; insn = previous_insn (insn))
21773 if (insn == last_start)
21775 else if (!NONDEBUG_INSN_P (insn))
21779 rtx body = PATTERN (insn);
21780 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
21782 /* Inline asm could occupy zero bytes. */
21783 else if (GET_CODE (body) == ASM_INPUT
21784 || asm_noperands (body) >= 0)
21786 #ifdef HAVE_attr_length
21787 else if (get_attr_min_length (insn) == 0)
21792 /* Assume insn has non-zero length. */
21793 maybe_at_text_label_p = false;
21797 if (maybe_at_text_label_p)
21799 last_start = loc_note;
21800 first_loclabel_num_not_at_text_label = loclabel_num;
21807 struct call_arg_loc_node *ca_loc
21808 = ggc_cleared_alloc<call_arg_loc_node> ();
21809 rtx_insn *prev = prev_real_insn (loc_note);
21811 ca_loc->call_arg_loc_note = loc_note;
21812 ca_loc->next = NULL;
21813 ca_loc->label = last_label;
21816 || (NONJUMP_INSN_P (prev)
21817 && GET_CODE (PATTERN (prev)) == SEQUENCE
21818 && CALL_P (XVECEXP (PATTERN (prev), 0, 0)))));
21819 if (!CALL_P (prev))
21820 prev = as_a <rtx_sequence *> (PATTERN (prev))->insn (0);
21821 ca_loc->tail_call_p = SIBLING_CALL_P (prev);
21822 x = get_call_rtx_from (PATTERN (prev));
21825 x = XEXP (XEXP (x, 0), 0);
21826 if (GET_CODE (x) == SYMBOL_REF
21827 && SYMBOL_REF_DECL (x)
21828 && TREE_CODE (SYMBOL_REF_DECL (x)) == FUNCTION_DECL)
21829 ca_loc->symbol_ref = x;
21831 ca_loc->block = insn_scope (prev);
21832 if (call_arg_locations)
21833 call_arg_loc_last->next = ca_loc;
21835 call_arg_locations = ca_loc;
21836 call_arg_loc_last = ca_loc;
21838 else if (!NOTE_DURING_CALL_P (loc_note))
21839 newloc->label = last_label;
21842 if (!last_postcall_label)
21844 sprintf (loclabel, "%s-1", last_label);
21845 last_postcall_label = ggc_strdup (loclabel);
21847 newloc->label = last_postcall_label;
21850 last_var_location_insn = next_real;
21851 last_in_cold_section_p = in_cold_section_p;
21854 /* Note in one location list that text section has changed. */
21857 var_location_switch_text_section_1 (var_loc_list **slot, void *)
21859 var_loc_list *list = *slot;
21861 list->last_before_switch
21862 = list->last->next ? list->last->next : list->last;
21866 /* Note in all location lists that text section has changed. */
21869 var_location_switch_text_section (void)
21871 if (decl_loc_table == NULL)
21874 decl_loc_table->traverse<void *, var_location_switch_text_section_1> (NULL);
21877 /* Create a new line number table. */
21879 static dw_line_info_table *
21880 new_line_info_table (void)
21882 dw_line_info_table *table;
21884 table = ggc_cleared_alloc<dw_line_info_table_struct> ();
21885 table->file_num = 1;
21886 table->line_num = 1;
21887 table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
21892 /* Lookup the "current" table into which we emit line info, so
21893 that we don't have to do it for every source line. */
21896 set_cur_line_info_table (section *sec)
21898 dw_line_info_table *table;
21900 if (sec == text_section)
21901 table = text_section_line_info;
21902 else if (sec == cold_text_section)
21904 table = cold_text_section_line_info;
21907 cold_text_section_line_info = table = new_line_info_table ();
21908 table->end_label = cold_end_label;
21913 const char *end_label;
21915 if (flag_reorder_blocks_and_partition)
21917 if (in_cold_section_p)
21918 end_label = crtl->subsections.cold_section_end_label;
21920 end_label = crtl->subsections.hot_section_end_label;
21924 char label[MAX_ARTIFICIAL_LABEL_BYTES];
21925 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
21926 current_function_funcdef_no);
21927 end_label = ggc_strdup (label);
21930 table = new_line_info_table ();
21931 table->end_label = end_label;
21933 vec_safe_push (separate_line_info, table);
21936 if (DWARF2_ASM_LINE_DEBUG_INFO)
21937 table->is_stmt = (cur_line_info_table
21938 ? cur_line_info_table->is_stmt
21939 : DWARF_LINE_DEFAULT_IS_STMT_START);
21940 cur_line_info_table = table;
21944 /* We need to reset the locations at the beginning of each
21945 function. We can't do this in the end_function hook, because the
21946 declarations that use the locations won't have been output when
21947 that hook is called. Also compute have_multiple_function_sections here. */
21950 dwarf2out_begin_function (tree fun)
21952 section *sec = function_section (fun);
21954 if (sec != text_section)
21955 have_multiple_function_sections = true;
21957 if (flag_reorder_blocks_and_partition && !cold_text_section)
21959 gcc_assert (current_function_decl == fun);
21960 cold_text_section = unlikely_text_section ();
21961 switch_to_section (cold_text_section);
21962 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
21963 switch_to_section (sec);
21966 dwarf2out_note_section_used ();
21967 call_site_count = 0;
21968 tail_call_site_count = 0;
21970 set_cur_line_info_table (sec);
21973 /* Helper function of dwarf2out_end_function, called only after emitting
21974 the very first function into assembly. Check if some .debug_loc range
21975 might end with a .LVL* label that could be equal to .Ltext0.
21976 In that case we must force using absolute addresses in .debug_loc ranges,
21977 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
21978 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
21980 Set have_multiple_function_sections to true in that case and
21981 terminate htab traversal. */
21984 find_empty_loc_ranges_at_text_label (var_loc_list **slot, int)
21986 var_loc_list *entry = *slot;
21987 struct var_loc_node *node;
21989 node = entry->first;
21990 if (node && node->next && node->next->label)
21993 const char *label = node->next->label;
21994 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
21996 for (i = 0; i < first_loclabel_num_not_at_text_label; i++)
21998 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", i);
21999 if (strcmp (label, loclabel) == 0)
22001 have_multiple_function_sections = true;
22009 /* Hook called after emitting a function into assembly.
22010 This does something only for the very first function emitted. */
22013 dwarf2out_end_function (unsigned int)
22015 if (in_first_function_p
22016 && !have_multiple_function_sections
22017 && first_loclabel_num_not_at_text_label
22019 decl_loc_table->traverse<int, find_empty_loc_ranges_at_text_label> (0);
22020 in_first_function_p = false;
22021 maybe_at_text_label_p = false;
22024 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
22027 push_dw_line_info_entry (dw_line_info_table *table,
22028 enum dw_line_info_opcode opcode, unsigned int val)
22030 dw_line_info_entry e;
22033 vec_safe_push (table->entries, e);
22036 /* Output a label to mark the beginning of a source code line entry
22037 and record information relating to this source line, in
22038 'line_info_table' for later output of the .debug_line section. */
22039 /* ??? The discriminator parameter ought to be unsigned. */
22042 dwarf2out_source_line (unsigned int line, const char *filename,
22043 int discriminator, bool is_stmt)
22045 unsigned int file_num;
22046 dw_line_info_table *table;
22048 if (debug_info_level < DINFO_LEVEL_TERSE || line == 0)
22051 /* The discriminator column was added in dwarf4. Simplify the below
22052 by simply removing it if we're not supposed to output it. */
22053 if (dwarf_version < 4 && dwarf_strict)
22056 table = cur_line_info_table;
22057 file_num = maybe_emit_file (lookup_filename (filename));
22059 /* ??? TODO: Elide duplicate line number entries. Traditionally,
22060 the debugger has used the second (possibly duplicate) line number
22061 at the beginning of the function to mark the end of the prologue.
22062 We could eliminate any other duplicates within the function. For
22063 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
22064 that second line number entry. */
22065 /* Recall that this end-of-prologue indication is *not* the same thing
22066 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
22067 to which the hook corresponds, follows the last insn that was
22068 emitted by gen_prologue. What we need is to precede the first insn
22069 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
22070 insn that corresponds to something the user wrote. These may be
22071 very different locations once scheduling is enabled. */
22073 if (0 && file_num == table->file_num
22074 && line == table->line_num
22075 && discriminator == table->discrim_num
22076 && is_stmt == table->is_stmt)
22079 switch_to_section (current_function_section ());
22081 /* If requested, emit something human-readable. */
22082 if (flag_debug_asm)
22083 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line);
22085 if (DWARF2_ASM_LINE_DEBUG_INFO)
22087 /* Emit the .loc directive understood by GNU as. */
22088 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
22089 file_num, line, is_stmt, discriminator */
22090 fputs ("\t.loc ", asm_out_file);
22091 fprint_ul (asm_out_file, file_num);
22092 putc (' ', asm_out_file);
22093 fprint_ul (asm_out_file, line);
22094 putc (' ', asm_out_file);
22095 putc ('0', asm_out_file);
22097 if (is_stmt != table->is_stmt)
22099 fputs (" is_stmt ", asm_out_file);
22100 putc (is_stmt ? '1' : '0', asm_out_file);
22102 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
22104 gcc_assert (discriminator > 0);
22105 fputs (" discriminator ", asm_out_file);
22106 fprint_ul (asm_out_file, (unsigned long) discriminator);
22108 putc ('\n', asm_out_file);
22112 unsigned int label_num = ++line_info_label_num;
22114 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num);
22116 push_dw_line_info_entry (table, LI_set_address, label_num);
22117 if (file_num != table->file_num)
22118 push_dw_line_info_entry (table, LI_set_file, file_num);
22119 if (discriminator != table->discrim_num)
22120 push_dw_line_info_entry (table, LI_set_discriminator, discriminator);
22121 if (is_stmt != table->is_stmt)
22122 push_dw_line_info_entry (table, LI_negate_stmt, 0);
22123 push_dw_line_info_entry (table, LI_set_line, line);
22126 table->file_num = file_num;
22127 table->line_num = line;
22128 table->discrim_num = discriminator;
22129 table->is_stmt = is_stmt;
22130 table->in_use = true;
22133 /* Record the beginning of a new source file. */
22136 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
22138 if (flag_eliminate_dwarf2_dups)
22140 /* Record the beginning of the file for break_out_includes. */
22141 dw_die_ref bincl_die;
22143 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die (), NULL);
22144 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
22147 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22150 e.code = DW_MACINFO_start_file;
22152 e.info = ggc_strdup (filename);
22153 vec_safe_push (macinfo_table, e);
22157 /* Record the end of a source file. */
22160 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
22162 if (flag_eliminate_dwarf2_dups)
22163 /* Record the end of the file for break_out_includes. */
22164 new_die (DW_TAG_GNU_EINCL, comp_unit_die (), NULL);
22166 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22169 e.code = DW_MACINFO_end_file;
22172 vec_safe_push (macinfo_table, e);
22176 /* Called from debug_define in toplev.c. The `buffer' parameter contains
22177 the tail part of the directive line, i.e. the part which is past the
22178 initial whitespace, #, whitespace, directive-name, whitespace part. */
22181 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
22182 const char *buffer ATTRIBUTE_UNUSED)
22184 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22187 /* Insert a dummy first entry to be able to optimize the whole
22188 predefined macro block using DW_MACRO_GNU_transparent_include. */
22189 if (macinfo_table->is_empty () && lineno <= 1)
22194 vec_safe_push (macinfo_table, e);
22196 e.code = DW_MACINFO_define;
22198 e.info = ggc_strdup (buffer);
22199 vec_safe_push (macinfo_table, e);
22203 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
22204 the tail part of the directive line, i.e. the part which is past the
22205 initial whitespace, #, whitespace, directive-name, whitespace part. */
22208 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
22209 const char *buffer ATTRIBUTE_UNUSED)
22211 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22214 /* Insert a dummy first entry to be able to optimize the whole
22215 predefined macro block using DW_MACRO_GNU_transparent_include. */
22216 if (macinfo_table->is_empty () && lineno <= 1)
22221 vec_safe_push (macinfo_table, e);
22223 e.code = DW_MACINFO_undef;
22225 e.info = ggc_strdup (buffer);
22226 vec_safe_push (macinfo_table, e);
22230 /* Helpers to manipulate hash table of CUs. */
22232 struct macinfo_entry_hasher : typed_noop_remove <macinfo_entry>
22234 typedef macinfo_entry *value_type;
22235 typedef macinfo_entry *compare_type;
22236 static inline hashval_t hash (const macinfo_entry *);
22237 static inline bool equal (const macinfo_entry *, const macinfo_entry *);
22241 macinfo_entry_hasher::hash (const macinfo_entry *entry)
22243 return htab_hash_string (entry->info);
22247 macinfo_entry_hasher::equal (const macinfo_entry *entry1,
22248 const macinfo_entry *entry2)
22250 return !strcmp (entry1->info, entry2->info);
22253 typedef hash_table<macinfo_entry_hasher> macinfo_hash_type;
22255 /* Output a single .debug_macinfo entry. */
22258 output_macinfo_op (macinfo_entry *ref)
22262 struct indirect_string_node *node;
22263 char label[MAX_ARTIFICIAL_LABEL_BYTES];
22264 struct dwarf_file_data *fd;
22268 case DW_MACINFO_start_file:
22269 fd = lookup_filename (ref->info);
22270 file_num = maybe_emit_file (fd);
22271 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
22272 dw2_asm_output_data_uleb128 (ref->lineno,
22273 "Included from line number %lu",
22274 (unsigned long) ref->lineno);
22275 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info);
22277 case DW_MACINFO_end_file:
22278 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
22280 case DW_MACINFO_define:
22281 case DW_MACINFO_undef:
22282 len = strlen (ref->info) + 1;
22284 && len > DWARF_OFFSET_SIZE
22285 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22286 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
22288 ref->code = ref->code == DW_MACINFO_define
22289 ? DW_MACRO_GNU_define_indirect
22290 : DW_MACRO_GNU_undef_indirect;
22291 output_macinfo_op (ref);
22294 dw2_asm_output_data (1, ref->code,
22295 ref->code == DW_MACINFO_define
22296 ? "Define macro" : "Undefine macro");
22297 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22298 (unsigned long) ref->lineno);
22299 dw2_asm_output_nstring (ref->info, -1, "The macro");
22301 case DW_MACRO_GNU_define_indirect:
22302 case DW_MACRO_GNU_undef_indirect:
22303 node = find_AT_string (ref->info);
22305 && ((node->form == DW_FORM_strp)
22306 || (node->form == DW_FORM_GNU_str_index)));
22307 dw2_asm_output_data (1, ref->code,
22308 ref->code == DW_MACRO_GNU_define_indirect
22309 ? "Define macro indirect"
22310 : "Undefine macro indirect");
22311 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22312 (unsigned long) ref->lineno);
22313 if (node->form == DW_FORM_strp)
22314 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
22315 debug_str_section, "The macro: \"%s\"",
22318 dw2_asm_output_data_uleb128 (node->index, "The macro: \"%s\"",
22321 case DW_MACRO_GNU_transparent_include:
22322 dw2_asm_output_data (1, ref->code, "Transparent include");
22323 ASM_GENERATE_INTERNAL_LABEL (label,
22324 DEBUG_MACRO_SECTION_LABEL, ref->lineno);
22325 dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL);
22328 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n",
22329 ASM_COMMENT_START, (unsigned long) ref->code);
22334 /* Attempt to make a sequence of define/undef macinfo ops shareable with
22335 other compilation unit .debug_macinfo sections. IDX is the first
22336 index of a define/undef, return the number of ops that should be
22337 emitted in a comdat .debug_macinfo section and emit
22338 a DW_MACRO_GNU_transparent_include entry referencing it.
22339 If the define/undef entry should be emitted normally, return 0. */
22342 optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files,
22343 macinfo_hash_type **macinfo_htab)
22345 macinfo_entry *first, *second, *cur, *inc;
22346 char linebuf[sizeof (HOST_WIDE_INT) * 3 + 1];
22347 unsigned char checksum[16];
22348 struct md5_ctx ctx;
22349 char *grp_name, *tail;
22351 unsigned int i, count, encoded_filename_len, linebuf_len;
22352 macinfo_entry **slot;
22354 first = &(*macinfo_table)[idx];
22355 second = &(*macinfo_table)[idx + 1];
22357 /* Optimize only if there are at least two consecutive define/undef ops,
22358 and either all of them are before first DW_MACINFO_start_file
22359 with lineno {0,1} (i.e. predefined macro block), or all of them are
22360 in some included header file. */
22361 if (second->code != DW_MACINFO_define && second->code != DW_MACINFO_undef)
22363 if (vec_safe_is_empty (files))
22365 if (first->lineno > 1 || second->lineno > 1)
22368 else if (first->lineno == 0)
22371 /* Find the last define/undef entry that can be grouped together
22372 with first and at the same time compute md5 checksum of their
22373 codes, linenumbers and strings. */
22374 md5_init_ctx (&ctx);
22375 for (i = idx; macinfo_table->iterate (i, &cur); i++)
22376 if (cur->code != DW_MACINFO_define && cur->code != DW_MACINFO_undef)
22378 else if (vec_safe_is_empty (files) && cur->lineno > 1)
22382 unsigned char code = cur->code;
22383 md5_process_bytes (&code, 1, &ctx);
22384 checksum_uleb128 (cur->lineno, &ctx);
22385 md5_process_bytes (cur->info, strlen (cur->info) + 1, &ctx);
22387 md5_finish_ctx (&ctx, checksum);
22390 /* From the containing include filename (if any) pick up just
22391 usable characters from its basename. */
22392 if (vec_safe_is_empty (files))
22395 base = lbasename (files->last ().info);
22396 for (encoded_filename_len = 0, i = 0; base[i]; i++)
22397 if (ISIDNUM (base[i]) || base[i] == '.')
22398 encoded_filename_len++;
22399 /* Count . at the end. */
22400 if (encoded_filename_len)
22401 encoded_filename_len++;
22403 sprintf (linebuf, HOST_WIDE_INT_PRINT_UNSIGNED, first->lineno);
22404 linebuf_len = strlen (linebuf);
22406 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
22407 grp_name = XALLOCAVEC (char, 4 + encoded_filename_len + linebuf_len + 1
22409 memcpy (grp_name, DWARF_OFFSET_SIZE == 4 ? "wm4." : "wm8.", 4);
22410 tail = grp_name + 4;
22411 if (encoded_filename_len)
22413 for (i = 0; base[i]; i++)
22414 if (ISIDNUM (base[i]) || base[i] == '.')
22418 memcpy (tail, linebuf, linebuf_len);
22419 tail += linebuf_len;
22421 for (i = 0; i < 16; i++)
22422 sprintf (tail + i * 2, "%02x", checksum[i] & 0xff);
22424 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
22425 in the empty vector entry before the first define/undef. */
22426 inc = &(*macinfo_table)[idx - 1];
22427 inc->code = DW_MACRO_GNU_transparent_include;
22429 inc->info = ggc_strdup (grp_name);
22430 if (!*macinfo_htab)
22431 *macinfo_htab = new macinfo_hash_type (10);
22432 /* Avoid emitting duplicates. */
22433 slot = (*macinfo_htab)->find_slot (inc, INSERT);
22438 /* If such an entry has been used before, just emit
22439 a DW_MACRO_GNU_transparent_include op. */
22441 output_macinfo_op (inc);
22442 /* And clear all macinfo_entry in the range to avoid emitting them
22443 in the second pass. */
22444 for (i = idx; macinfo_table->iterate (i, &cur) && i < idx + count; i++)
22453 inc->lineno = (*macinfo_htab)->elements ();
22454 output_macinfo_op (inc);
22459 /* Save any strings needed by the macinfo table in the debug str
22460 table. All strings must be collected into the table by the time
22461 index_string is called. */
22464 save_macinfo_strings (void)
22468 macinfo_entry *ref;
22470 for (i = 0; macinfo_table && macinfo_table->iterate (i, &ref); i++)
22474 /* Match the logic in output_macinfo_op to decide on
22475 indirect strings. */
22476 case DW_MACINFO_define:
22477 case DW_MACINFO_undef:
22478 len = strlen (ref->info) + 1;
22480 && len > DWARF_OFFSET_SIZE
22481 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22482 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
22483 set_indirect_string (find_AT_string (ref->info));
22485 case DW_MACRO_GNU_define_indirect:
22486 case DW_MACRO_GNU_undef_indirect:
22487 set_indirect_string (find_AT_string (ref->info));
22495 /* Output macinfo section(s). */
22498 output_macinfo (void)
22501 unsigned long length = vec_safe_length (macinfo_table);
22502 macinfo_entry *ref;
22503 vec<macinfo_entry, va_gc> *files = NULL;
22504 macinfo_hash_type *macinfo_htab = NULL;
22509 /* output_macinfo* uses these interchangeably. */
22510 gcc_assert ((int) DW_MACINFO_define == (int) DW_MACRO_GNU_define
22511 && (int) DW_MACINFO_undef == (int) DW_MACRO_GNU_undef
22512 && (int) DW_MACINFO_start_file == (int) DW_MACRO_GNU_start_file
22513 && (int) DW_MACINFO_end_file == (int) DW_MACRO_GNU_end_file);
22515 /* For .debug_macro emit the section header. */
22518 dw2_asm_output_data (2, 4, "DWARF macro version number");
22519 if (DWARF_OFFSET_SIZE == 8)
22520 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
22522 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
22523 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
22524 (!dwarf_split_debug_info ? debug_line_section_label
22525 : debug_skeleton_line_section_label),
22526 debug_line_section, NULL);
22529 /* In the first loop, it emits the primary .debug_macinfo section
22530 and after each emitted op the macinfo_entry is cleared.
22531 If a longer range of define/undef ops can be optimized using
22532 DW_MACRO_GNU_transparent_include, the
22533 DW_MACRO_GNU_transparent_include op is emitted and kept in
22534 the vector before the first define/undef in the range and the
22535 whole range of define/undef ops is not emitted and kept. */
22536 for (i = 0; macinfo_table->iterate (i, &ref); i++)
22540 case DW_MACINFO_start_file:
22541 vec_safe_push (files, *ref);
22543 case DW_MACINFO_end_file:
22544 if (!vec_safe_is_empty (files))
22547 case DW_MACINFO_define:
22548 case DW_MACINFO_undef:
22550 && HAVE_COMDAT_GROUP
22551 && vec_safe_length (files) != 1
22554 && (*macinfo_table)[i - 1].code == 0)
22556 unsigned count = optimize_macinfo_range (i, files, &macinfo_htab);
22565 /* A dummy entry may be inserted at the beginning to be able
22566 to optimize the whole block of predefined macros. */
22572 output_macinfo_op (ref);
22580 delete macinfo_htab;
22581 macinfo_htab = NULL;
22583 /* If any DW_MACRO_GNU_transparent_include were used, on those
22584 DW_MACRO_GNU_transparent_include entries terminate the
22585 current chain and switch to a new comdat .debug_macinfo
22586 section and emit the define/undef entries within it. */
22587 for (i = 0; macinfo_table->iterate (i, &ref); i++)
22592 case DW_MACRO_GNU_transparent_include:
22594 char label[MAX_ARTIFICIAL_LABEL_BYTES];
22595 tree comdat_key = get_identifier (ref->info);
22596 /* Terminate the previous .debug_macinfo section. */
22597 dw2_asm_output_data (1, 0, "End compilation unit");
22598 targetm.asm_out.named_section (DEBUG_MACRO_SECTION,
22600 | SECTION_LINKONCE,
22602 ASM_GENERATE_INTERNAL_LABEL (label,
22603 DEBUG_MACRO_SECTION_LABEL,
22605 ASM_OUTPUT_LABEL (asm_out_file, label);
22608 dw2_asm_output_data (2, 4, "DWARF macro version number");
22609 if (DWARF_OFFSET_SIZE == 8)
22610 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22612 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22615 case DW_MACINFO_define:
22616 case DW_MACINFO_undef:
22617 output_macinfo_op (ref);
22622 gcc_unreachable ();
22626 /* Set up for Dwarf output at the start of compilation. */
22629 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
22631 /* This option is currently broken, see (PR53118 and PR46102). */
22632 if (flag_eliminate_dwarf2_dups
22633 && strstr (lang_hooks.name, "C++"))
22635 warning (0, "-feliminate-dwarf2-dups is broken for C++, ignoring");
22636 flag_eliminate_dwarf2_dups = 0;
22639 /* Allocate the file_table. */
22640 file_table = hash_table<dwarf_file_hasher>::create_ggc (50);
22642 /* Allocate the decl_die_table. */
22643 decl_die_table = hash_table<decl_die_hasher>::create_ggc (10);
22645 /* Allocate the decl_loc_table. */
22646 decl_loc_table = hash_table<decl_loc_hasher>::create_ggc (10);
22648 /* Allocate the cached_dw_loc_list_table. */
22649 cached_dw_loc_list_table = hash_table<dw_loc_list_hasher>::create_ggc (10);
22651 /* Allocate the initial hunk of the decl_scope_table. */
22652 vec_alloc (decl_scope_table, 256);
22654 /* Allocate the initial hunk of the abbrev_die_table. */
22655 abbrev_die_table = ggc_cleared_vec_alloc<dw_die_ref>
22656 (ABBREV_DIE_TABLE_INCREMENT);
22657 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
22658 /* Zero-th entry is allocated, but unused. */
22659 abbrev_die_table_in_use = 1;
22661 /* Allocate the pubtypes and pubnames vectors. */
22662 vec_alloc (pubname_table, 32);
22663 vec_alloc (pubtype_table, 32);
22665 vec_alloc (incomplete_types, 64);
22667 vec_alloc (used_rtx_array, 32);
22669 if (!dwarf_split_debug_info)
22671 debug_info_section = get_section (DEBUG_INFO_SECTION,
22672 SECTION_DEBUG, NULL);
22673 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
22674 SECTION_DEBUG, NULL);
22675 debug_loc_section = get_section (DEBUG_LOC_SECTION,
22676 SECTION_DEBUG, NULL);
22680 debug_info_section = get_section (DEBUG_DWO_INFO_SECTION,
22681 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22682 debug_abbrev_section = get_section (DEBUG_DWO_ABBREV_SECTION,
22683 SECTION_DEBUG | SECTION_EXCLUDE,
22685 debug_addr_section = get_section (DEBUG_ADDR_SECTION,
22686 SECTION_DEBUG, NULL);
22687 debug_skeleton_info_section = get_section (DEBUG_INFO_SECTION,
22688 SECTION_DEBUG, NULL);
22689 debug_skeleton_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
22690 SECTION_DEBUG, NULL);
22691 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label,
22692 DEBUG_SKELETON_ABBREV_SECTION_LABEL, 0);
22694 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22695 the main .o, but the skeleton_line goes into the split off dwo. */
22696 debug_skeleton_line_section
22697 = get_section (DEBUG_DWO_LINE_SECTION,
22698 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22699 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label,
22700 DEBUG_SKELETON_LINE_SECTION_LABEL, 0);
22701 debug_str_offsets_section = get_section (DEBUG_STR_OFFSETS_SECTION,
22702 SECTION_DEBUG | SECTION_EXCLUDE,
22704 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label,
22705 DEBUG_SKELETON_INFO_SECTION_LABEL, 0);
22706 debug_loc_section = get_section (DEBUG_DWO_LOC_SECTION,
22707 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22708 debug_str_dwo_section = get_section (DEBUG_STR_DWO_SECTION,
22709 DEBUG_STR_DWO_SECTION_FLAGS, NULL);
22711 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
22712 SECTION_DEBUG, NULL);
22713 debug_macinfo_section = get_section (dwarf_strict
22714 ? DEBUG_MACINFO_SECTION
22715 : DEBUG_MACRO_SECTION,
22716 DEBUG_MACRO_SECTION_FLAGS, NULL);
22717 debug_line_section = get_section (DEBUG_LINE_SECTION,
22718 SECTION_DEBUG, NULL);
22719 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
22720 SECTION_DEBUG, NULL);
22721 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
22722 SECTION_DEBUG, NULL);
22723 debug_str_section = get_section (DEBUG_STR_SECTION,
22724 DEBUG_STR_SECTION_FLAGS, NULL);
22725 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
22726 SECTION_DEBUG, NULL);
22727 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
22728 SECTION_DEBUG, NULL);
22730 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
22731 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
22732 DEBUG_ABBREV_SECTION_LABEL, 0);
22733 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
22734 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
22735 COLD_TEXT_SECTION_LABEL, 0);
22736 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
22738 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
22739 DEBUG_INFO_SECTION_LABEL, 0);
22740 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
22741 DEBUG_LINE_SECTION_LABEL, 0);
22742 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
22743 DEBUG_RANGES_SECTION_LABEL, 0);
22744 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label,
22745 DEBUG_ADDR_SECTION_LABEL, 0);
22746 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
22748 ? DEBUG_MACINFO_SECTION_LABEL
22749 : DEBUG_MACRO_SECTION_LABEL, 0);
22750 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, DEBUG_LOC_SECTION_LABEL, 0);
22752 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22753 vec_alloc (macinfo_table, 64);
22755 switch_to_section (text_section);
22756 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
22758 /* Make sure the line number table for .text always exists. */
22759 text_section_line_info = new_line_info_table ();
22760 text_section_line_info->end_label = text_end_label;
22763 /* Called before compile () starts outputtting functions, variables
22764 and toplevel asms into assembly. */
22767 dwarf2out_assembly_start (void)
22769 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22770 && dwarf2out_do_cfi_asm ()
22771 && (!(flag_unwind_tables || flag_exceptions)
22772 || targetm_common.except_unwind_info (&global_options) != UI_DWARF2))
22773 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
22776 /* A helper function for dwarf2out_finish called through
22777 htab_traverse. Assign a string its index. All strings must be
22778 collected into the table by the time index_string is called,
22779 because the indexing code relies on htab_traverse to traverse nodes
22780 in the same order for each run. */
22783 index_string (indirect_string_node **h, unsigned int *index)
22785 indirect_string_node *node = *h;
22787 find_string_form (node);
22788 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22790 gcc_assert (node->index == NO_INDEX_ASSIGNED);
22791 node->index = *index;
22797 /* A helper function for output_indirect_strings called through
22798 htab_traverse. Output the offset to a string and update the
22802 output_index_string_offset (indirect_string_node **h, unsigned int *offset)
22804 indirect_string_node *node = *h;
22806 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22808 /* Assert that this node has been assigned an index. */
22809 gcc_assert (node->index != NO_INDEX_ASSIGNED
22810 && node->index != NOT_INDEXED);
22811 dw2_asm_output_data (DWARF_OFFSET_SIZE, *offset,
22812 "indexed string 0x%x: %s", node->index, node->str);
22813 *offset += strlen (node->str) + 1;
22818 /* A helper function for dwarf2out_finish called through
22819 htab_traverse. Output the indexed string. */
22822 output_index_string (indirect_string_node **h, unsigned int *cur_idx)
22824 struct indirect_string_node *node = *h;
22826 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22828 /* Assert that the strings are output in the same order as their
22829 indexes were assigned. */
22830 gcc_assert (*cur_idx == node->index);
22831 assemble_string (node->str, strlen (node->str) + 1);
22837 /* A helper function for dwarf2out_finish called through
22838 htab_traverse. Emit one queued .debug_str string. */
22841 output_indirect_string (indirect_string_node **h, void *)
22843 struct indirect_string_node *node = *h;
22845 node->form = find_string_form (node);
22846 if (node->form == DW_FORM_strp && node->refcount > 0)
22848 ASM_OUTPUT_LABEL (asm_out_file, node->label);
22849 assemble_string (node->str, strlen (node->str) + 1);
22855 /* Output the indexed string table. */
22858 output_indirect_strings (void)
22860 switch_to_section (debug_str_section);
22861 if (!dwarf_split_debug_info)
22862 debug_str_hash->traverse<void *, output_indirect_string> (NULL);
22865 unsigned int offset = 0;
22866 unsigned int cur_idx = 0;
22868 skeleton_debug_str_hash->traverse<void *, output_indirect_string> (NULL);
22870 switch_to_section (debug_str_offsets_section);
22871 debug_str_hash->traverse_noresize
22872 <unsigned int *, output_index_string_offset> (&offset);
22873 switch_to_section (debug_str_dwo_section);
22874 debug_str_hash->traverse_noresize<unsigned int *, output_index_string>
22879 /* Callback for htab_traverse to assign an index to an entry in the
22880 table, and to write that entry to the .debug_addr section. */
22883 output_addr_table_entry (addr_table_entry **slot, unsigned int *cur_index)
22885 addr_table_entry *entry = *slot;
22887 if (entry->refcount == 0)
22889 gcc_assert (entry->index == NO_INDEX_ASSIGNED
22890 || entry->index == NOT_INDEXED);
22894 gcc_assert (entry->index == *cur_index);
22897 switch (entry->kind)
22900 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, entry->addr.rtl,
22901 "0x%x", entry->index);
22903 case ate_kind_rtx_dtprel:
22904 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
22905 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
22908 fputc ('\n', asm_out_file);
22910 case ate_kind_label:
22911 dw2_asm_output_addr (DWARF2_ADDR_SIZE, entry->addr.label,
22912 "0x%x", entry->index);
22915 gcc_unreachable ();
22920 /* Produce the .debug_addr section. */
22923 output_addr_table (void)
22925 unsigned int index = 0;
22926 if (addr_index_table == NULL || addr_index_table->size () == 0)
22929 switch_to_section (debug_addr_section);
22931 ->traverse_noresize<unsigned int *, output_addr_table_entry> (&index);
22934 #if ENABLE_ASSERT_CHECKING
22935 /* Verify that all marks are clear. */
22938 verify_marks_clear (dw_die_ref die)
22942 gcc_assert (! die->die_mark);
22943 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
22945 #endif /* ENABLE_ASSERT_CHECKING */
22947 /* Clear the marks for a die and its children.
22948 Be cool if the mark isn't set. */
22951 prune_unmark_dies (dw_die_ref die)
22957 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
22960 /* Given DIE that we're marking as used, find any other dies
22961 it references as attributes and mark them as used. */
22964 prune_unused_types_walk_attribs (dw_die_ref die)
22969 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
22971 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
22973 /* A reference to another DIE.
22974 Make sure that it will get emitted.
22975 If it was broken out into a comdat group, don't follow it. */
22976 if (! AT_ref (a)->comdat_type_p
22977 || a->dw_attr == DW_AT_specification)
22978 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
22980 /* Set the string's refcount to 0 so that prune_unused_types_mark
22981 accounts properly for it. */
22982 if (AT_class (a) == dw_val_class_str)
22983 a->dw_attr_val.v.val_str->refcount = 0;
22987 /* Mark the generic parameters and arguments children DIEs of DIE. */
22990 prune_unused_types_mark_generic_parms_dies (dw_die_ref die)
22994 if (die == NULL || die->die_child == NULL)
22996 c = die->die_child;
22999 if (is_template_parameter (c))
23000 prune_unused_types_mark (c, 1);
23002 } while (c && c != die->die_child);
23005 /* Mark DIE as being used. If DOKIDS is true, then walk down
23006 to DIE's children. */
23009 prune_unused_types_mark (dw_die_ref die, int dokids)
23013 if (die->die_mark == 0)
23015 /* We haven't done this node yet. Mark it as used. */
23017 /* If this is the DIE of a generic type instantiation,
23018 mark the children DIEs that describe its generic parms and
23020 prune_unused_types_mark_generic_parms_dies (die);
23022 /* We also have to mark its parents as used.
23023 (But we don't want to mark our parent's kids due to this,
23024 unless it is a class.) */
23025 if (die->die_parent)
23026 prune_unused_types_mark (die->die_parent,
23027 class_scope_p (die->die_parent));
23029 /* Mark any referenced nodes. */
23030 prune_unused_types_walk_attribs (die);
23032 /* If this node is a specification,
23033 also mark the definition, if it exists. */
23034 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
23035 prune_unused_types_mark (die->die_definition, 1);
23038 if (dokids && die->die_mark != 2)
23040 /* We need to walk the children, but haven't done so yet.
23041 Remember that we've walked the kids. */
23044 /* If this is an array type, we need to make sure our
23045 kids get marked, even if they're types. If we're
23046 breaking out types into comdat sections, do this
23047 for all type definitions. */
23048 if (die->die_tag == DW_TAG_array_type
23049 || (use_debug_types
23050 && is_type_die (die) && ! is_declaration_die (die)))
23051 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
23053 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23057 /* For local classes, look if any static member functions were emitted
23058 and if so, mark them. */
23061 prune_unused_types_walk_local_classes (dw_die_ref die)
23065 if (die->die_mark == 2)
23068 switch (die->die_tag)
23070 case DW_TAG_structure_type:
23071 case DW_TAG_union_type:
23072 case DW_TAG_class_type:
23075 case DW_TAG_subprogram:
23076 if (!get_AT_flag (die, DW_AT_declaration)
23077 || die->die_definition != NULL)
23078 prune_unused_types_mark (die, 1);
23085 /* Mark children. */
23086 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
23089 /* Walk the tree DIE and mark types that we actually use. */
23092 prune_unused_types_walk (dw_die_ref die)
23096 /* Don't do anything if this node is already marked and
23097 children have been marked as well. */
23098 if (die->die_mark == 2)
23101 switch (die->die_tag)
23103 case DW_TAG_structure_type:
23104 case DW_TAG_union_type:
23105 case DW_TAG_class_type:
23106 if (die->die_perennial_p)
23109 for (c = die->die_parent; c; c = c->die_parent)
23110 if (c->die_tag == DW_TAG_subprogram)
23113 /* Finding used static member functions inside of classes
23114 is needed just for local classes, because for other classes
23115 static member function DIEs with DW_AT_specification
23116 are emitted outside of the DW_TAG_*_type. If we ever change
23117 it, we'd need to call this even for non-local classes. */
23119 prune_unused_types_walk_local_classes (die);
23121 /* It's a type node --- don't mark it. */
23124 case DW_TAG_const_type:
23125 case DW_TAG_packed_type:
23126 case DW_TAG_pointer_type:
23127 case DW_TAG_reference_type:
23128 case DW_TAG_rvalue_reference_type:
23129 case DW_TAG_volatile_type:
23130 case DW_TAG_typedef:
23131 case DW_TAG_array_type:
23132 case DW_TAG_interface_type:
23133 case DW_TAG_friend:
23134 case DW_TAG_variant_part:
23135 case DW_TAG_enumeration_type:
23136 case DW_TAG_subroutine_type:
23137 case DW_TAG_string_type:
23138 case DW_TAG_set_type:
23139 case DW_TAG_subrange_type:
23140 case DW_TAG_ptr_to_member_type:
23141 case DW_TAG_file_type:
23142 if (die->die_perennial_p)
23145 /* It's a type node --- don't mark it. */
23149 /* Mark everything else. */
23153 if (die->die_mark == 0)
23157 /* Now, mark any dies referenced from here. */
23158 prune_unused_types_walk_attribs (die);
23163 /* Mark children. */
23164 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23167 /* Increment the string counts on strings referred to from DIE's
23171 prune_unused_types_update_strings (dw_die_ref die)
23176 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
23177 if (AT_class (a) == dw_val_class_str)
23179 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
23181 /* Avoid unnecessarily putting strings that are used less than
23182 twice in the hash table. */
23184 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
23186 indirect_string_node **slot
23187 = debug_str_hash->find_slot_with_hash (s->str,
23188 htab_hash_string (s->str),
23190 gcc_assert (*slot == NULL);
23196 /* Remove from the tree DIE any dies that aren't marked. */
23199 prune_unused_types_prune (dw_die_ref die)
23203 gcc_assert (die->die_mark);
23204 prune_unused_types_update_strings (die);
23206 if (! die->die_child)
23209 c = die->die_child;
23211 dw_die_ref prev = c;
23212 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
23213 if (c == die->die_child)
23215 /* No marked children between 'prev' and the end of the list. */
23217 /* No marked children at all. */
23218 die->die_child = NULL;
23221 prev->die_sib = c->die_sib;
23222 die->die_child = prev;
23227 if (c != prev->die_sib)
23229 prune_unused_types_prune (c);
23230 } while (c != die->die_child);
23233 /* Remove dies representing declarations that we never use. */
23236 prune_unused_types (void)
23239 limbo_die_node *node;
23240 comdat_type_node *ctnode;
23242 dw_die_ref base_type;
23244 #if ENABLE_ASSERT_CHECKING
23245 /* All the marks should already be clear. */
23246 verify_marks_clear (comp_unit_die ());
23247 for (node = limbo_die_list; node; node = node->next)
23248 verify_marks_clear (node->die);
23249 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23250 verify_marks_clear (ctnode->root_die);
23251 #endif /* ENABLE_ASSERT_CHECKING */
23253 /* Mark types that are used in global variables. */
23254 premark_types_used_by_global_vars ();
23256 /* Set the mark on nodes that are actually used. */
23257 prune_unused_types_walk (comp_unit_die ());
23258 for (node = limbo_die_list; node; node = node->next)
23259 prune_unused_types_walk (node->die);
23260 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23262 prune_unused_types_walk (ctnode->root_die);
23263 prune_unused_types_mark (ctnode->type_die, 1);
23266 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
23267 are unusual in that they are pubnames that are the children of pubtypes.
23268 They should only be marked via their parent DW_TAG_enumeration_type die,
23269 not as roots in themselves. */
23270 FOR_EACH_VEC_ELT (*pubname_table, i, pub)
23271 if (pub->die->die_tag != DW_TAG_enumerator)
23272 prune_unused_types_mark (pub->die, 1);
23273 for (i = 0; base_types.iterate (i, &base_type); i++)
23274 prune_unused_types_mark (base_type, 1);
23276 if (debug_str_hash)
23277 debug_str_hash->empty ();
23278 if (skeleton_debug_str_hash)
23279 skeleton_debug_str_hash->empty ();
23280 prune_unused_types_prune (comp_unit_die ());
23281 for (node = limbo_die_list; node; node = node->next)
23282 prune_unused_types_prune (node->die);
23283 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23284 prune_unused_types_prune (ctnode->root_die);
23286 /* Leave the marks clear. */
23287 prune_unmark_dies (comp_unit_die ());
23288 for (node = limbo_die_list; node; node = node->next)
23289 prune_unmark_dies (node->die);
23290 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23291 prune_unmark_dies (ctnode->root_die);
23294 /* Set the parameter to true if there are any relative pathnames in
23297 file_table_relative_p (dwarf_file_data **slot, bool *p)
23299 struct dwarf_file_data *d = *slot;
23300 if (!IS_ABSOLUTE_PATH (d->filename))
23308 /* Helpers to manipulate hash table of comdat type units. */
23310 struct comdat_type_hasher : typed_noop_remove <comdat_type_node>
23312 typedef comdat_type_node *value_type;
23313 typedef comdat_type_node *compare_type;
23314 static inline hashval_t hash (const comdat_type_node *);
23315 static inline bool equal (const comdat_type_node *, const comdat_type_node *);
23319 comdat_type_hasher::hash (const comdat_type_node *type_node)
23322 memcpy (&h, type_node->signature, sizeof (h));
23327 comdat_type_hasher::equal (const comdat_type_node *type_node_1,
23328 const comdat_type_node *type_node_2)
23330 return (! memcmp (type_node_1->signature, type_node_2->signature,
23331 DWARF_TYPE_SIGNATURE_SIZE));
23334 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
23335 to the location it would have been added, should we know its
23336 DECL_ASSEMBLER_NAME when we added other attributes. This will
23337 probably improve compactness of debug info, removing equivalent
23338 abbrevs, and hide any differences caused by deferring the
23339 computation of the assembler name, triggered by e.g. PCH. */
23342 move_linkage_attr (dw_die_ref die)
23344 unsigned ix = vec_safe_length (die->die_attr);
23345 dw_attr_node linkage = (*die->die_attr)[ix - 1];
23347 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
23348 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
23352 dw_attr_node *prev = &(*die->die_attr)[ix - 1];
23354 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
23358 if (ix != vec_safe_length (die->die_attr) - 1)
23360 die->die_attr->pop ();
23361 die->die_attr->quick_insert (ix, linkage);
23365 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
23366 referenced from typed stack ops and count how often they are used. */
23369 mark_base_types (dw_loc_descr_ref loc)
23371 dw_die_ref base_type = NULL;
23373 for (; loc; loc = loc->dw_loc_next)
23375 switch (loc->dw_loc_opc)
23377 case DW_OP_GNU_regval_type:
23378 case DW_OP_GNU_deref_type:
23379 base_type = loc->dw_loc_oprnd2.v.val_die_ref.die;
23381 case DW_OP_GNU_convert:
23382 case DW_OP_GNU_reinterpret:
23383 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
23386 case DW_OP_GNU_const_type:
23387 base_type = loc->dw_loc_oprnd1.v.val_die_ref.die;
23389 case DW_OP_GNU_entry_value:
23390 mark_base_types (loc->dw_loc_oprnd1.v.val_loc);
23395 gcc_assert (base_type->die_parent == comp_unit_die ());
23396 if (base_type->die_mark)
23397 base_type->die_mark++;
23400 base_types.safe_push (base_type);
23401 base_type->die_mark = 1;
23406 /* Comparison function for sorting marked base types. */
23409 base_type_cmp (const void *x, const void *y)
23411 dw_die_ref dx = *(const dw_die_ref *) x;
23412 dw_die_ref dy = *(const dw_die_ref *) y;
23413 unsigned int byte_size1, byte_size2;
23414 unsigned int encoding1, encoding2;
23415 if (dx->die_mark > dy->die_mark)
23417 if (dx->die_mark < dy->die_mark)
23419 byte_size1 = get_AT_unsigned (dx, DW_AT_byte_size);
23420 byte_size2 = get_AT_unsigned (dy, DW_AT_byte_size);
23421 if (byte_size1 < byte_size2)
23423 if (byte_size1 > byte_size2)
23425 encoding1 = get_AT_unsigned (dx, DW_AT_encoding);
23426 encoding2 = get_AT_unsigned (dy, DW_AT_encoding);
23427 if (encoding1 < encoding2)
23429 if (encoding1 > encoding2)
23434 /* Move base types marked by mark_base_types as early as possible
23435 in the CU, sorted by decreasing usage count both to make the
23436 uleb128 references as small as possible and to make sure they
23437 will have die_offset already computed by calc_die_sizes when
23438 sizes of typed stack loc ops is computed. */
23441 move_marked_base_types (void)
23444 dw_die_ref base_type, die, c;
23446 if (base_types.is_empty ())
23449 /* Sort by decreasing usage count, they will be added again in that
23451 base_types.qsort (base_type_cmp);
23452 die = comp_unit_die ();
23453 c = die->die_child;
23456 dw_die_ref prev = c;
23458 while (c->die_mark)
23460 remove_child_with_prev (c, prev);
23461 /* As base types got marked, there must be at least
23462 one node other than DW_TAG_base_type. */
23463 gcc_assert (c != c->die_sib);
23467 while (c != die->die_child);
23468 gcc_assert (die->die_child);
23469 c = die->die_child;
23470 for (i = 0; base_types.iterate (i, &base_type); i++)
23472 base_type->die_mark = 0;
23473 base_type->die_sib = c->die_sib;
23474 c->die_sib = base_type;
23479 /* Helper function for resolve_addr, attempt to resolve
23480 one CONST_STRING, return true if successful. Similarly verify that
23481 SYMBOL_REFs refer to variables emitted in the current CU. */
23484 resolve_one_addr (rtx *addr)
23488 if (GET_CODE (rtl) == CONST_STRING)
23490 size_t len = strlen (XSTR (rtl, 0)) + 1;
23491 tree t = build_string (len, XSTR (rtl, 0));
23492 tree tlen = size_int (len - 1);
23494 = build_array_type (char_type_node, build_index_type (tlen));
23495 rtl = lookup_constant_def (t);
23496 if (!rtl || !MEM_P (rtl))
23498 rtl = XEXP (rtl, 0);
23499 if (GET_CODE (rtl) == SYMBOL_REF
23500 && SYMBOL_REF_DECL (rtl)
23501 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
23503 vec_safe_push (used_rtx_array, rtl);
23508 if (GET_CODE (rtl) == SYMBOL_REF
23509 && SYMBOL_REF_DECL (rtl))
23511 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl))
23513 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl))))
23516 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
23520 if (GET_CODE (rtl) == CONST)
23522 subrtx_ptr_iterator::array_type array;
23523 FOR_EACH_SUBRTX_PTR (iter, array, &XEXP (rtl, 0), ALL)
23524 if (!resolve_one_addr (*iter))
23531 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
23532 if possible, and create DW_TAG_dwarf_procedure that can be referenced
23533 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
23536 string_cst_pool_decl (tree t)
23538 rtx rtl = output_constant_def (t, 1);
23539 unsigned char *array;
23540 dw_loc_descr_ref l;
23545 if (!rtl || !MEM_P (rtl))
23547 rtl = XEXP (rtl, 0);
23548 if (GET_CODE (rtl) != SYMBOL_REF
23549 || SYMBOL_REF_DECL (rtl) == NULL_TREE)
23552 decl = SYMBOL_REF_DECL (rtl);
23553 if (!lookup_decl_die (decl))
23555 len = TREE_STRING_LENGTH (t);
23556 vec_safe_push (used_rtx_array, rtl);
23557 ref = new_die (DW_TAG_dwarf_procedure, comp_unit_die (), decl);
23558 array = ggc_vec_alloc<unsigned char> (len);
23559 memcpy (array, TREE_STRING_POINTER (t), len);
23560 l = new_loc_descr (DW_OP_implicit_value, len, 0);
23561 l->dw_loc_oprnd2.val_class = dw_val_class_vec;
23562 l->dw_loc_oprnd2.v.val_vec.length = len;
23563 l->dw_loc_oprnd2.v.val_vec.elt_size = 1;
23564 l->dw_loc_oprnd2.v.val_vec.array = array;
23565 add_AT_loc (ref, DW_AT_location, l);
23566 equate_decl_number_to_die (decl, ref);
23571 /* Helper function of resolve_addr_in_expr. LOC is
23572 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23573 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23574 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23575 with DW_OP_GNU_implicit_pointer if possible
23576 and return true, if unsuccessful, return false. */
23579 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc)
23581 rtx rtl = loc->dw_loc_oprnd1.v.val_addr;
23582 HOST_WIDE_INT offset = 0;
23583 dw_die_ref ref = NULL;
23586 if (GET_CODE (rtl) == CONST
23587 && GET_CODE (XEXP (rtl, 0)) == PLUS
23588 && CONST_INT_P (XEXP (XEXP (rtl, 0), 1)))
23590 offset = INTVAL (XEXP (XEXP (rtl, 0), 1));
23591 rtl = XEXP (XEXP (rtl, 0), 0);
23593 if (GET_CODE (rtl) == CONST_STRING)
23595 size_t len = strlen (XSTR (rtl, 0)) + 1;
23596 tree t = build_string (len, XSTR (rtl, 0));
23597 tree tlen = size_int (len - 1);
23600 = build_array_type (char_type_node, build_index_type (tlen));
23601 rtl = string_cst_pool_decl (t);
23605 if (GET_CODE (rtl) == SYMBOL_REF && SYMBOL_REF_DECL (rtl))
23607 decl = SYMBOL_REF_DECL (rtl);
23608 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
23610 ref = lookup_decl_die (decl);
23611 if (ref && (get_AT (ref, DW_AT_location)
23612 || get_AT (ref, DW_AT_const_value)))
23614 loc->dw_loc_opc = DW_OP_GNU_implicit_pointer;
23615 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23616 loc->dw_loc_oprnd1.val_entry = NULL;
23617 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
23618 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
23619 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
23620 loc->dw_loc_oprnd2.v.val_int = offset;
23628 /* Helper function for resolve_addr, handle one location
23629 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23630 the location list couldn't be resolved. */
23633 resolve_addr_in_expr (dw_loc_descr_ref loc)
23635 dw_loc_descr_ref keep = NULL;
23636 for (dw_loc_descr_ref prev = NULL; loc; prev = loc, loc = loc->dw_loc_next)
23637 switch (loc->dw_loc_opc)
23640 if (!resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
23643 || prev->dw_loc_opc == DW_OP_piece
23644 || prev->dw_loc_opc == DW_OP_bit_piece)
23645 && loc->dw_loc_next
23646 && loc->dw_loc_next->dw_loc_opc == DW_OP_stack_value
23648 && optimize_one_addr_into_implicit_ptr (loc))
23653 case DW_OP_GNU_addr_index:
23654 case DW_OP_GNU_const_index:
23655 if (loc->dw_loc_opc == DW_OP_GNU_addr_index
23656 || (loc->dw_loc_opc == DW_OP_GNU_const_index && loc->dtprel))
23658 rtx rtl = loc->dw_loc_oprnd1.val_entry->addr.rtl;
23659 if (!resolve_one_addr (&rtl))
23661 remove_addr_table_entry (loc->dw_loc_oprnd1.val_entry);
23662 loc->dw_loc_oprnd1.val_entry =
23663 add_addr_table_entry (rtl, ate_kind_rtx);
23666 case DW_OP_const4u:
23667 case DW_OP_const8u:
23669 && !resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
23672 case DW_OP_plus_uconst:
23673 if (size_of_loc_descr (loc)
23674 > size_of_int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned)
23676 && loc->dw_loc_oprnd1.v.val_unsigned > 0)
23678 dw_loc_descr_ref repl
23679 = int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned);
23680 add_loc_descr (&repl, new_loc_descr (DW_OP_plus, 0, 0));
23681 add_loc_descr (&repl, loc->dw_loc_next);
23685 case DW_OP_implicit_value:
23686 if (loc->dw_loc_oprnd2.val_class == dw_val_class_addr
23687 && !resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr))
23690 case DW_OP_GNU_implicit_pointer:
23691 case DW_OP_GNU_parameter_ref:
23692 if (loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
23695 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
23698 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23699 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
23700 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
23703 case DW_OP_GNU_const_type:
23704 case DW_OP_GNU_regval_type:
23705 case DW_OP_GNU_deref_type:
23706 case DW_OP_GNU_convert:
23707 case DW_OP_GNU_reinterpret:
23708 while (loc->dw_loc_next
23709 && loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_convert)
23711 dw_die_ref base1, base2;
23712 unsigned enc1, enc2, size1, size2;
23713 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
23714 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
23715 base1 = loc->dw_loc_oprnd2.v.val_die_ref.die;
23716 else if (loc->dw_loc_oprnd1.val_class
23717 == dw_val_class_unsigned_const)
23720 base1 = loc->dw_loc_oprnd1.v.val_die_ref.die;
23721 if (loc->dw_loc_next->dw_loc_oprnd1.val_class
23722 == dw_val_class_unsigned_const)
23724 base2 = loc->dw_loc_next->dw_loc_oprnd1.v.val_die_ref.die;
23725 gcc_assert (base1->die_tag == DW_TAG_base_type
23726 && base2->die_tag == DW_TAG_base_type);
23727 enc1 = get_AT_unsigned (base1, DW_AT_encoding);
23728 enc2 = get_AT_unsigned (base2, DW_AT_encoding);
23729 size1 = get_AT_unsigned (base1, DW_AT_byte_size);
23730 size2 = get_AT_unsigned (base2, DW_AT_byte_size);
23732 && (((enc1 == DW_ATE_unsigned || enc1 == DW_ATE_signed)
23733 && (enc2 == DW_ATE_unsigned || enc2 == DW_ATE_signed)
23737 /* Optimize away next DW_OP_GNU_convert after
23738 adjusting LOC's base type die reference. */
23739 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
23740 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
23741 loc->dw_loc_oprnd2.v.val_die_ref.die = base2;
23743 loc->dw_loc_oprnd1.v.val_die_ref.die = base2;
23744 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
23747 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23748 point typed stack entry. */
23749 else if (enc1 != DW_ATE_unsigned && enc1 != DW_ATE_signed)
23750 keep = loc->dw_loc_next;
23760 /* Helper function of resolve_addr. DIE had DW_AT_location of
23761 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23762 and DW_OP_addr couldn't be resolved. resolve_addr has already
23763 removed the DW_AT_location attribute. This function attempts to
23764 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23765 to it or DW_AT_const_value attribute, if possible. */
23768 optimize_location_into_implicit_ptr (dw_die_ref die, tree decl)
23770 if (TREE_CODE (decl) != VAR_DECL
23771 || lookup_decl_die (decl) != die
23772 || DECL_EXTERNAL (decl)
23773 || !TREE_STATIC (decl)
23774 || DECL_INITIAL (decl) == NULL_TREE
23775 || DECL_P (DECL_INITIAL (decl))
23776 || get_AT (die, DW_AT_const_value))
23779 tree init = DECL_INITIAL (decl);
23780 HOST_WIDE_INT offset = 0;
23781 /* For variables that have been optimized away and thus
23782 don't have a memory location, see if we can emit
23783 DW_AT_const_value instead. */
23784 if (tree_add_const_value_attribute (die, init))
23788 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23789 and ADDR_EXPR refers to a decl that has DW_AT_location or
23790 DW_AT_const_value (but isn't addressable, otherwise
23791 resolving the original DW_OP_addr wouldn't fail), see if
23792 we can add DW_OP_GNU_implicit_pointer. */
23794 if (TREE_CODE (init) == POINTER_PLUS_EXPR
23795 && tree_fits_shwi_p (TREE_OPERAND (init, 1)))
23797 offset = tree_to_shwi (TREE_OPERAND (init, 1));
23798 init = TREE_OPERAND (init, 0);
23801 if (TREE_CODE (init) != ADDR_EXPR)
23803 if ((TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST
23804 && !TREE_ASM_WRITTEN (TREE_OPERAND (init, 0)))
23805 || (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL
23806 && !DECL_EXTERNAL (TREE_OPERAND (init, 0))
23807 && TREE_OPERAND (init, 0) != decl))
23810 dw_loc_descr_ref l;
23812 if (TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST)
23814 rtx rtl = string_cst_pool_decl (TREE_OPERAND (init, 0));
23817 decl = SYMBOL_REF_DECL (rtl);
23820 decl = TREE_OPERAND (init, 0);
23821 ref = lookup_decl_die (decl);
23823 || (!get_AT (ref, DW_AT_location)
23824 && !get_AT (ref, DW_AT_const_value)))
23826 l = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
23827 l->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23828 l->dw_loc_oprnd1.v.val_die_ref.die = ref;
23829 l->dw_loc_oprnd1.v.val_die_ref.external = 0;
23830 add_AT_loc (die, DW_AT_location, l);
23834 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23835 an address in .rodata section if the string literal is emitted there,
23836 or remove the containing location list or replace DW_AT_const_value
23837 with DW_AT_location and empty location expression, if it isn't found
23838 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23839 to something that has been emitted in the current CU. */
23842 resolve_addr (dw_die_ref die)
23846 dw_loc_list_ref *curr, *start, loc;
23849 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
23850 switch (AT_class (a))
23852 case dw_val_class_loc_list:
23853 start = curr = AT_loc_list_ptr (a);
23856 /* The same list can be referenced more than once. See if we have
23857 already recorded the result from a previous pass. */
23859 *curr = loc->dw_loc_next;
23860 else if (!loc->resolved_addr)
23862 /* As things stand, we do not expect or allow one die to
23863 reference a suffix of another die's location list chain.
23864 References must be identical or completely separate.
23865 There is therefore no need to cache the result of this
23866 pass on any list other than the first; doing so
23867 would lead to unnecessary writes. */
23870 gcc_assert (!(*curr)->replaced && !(*curr)->resolved_addr);
23871 if (!resolve_addr_in_expr ((*curr)->expr))
23873 dw_loc_list_ref next = (*curr)->dw_loc_next;
23874 dw_loc_descr_ref l = (*curr)->expr;
23876 if (next && (*curr)->ll_symbol)
23878 gcc_assert (!next->ll_symbol);
23879 next->ll_symbol = (*curr)->ll_symbol;
23881 if (dwarf_split_debug_info)
23882 remove_loc_list_addr_table_entries (l);
23887 mark_base_types ((*curr)->expr);
23888 curr = &(*curr)->dw_loc_next;
23892 loc->resolved_addr = 1;
23896 loc->dw_loc_next = *start;
23901 remove_AT (die, a->dw_attr);
23905 case dw_val_class_loc:
23907 dw_loc_descr_ref l = AT_loc (a);
23908 /* For -gdwarf-2 don't attempt to optimize
23909 DW_AT_data_member_location containing
23910 DW_OP_plus_uconst - older consumers might
23911 rely on it being that op instead of a more complex,
23912 but shorter, location description. */
23913 if ((dwarf_version > 2
23914 || a->dw_attr != DW_AT_data_member_location
23916 || l->dw_loc_opc != DW_OP_plus_uconst
23917 || l->dw_loc_next != NULL)
23918 && !resolve_addr_in_expr (l))
23920 if (dwarf_split_debug_info)
23921 remove_loc_list_addr_table_entries (l);
23923 && l->dw_loc_next == NULL
23924 && l->dw_loc_opc == DW_OP_addr
23925 && GET_CODE (l->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF
23926 && SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr)
23927 && a->dw_attr == DW_AT_location)
23929 tree decl = SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr);
23930 remove_AT (die, a->dw_attr);
23932 optimize_location_into_implicit_ptr (die, decl);
23935 remove_AT (die, a->dw_attr);
23939 mark_base_types (l);
23942 case dw_val_class_addr:
23943 if (a->dw_attr == DW_AT_const_value
23944 && !resolve_one_addr (&a->dw_attr_val.v.val_addr))
23946 if (AT_index (a) != NOT_INDEXED)
23947 remove_addr_table_entry (a->dw_attr_val.val_entry);
23948 remove_AT (die, a->dw_attr);
23951 if (die->die_tag == DW_TAG_GNU_call_site
23952 && a->dw_attr == DW_AT_abstract_origin)
23954 tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr);
23955 dw_die_ref tdie = lookup_decl_die (tdecl);
23957 && DECL_EXTERNAL (tdecl)
23958 && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE)
23960 force_decl_die (tdecl);
23961 tdie = lookup_decl_die (tdecl);
23965 a->dw_attr_val.val_class = dw_val_class_die_ref;
23966 a->dw_attr_val.v.val_die_ref.die = tdie;
23967 a->dw_attr_val.v.val_die_ref.external = 0;
23971 if (AT_index (a) != NOT_INDEXED)
23972 remove_addr_table_entry (a->dw_attr_val.val_entry);
23973 remove_AT (die, a->dw_attr);
23982 FOR_EACH_CHILD (die, c, resolve_addr (c));
23985 /* Helper routines for optimize_location_lists.
23986 This pass tries to share identical local lists in .debug_loc
23989 /* Iteratively hash operands of LOC opcode into HSTATE. */
23992 hash_loc_operands (dw_loc_descr_ref loc, inchash::hash &hstate)
23994 dw_val_ref val1 = &loc->dw_loc_oprnd1;
23995 dw_val_ref val2 = &loc->dw_loc_oprnd2;
23997 switch (loc->dw_loc_opc)
23999 case DW_OP_const4u:
24000 case DW_OP_const8u:
24004 case DW_OP_const1u:
24005 case DW_OP_const1s:
24006 case DW_OP_const2u:
24007 case DW_OP_const2s:
24008 case DW_OP_const4s:
24009 case DW_OP_const8s:
24013 case DW_OP_plus_uconst:
24049 case DW_OP_deref_size:
24050 case DW_OP_xderef_size:
24051 hstate.add_object (val1->v.val_int);
24058 gcc_assert (val1->val_class == dw_val_class_loc);
24059 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
24060 hstate.add_object (offset);
24063 case DW_OP_implicit_value:
24064 hstate.add_object (val1->v.val_unsigned);
24065 switch (val2->val_class)
24067 case dw_val_class_const:
24068 hstate.add_object (val2->v.val_int);
24070 case dw_val_class_vec:
24072 unsigned int elt_size = val2->v.val_vec.elt_size;
24073 unsigned int len = val2->v.val_vec.length;
24075 hstate.add_int (elt_size);
24076 hstate.add_int (len);
24077 hstate.add (val2->v.val_vec.array, len * elt_size);
24080 case dw_val_class_const_double:
24081 hstate.add_object (val2->v.val_double.low);
24082 hstate.add_object (val2->v.val_double.high);
24084 case dw_val_class_wide_int:
24085 hstate.add (val2->v.val_wide->get_val (),
24086 get_full_len (*val2->v.val_wide)
24087 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
24089 case dw_val_class_addr:
24090 inchash::add_rtx (val2->v.val_addr, hstate);
24093 gcc_unreachable ();
24097 case DW_OP_bit_piece:
24098 hstate.add_object (val1->v.val_int);
24099 hstate.add_object (val2->v.val_int);
24105 unsigned char dtprel = 0xd1;
24106 hstate.add_object (dtprel);
24108 inchash::add_rtx (val1->v.val_addr, hstate);
24110 case DW_OP_GNU_addr_index:
24111 case DW_OP_GNU_const_index:
24115 unsigned char dtprel = 0xd1;
24116 hstate.add_object (dtprel);
24118 inchash::add_rtx (val1->val_entry->addr.rtl, hstate);
24121 case DW_OP_GNU_implicit_pointer:
24122 hstate.add_int (val2->v.val_int);
24124 case DW_OP_GNU_entry_value:
24125 hstate.add_object (val1->v.val_loc);
24127 case DW_OP_GNU_regval_type:
24128 case DW_OP_GNU_deref_type:
24130 unsigned int byte_size
24131 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_byte_size);
24132 unsigned int encoding
24133 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_encoding);
24134 hstate.add_object (val1->v.val_int);
24135 hstate.add_object (byte_size);
24136 hstate.add_object (encoding);
24139 case DW_OP_GNU_convert:
24140 case DW_OP_GNU_reinterpret:
24141 if (val1->val_class == dw_val_class_unsigned_const)
24143 hstate.add_object (val1->v.val_unsigned);
24147 case DW_OP_GNU_const_type:
24149 unsigned int byte_size
24150 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_byte_size);
24151 unsigned int encoding
24152 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_encoding);
24153 hstate.add_object (byte_size);
24154 hstate.add_object (encoding);
24155 if (loc->dw_loc_opc != DW_OP_GNU_const_type)
24157 hstate.add_object (val2->val_class);
24158 switch (val2->val_class)
24160 case dw_val_class_const:
24161 hstate.add_object (val2->v.val_int);
24163 case dw_val_class_vec:
24165 unsigned int elt_size = val2->v.val_vec.elt_size;
24166 unsigned int len = val2->v.val_vec.length;
24168 hstate.add_object (elt_size);
24169 hstate.add_object (len);
24170 hstate.add (val2->v.val_vec.array, len * elt_size);
24173 case dw_val_class_const_double:
24174 hstate.add_object (val2->v.val_double.low);
24175 hstate.add_object (val2->v.val_double.high);
24177 case dw_val_class_wide_int:
24178 hstate.add (val2->v.val_wide->get_val (),
24179 get_full_len (*val2->v.val_wide)
24180 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
24183 gcc_unreachable ();
24189 /* Other codes have no operands. */
24194 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
24197 hash_locs (dw_loc_descr_ref loc, inchash::hash &hstate)
24199 dw_loc_descr_ref l;
24200 bool sizes_computed = false;
24201 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
24202 size_of_locs (loc);
24204 for (l = loc; l != NULL; l = l->dw_loc_next)
24206 enum dwarf_location_atom opc = l->dw_loc_opc;
24207 hstate.add_object (opc);
24208 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed)
24210 size_of_locs (loc);
24211 sizes_computed = true;
24213 hash_loc_operands (l, hstate);
24217 /* Compute hash of the whole location list LIST_HEAD. */
24220 hash_loc_list (dw_loc_list_ref list_head)
24222 dw_loc_list_ref curr = list_head;
24223 inchash::hash hstate;
24225 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
24227 hstate.add (curr->begin, strlen (curr->begin) + 1);
24228 hstate.add (curr->end, strlen (curr->end) + 1);
24230 hstate.add (curr->section, strlen (curr->section) + 1);
24231 hash_locs (curr->expr, hstate);
24233 list_head->hash = hstate.end ();
24236 /* Return true if X and Y opcodes have the same operands. */
24239 compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y)
24241 dw_val_ref valx1 = &x->dw_loc_oprnd1;
24242 dw_val_ref valx2 = &x->dw_loc_oprnd2;
24243 dw_val_ref valy1 = &y->dw_loc_oprnd1;
24244 dw_val_ref valy2 = &y->dw_loc_oprnd2;
24246 switch (x->dw_loc_opc)
24248 case DW_OP_const4u:
24249 case DW_OP_const8u:
24253 case DW_OP_const1u:
24254 case DW_OP_const1s:
24255 case DW_OP_const2u:
24256 case DW_OP_const2s:
24257 case DW_OP_const4s:
24258 case DW_OP_const8s:
24262 case DW_OP_plus_uconst:
24298 case DW_OP_deref_size:
24299 case DW_OP_xderef_size:
24300 return valx1->v.val_int == valy1->v.val_int;
24303 /* If splitting debug info, the use of DW_OP_GNU_addr_index
24304 can cause irrelevant differences in dw_loc_addr. */
24305 gcc_assert (valx1->val_class == dw_val_class_loc
24306 && valy1->val_class == dw_val_class_loc
24307 && (dwarf_split_debug_info
24308 || x->dw_loc_addr == y->dw_loc_addr));
24309 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr;
24310 case DW_OP_implicit_value:
24311 if (valx1->v.val_unsigned != valy1->v.val_unsigned
24312 || valx2->val_class != valy2->val_class)
24314 switch (valx2->val_class)
24316 case dw_val_class_const:
24317 return valx2->v.val_int == valy2->v.val_int;
24318 case dw_val_class_vec:
24319 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24320 && valx2->v.val_vec.length == valy2->v.val_vec.length
24321 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24322 valx2->v.val_vec.elt_size
24323 * valx2->v.val_vec.length) == 0;
24324 case dw_val_class_const_double:
24325 return valx2->v.val_double.low == valy2->v.val_double.low
24326 && valx2->v.val_double.high == valy2->v.val_double.high;
24327 case dw_val_class_wide_int:
24328 return *valx2->v.val_wide == *valy2->v.val_wide;
24329 case dw_val_class_addr:
24330 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr);
24332 gcc_unreachable ();
24335 case DW_OP_bit_piece:
24336 return valx1->v.val_int == valy1->v.val_int
24337 && valx2->v.val_int == valy2->v.val_int;
24340 return rtx_equal_p (valx1->v.val_addr, valy1->v.val_addr);
24341 case DW_OP_GNU_addr_index:
24342 case DW_OP_GNU_const_index:
24344 rtx ax1 = valx1->val_entry->addr.rtl;
24345 rtx ay1 = valy1->val_entry->addr.rtl;
24346 return rtx_equal_p (ax1, ay1);
24348 case DW_OP_GNU_implicit_pointer:
24349 return valx1->val_class == dw_val_class_die_ref
24350 && valx1->val_class == valy1->val_class
24351 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die
24352 && valx2->v.val_int == valy2->v.val_int;
24353 case DW_OP_GNU_entry_value:
24354 return compare_loc_operands (valx1->v.val_loc, valy1->v.val_loc);
24355 case DW_OP_GNU_const_type:
24356 if (valx1->v.val_die_ref.die != valy1->v.val_die_ref.die
24357 || valx2->val_class != valy2->val_class)
24359 switch (valx2->val_class)
24361 case dw_val_class_const:
24362 return valx2->v.val_int == valy2->v.val_int;
24363 case dw_val_class_vec:
24364 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24365 && valx2->v.val_vec.length == valy2->v.val_vec.length
24366 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24367 valx2->v.val_vec.elt_size
24368 * valx2->v.val_vec.length) == 0;
24369 case dw_val_class_const_double:
24370 return valx2->v.val_double.low == valy2->v.val_double.low
24371 && valx2->v.val_double.high == valy2->v.val_double.high;
24372 case dw_val_class_wide_int:
24373 return *valx2->v.val_wide == *valy2->v.val_wide;
24375 gcc_unreachable ();
24377 case DW_OP_GNU_regval_type:
24378 case DW_OP_GNU_deref_type:
24379 return valx1->v.val_int == valy1->v.val_int
24380 && valx2->v.val_die_ref.die == valy2->v.val_die_ref.die;
24381 case DW_OP_GNU_convert:
24382 case DW_OP_GNU_reinterpret:
24383 if (valx1->val_class != valy1->val_class)
24385 if (valx1->val_class == dw_val_class_unsigned_const)
24386 return valx1->v.val_unsigned == valy1->v.val_unsigned;
24387 return valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
24388 case DW_OP_GNU_parameter_ref:
24389 return valx1->val_class == dw_val_class_die_ref
24390 && valx1->val_class == valy1->val_class
24391 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
24393 /* Other codes have no operands. */
24398 /* Return true if DWARF location expressions X and Y are the same. */
24401 compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y)
24403 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next)
24404 if (x->dw_loc_opc != y->dw_loc_opc
24405 || x->dtprel != y->dtprel
24406 || !compare_loc_operands (x, y))
24408 return x == NULL && y == NULL;
24411 /* Hashtable helpers. */
24413 struct loc_list_hasher : typed_noop_remove <dw_loc_list_struct>
24415 typedef dw_loc_list_struct *value_type;
24416 typedef dw_loc_list_struct *compare_type;
24417 static inline hashval_t hash (const dw_loc_list_struct *);
24418 static inline bool equal (const dw_loc_list_struct *,
24419 const dw_loc_list_struct *);
24422 /* Return precomputed hash of location list X. */
24425 loc_list_hasher::hash (const dw_loc_list_struct *x)
24430 /* Return true if location lists A and B are the same. */
24433 loc_list_hasher::equal (const dw_loc_list_struct *a,
24434 const dw_loc_list_struct *b)
24438 if (a->hash != b->hash)
24440 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next)
24441 if (strcmp (a->begin, b->begin) != 0
24442 || strcmp (a->end, b->end) != 0
24443 || (a->section == NULL) != (b->section == NULL)
24444 || (a->section && strcmp (a->section, b->section) != 0)
24445 || !compare_locs (a->expr, b->expr))
24447 return a == NULL && b == NULL;
24450 typedef hash_table<loc_list_hasher> loc_list_hash_type;
24453 /* Recursively optimize location lists referenced from DIE
24454 children and share them whenever possible. */
24457 optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type *htab)
24462 dw_loc_list_struct **slot;
24464 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
24465 if (AT_class (a) == dw_val_class_loc_list)
24467 dw_loc_list_ref list = AT_loc_list (a);
24468 /* TODO: perform some optimizations here, before hashing
24469 it and storing into the hash table. */
24470 hash_loc_list (list);
24471 slot = htab->find_slot_with_hash (list, list->hash, INSERT);
24475 a->dw_attr_val.v.val_loc_list = *slot;
24478 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab));
24482 /* Recursively assign each location list a unique index into the debug_addr
24486 index_location_lists (dw_die_ref die)
24492 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
24493 if (AT_class (a) == dw_val_class_loc_list)
24495 dw_loc_list_ref list = AT_loc_list (a);
24496 dw_loc_list_ref curr;
24497 for (curr = list; curr != NULL; curr = curr->dw_loc_next)
24499 /* Don't index an entry that has already been indexed
24500 or won't be output. */
24501 if (curr->begin_entry != NULL
24502 || (strcmp (curr->begin, curr->end) == 0 && !curr->force))
24506 = add_addr_table_entry (xstrdup (curr->begin),
24511 FOR_EACH_CHILD (die, c, index_location_lists (c));
24514 /* Optimize location lists referenced from DIE
24515 children and share them whenever possible. */
24518 optimize_location_lists (dw_die_ref die)
24520 loc_list_hash_type htab (500);
24521 optimize_location_lists_1 (die, &htab);
24524 /* Output stuff that dwarf requires at the end of every file,
24525 and generate the DWARF-2 debugging info. */
24528 dwarf2out_finish (const char *filename)
24530 limbo_die_node *node, *next_node;
24531 comdat_type_node *ctnode;
24533 dw_die_ref main_comp_unit_die;
24535 /* PCH might result in DW_AT_producer string being restored from the
24536 header compilation, so always fill it with empty string initially
24537 and overwrite only here. */
24538 dw_attr_ref producer = get_AT (comp_unit_die (), DW_AT_producer);
24539 producer_string = gen_producer_string ();
24540 producer->dw_attr_val.v.val_str->refcount--;
24541 producer->dw_attr_val.v.val_str = find_AT_string (producer_string);
24543 gen_scheduled_generic_parms_dies ();
24544 gen_remaining_tmpl_value_param_die_attribute ();
24546 /* Add the name for the main input file now. We delayed this from
24547 dwarf2out_init to avoid complications with PCH.
24548 For LTO produced units use a fixed artificial name to avoid
24549 leaking tempfile names into the dwarf. */
24551 add_name_attribute (comp_unit_die (), remap_debug_filename (filename));
24553 add_name_attribute (comp_unit_die (), "<artificial>");
24554 if (!IS_ABSOLUTE_PATH (filename) || targetm.force_at_comp_dir)
24555 add_comp_dir_attribute (comp_unit_die ());
24556 else if (get_AT (comp_unit_die (), DW_AT_comp_dir) == NULL)
24559 file_table->traverse<bool *, file_table_relative_p> (&p);
24561 add_comp_dir_attribute (comp_unit_die ());
24564 if (deferred_locations_list)
24565 for (i = 0; i < deferred_locations_list->length (); i++)
24567 add_location_or_const_value_attribute (
24568 (*deferred_locations_list)[i].die,
24569 (*deferred_locations_list)[i].variable,
24574 /* Traverse the limbo die list, and add parent/child links. The only
24575 dies without parents that should be here are concrete instances of
24576 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24577 For concrete instances, we can get the parent die from the abstract
24579 for (node = limbo_die_list; node; node = next_node)
24581 dw_die_ref die = node->die;
24582 next_node = node->next;
24584 if (die->die_parent == NULL)
24586 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
24588 if (origin && origin->die_parent)
24589 add_child_die (origin->die_parent, die);
24590 else if (is_cu_die (die))
24592 else if (seen_error ())
24593 /* It's OK to be confused by errors in the input. */
24594 add_child_die (comp_unit_die (), die);
24597 /* In certain situations, the lexical block containing a
24598 nested function can be optimized away, which results
24599 in the nested function die being orphaned. Likewise
24600 with the return type of that nested function. Force
24601 this to be a child of the containing function.
24603 It may happen that even the containing function got fully
24604 inlined and optimized out. In that case we are lost and
24605 assign the empty child. This should not be big issue as
24606 the function is likely unreachable too. */
24607 gcc_assert (node->created_for);
24609 if (DECL_P (node->created_for))
24610 origin = get_context_die (DECL_CONTEXT (node->created_for));
24611 else if (TYPE_P (node->created_for))
24612 origin = scope_die_for (node->created_for, comp_unit_die ());
24614 origin = comp_unit_die ();
24616 add_child_die (origin, die);
24621 limbo_die_list = NULL;
24623 #if ENABLE_ASSERT_CHECKING
24625 dw_die_ref die = comp_unit_die (), c;
24626 FOR_EACH_CHILD (die, c, gcc_assert (! c->die_mark));
24629 resolve_addr (comp_unit_die ());
24630 move_marked_base_types ();
24632 for (node = deferred_asm_name; node; node = node->next)
24634 tree decl = node->created_for;
24635 /* When generating LTO bytecode we can not generate new assembler
24636 names at this point and all important decls got theirs via
24638 if (((!flag_generate_lto && !flag_generate_offload)
24639 || DECL_ASSEMBLER_NAME_SET_P (decl))
24640 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
24642 add_linkage_attr (node->die, decl);
24643 move_linkage_attr (node->die);
24647 deferred_asm_name = NULL;
24649 /* Walk through the list of incomplete types again, trying once more to
24650 emit full debugging info for them. */
24651 retry_incomplete_types ();
24653 if (flag_eliminate_unused_debug_types)
24654 prune_unused_types ();
24656 /* Generate separate COMDAT sections for type DIEs. */
24657 if (use_debug_types)
24659 break_out_comdat_types (comp_unit_die ());
24661 /* Each new type_unit DIE was added to the limbo die list when created.
24662 Since these have all been added to comdat_type_list, clear the
24664 limbo_die_list = NULL;
24666 /* For each new comdat type unit, copy declarations for incomplete
24667 types to make the new unit self-contained (i.e., no direct
24668 references to the main compile unit). */
24669 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24670 copy_decls_for_unworthy_types (ctnode->root_die);
24671 copy_decls_for_unworthy_types (comp_unit_die ());
24673 /* In the process of copying declarations from one unit to another,
24674 we may have left some declarations behind that are no longer
24675 referenced. Prune them. */
24676 prune_unused_types ();
24679 /* Generate separate CUs for each of the include files we've seen.
24680 They will go into limbo_die_list. */
24681 if (flag_eliminate_dwarf2_dups)
24682 break_out_includes (comp_unit_die ());
24684 /* Traverse the DIE's and add add sibling attributes to those DIE's
24685 that have children. */
24686 add_sibling_attributes (comp_unit_die ());
24687 for (node = limbo_die_list; node; node = node->next)
24688 add_sibling_attributes (node->die);
24689 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24690 add_sibling_attributes (ctnode->root_die);
24692 /* When splitting DWARF info, we put some attributes in the
24693 skeleton compile_unit DIE that remains in the .o, while
24694 most attributes go in the DWO compile_unit_die. */
24695 if (dwarf_split_debug_info)
24696 main_comp_unit_die = gen_compile_unit_die (NULL);
24698 main_comp_unit_die = comp_unit_die ();
24700 /* Output a terminator label for the .text section. */
24701 switch_to_section (text_section);
24702 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
24703 if (cold_text_section)
24705 switch_to_section (cold_text_section);
24706 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
24709 /* We can only use the low/high_pc attributes if all of the code was
24711 if (!have_multiple_function_sections
24712 || (dwarf_version < 3 && dwarf_strict))
24714 /* Don't add if the CU has no associated code. */
24715 if (text_section_used)
24716 add_AT_low_high_pc (main_comp_unit_die, text_section_label,
24717 text_end_label, true);
24723 bool range_list_added = false;
24725 if (text_section_used)
24726 add_ranges_by_labels (main_comp_unit_die, text_section_label,
24727 text_end_label, &range_list_added, true);
24728 if (cold_text_section_used)
24729 add_ranges_by_labels (main_comp_unit_die, cold_text_section_label,
24730 cold_end_label, &range_list_added, true);
24732 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
24734 if (DECL_IGNORED_P (fde->decl))
24736 if (!fde->in_std_section)
24737 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_begin,
24738 fde->dw_fde_end, &range_list_added,
24740 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
24741 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_second_begin,
24742 fde->dw_fde_second_end, &range_list_added,
24746 if (range_list_added)
24748 /* We need to give .debug_loc and .debug_ranges an appropriate
24749 "base address". Use zero so that these addresses become
24750 absolute. Historically, we've emitted the unexpected
24751 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24752 Emit both to give time for other tools to adapt. */
24753 add_AT_addr (main_comp_unit_die, DW_AT_low_pc, const0_rtx, true);
24754 if (! dwarf_strict && dwarf_version < 4)
24755 add_AT_addr (main_comp_unit_die, DW_AT_entry_pc, const0_rtx, true);
24761 if (debug_info_level >= DINFO_LEVEL_TERSE)
24762 add_AT_lineptr (main_comp_unit_die, DW_AT_stmt_list,
24763 debug_line_section_label);
24766 add_AT_macptr (comp_unit_die (),
24767 dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros,
24768 macinfo_section_label);
24770 if (dwarf_split_debug_info)
24772 /* optimize_location_lists calculates the size of the lists,
24773 so index them first, and assign indices to the entries.
24774 Although optimize_location_lists will remove entries from
24775 the table, it only does so for duplicates, and therefore
24776 only reduces ref_counts to 1. */
24777 index_location_lists (comp_unit_die ());
24779 if (addr_index_table != NULL)
24781 unsigned int index = 0;
24783 ->traverse_noresize<unsigned int *, index_addr_table_entry>
24788 if (have_location_lists)
24789 optimize_location_lists (comp_unit_die ());
24791 save_macinfo_strings ();
24793 if (dwarf_split_debug_info)
24795 unsigned int index = 0;
24797 /* Add attributes common to skeleton compile_units and
24798 type_units. Because these attributes include strings, it
24799 must be done before freezing the string table. Top-level
24800 skeleton die attrs are added when the skeleton type unit is
24801 created, so ensure it is created by this point. */
24802 add_top_level_skeleton_die_attrs (main_comp_unit_die);
24803 debug_str_hash->traverse_noresize<unsigned int *, index_string> (&index);
24806 /* Output all of the compilation units. We put the main one last so that
24807 the offsets are available to output_pubnames. */
24808 for (node = limbo_die_list; node; node = node->next)
24809 output_comp_unit (node->die, 0);
24811 hash_table<comdat_type_hasher> comdat_type_table (100);
24812 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24814 comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT);
24816 /* Don't output duplicate types. */
24817 if (*slot != HTAB_EMPTY_ENTRY)
24820 /* Add a pointer to the line table for the main compilation unit
24821 so that the debugger can make sense of DW_AT_decl_file
24823 if (debug_info_level >= DINFO_LEVEL_TERSE)
24824 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
24825 (!dwarf_split_debug_info
24826 ? debug_line_section_label
24827 : debug_skeleton_line_section_label));
24829 output_comdat_type_unit (ctnode);
24833 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24834 both the main_cu and all skeleton TUs. Making this call unconditional
24835 would end up either adding a second copy of the AT_pubnames attribute, or
24836 requiring a special case in add_top_level_skeleton_die_attrs. */
24837 if (!dwarf_split_debug_info)
24838 add_AT_pubnames (comp_unit_die ());
24840 if (dwarf_split_debug_info)
24843 unsigned char checksum[16];
24844 struct md5_ctx ctx;
24846 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24847 md5_init_ctx (&ctx);
24849 die_checksum (comp_unit_die (), &ctx, &mark);
24850 unmark_all_dies (comp_unit_die ());
24851 md5_finish_ctx (&ctx, checksum);
24853 /* Use the first 8 bytes of the checksum as the dwo_id,
24854 and add it to both comp-unit DIEs. */
24855 add_AT_data8 (main_comp_unit_die, DW_AT_GNU_dwo_id, checksum);
24856 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id, checksum);
24858 /* Add the base offset of the ranges table to the skeleton
24860 if (ranges_table_in_use)
24861 add_AT_lineptr (main_comp_unit_die, DW_AT_GNU_ranges_base,
24862 ranges_section_label);
24864 switch_to_section (debug_addr_section);
24865 ASM_OUTPUT_LABEL (asm_out_file, debug_addr_section_label);
24866 output_addr_table ();
24869 /* Output the main compilation unit if non-empty or if .debug_macinfo
24870 or .debug_macro will be emitted. */
24871 output_comp_unit (comp_unit_die (), have_macinfo);
24873 if (dwarf_split_debug_info && info_section_emitted)
24874 output_skeleton_debug_sections (main_comp_unit_die);
24876 /* Output the abbreviation table. */
24877 if (abbrev_die_table_in_use != 1)
24879 switch_to_section (debug_abbrev_section);
24880 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
24881 output_abbrev_section ();
24884 /* Output location list section if necessary. */
24885 if (have_location_lists)
24887 /* Output the location lists info. */
24888 switch_to_section (debug_loc_section);
24889 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
24890 output_location_lists (comp_unit_die ());
24893 output_pubtables ();
24895 /* Output the address range information if a CU (.debug_info section)
24896 was emitted. We output an empty table even if we had no functions
24897 to put in it. This because the consumer has no way to tell the
24898 difference between an empty table that we omitted and failure to
24899 generate a table that would have contained data. */
24900 if (info_section_emitted)
24902 unsigned long aranges_length = size_of_aranges ();
24904 switch_to_section (debug_aranges_section);
24905 output_aranges (aranges_length);
24908 /* Output ranges section if necessary. */
24909 if (ranges_table_in_use)
24911 switch_to_section (debug_ranges_section);
24912 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
24916 /* Have to end the macro section. */
24919 switch_to_section (debug_macinfo_section);
24920 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
24922 dw2_asm_output_data (1, 0, "End compilation unit");
24925 /* Output the source line correspondence table. We must do this
24926 even if there is no line information. Otherwise, on an empty
24927 translation unit, we will generate a present, but empty,
24928 .debug_info section. IRIX 6.5 `nm' will then complain when
24929 examining the file. This is done late so that any filenames
24930 used by the debug_info section are marked as 'used'. */
24931 switch_to_section (debug_line_section);
24932 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
24933 if (! DWARF2_ASM_LINE_DEBUG_INFO)
24934 output_line_info (false);
24936 if (dwarf_split_debug_info && info_section_emitted)
24938 switch_to_section (debug_skeleton_line_section);
24939 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_line_section_label);
24940 output_line_info (true);
24943 /* If we emitted any indirect strings, output the string table too. */
24944 if (debug_str_hash || skeleton_debug_str_hash)
24945 output_indirect_strings ();
24948 /* Reset all state within dwarf2out.c so that we can rerun the compiler
24949 within the same process. For use by toplev::finalize. */
24952 dwarf2out_c_finalize (void)
24954 last_var_location_insn = NULL;
24955 cached_next_real_insn = NULL;
24956 used_rtx_array = NULL;
24957 incomplete_types = NULL;
24958 decl_scope_table = NULL;
24959 debug_info_section = NULL;
24960 debug_skeleton_info_section = NULL;
24961 debug_abbrev_section = NULL;
24962 debug_skeleton_abbrev_section = NULL;
24963 debug_aranges_section = NULL;
24964 debug_addr_section = NULL;
24965 debug_macinfo_section = NULL;
24966 debug_line_section = NULL;
24967 debug_skeleton_line_section = NULL;
24968 debug_loc_section = NULL;
24969 debug_pubnames_section = NULL;
24970 debug_pubtypes_section = NULL;
24971 debug_str_section = NULL;
24972 debug_str_dwo_section = NULL;
24973 debug_str_offsets_section = NULL;
24974 debug_ranges_section = NULL;
24975 debug_frame_section = NULL;
24977 debug_str_hash = NULL;
24978 skeleton_debug_str_hash = NULL;
24979 dw2_string_counter = 0;
24980 have_multiple_function_sections = false;
24981 text_section_used = false;
24982 cold_text_section_used = false;
24983 cold_text_section = NULL;
24984 current_unit_personality = NULL;
24986 deferred_locations_list = NULL;
24988 next_die_offset = 0;
24989 single_comp_unit_die = NULL;
24990 comdat_type_list = NULL;
24991 limbo_die_list = NULL;
24992 deferred_asm_name = NULL;
24994 decl_die_table = NULL;
24995 common_block_die_table = NULL;
24996 decl_loc_table = NULL;
24997 call_arg_locations = NULL;
24998 call_arg_loc_last = NULL;
24999 call_site_count = -1;
25000 tail_call_site_count = -1;
25001 //block_map = NULL;
25002 cached_dw_loc_list_table = NULL;
25003 abbrev_die_table = NULL;
25004 abbrev_die_table_allocated = 0;
25005 abbrev_die_table_in_use = 0;
25006 line_info_label_num = 0;
25007 cur_line_info_table = NULL;
25008 text_section_line_info = NULL;
25009 cold_text_section_line_info = NULL;
25010 separate_line_info = NULL;
25011 info_section_emitted = false;
25012 pubname_table = NULL;
25013 pubtype_table = NULL;
25014 macinfo_table = NULL;
25015 ranges_table = NULL;
25016 ranges_table_allocated = 0;
25017 ranges_table_in_use = 0;
25018 ranges_by_label = 0;
25019 ranges_by_label_allocated = 0;
25020 ranges_by_label_in_use = 0;
25021 have_location_lists = false;
25024 last_emitted_file = NULL;
25026 file_table_last_lookup = NULL;
25027 tmpl_value_parm_die_table = NULL;
25028 generic_type_instances = NULL;
25029 frame_pointer_fb_offset = 0;
25030 frame_pointer_fb_offset_valid = false;
25031 base_types.release ();
25032 XDELETEVEC (producer_string);
25033 producer_string = NULL;
25036 #include "gt-dwarf2out.h"