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
392 of the number. Some constants have a large uniform precision, so
393 we get the precision needed for the actual value of the number. */
396 get_full_len (const wide_int &op)
398 int prec = wi::min_precision (op, UNSIGNED);
399 return ((prec + HOST_BITS_PER_WIDE_INT - 1)
400 / HOST_BITS_PER_WIDE_INT);
404 should_emit_struct_debug (tree type, enum debug_info_usage usage)
406 enum debug_struct_file criterion;
408 bool generic = lang_hooks.types.generic_p (type);
411 criterion = debug_struct_generic[usage];
413 criterion = debug_struct_ordinary[usage];
415 if (criterion == DINFO_STRUCT_FILE_NONE)
416 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
417 if (criterion == DINFO_STRUCT_FILE_ANY)
418 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
420 type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
422 if (type_decl != NULL)
424 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
425 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
427 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
428 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
431 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
434 /* Return a pointer to a copy of the section string name S with all
435 attributes stripped off, and an asterisk prepended (for assemble_name). */
438 stripattributes (const char *s)
440 char *stripped = XNEWVEC (char, strlen (s) + 2);
445 while (*s && *s != ',')
452 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
453 switch to the data section instead, and write out a synthetic start label
454 for collect2 the first time around. */
457 switch_to_eh_frame_section (bool back)
461 #ifdef EH_FRAME_SECTION_NAME
462 if (eh_frame_section == 0)
466 if (EH_TABLES_CAN_BE_READ_ONLY)
472 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
474 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
476 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
479 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
480 && (fde_encoding & 0x70) != DW_EH_PE_aligned
481 && (per_encoding & 0x70) != DW_EH_PE_absptr
482 && (per_encoding & 0x70) != DW_EH_PE_aligned
483 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
484 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
485 ? 0 : SECTION_WRITE);
488 flags = SECTION_WRITE;
489 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
491 #endif /* EH_FRAME_SECTION_NAME */
493 if (eh_frame_section)
494 switch_to_section (eh_frame_section);
497 /* We have no special eh_frame section. Put the information in
498 the data section and emit special labels to guide collect2. */
499 switch_to_section (data_section);
503 label = get_file_function_name ("F");
504 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
505 targetm.asm_out.globalize_label (asm_out_file,
506 IDENTIFIER_POINTER (label));
507 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
512 /* Switch [BACK] to the eh or debug frame table section, depending on
516 switch_to_frame_table_section (int for_eh, bool back)
519 switch_to_eh_frame_section (back);
522 if (!debug_frame_section)
523 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
524 SECTION_DEBUG, NULL);
525 switch_to_section (debug_frame_section);
529 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
531 enum dw_cfi_oprnd_type
532 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
537 case DW_CFA_GNU_window_save:
538 case DW_CFA_remember_state:
539 case DW_CFA_restore_state:
540 return dw_cfi_oprnd_unused;
543 case DW_CFA_advance_loc1:
544 case DW_CFA_advance_loc2:
545 case DW_CFA_advance_loc4:
546 case DW_CFA_MIPS_advance_loc8:
547 return dw_cfi_oprnd_addr;
550 case DW_CFA_offset_extended:
552 case DW_CFA_offset_extended_sf:
553 case DW_CFA_def_cfa_sf:
555 case DW_CFA_restore_extended:
556 case DW_CFA_undefined:
557 case DW_CFA_same_value:
558 case DW_CFA_def_cfa_register:
559 case DW_CFA_register:
560 case DW_CFA_expression:
561 return dw_cfi_oprnd_reg_num;
563 case DW_CFA_def_cfa_offset:
564 case DW_CFA_GNU_args_size:
565 case DW_CFA_def_cfa_offset_sf:
566 return dw_cfi_oprnd_offset;
568 case DW_CFA_def_cfa_expression:
569 return dw_cfi_oprnd_loc;
576 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
578 enum dw_cfi_oprnd_type
579 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
584 case DW_CFA_def_cfa_sf:
586 case DW_CFA_offset_extended_sf:
587 case DW_CFA_offset_extended:
588 return dw_cfi_oprnd_offset;
590 case DW_CFA_register:
591 return dw_cfi_oprnd_reg_num;
593 case DW_CFA_expression:
594 return dw_cfi_oprnd_loc;
597 return dw_cfi_oprnd_unused;
601 /* Output one FDE. */
604 output_fde (dw_fde_ref fde, bool for_eh, bool second,
605 char *section_start_label, int fde_encoding, char *augmentation,
606 bool any_lsda_needed, int lsda_encoding)
608 const char *begin, *end;
609 static unsigned int j;
612 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
614 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
616 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
617 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
618 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
619 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
620 " indicating 64-bit DWARF extension");
621 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
623 ASM_OUTPUT_LABEL (asm_out_file, l1);
626 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
628 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
629 debug_frame_section, "FDE CIE offset");
631 begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
632 end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
636 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
637 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
638 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
639 "FDE initial location");
640 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
641 end, begin, "FDE address range");
645 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
646 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
653 int size = size_of_encoded_value (lsda_encoding);
655 if (lsda_encoding == DW_EH_PE_aligned)
657 int offset = ( 4 /* Length */
659 + 2 * size_of_encoded_value (fde_encoding)
660 + 1 /* Augmentation size */ );
661 int pad = -offset & (PTR_SIZE - 1);
664 gcc_assert (size_of_uleb128 (size) == 1);
667 dw2_asm_output_data_uleb128 (size, "Augmentation size");
669 if (fde->uses_eh_lsda)
671 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
672 fde->funcdef_number);
673 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
674 gen_rtx_SYMBOL_REF (Pmode, l1),
676 "Language Specific Data Area");
680 if (lsda_encoding == DW_EH_PE_aligned)
681 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
682 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
683 "Language Specific Data Area (none)");
687 dw2_asm_output_data_uleb128 (0, "Augmentation size");
690 /* Loop through the Call Frame Instructions associated with this FDE. */
691 fde->dw_fde_current_label = begin;
693 size_t from, until, i;
696 until = vec_safe_length (fde->dw_fde_cfi);
698 if (fde->dw_fde_second_begin == NULL)
701 until = fde->dw_fde_switch_cfi_index;
703 from = fde->dw_fde_switch_cfi_index;
705 for (i = from; i < until; i++)
706 output_cfi ((*fde->dw_fde_cfi)[i], fde, for_eh);
709 /* If we are to emit a ref/link from function bodies to their frame tables,
710 do it now. This is typically performed to make sure that tables
711 associated with functions are dragged with them and not discarded in
712 garbage collecting links. We need to do this on a per function basis to
713 cope with -ffunction-sections. */
715 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
716 /* Switch to the function section, emit the ref to the tables, and
717 switch *back* into the table section. */
718 switch_to_section (function_section (fde->decl));
719 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
720 switch_to_frame_table_section (for_eh, true);
723 /* Pad the FDE out to an address sized boundary. */
724 ASM_OUTPUT_ALIGN (asm_out_file,
725 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
726 ASM_OUTPUT_LABEL (asm_out_file, l2);
731 /* Return true if frame description entry FDE is needed for EH. */
734 fde_needed_for_eh_p (dw_fde_ref fde)
736 if (flag_asynchronous_unwind_tables)
739 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
742 if (fde->uses_eh_lsda)
745 /* If exceptions are enabled, we have collected nothrow info. */
746 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
752 /* Output the call frame information used to record information
753 that relates to calculating the frame pointer, and records the
754 location of saved registers. */
757 output_call_frame_info (int for_eh)
762 char l1[20], l2[20], section_start_label[20];
763 bool any_lsda_needed = false;
764 char augmentation[6];
765 int augmentation_size;
766 int fde_encoding = DW_EH_PE_absptr;
767 int per_encoding = DW_EH_PE_absptr;
768 int lsda_encoding = DW_EH_PE_absptr;
770 rtx personality = NULL;
773 /* Don't emit a CIE if there won't be any FDEs. */
777 /* Nothing to do if the assembler's doing it all. */
778 if (dwarf2out_do_cfi_asm ())
781 /* If we don't have any functions we'll want to unwind out of, don't emit
782 any EH unwind information. If we make FDEs linkonce, we may have to
783 emit an empty label for an FDE that wouldn't otherwise be emitted. We
784 want to avoid having an FDE kept around when the function it refers to
785 is discarded. Example where this matters: a primary function template
786 in C++ requires EH information, an explicit specialization doesn't. */
789 bool any_eh_needed = false;
791 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
793 if (fde->uses_eh_lsda)
794 any_eh_needed = any_lsda_needed = true;
795 else if (fde_needed_for_eh_p (fde))
796 any_eh_needed = true;
797 else if (TARGET_USES_WEAK_UNWIND_INFO)
798 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
805 /* We're going to be generating comments, so turn on app. */
809 /* Switch to the proper frame section, first time. */
810 switch_to_frame_table_section (for_eh, false);
812 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
813 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
815 /* Output the CIE. */
816 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
817 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
818 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
819 dw2_asm_output_data (4, 0xffffffff,
820 "Initial length escape value indicating 64-bit DWARF extension");
821 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
822 "Length of Common Information Entry");
823 ASM_OUTPUT_LABEL (asm_out_file, l1);
825 /* Now that the CIE pointer is PC-relative for EH,
826 use 0 to identify the CIE. */
827 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
828 (for_eh ? 0 : DWARF_CIE_ID),
829 "CIE Identifier Tag");
831 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
832 use CIE version 1, unless that would produce incorrect results
833 due to overflowing the return register column. */
834 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
836 if (return_reg >= 256 || dwarf_version > 2)
838 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
841 augmentation_size = 0;
843 personality = current_unit_personality;
849 z Indicates that a uleb128 is present to size the
850 augmentation section.
851 L Indicates the encoding (and thus presence) of
852 an LSDA pointer in the FDE augmentation.
853 R Indicates a non-default pointer encoding for
855 P Indicates the presence of an encoding + language
856 personality routine in the CIE augmentation. */
858 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
859 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
860 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
862 p = augmentation + 1;
866 augmentation_size += 1 + size_of_encoded_value (per_encoding);
867 assemble_external_libcall (personality);
872 augmentation_size += 1;
874 if (fde_encoding != DW_EH_PE_absptr)
877 augmentation_size += 1;
879 if (p > augmentation + 1)
881 augmentation[0] = 'z';
885 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
886 if (personality && per_encoding == DW_EH_PE_aligned)
888 int offset = ( 4 /* Length */
890 + 1 /* CIE version */
891 + strlen (augmentation) + 1 /* Augmentation */
892 + size_of_uleb128 (1) /* Code alignment */
893 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
895 + 1 /* Augmentation size */
896 + 1 /* Personality encoding */ );
897 int pad = -offset & (PTR_SIZE - 1);
899 augmentation_size += pad;
901 /* Augmentations should be small, so there's scarce need to
902 iterate for a solution. Die if we exceed one uleb128 byte. */
903 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
907 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
908 if (dw_cie_version >= 4)
910 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
911 dw2_asm_output_data (1, 0, "CIE Segment Size");
913 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
914 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
915 "CIE Data Alignment Factor");
917 if (dw_cie_version == 1)
918 dw2_asm_output_data (1, return_reg, "CIE RA Column");
920 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
924 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
927 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
928 eh_data_format_name (per_encoding));
929 dw2_asm_output_encoded_addr_rtx (per_encoding,
935 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
936 eh_data_format_name (lsda_encoding));
938 if (fde_encoding != DW_EH_PE_absptr)
939 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
940 eh_data_format_name (fde_encoding));
943 FOR_EACH_VEC_ELT (*cie_cfi_vec, i, cfi)
944 output_cfi (cfi, NULL, for_eh);
946 /* Pad the CIE out to an address sized boundary. */
947 ASM_OUTPUT_ALIGN (asm_out_file,
948 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
949 ASM_OUTPUT_LABEL (asm_out_file, l2);
951 /* Loop through all of the FDE's. */
952 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
956 /* Don't emit EH unwind info for leaf functions that don't need it. */
957 if (for_eh && !fde_needed_for_eh_p (fde))
960 for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
961 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
962 augmentation, any_lsda_needed, lsda_encoding);
965 if (for_eh && targetm.terminate_dw2_eh_frame_info)
966 dw2_asm_output_data (4, 0, "End of Table");
968 /* Turn off app to make assembly quicker. */
973 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
976 dwarf2out_do_cfi_startproc (bool second)
980 rtx personality = get_personality_function (current_function_decl);
982 fprintf (asm_out_file, "\t.cfi_startproc\n");
986 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
989 /* ??? The GAS support isn't entirely consistent. We have to
990 handle indirect support ourselves, but PC-relative is done
991 in the assembler. Further, the assembler can't handle any
992 of the weirder relocation types. */
993 if (enc & DW_EH_PE_indirect)
994 ref = dw2_force_const_mem (ref, true);
996 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
997 output_addr_const (asm_out_file, ref);
998 fputc ('\n', asm_out_file);
1001 if (crtl->uses_eh_lsda)
1005 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1006 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
1007 current_function_funcdef_no);
1008 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
1009 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
1011 if (enc & DW_EH_PE_indirect)
1012 ref = dw2_force_const_mem (ref, true);
1014 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
1015 output_addr_const (asm_out_file, ref);
1016 fputc ('\n', asm_out_file);
1020 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1021 this allocation may be done before pass_final. */
1024 dwarf2out_alloc_current_fde (void)
1028 fde = ggc_cleared_alloc<dw_fde_node> ();
1029 fde->decl = current_function_decl;
1030 fde->funcdef_number = current_function_funcdef_no;
1031 fde->fde_index = vec_safe_length (fde_vec);
1032 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
1033 fde->uses_eh_lsda = crtl->uses_eh_lsda;
1034 fde->nothrow = crtl->nothrow;
1035 fde->drap_reg = INVALID_REGNUM;
1036 fde->vdrap_reg = INVALID_REGNUM;
1038 /* Record the FDE associated with this function. */
1040 vec_safe_push (fde_vec, fde);
1045 /* Output a marker (i.e. a label) for the beginning of a function, before
1049 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
1050 const char *file ATTRIBUTE_UNUSED)
1052 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1058 current_function_func_begin_label = NULL;
1060 do_frame = dwarf2out_do_frame ();
1062 /* ??? current_function_func_begin_label is also used by except.c for
1063 call-site information. We must emit this label if it might be used. */
1065 && (!flag_exceptions
1066 || targetm_common.except_unwind_info (&global_options) == UI_SJLJ))
1069 fnsec = function_section (current_function_decl);
1070 switch_to_section (fnsec);
1071 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1072 current_function_funcdef_no);
1073 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
1074 current_function_funcdef_no);
1075 dup_label = xstrdup (label);
1076 current_function_func_begin_label = dup_label;
1078 /* We can elide the fde allocation if we're not emitting debug info. */
1082 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1083 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1084 would include pass_dwarf2_frame. If we've not created the FDE yet,
1088 fde = dwarf2out_alloc_current_fde ();
1090 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1091 fde->dw_fde_begin = dup_label;
1092 fde->dw_fde_current_label = dup_label;
1093 fde->in_std_section = (fnsec == text_section
1094 || (cold_text_section && fnsec == cold_text_section));
1096 /* We only want to output line number information for the genuine dwarf2
1097 prologue case, not the eh frame case. */
1098 #ifdef DWARF2_DEBUGGING_INFO
1100 dwarf2out_source_line (line, file, 0, true);
1103 if (dwarf2out_do_cfi_asm ())
1104 dwarf2out_do_cfi_startproc (false);
1107 rtx personality = get_personality_function (current_function_decl);
1108 if (!current_unit_personality)
1109 current_unit_personality = personality;
1111 /* We cannot keep a current personality per function as without CFI
1112 asm, at the point where we emit the CFI data, there is no current
1113 function anymore. */
1114 if (personality && current_unit_personality != personality)
1115 sorry ("multiple EH personalities are supported only with assemblers "
1116 "supporting .cfi_personality directive");
1120 /* Output a marker (i.e. a label) for the end of the generated code
1121 for a function prologue. This gets called *after* the prologue code has
1125 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
1126 const char *file ATTRIBUTE_UNUSED)
1128 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1130 /* Output a label to mark the endpoint of the code generated for this
1132 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1133 current_function_funcdef_no);
1134 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
1135 current_function_funcdef_no);
1136 cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1139 /* Output a marker (i.e. a label) for the beginning of the generated code
1140 for a function epilogue. This gets called *before* the prologue code has
1144 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1145 const char *file ATTRIBUTE_UNUSED)
1147 dw_fde_ref fde = cfun->fde;
1148 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1150 if (fde->dw_fde_vms_begin_epilogue)
1153 /* Output a label to mark the endpoint of the code generated for this
1155 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1156 current_function_funcdef_no);
1157 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
1158 current_function_funcdef_no);
1159 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1162 /* Output a marker (i.e. a label) for the absolute end of the generated code
1163 for a function definition. This gets called *after* the epilogue code has
1167 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1168 const char *file ATTRIBUTE_UNUSED)
1171 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1173 last_var_location_insn = NULL;
1174 cached_next_real_insn = NULL;
1176 if (dwarf2out_do_cfi_asm ())
1177 fprintf (asm_out_file, "\t.cfi_endproc\n");
1179 /* Output a label to mark the endpoint of the code generated for this
1181 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1182 current_function_funcdef_no);
1183 ASM_OUTPUT_LABEL (asm_out_file, label);
1185 gcc_assert (fde != NULL);
1186 if (fde->dw_fde_second_begin == NULL)
1187 fde->dw_fde_end = xstrdup (label);
1191 dwarf2out_frame_finish (void)
1193 /* Output call frame information. */
1194 if (targetm.debug_unwind_info () == UI_DWARF2)
1195 output_call_frame_info (0);
1197 /* Output another copy for the unwinder. */
1198 if ((flag_unwind_tables || flag_exceptions)
1199 && targetm_common.except_unwind_info (&global_options) == UI_DWARF2)
1200 output_call_frame_info (1);
1203 /* Note that the current function section is being used for code. */
1206 dwarf2out_note_section_used (void)
1208 section *sec = current_function_section ();
1209 if (sec == text_section)
1210 text_section_used = true;
1211 else if (sec == cold_text_section)
1212 cold_text_section_used = true;
1215 static void var_location_switch_text_section (void);
1216 static void set_cur_line_info_table (section *);
1219 dwarf2out_switch_text_section (void)
1222 dw_fde_ref fde = cfun->fde;
1224 gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
1226 if (!in_cold_section_p)
1228 fde->dw_fde_end = crtl->subsections.cold_section_end_label;
1229 fde->dw_fde_second_begin = crtl->subsections.hot_section_label;
1230 fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
1234 fde->dw_fde_end = crtl->subsections.hot_section_end_label;
1235 fde->dw_fde_second_begin = crtl->subsections.cold_section_label;
1236 fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
1238 have_multiple_function_sections = true;
1240 /* There is no need to mark used sections when not debugging. */
1241 if (cold_text_section != NULL)
1242 dwarf2out_note_section_used ();
1244 if (dwarf2out_do_cfi_asm ())
1245 fprintf (asm_out_file, "\t.cfi_endproc\n");
1247 /* Now do the real section switch. */
1248 sect = current_function_section ();
1249 switch_to_section (sect);
1251 fde->second_in_std_section
1252 = (sect == text_section
1253 || (cold_text_section && sect == cold_text_section));
1255 if (dwarf2out_do_cfi_asm ())
1256 dwarf2out_do_cfi_startproc (true);
1258 var_location_switch_text_section ();
1260 if (cold_text_section != NULL)
1261 set_cur_line_info_table (sect);
1264 /* And now, the subset of the debugging information support code necessary
1265 for emitting location expressions. */
1267 /* Data about a single source file. */
1268 struct GTY((for_user)) dwarf_file_data {
1269 const char * filename;
1273 typedef struct GTY(()) deferred_locations_struct
1277 } deferred_locations;
1280 static GTY(()) vec<deferred_locations, va_gc> *deferred_locations_list;
1283 /* Describe an entry into the .debug_addr section. */
1287 ate_kind_rtx_dtprel,
1291 typedef struct GTY((for_user)) addr_table_entry_struct {
1293 unsigned int refcount;
1295 union addr_table_entry_struct_union
1297 rtx GTY ((tag ("0"))) rtl;
1298 char * GTY ((tag ("1"))) label;
1300 GTY ((desc ("%1.kind"))) addr;
1304 /* Location lists are ranges + location descriptions for that range,
1305 so you can track variables that are in different places over
1306 their entire life. */
1307 typedef struct GTY(()) dw_loc_list_struct {
1308 dw_loc_list_ref dw_loc_next;
1309 const char *begin; /* Label and addr_entry for start of range */
1310 addr_table_entry *begin_entry;
1311 const char *end; /* Label for end of range */
1312 char *ll_symbol; /* Label for beginning of location list.
1313 Only on head of list */
1314 const char *section; /* Section this loclist is relative to */
1315 dw_loc_descr_ref expr;
1317 /* True if all addresses in this and subsequent lists are known to be
1320 /* True if this list has been replaced by dw_loc_next. */
1323 /* True if the range should be emitted even if begin and end
1328 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
1330 /* Convert a DWARF stack opcode into its string name. */
1333 dwarf_stack_op_name (unsigned int op)
1335 const char *name = get_DW_OP_name (op);
1340 return "OP_<unknown>";
1343 /* Return a pointer to a newly allocated location description. Location
1344 descriptions are simple expression terms that can be strung
1345 together to form more complicated location (address) descriptions. */
1347 static inline dw_loc_descr_ref
1348 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
1349 unsigned HOST_WIDE_INT oprnd2)
1351 dw_loc_descr_ref descr = ggc_cleared_alloc<dw_loc_descr_node> ();
1353 descr->dw_loc_opc = op;
1354 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
1355 descr->dw_loc_oprnd1.val_entry = NULL;
1356 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
1357 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
1358 descr->dw_loc_oprnd2.val_entry = NULL;
1359 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
1364 /* Return a pointer to a newly allocated location description for
1367 static inline dw_loc_descr_ref
1368 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
1371 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
1374 return new_loc_descr (DW_OP_bregx, reg, offset);
1377 /* Add a location description term to a location description expression. */
1380 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
1382 dw_loc_descr_ref *d;
1384 /* Find the end of the chain. */
1385 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
1391 /* Compare two location operands for exact equality. */
1394 dw_val_equal_p (dw_val_node *a, dw_val_node *b)
1396 if (a->val_class != b->val_class)
1398 switch (a->val_class)
1400 case dw_val_class_none:
1402 case dw_val_class_addr:
1403 return rtx_equal_p (a->v.val_addr, b->v.val_addr);
1405 case dw_val_class_offset:
1406 case dw_val_class_unsigned_const:
1407 case dw_val_class_const:
1408 case dw_val_class_range_list:
1409 case dw_val_class_lineptr:
1410 case dw_val_class_macptr:
1411 /* These are all HOST_WIDE_INT, signed or unsigned. */
1412 return a->v.val_unsigned == b->v.val_unsigned;
1414 case dw_val_class_loc:
1415 return a->v.val_loc == b->v.val_loc;
1416 case dw_val_class_loc_list:
1417 return a->v.val_loc_list == b->v.val_loc_list;
1418 case dw_val_class_die_ref:
1419 return a->v.val_die_ref.die == b->v.val_die_ref.die;
1420 case dw_val_class_fde_ref:
1421 return a->v.val_fde_index == b->v.val_fde_index;
1422 case dw_val_class_lbl_id:
1423 case dw_val_class_high_pc:
1424 return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0;
1425 case dw_val_class_str:
1426 return a->v.val_str == b->v.val_str;
1427 case dw_val_class_flag:
1428 return a->v.val_flag == b->v.val_flag;
1429 case dw_val_class_file:
1430 return a->v.val_file == b->v.val_file;
1431 case dw_val_class_decl_ref:
1432 return a->v.val_decl_ref == b->v.val_decl_ref;
1434 case dw_val_class_const_double:
1435 return (a->v.val_double.high == b->v.val_double.high
1436 && a->v.val_double.low == b->v.val_double.low);
1438 case dw_val_class_wide_int:
1439 return *a->v.val_wide == *b->v.val_wide;
1441 case dw_val_class_vec:
1443 size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length;
1444 size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length;
1446 return (a_len == b_len
1447 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len));
1450 case dw_val_class_data8:
1451 return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0;
1453 case dw_val_class_vms_delta:
1454 return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)
1455 && !strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1));
1460 /* Compare two location atoms for exact equality. */
1463 loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b)
1465 if (a->dw_loc_opc != b->dw_loc_opc)
1468 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1469 address size, but since we always allocate cleared storage it
1470 should be zero for other types of locations. */
1471 if (a->dtprel != b->dtprel)
1474 return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1)
1475 && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2));
1478 /* Compare two complete location expressions for exact equality. */
1481 loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b)
1487 if (a == NULL || b == NULL)
1489 if (!loc_descr_equal_p_1 (a, b))
1498 /* Add a constant OFFSET to a location expression. */
1501 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
1503 dw_loc_descr_ref loc;
1506 gcc_assert (*list_head != NULL);
1511 /* Find the end of the chain. */
1512 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
1516 if (loc->dw_loc_opc == DW_OP_fbreg
1517 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
1518 p = &loc->dw_loc_oprnd1.v.val_int;
1519 else if (loc->dw_loc_opc == DW_OP_bregx)
1520 p = &loc->dw_loc_oprnd2.v.val_int;
1522 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1523 offset. Don't optimize if an signed integer overflow would happen. */
1525 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1526 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1529 else if (offset > 0)
1530 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1534 loc->dw_loc_next = int_loc_descriptor (-offset);
1535 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
1539 /* Add a constant OFFSET to a location list. */
1542 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
1545 for (d = list_head; d != NULL; d = d->dw_loc_next)
1546 loc_descr_plus_const (&d->expr, offset);
1549 #define DWARF_REF_SIZE \
1550 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1552 static unsigned long int get_base_type_offset (dw_die_ref);
1554 /* Return the size of a location descriptor. */
1556 static unsigned long
1557 size_of_loc_descr (dw_loc_descr_ref loc)
1559 unsigned long size = 1;
1561 switch (loc->dw_loc_opc)
1564 size += DWARF2_ADDR_SIZE;
1566 case DW_OP_GNU_addr_index:
1567 case DW_OP_GNU_const_index:
1568 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
1569 size += size_of_uleb128 (loc->dw_loc_oprnd1.val_entry->index);
1588 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1591 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1596 case DW_OP_plus_uconst:
1597 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1635 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1638 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1641 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1644 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1645 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1648 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1650 case DW_OP_bit_piece:
1651 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1652 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
1654 case DW_OP_deref_size:
1655 case DW_OP_xderef_size:
1664 case DW_OP_call_ref:
1665 size += DWARF_REF_SIZE;
1667 case DW_OP_implicit_value:
1668 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1669 + loc->dw_loc_oprnd1.v.val_unsigned;
1671 case DW_OP_GNU_implicit_pointer:
1672 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1674 case DW_OP_GNU_entry_value:
1676 unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
1677 size += size_of_uleb128 (op_size) + op_size;
1680 case DW_OP_GNU_const_type:
1683 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1684 size += size_of_uleb128 (o) + 1;
1685 switch (loc->dw_loc_oprnd2.val_class)
1687 case dw_val_class_vec:
1688 size += loc->dw_loc_oprnd2.v.val_vec.length
1689 * loc->dw_loc_oprnd2.v.val_vec.elt_size;
1691 case dw_val_class_const:
1692 size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1694 case dw_val_class_const_double:
1695 size += HOST_BITS_PER_DOUBLE_INT / BITS_PER_UNIT;
1697 case dw_val_class_wide_int:
1698 size += (get_full_len (*loc->dw_loc_oprnd2.v.val_wide)
1699 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
1706 case DW_OP_GNU_regval_type:
1709 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1710 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1711 + size_of_uleb128 (o);
1714 case DW_OP_GNU_deref_type:
1717 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1718 size += 1 + size_of_uleb128 (o);
1721 case DW_OP_GNU_convert:
1722 case DW_OP_GNU_reinterpret:
1723 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
1724 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1728 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1729 size += size_of_uleb128 (o);
1732 case DW_OP_GNU_parameter_ref:
1742 /* Return the size of a series of location descriptors. */
1745 size_of_locs (dw_loc_descr_ref loc)
1750 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1751 field, to avoid writing to a PCH file. */
1752 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1754 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
1756 size += size_of_loc_descr (l);
1761 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
1763 l->dw_loc_addr = size;
1764 size += size_of_loc_descr (l);
1770 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
1771 static void get_ref_die_offset_label (char *, dw_die_ref);
1772 static unsigned long int get_ref_die_offset (dw_die_ref);
1774 /* Output location description stack opcode's operands (if any).
1775 The for_eh_or_skip parameter controls whether register numbers are
1776 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1777 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1778 info). This should be suppressed for the cases that have not been converted
1779 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1782 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
1784 dw_val_ref val1 = &loc->dw_loc_oprnd1;
1785 dw_val_ref val2 = &loc->dw_loc_oprnd2;
1787 switch (loc->dw_loc_opc)
1789 #ifdef DWARF2_DEBUGGING_INFO
1792 dw2_asm_output_data (2, val1->v.val_int, NULL);
1797 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1798 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
1800 fputc ('\n', asm_out_file);
1805 dw2_asm_output_data (4, val1->v.val_int, NULL);
1810 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
1811 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
1813 fputc ('\n', asm_out_file);
1818 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
1819 dw2_asm_output_data (8, val1->v.val_int, NULL);
1826 gcc_assert (val1->val_class == dw_val_class_loc);
1827 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
1829 dw2_asm_output_data (2, offset, NULL);
1832 case DW_OP_implicit_value:
1833 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1834 switch (val2->val_class)
1836 case dw_val_class_const:
1837 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
1839 case dw_val_class_vec:
1841 unsigned int elt_size = val2->v.val_vec.elt_size;
1842 unsigned int len = val2->v.val_vec.length;
1846 if (elt_size > sizeof (HOST_WIDE_INT))
1851 for (i = 0, p = val2->v.val_vec.array;
1854 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
1855 "fp or vector constant word %u", i);
1858 case dw_val_class_const_double:
1860 unsigned HOST_WIDE_INT first, second;
1862 if (WORDS_BIG_ENDIAN)
1864 first = val2->v.val_double.high;
1865 second = val2->v.val_double.low;
1869 first = val2->v.val_double.low;
1870 second = val2->v.val_double.high;
1872 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1874 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1878 case dw_val_class_wide_int:
1881 int len = get_full_len (*val2->v.val_wide);
1882 if (WORDS_BIG_ENDIAN)
1883 for (i = len - 1; i >= 0; --i)
1884 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1885 val2->v.val_wide->elt (i), NULL);
1887 for (i = 0; i < len; ++i)
1888 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
1889 val2->v.val_wide->elt (i), NULL);
1892 case dw_val_class_addr:
1893 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
1894 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
1909 case DW_OP_implicit_value:
1910 /* We currently don't make any attempt to make sure these are
1911 aligned properly like we do for the main unwind info, so
1912 don't support emitting things larger than a byte if we're
1913 only doing unwinding. */
1918 dw2_asm_output_data (1, val1->v.val_int, NULL);
1921 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1924 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1927 dw2_asm_output_data (1, val1->v.val_int, NULL);
1929 case DW_OP_plus_uconst:
1930 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1964 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1968 unsigned r = val1->v.val_unsigned;
1969 if (for_eh_or_skip >= 0)
1970 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
1971 gcc_assert (size_of_uleb128 (r)
1972 == size_of_uleb128 (val1->v.val_unsigned));
1973 dw2_asm_output_data_uleb128 (r, NULL);
1977 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
1981 unsigned r = val1->v.val_unsigned;
1982 if (for_eh_or_skip >= 0)
1983 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
1984 gcc_assert (size_of_uleb128 (r)
1985 == size_of_uleb128 (val1->v.val_unsigned));
1986 dw2_asm_output_data_uleb128 (r, NULL);
1987 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
1991 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1993 case DW_OP_bit_piece:
1994 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
1995 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
1997 case DW_OP_deref_size:
1998 case DW_OP_xderef_size:
1999 dw2_asm_output_data (1, val1->v.val_int, NULL);
2005 if (targetm.asm_out.output_dwarf_dtprel)
2007 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
2010 fputc ('\n', asm_out_file);
2017 #ifdef DWARF2_DEBUGGING_INFO
2018 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2025 case DW_OP_GNU_addr_index:
2026 case DW_OP_GNU_const_index:
2027 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
2028 dw2_asm_output_data_uleb128 (loc->dw_loc_oprnd1.val_entry->index,
2029 "(index into .debug_addr)");
2032 case DW_OP_GNU_implicit_pointer:
2034 char label[MAX_ARTIFICIAL_LABEL_BYTES
2035 + HOST_BITS_PER_WIDE_INT / 2 + 2];
2036 gcc_assert (val1->val_class == dw_val_class_die_ref);
2037 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2038 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2039 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2043 case DW_OP_GNU_entry_value:
2044 dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
2045 output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
2048 case DW_OP_GNU_const_type:
2050 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
2052 dw2_asm_output_data_uleb128 (o, NULL);
2053 switch (val2->val_class)
2055 case dw_val_class_const:
2056 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2057 dw2_asm_output_data (1, l, NULL);
2058 dw2_asm_output_data (l, val2->v.val_int, NULL);
2060 case dw_val_class_vec:
2062 unsigned int elt_size = val2->v.val_vec.elt_size;
2063 unsigned int len = val2->v.val_vec.length;
2068 dw2_asm_output_data (1, l, NULL);
2069 if (elt_size > sizeof (HOST_WIDE_INT))
2074 for (i = 0, p = val2->v.val_vec.array;
2077 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2078 "fp or vector constant word %u", i);
2081 case dw_val_class_const_double:
2083 unsigned HOST_WIDE_INT first, second;
2084 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2086 dw2_asm_output_data (1, 2 * l, NULL);
2087 if (WORDS_BIG_ENDIAN)
2089 first = val2->v.val_double.high;
2090 second = val2->v.val_double.low;
2094 first = val2->v.val_double.low;
2095 second = val2->v.val_double.high;
2097 dw2_asm_output_data (l, first, NULL);
2098 dw2_asm_output_data (l, second, NULL);
2101 case dw_val_class_wide_int:
2104 int len = get_full_len (*val2->v.val_wide);
2105 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2107 dw2_asm_output_data (1, len * l, NULL);
2108 if (WORDS_BIG_ENDIAN)
2109 for (i = len - 1; i >= 0; --i)
2110 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2112 for (i = 0; i < len; ++i)
2113 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2121 case DW_OP_GNU_regval_type:
2123 unsigned r = val1->v.val_unsigned;
2124 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2126 if (for_eh_or_skip >= 0)
2128 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2129 gcc_assert (size_of_uleb128 (r)
2130 == size_of_uleb128 (val1->v.val_unsigned));
2132 dw2_asm_output_data_uleb128 (r, NULL);
2133 dw2_asm_output_data_uleb128 (o, NULL);
2136 case DW_OP_GNU_deref_type:
2138 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2140 dw2_asm_output_data (1, val1->v.val_int, NULL);
2141 dw2_asm_output_data_uleb128 (o, NULL);
2144 case DW_OP_GNU_convert:
2145 case DW_OP_GNU_reinterpret:
2146 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
2147 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2150 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
2152 dw2_asm_output_data_uleb128 (o, NULL);
2156 case DW_OP_GNU_parameter_ref:
2159 gcc_assert (val1->val_class == dw_val_class_die_ref);
2160 o = get_ref_die_offset (val1->v.val_die_ref.die);
2161 dw2_asm_output_data (4, o, NULL);
2166 /* Other codes have no operands. */
2171 /* Output a sequence of location operations.
2172 The for_eh_or_skip parameter controls whether register numbers are
2173 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2174 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2175 info). This should be suppressed for the cases that have not been converted
2176 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2179 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
2181 for (; loc != NULL; loc = loc->dw_loc_next)
2183 enum dwarf_location_atom opc = loc->dw_loc_opc;
2184 /* Output the opcode. */
2185 if (for_eh_or_skip >= 0
2186 && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2188 unsigned r = (opc - DW_OP_breg0);
2189 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2190 gcc_assert (r <= 31);
2191 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2193 else if (for_eh_or_skip >= 0
2194 && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2196 unsigned r = (opc - DW_OP_reg0);
2197 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2198 gcc_assert (r <= 31);
2199 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2202 dw2_asm_output_data (1, opc,
2203 "%s", dwarf_stack_op_name (opc));
2205 /* Output the operand(s) (if any). */
2206 output_loc_operands (loc, for_eh_or_skip);
2210 /* Output location description stack opcode's operands (if any).
2211 The output is single bytes on a line, suitable for .cfi_escape. */
2214 output_loc_operands_raw (dw_loc_descr_ref loc)
2216 dw_val_ref val1 = &loc->dw_loc_oprnd1;
2217 dw_val_ref val2 = &loc->dw_loc_oprnd2;
2219 switch (loc->dw_loc_opc)
2222 case DW_OP_GNU_addr_index:
2223 case DW_OP_GNU_const_index:
2224 case DW_OP_implicit_value:
2225 /* We cannot output addresses in .cfi_escape, only bytes. */
2231 case DW_OP_deref_size:
2232 case DW_OP_xderef_size:
2233 fputc (',', asm_out_file);
2234 dw2_asm_output_data_raw (1, val1->v.val_int);
2239 fputc (',', asm_out_file);
2240 dw2_asm_output_data_raw (2, val1->v.val_int);
2245 fputc (',', asm_out_file);
2246 dw2_asm_output_data_raw (4, val1->v.val_int);
2251 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2252 fputc (',', asm_out_file);
2253 dw2_asm_output_data_raw (8, val1->v.val_int);
2261 gcc_assert (val1->val_class == dw_val_class_loc);
2262 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2264 fputc (',', asm_out_file);
2265 dw2_asm_output_data_raw (2, offset);
2271 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2272 gcc_assert (size_of_uleb128 (r)
2273 == size_of_uleb128 (val1->v.val_unsigned));
2274 fputc (',', asm_out_file);
2275 dw2_asm_output_data_uleb128_raw (r);
2280 case DW_OP_plus_uconst:
2282 fputc (',', asm_out_file);
2283 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2286 case DW_OP_bit_piece:
2287 fputc (',', asm_out_file);
2288 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2289 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
2326 fputc (',', asm_out_file);
2327 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
2332 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2333 gcc_assert (size_of_uleb128 (r)
2334 == size_of_uleb128 (val1->v.val_unsigned));
2335 fputc (',', asm_out_file);
2336 dw2_asm_output_data_uleb128_raw (r);
2337 fputc (',', asm_out_file);
2338 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
2342 case DW_OP_GNU_implicit_pointer:
2343 case DW_OP_GNU_entry_value:
2344 case DW_OP_GNU_const_type:
2345 case DW_OP_GNU_regval_type:
2346 case DW_OP_GNU_deref_type:
2347 case DW_OP_GNU_convert:
2348 case DW_OP_GNU_reinterpret:
2349 case DW_OP_GNU_parameter_ref:
2354 /* Other codes have no operands. */
2360 output_loc_sequence_raw (dw_loc_descr_ref loc)
2364 enum dwarf_location_atom opc = loc->dw_loc_opc;
2365 /* Output the opcode. */
2366 if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2368 unsigned r = (opc - DW_OP_breg0);
2369 r = DWARF2_FRAME_REG_OUT (r, 1);
2370 gcc_assert (r <= 31);
2371 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2373 else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2375 unsigned r = (opc - DW_OP_reg0);
2376 r = DWARF2_FRAME_REG_OUT (r, 1);
2377 gcc_assert (r <= 31);
2378 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2380 /* Output the opcode. */
2381 fprintf (asm_out_file, "%#x", opc);
2382 output_loc_operands_raw (loc);
2384 if (!loc->dw_loc_next)
2386 loc = loc->dw_loc_next;
2388 fputc (',', asm_out_file);
2392 /* This function builds a dwarf location descriptor sequence from a
2393 dw_cfa_location, adding the given OFFSET to the result of the
2396 struct dw_loc_descr_node *
2397 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
2399 struct dw_loc_descr_node *head, *tmp;
2401 offset += cfa->offset;
2405 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
2406 head->dw_loc_oprnd1.val_class = dw_val_class_const;
2407 head->dw_loc_oprnd1.val_entry = NULL;
2408 tmp = new_loc_descr (DW_OP_deref, 0, 0);
2409 add_loc_descr (&head, tmp);
2412 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
2413 add_loc_descr (&head, tmp);
2417 head = new_reg_loc_descr (cfa->reg, offset);
2422 /* This function builds a dwarf location descriptor sequence for
2423 the address at OFFSET from the CFA when stack is aligned to
2426 struct dw_loc_descr_node *
2427 build_cfa_aligned_loc (dw_cfa_location *cfa,
2428 HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
2430 struct dw_loc_descr_node *head;
2431 unsigned int dwarf_fp
2432 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
2434 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2435 if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
2437 head = new_reg_loc_descr (dwarf_fp, 0);
2438 add_loc_descr (&head, int_loc_descriptor (alignment));
2439 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
2440 loc_descr_plus_const (&head, offset);
2443 head = new_reg_loc_descr (dwarf_fp, offset);
2447 /* And now, the support for symbolic debugging information. */
2449 /* .debug_str support. */
2451 static void dwarf2out_init (const char *);
2452 static void dwarf2out_finish (const char *);
2453 static void dwarf2out_assembly_start (void);
2454 static void dwarf2out_define (unsigned int, const char *);
2455 static void dwarf2out_undef (unsigned int, const char *);
2456 static void dwarf2out_start_source_file (unsigned, const char *);
2457 static void dwarf2out_end_source_file (unsigned);
2458 static void dwarf2out_function_decl (tree);
2459 static void dwarf2out_begin_block (unsigned, unsigned);
2460 static void dwarf2out_end_block (unsigned, unsigned);
2461 static bool dwarf2out_ignore_block (const_tree);
2462 static void dwarf2out_global_decl (tree);
2463 static void dwarf2out_type_decl (tree, int);
2464 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
2465 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
2467 static void dwarf2out_abstract_function (tree);
2468 static void dwarf2out_var_location (rtx_insn *);
2469 static void dwarf2out_begin_function (tree);
2470 static void dwarf2out_end_function (unsigned int);
2471 static void dwarf2out_register_main_translation_unit (tree unit);
2472 static void dwarf2out_set_name (tree, tree);
2474 /* The debug hooks structure. */
2476 const struct gcc_debug_hooks dwarf2_debug_hooks =
2480 dwarf2out_assembly_start,
2483 dwarf2out_start_source_file,
2484 dwarf2out_end_source_file,
2485 dwarf2out_begin_block,
2486 dwarf2out_end_block,
2487 dwarf2out_ignore_block,
2488 dwarf2out_source_line,
2489 dwarf2out_begin_prologue,
2490 #if VMS_DEBUGGING_INFO
2491 dwarf2out_vms_end_prologue,
2492 dwarf2out_vms_begin_epilogue,
2494 debug_nothing_int_charstar,
2495 debug_nothing_int_charstar,
2497 dwarf2out_end_epilogue,
2498 dwarf2out_begin_function,
2499 dwarf2out_end_function, /* end_function */
2500 dwarf2out_register_main_translation_unit,
2501 dwarf2out_function_decl, /* function_decl */
2502 dwarf2out_global_decl,
2503 dwarf2out_type_decl, /* type_decl */
2504 dwarf2out_imported_module_or_decl,
2505 debug_nothing_tree, /* deferred_inline_function */
2506 /* The DWARF 2 backend tries to reduce debugging bloat by not
2507 emitting the abstract description of inline functions until
2508 something tries to reference them. */
2509 dwarf2out_abstract_function, /* outlining_inline_function */
2510 debug_nothing_rtx_code_label, /* label */
2511 debug_nothing_int, /* handle_pch */
2512 dwarf2out_var_location,
2513 dwarf2out_switch_text_section,
2515 1, /* start_end_main_source_file */
2516 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */
2519 /* NOTE: In the comments in this file, many references are made to
2520 "Debugging Information Entries". This term is abbreviated as `DIE'
2521 throughout the remainder of this file. */
2523 /* An internal representation of the DWARF output is built, and then
2524 walked to generate the DWARF debugging info. The walk of the internal
2525 representation is done after the entire program has been compiled.
2526 The types below are used to describe the internal representation. */
2528 /* Whether to put type DIEs into their own section .debug_types instead
2529 of making them part of the .debug_info section. Only supported for
2530 Dwarf V4 or higher and the user didn't disable them through
2531 -fno-debug-types-section. It is more efficient to put them in a
2532 separate comdat sections since the linker will then be able to
2533 remove duplicates. But not all tools support .debug_types sections
2536 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2538 /* Various DIE's use offsets relative to the beginning of the
2539 .debug_info section to refer to each other. */
2541 typedef long int dw_offset;
2543 /* Define typedefs here to avoid circular dependencies. */
2545 typedef struct dw_attr_struct *dw_attr_ref;
2546 typedef struct dw_line_info_struct *dw_line_info_ref;
2547 typedef struct pubname_struct *pubname_ref;
2548 typedef struct dw_ranges_struct *dw_ranges_ref;
2549 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
2550 typedef struct comdat_type_struct *comdat_type_node_ref;
2552 /* The entries in the line_info table more-or-less mirror the opcodes
2553 that are used in the real dwarf line table. Arrays of these entries
2554 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2557 enum dw_line_info_opcode {
2558 /* Emit DW_LNE_set_address; the operand is the label index. */
2561 /* Emit a row to the matrix with the given line. This may be done
2562 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2566 /* Emit a DW_LNS_set_file. */
2569 /* Emit a DW_LNS_set_column. */
2572 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2575 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2576 LI_set_prologue_end,
2577 LI_set_epilogue_begin,
2579 /* Emit a DW_LNE_set_discriminator. */
2580 LI_set_discriminator
2583 typedef struct GTY(()) dw_line_info_struct {
2584 enum dw_line_info_opcode opcode;
2586 } dw_line_info_entry;
2589 typedef struct GTY(()) dw_line_info_table_struct {
2590 /* The label that marks the end of this section. */
2591 const char *end_label;
2593 /* The values for the last row of the matrix, as collected in the table.
2594 These are used to minimize the changes to the next row. */
2595 unsigned int file_num;
2596 unsigned int line_num;
2597 unsigned int column_num;
2602 vec<dw_line_info_entry, va_gc> *entries;
2603 } dw_line_info_table;
2605 typedef dw_line_info_table *dw_line_info_table_p;
2608 /* Each DIE attribute has a field specifying the attribute kind,
2609 a link to the next attribute in the chain, and an attribute value.
2610 Attributes are typically linked below the DIE they modify. */
2612 typedef struct GTY(()) dw_attr_struct {
2613 enum dwarf_attribute dw_attr;
2614 dw_val_node dw_attr_val;
2619 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2620 The children of each node form a circular list linked by
2621 die_sib. die_child points to the node *before* the "first" child node. */
2623 typedef struct GTY((chain_circular ("%h.die_sib"), for_user)) die_struct {
2624 union die_symbol_or_type_node
2626 const char * GTY ((tag ("0"))) die_symbol;
2627 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
2629 GTY ((desc ("%0.comdat_type_p"))) die_id;
2630 vec<dw_attr_node, va_gc> *die_attr;
2631 dw_die_ref die_parent;
2632 dw_die_ref die_child;
2634 dw_die_ref die_definition; /* ref from a specification to its definition */
2635 dw_offset die_offset;
2636 unsigned long die_abbrev;
2638 unsigned int decl_id;
2639 enum dwarf_tag die_tag;
2640 /* Die is used and must not be pruned as unused. */
2641 BOOL_BITFIELD die_perennial_p : 1;
2642 BOOL_BITFIELD comdat_type_p : 1; /* DIE has a type signature */
2643 /* Lots of spare bits. */
2647 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2648 #define FOR_EACH_CHILD(die, c, expr) do { \
2649 c = die->die_child; \
2653 } while (c != die->die_child); \
2656 /* The pubname structure */
2658 typedef struct GTY(()) pubname_struct {
2665 struct GTY(()) dw_ranges_struct {
2666 /* If this is positive, it's a block number, otherwise it's a
2667 bitwise-negated index into dw_ranges_by_label. */
2671 /* A structure to hold a macinfo entry. */
2673 typedef struct GTY(()) macinfo_struct {
2675 unsigned HOST_WIDE_INT lineno;
2681 struct GTY(()) dw_ranges_by_label_struct {
2686 /* The comdat type node structure. */
2687 typedef struct GTY(()) comdat_type_struct
2689 dw_die_ref root_die;
2690 dw_die_ref type_die;
2691 dw_die_ref skeleton_die;
2692 char signature[DWARF_TYPE_SIGNATURE_SIZE];
2693 struct comdat_type_struct *next;
2697 /* The limbo die list structure. */
2698 typedef struct GTY(()) limbo_die_struct {
2701 struct limbo_die_struct *next;
2705 typedef struct skeleton_chain_struct
2709 struct skeleton_chain_struct *parent;
2711 skeleton_chain_node;
2713 /* Define a macro which returns nonzero for a TYPE_DECL which was
2714 implicitly generated for a type.
2716 Note that, unlike the C front-end (which generates a NULL named
2717 TYPE_DECL node for each complete tagged type, each array type,
2718 and each function type node created) the C++ front-end generates
2719 a _named_ TYPE_DECL node for each tagged type node created.
2720 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2721 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
2722 front-end, but for each type, tagged or not. */
2724 #define TYPE_DECL_IS_STUB(decl) \
2725 (DECL_NAME (decl) == NULL_TREE \
2726 || (DECL_ARTIFICIAL (decl) \
2727 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2728 /* This is necessary for stub decls that \
2729 appear in nested inline functions. */ \
2730 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2731 && (decl_ultimate_origin (decl) \
2732 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2734 /* Information concerning the compilation unit's programming
2735 language, and compiler version. */
2737 /* Fixed size portion of the DWARF compilation unit header. */
2738 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
2739 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
2741 /* Fixed size portion of the DWARF comdat type unit header. */
2742 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
2743 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
2744 + DWARF_OFFSET_SIZE)
2746 /* Fixed size portion of public names info. */
2747 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2749 /* Fixed size portion of the address range info. */
2750 #define DWARF_ARANGES_HEADER_SIZE \
2751 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2752 DWARF2_ADDR_SIZE * 2) \
2753 - DWARF_INITIAL_LENGTH_SIZE)
2755 /* Size of padding portion in the address range info. It must be
2756 aligned to twice the pointer size. */
2757 #define DWARF_ARANGES_PAD_SIZE \
2758 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
2759 DWARF2_ADDR_SIZE * 2) \
2760 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
2762 /* Use assembler line directives if available. */
2763 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2764 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
2765 #define DWARF2_ASM_LINE_DEBUG_INFO 1
2767 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2771 /* Minimum line offset in a special line info. opcode.
2772 This value was chosen to give a reasonable range of values. */
2773 #define DWARF_LINE_BASE -10
2775 /* First special line opcode - leave room for the standard opcodes. */
2776 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
2778 /* Range of line offsets in a special line info. opcode. */
2779 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2781 /* Flag that indicates the initial value of the is_stmt_start flag.
2782 In the present implementation, we do not mark any lines as
2783 the beginning of a source statement, because that information
2784 is not made available by the GCC front-end. */
2785 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2787 /* Maximum number of operations per instruction bundle. */
2788 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
2789 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
2792 /* This location is used by calc_die_sizes() to keep track
2793 the offset of each DIE within the .debug_info section. */
2794 static unsigned long next_die_offset;
2796 /* Record the root of the DIE's built for the current compilation unit. */
2797 static GTY(()) dw_die_ref single_comp_unit_die;
2799 /* A list of type DIEs that have been separated into comdat sections. */
2800 static GTY(()) comdat_type_node *comdat_type_list;
2802 /* A list of DIEs with a NULL parent waiting to be relocated. */
2803 static GTY(()) limbo_die_node *limbo_die_list;
2805 /* A list of DIEs for which we may have to generate
2806 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
2807 static GTY(()) limbo_die_node *deferred_asm_name;
2809 struct dwarf_file_hasher : ggc_hasher<dwarf_file_data *>
2811 typedef const char *compare_type;
2813 static hashval_t hash (dwarf_file_data *);
2814 static bool equal (dwarf_file_data *, const char *);
2817 /* Filenames referenced by this compilation unit. */
2818 static GTY(()) hash_table<dwarf_file_hasher> *file_table;
2820 struct decl_die_hasher : ggc_hasher<die_node *>
2822 typedef tree compare_type;
2824 static hashval_t hash (die_node *);
2825 static bool equal (die_node *, tree);
2827 /* A hash table of references to DIE's that describe declarations.
2828 The key is a DECL_UID() which is a unique number identifying each decl. */
2829 static GTY (()) hash_table<decl_die_hasher> *decl_die_table;
2831 struct block_die_hasher : ggc_hasher<die_struct *>
2833 static hashval_t hash (die_struct *);
2834 static bool equal (die_struct *, die_struct *);
2837 /* A hash table of references to DIE's that describe COMMON blocks.
2838 The key is DECL_UID() ^ die_parent. */
2839 static GTY (()) hash_table<block_die_hasher> *common_block_die_table;
2841 typedef struct GTY(()) die_arg_entry_struct {
2847 /* Node of the variable location list. */
2848 struct GTY ((chain_next ("%h.next"))) var_loc_node {
2849 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
2850 EXPR_LIST chain. For small bitsizes, bitsize is encoded
2851 in mode of the EXPR_LIST node and first EXPR_LIST operand
2852 is either NOTE_INSN_VAR_LOCATION for a piece with a known
2853 location or NULL for padding. For larger bitsizes,
2854 mode is 0 and first operand is a CONCAT with bitsize
2855 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
2856 NULL as second operand. */
2858 const char * GTY (()) label;
2859 struct var_loc_node * GTY (()) next;
2862 /* Variable location list. */
2863 struct GTY ((for_user)) var_loc_list_def {
2864 struct var_loc_node * GTY (()) first;
2866 /* Pointer to the last but one or last element of the
2867 chained list. If the list is empty, both first and
2868 last are NULL, if the list contains just one node
2869 or the last node certainly is not redundant, it points
2870 to the last node, otherwise points to the last but one.
2871 Do not mark it for GC because it is marked through the chain. */
2872 struct var_loc_node * GTY ((skip ("%h"))) last;
2874 /* Pointer to the last element before section switch,
2875 if NULL, either sections weren't switched or first
2876 is after section switch. */
2877 struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
2879 /* DECL_UID of the variable decl. */
2880 unsigned int decl_id;
2882 typedef struct var_loc_list_def var_loc_list;
2884 /* Call argument location list. */
2885 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
2886 rtx GTY (()) call_arg_loc_note;
2887 const char * GTY (()) label;
2888 tree GTY (()) block;
2890 rtx GTY (()) symbol_ref;
2891 struct call_arg_loc_node * GTY (()) next;
2895 struct decl_loc_hasher : ggc_hasher<var_loc_list *>
2897 typedef const_tree compare_type;
2899 static hashval_t hash (var_loc_list *);
2900 static bool equal (var_loc_list *, const_tree);
2903 /* Table of decl location linked lists. */
2904 static GTY (()) hash_table<decl_loc_hasher> *decl_loc_table;
2906 /* Head and tail of call_arg_loc chain. */
2907 static GTY (()) struct call_arg_loc_node *call_arg_locations;
2908 static struct call_arg_loc_node *call_arg_loc_last;
2910 /* Number of call sites in the current function. */
2911 static int call_site_count = -1;
2912 /* Number of tail call sites in the current function. */
2913 static int tail_call_site_count = -1;
2915 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
2917 static vec<dw_die_ref> block_map;
2919 /* A cached location list. */
2920 struct GTY ((for_user)) cached_dw_loc_list_def {
2921 /* The DECL_UID of the decl that this entry describes. */
2922 unsigned int decl_id;
2924 /* The cached location list. */
2925 dw_loc_list_ref loc_list;
2927 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
2929 struct dw_loc_list_hasher : ggc_hasher<cached_dw_loc_list *>
2932 typedef const_tree compare_type;
2934 static hashval_t hash (cached_dw_loc_list *);
2935 static bool equal (cached_dw_loc_list *, const_tree);
2938 /* Table of cached location lists. */
2939 static GTY (()) hash_table<dw_loc_list_hasher> *cached_dw_loc_list_table;
2941 /* A pointer to the base of a list of references to DIE's that
2942 are uniquely identified by their tag, presence/absence of
2943 children DIE's, and list of attribute/value pairs. */
2944 static GTY((length ("abbrev_die_table_allocated")))
2945 dw_die_ref *abbrev_die_table;
2947 /* Number of elements currently allocated for abbrev_die_table. */
2948 static GTY(()) unsigned abbrev_die_table_allocated;
2950 /* Number of elements in type_die_table currently in use. */
2951 static GTY(()) unsigned abbrev_die_table_in_use;
2953 /* Size (in elements) of increments by which we may expand the
2954 abbrev_die_table. */
2955 #define ABBREV_DIE_TABLE_INCREMENT 256
2957 /* A global counter for generating labels for line number data. */
2958 static unsigned int line_info_label_num;
2960 /* The current table to which we should emit line number information
2961 for the current function. This will be set up at the beginning of
2962 assembly for the function. */
2963 static dw_line_info_table *cur_line_info_table;
2965 /* The two default tables of line number info. */
2966 static GTY(()) dw_line_info_table *text_section_line_info;
2967 static GTY(()) dw_line_info_table *cold_text_section_line_info;
2969 /* The set of all non-default tables of line number info. */
2970 static GTY(()) vec<dw_line_info_table_p, va_gc> *separate_line_info;
2972 /* A flag to tell pubnames/types export if there is an info section to
2974 static bool info_section_emitted;
2976 /* A pointer to the base of a table that contains a list of publicly
2977 accessible names. */
2978 static GTY (()) vec<pubname_entry, va_gc> *pubname_table;
2980 /* A pointer to the base of a table that contains a list of publicly
2981 accessible types. */
2982 static GTY (()) vec<pubname_entry, va_gc> *pubtype_table;
2984 /* A pointer to the base of a table that contains a list of macro
2985 defines/undefines (and file start/end markers). */
2986 static GTY (()) vec<macinfo_entry, va_gc> *macinfo_table;
2988 /* True if .debug_macinfo or .debug_macros section is going to be
2990 #define have_macinfo \
2991 (debug_info_level >= DINFO_LEVEL_VERBOSE \
2992 && !macinfo_table->is_empty ())
2994 /* Array of dies for which we should generate .debug_ranges info. */
2995 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
2997 /* Number of elements currently allocated for ranges_table. */
2998 static GTY(()) unsigned ranges_table_allocated;
3000 /* Number of elements in ranges_table currently in use. */
3001 static GTY(()) unsigned ranges_table_in_use;
3003 /* Array of pairs of labels referenced in ranges_table. */
3004 static GTY ((length ("ranges_by_label_allocated")))
3005 dw_ranges_by_label_ref ranges_by_label;
3007 /* Number of elements currently allocated for ranges_by_label. */
3008 static GTY(()) unsigned ranges_by_label_allocated;
3010 /* Number of elements in ranges_by_label currently in use. */
3011 static GTY(()) unsigned ranges_by_label_in_use;
3013 /* Size (in elements) of increments by which we may expand the
3015 #define RANGES_TABLE_INCREMENT 64
3017 /* Whether we have location lists that need outputting */
3018 static GTY(()) bool have_location_lists;
3020 /* Unique label counter. */
3021 static GTY(()) unsigned int loclabel_num;
3023 /* Unique label counter for point-of-call tables. */
3024 static GTY(()) unsigned int poc_label_num;
3026 /* The last file entry emitted by maybe_emit_file(). */
3027 static GTY(()) struct dwarf_file_data * last_emitted_file;
3029 /* Number of internal labels generated by gen_internal_sym(). */
3030 static GTY(()) int label_num;
3032 /* Cached result of previous call to lookup_filename. */
3033 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
3035 static GTY(()) vec<die_arg_entry, va_gc> *tmpl_value_parm_die_table;
3037 /* Instances of generic types for which we need to generate debug
3038 info that describe their generic parameters and arguments. That
3039 generation needs to happen once all types are properly laid out so
3040 we do it at the end of compilation. */
3041 static GTY(()) vec<tree, va_gc> *generic_type_instances;
3043 /* Offset from the "steady-state frame pointer" to the frame base,
3044 within the current function. */
3045 static HOST_WIDE_INT frame_pointer_fb_offset;
3046 static bool frame_pointer_fb_offset_valid;
3048 static vec<dw_die_ref> base_types;
3050 /* Flags to represent a set of attribute classes for attributes that represent
3051 a scalar value (bounds, pointers, ...). */
3054 dw_scalar_form_constant = 0x01,
3055 dw_scalar_form_exprloc = 0x02,
3056 dw_scalar_form_reference = 0x04
3059 /* Forward declarations for functions defined in this file. */
3061 static int is_pseudo_reg (const_rtx);
3062 static tree type_main_variant (tree);
3063 static int is_tagged_type (const_tree);
3064 static const char *dwarf_tag_name (unsigned);
3065 static const char *dwarf_attr_name (unsigned);
3066 static const char *dwarf_form_name (unsigned);
3067 static tree decl_ultimate_origin (const_tree);
3068 static tree decl_class_context (tree);
3069 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3070 static inline enum dw_val_class AT_class (dw_attr_ref);
3071 static inline unsigned int AT_index (dw_attr_ref);
3072 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3073 static inline unsigned AT_flag (dw_attr_ref);
3074 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3075 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3076 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3077 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3078 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
3079 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
3080 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3081 unsigned int, unsigned char *);
3082 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
3083 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3084 static inline const char *AT_string (dw_attr_ref);
3085 static enum dwarf_form AT_string_form (dw_attr_ref);
3086 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3087 static void add_AT_specification (dw_die_ref, dw_die_ref);
3088 static inline dw_die_ref AT_ref (dw_attr_ref);
3089 static inline int AT_ref_external (dw_attr_ref);
3090 static inline void set_AT_ref_external (dw_attr_ref, int);
3091 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3092 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3093 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3094 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3096 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3097 static addr_table_entry *add_addr_table_entry (void *, enum ate_kind);
3098 static void remove_addr_table_entry (addr_table_entry *);
3099 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx, bool);
3100 static inline rtx AT_addr (dw_attr_ref);
3101 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3102 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3103 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3104 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3105 unsigned HOST_WIDE_INT);
3106 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3107 unsigned long, bool);
3108 static inline const char *AT_lbl (dw_attr_ref);
3109 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3110 static const char *get_AT_low_pc (dw_die_ref);
3111 static const char *get_AT_hi_pc (dw_die_ref);
3112 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3113 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3114 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3115 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3116 static bool is_cxx (void);
3117 static bool is_fortran (void);
3118 static bool is_ada (void);
3119 static void remove_AT (dw_die_ref, enum dwarf_attribute);
3120 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3121 static void add_child_die (dw_die_ref, dw_die_ref);
3122 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3123 static dw_die_ref lookup_type_die (tree);
3124 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
3125 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
3126 static void equate_type_number_to_die (tree, dw_die_ref);
3127 static dw_die_ref lookup_decl_die (tree);
3128 static var_loc_list *lookup_decl_loc (const_tree);
3129 static void equate_decl_number_to_die (tree, dw_die_ref);
3130 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
3131 static void print_spaces (FILE *);
3132 static void print_die (dw_die_ref, FILE *);
3133 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
3134 static dw_die_ref pop_compile_unit (dw_die_ref);
3135 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3136 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
3137 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3138 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
3139 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
3140 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
3141 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
3142 struct md5_ctx *, int *);
3143 struct checksum_attributes;
3144 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
3145 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
3146 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
3147 static void generate_type_signature (dw_die_ref, comdat_type_node *);
3148 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3149 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
3150 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
3151 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3152 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
3153 static void compute_section_prefix (dw_die_ref);
3154 static int is_type_die (dw_die_ref);
3155 static int is_comdat_die (dw_die_ref);
3156 static int is_symbol_die (dw_die_ref);
3157 static inline bool is_template_instantiation (dw_die_ref);
3158 static void assign_symbol_names (dw_die_ref);
3159 static void break_out_includes (dw_die_ref);
3160 static int is_declaration_die (dw_die_ref);
3161 static int should_move_die_to_comdat (dw_die_ref);
3162 static dw_die_ref clone_as_declaration (dw_die_ref);
3163 static dw_die_ref clone_die (dw_die_ref);
3164 static dw_die_ref clone_tree (dw_die_ref);
3165 static dw_die_ref copy_declaration_context (dw_die_ref, dw_die_ref);
3166 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
3167 static void generate_skeleton_bottom_up (skeleton_chain_node *);
3168 static dw_die_ref generate_skeleton (dw_die_ref);
3169 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
3172 static void break_out_comdat_types (dw_die_ref);
3173 static void copy_decls_for_unworthy_types (dw_die_ref);
3175 static void add_sibling_attributes (dw_die_ref);
3176 static void output_location_lists (dw_die_ref);
3177 static int constant_size (unsigned HOST_WIDE_INT);
3178 static unsigned long size_of_die (dw_die_ref);
3179 static void calc_die_sizes (dw_die_ref);
3180 static void calc_base_type_die_sizes (void);
3181 static void mark_dies (dw_die_ref);
3182 static void unmark_dies (dw_die_ref);
3183 static void unmark_all_dies (dw_die_ref);
3184 static unsigned long size_of_pubnames (vec<pubname_entry, va_gc> *);
3185 static unsigned long size_of_aranges (void);
3186 static enum dwarf_form value_format (dw_attr_ref);
3187 static void output_value_format (dw_attr_ref);
3188 static void output_abbrev_section (void);
3189 static void output_die_abbrevs (unsigned long, dw_die_ref);
3190 static void output_die_symbol (dw_die_ref);
3191 static void output_die (dw_die_ref);
3192 static void output_compilation_unit_header (void);
3193 static void output_comp_unit (dw_die_ref, int);
3194 static void output_comdat_type_unit (comdat_type_node *);
3195 static const char *dwarf2_name (tree, int);
3196 static void add_pubname (tree, dw_die_ref);
3197 static void add_enumerator_pubname (const char *, dw_die_ref);
3198 static void add_pubname_string (const char *, dw_die_ref);
3199 static void add_pubtype (tree, dw_die_ref);
3200 static void output_pubnames (vec<pubname_entry, va_gc> *);
3201 static void output_aranges (unsigned long);
3202 static unsigned int add_ranges_num (int);
3203 static unsigned int add_ranges (const_tree);
3204 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
3206 static void output_ranges (void);
3207 static dw_line_info_table *new_line_info_table (void);
3208 static void output_line_info (bool);
3209 static void output_file_names (void);
3210 static dw_die_ref base_type_die (tree);
3211 static int is_base_type (tree);
3212 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
3213 static int decl_quals (const_tree);
3214 static dw_die_ref modified_type_die (tree, int, dw_die_ref);
3215 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
3216 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
3217 static int type_is_enum (const_tree);
3218 static unsigned int dbx_reg_number (const_rtx);
3219 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
3220 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
3221 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
3222 enum var_init_status);
3223 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
3224 enum var_init_status);
3225 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
3226 enum var_init_status);
3227 static int is_based_loc (const_rtx);
3228 static bool resolve_one_addr (rtx *);
3229 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
3230 enum var_init_status);
3231 static dw_loc_descr_ref loc_descriptor (rtx, machine_mode mode,
3232 enum var_init_status);
3233 struct loc_descr_context;
3234 static dw_loc_list_ref loc_list_from_tree (tree, int,
3235 const struct loc_descr_context *);
3236 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int,
3237 const struct loc_descr_context *);
3238 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
3239 static tree field_type (const_tree);
3240 static unsigned int simple_type_align_in_bits (const_tree);
3241 static unsigned int simple_decl_align_in_bits (const_tree);
3242 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
3243 static HOST_WIDE_INT field_byte_offset (const_tree);
3244 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3246 static void add_data_member_location_attribute (dw_die_ref, tree);
3247 static bool add_const_value_attribute (dw_die_ref, rtx);
3248 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3249 static void insert_wide_int (const wide_int &, unsigned char *, int);
3250 static void insert_float (const_rtx, unsigned char *);
3251 static rtx rtl_for_decl_location (tree);
3252 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool,
3253 enum dwarf_attribute);
3254 static bool tree_add_const_value_attribute (dw_die_ref, tree);
3255 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
3256 static void add_name_attribute (dw_die_ref, const char *);
3257 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
3258 static void add_comp_dir_attribute (dw_die_ref);
3259 static void add_scalar_info (dw_die_ref, enum dwarf_attribute, tree, int,
3260 const struct loc_descr_context *);
3261 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree,
3262 const struct loc_descr_context *);
3263 static void add_subscript_info (dw_die_ref, tree, bool);
3264 static void add_byte_size_attribute (dw_die_ref, tree);
3265 static void add_bit_offset_attribute (dw_die_ref, tree);
3266 static void add_bit_size_attribute (dw_die_ref, tree);
3267 static void add_prototyped_attribute (dw_die_ref, tree);
3268 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
3269 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3270 static void add_src_coords_attributes (dw_die_ref, tree);
3271 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
3272 static void push_decl_scope (tree);
3273 static void pop_decl_scope (void);
3274 static dw_die_ref scope_die_for (tree, dw_die_ref);
3275 static inline int local_scope_p (dw_die_ref);
3276 static inline int class_scope_p (dw_die_ref);
3277 static inline int class_or_namespace_scope_p (dw_die_ref);
3278 static void add_type_attribute (dw_die_ref, tree, int, dw_die_ref);
3279 static void add_calling_convention_attribute (dw_die_ref, tree);
3280 static const char *type_tag (const_tree);
3281 static tree member_declared_type (const_tree);
3283 static const char *decl_start_label (tree);
3285 static void gen_array_type_die (tree, dw_die_ref);
3286 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
3288 static void gen_entry_point_die (tree, dw_die_ref);
3290 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
3291 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
3292 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
3293 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3294 static void gen_formal_types_die (tree, dw_die_ref);
3295 static void gen_subprogram_die (tree, dw_die_ref);
3296 static void gen_variable_die (tree, tree, dw_die_ref);
3297 static void gen_const_die (tree, dw_die_ref);
3298 static void gen_label_die (tree, dw_die_ref);
3299 static void gen_lexical_block_die (tree, dw_die_ref);
3300 static void gen_inlined_subroutine_die (tree, dw_die_ref);
3301 static void gen_field_die (tree, dw_die_ref);
3302 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3303 static dw_die_ref gen_compile_unit_die (const char *);
3304 static void gen_inheritance_die (tree, tree, dw_die_ref);
3305 static void gen_member_die (tree, dw_die_ref);
3306 static void gen_struct_or_union_type_die (tree, dw_die_ref,
3307 enum debug_info_usage);
3308 static void gen_subroutine_type_die (tree, dw_die_ref);
3309 static void gen_typedef_die (tree, dw_die_ref);
3310 static void gen_type_die (tree, dw_die_ref);
3311 static void gen_block_die (tree, dw_die_ref);
3312 static void decls_for_scope (tree, dw_die_ref);
3313 static inline int is_redundant_typedef (const_tree);
3314 static bool is_naming_typedef_decl (const_tree);
3315 static inline dw_die_ref get_context_die (tree);
3316 static void gen_namespace_die (tree, dw_die_ref);
3317 static dw_die_ref gen_namelist_decl (tree, dw_die_ref, tree);
3318 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
3319 static dw_die_ref force_decl_die (tree);
3320 static dw_die_ref force_type_die (tree);
3321 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3322 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
3323 static struct dwarf_file_data * lookup_filename (const char *);
3324 static void retry_incomplete_types (void);
3325 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3326 static void gen_generic_params_dies (tree);
3327 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
3328 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
3329 static void splice_child_die (dw_die_ref, dw_die_ref);
3330 static int file_info_cmp (const void *, const void *);
3331 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
3332 const char *, const char *);
3333 static void output_loc_list (dw_loc_list_ref);
3334 static char *gen_internal_sym (const char *);
3335 static bool want_pubnames (void);
3337 static void prune_unmark_dies (dw_die_ref);
3338 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
3339 static void prune_unused_types_mark (dw_die_ref, int);
3340 static void prune_unused_types_walk (dw_die_ref);
3341 static void prune_unused_types_walk_attribs (dw_die_ref);
3342 static void prune_unused_types_prune (dw_die_ref);
3343 static void prune_unused_types (void);
3344 static int maybe_emit_file (struct dwarf_file_data *fd);
3345 static inline const char *AT_vms_delta1 (dw_attr_ref);
3346 static inline const char *AT_vms_delta2 (dw_attr_ref);
3347 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
3348 const char *, const char *);
3349 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
3350 static void gen_remaining_tmpl_value_param_die_attribute (void);
3351 static bool generic_type_p (tree);
3352 static void schedule_generic_params_dies_gen (tree t);
3353 static void gen_scheduled_generic_parms_dies (void);
3355 static const char *comp_dir_string (void);
3357 static void hash_loc_operands (dw_loc_descr_ref, inchash::hash &);
3359 /* enum for tracking thread-local variables whose address is really an offset
3360 relative to the TLS pointer, which will need link-time relocation, but will
3361 not need relocation by the DWARF consumer. */
3369 /* Return the operator to use for an address of a variable. For dtprel_true, we
3370 use DW_OP_const*. For regular variables, which need both link-time
3371 relocation and consumer-level relocation (e.g., to account for shared objects
3372 loaded at a random address), we use DW_OP_addr*. */
3374 static inline enum dwarf_location_atom
3375 dw_addr_op (enum dtprel_bool dtprel)
3377 if (dtprel == dtprel_true)
3378 return (dwarf_split_debug_info ? DW_OP_GNU_const_index
3379 : (DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u));
3381 return dwarf_split_debug_info ? DW_OP_GNU_addr_index : DW_OP_addr;
3384 /* Return a pointer to a newly allocated address location description. If
3385 dwarf_split_debug_info is true, then record the address with the appropriate
3387 static inline dw_loc_descr_ref
3388 new_addr_loc_descr (rtx addr, enum dtprel_bool dtprel)
3390 dw_loc_descr_ref ref = new_loc_descr (dw_addr_op (dtprel), 0, 0);
3392 ref->dw_loc_oprnd1.val_class = dw_val_class_addr;
3393 ref->dw_loc_oprnd1.v.val_addr = addr;
3394 ref->dtprel = dtprel;
3395 if (dwarf_split_debug_info)
3396 ref->dw_loc_oprnd1.val_entry
3397 = add_addr_table_entry (addr,
3398 dtprel ? ate_kind_rtx_dtprel : ate_kind_rtx);
3400 ref->dw_loc_oprnd1.val_entry = NULL;
3405 /* Section names used to hold DWARF debugging information. */
3407 #ifndef DEBUG_INFO_SECTION
3408 #define DEBUG_INFO_SECTION ".debug_info"
3410 #ifndef DEBUG_DWO_INFO_SECTION
3411 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3413 #ifndef DEBUG_ABBREV_SECTION
3414 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3416 #ifndef DEBUG_DWO_ABBREV_SECTION
3417 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3419 #ifndef DEBUG_ARANGES_SECTION
3420 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3422 #ifndef DEBUG_ADDR_SECTION
3423 #define DEBUG_ADDR_SECTION ".debug_addr"
3425 #ifndef DEBUG_NORM_MACINFO_SECTION
3426 #define DEBUG_NORM_MACINFO_SECTION ".debug_macinfo"
3428 #ifndef DEBUG_DWO_MACINFO_SECTION
3429 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3431 #ifndef DEBUG_MACINFO_SECTION
3432 #define DEBUG_MACINFO_SECTION \
3433 (!dwarf_split_debug_info \
3434 ? (DEBUG_NORM_MACINFO_SECTION) : (DEBUG_DWO_MACINFO_SECTION))
3436 #ifndef DEBUG_NORM_MACRO_SECTION
3437 #define DEBUG_NORM_MACRO_SECTION ".debug_macro"
3439 #ifndef DEBUG_DWO_MACRO_SECTION
3440 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3442 #ifndef DEBUG_MACRO_SECTION
3443 #define DEBUG_MACRO_SECTION \
3444 (!dwarf_split_debug_info \
3445 ? (DEBUG_NORM_MACRO_SECTION) : (DEBUG_DWO_MACRO_SECTION))
3447 #ifndef DEBUG_LINE_SECTION
3448 #define DEBUG_LINE_SECTION ".debug_line"
3450 #ifndef DEBUG_DWO_LINE_SECTION
3451 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3453 #ifndef DEBUG_LOC_SECTION
3454 #define DEBUG_LOC_SECTION ".debug_loc"
3456 #ifndef DEBUG_DWO_LOC_SECTION
3457 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3459 #ifndef DEBUG_PUBNAMES_SECTION
3460 #define DEBUG_PUBNAMES_SECTION \
3461 ((debug_generate_pub_sections == 2) \
3462 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3464 #ifndef DEBUG_PUBTYPES_SECTION
3465 #define DEBUG_PUBTYPES_SECTION \
3466 ((debug_generate_pub_sections == 2) \
3467 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3469 #define DEBUG_NORM_STR_OFFSETS_SECTION ".debug_str_offsets"
3470 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3471 #ifndef DEBUG_STR_OFFSETS_SECTION
3472 #define DEBUG_STR_OFFSETS_SECTION \
3473 (!dwarf_split_debug_info \
3474 ? (DEBUG_NORM_STR_OFFSETS_SECTION) : (DEBUG_DWO_STR_OFFSETS_SECTION))
3476 #ifndef DEBUG_STR_DWO_SECTION
3477 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3479 #ifndef DEBUG_STR_SECTION
3480 #define DEBUG_STR_SECTION ".debug_str"
3482 #ifndef DEBUG_RANGES_SECTION
3483 #define DEBUG_RANGES_SECTION ".debug_ranges"
3486 /* Standard ELF section names for compiled code and data. */
3487 #ifndef TEXT_SECTION_NAME
3488 #define TEXT_SECTION_NAME ".text"
3491 /* Section flags for .debug_macinfo/.debug_macro section. */
3492 #define DEBUG_MACRO_SECTION_FLAGS \
3493 (dwarf_split_debug_info ? SECTION_DEBUG | SECTION_EXCLUDE : SECTION_DEBUG)
3495 /* Section flags for .debug_str section. */
3496 #define DEBUG_STR_SECTION_FLAGS \
3497 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3498 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3501 /* Section flags for .debug_str.dwo section. */
3502 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3504 /* Labels we insert at beginning sections we can reference instead of
3505 the section names themselves. */
3507 #ifndef TEXT_SECTION_LABEL
3508 #define TEXT_SECTION_LABEL "Ltext"
3510 #ifndef COLD_TEXT_SECTION_LABEL
3511 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3513 #ifndef DEBUG_LINE_SECTION_LABEL
3514 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3516 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3517 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3519 #ifndef DEBUG_INFO_SECTION_LABEL
3520 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3522 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3523 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3525 #ifndef DEBUG_ABBREV_SECTION_LABEL
3526 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3528 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3529 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3531 #ifndef DEBUG_ADDR_SECTION_LABEL
3532 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3534 #ifndef DEBUG_LOC_SECTION_LABEL
3535 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3537 #ifndef DEBUG_RANGES_SECTION_LABEL
3538 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3540 #ifndef DEBUG_MACINFO_SECTION_LABEL
3541 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3543 #ifndef DEBUG_MACRO_SECTION_LABEL
3544 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3546 #define SKELETON_COMP_DIE_ABBREV 1
3547 #define SKELETON_TYPE_DIE_ABBREV 2
3549 /* Definitions of defaults for formats and names of various special
3550 (artificial) labels which may be generated within this file (when the -g
3551 options is used and DWARF2_DEBUGGING_INFO is in effect.
3552 If necessary, these may be overridden from within the tm.h file, but
3553 typically, overriding these defaults is unnecessary. */
3555 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3556 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3557 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3558 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
3559 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3560 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3561 static char debug_skeleton_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3562 static char debug_skeleton_abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3563 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3564 static char debug_addr_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3565 static char debug_skeleton_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3566 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3567 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
3568 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
3570 #ifndef TEXT_END_LABEL
3571 #define TEXT_END_LABEL "Letext"
3573 #ifndef COLD_END_LABEL
3574 #define COLD_END_LABEL "Letext_cold"
3576 #ifndef BLOCK_BEGIN_LABEL
3577 #define BLOCK_BEGIN_LABEL "LBB"
3579 #ifndef BLOCK_END_LABEL
3580 #define BLOCK_END_LABEL "LBE"
3582 #ifndef LINE_CODE_LABEL
3583 #define LINE_CODE_LABEL "LM"
3587 /* Return the root of the DIE's built for the current compilation unit. */
3589 comp_unit_die (void)
3591 if (!single_comp_unit_die)
3592 single_comp_unit_die = gen_compile_unit_die (NULL);
3593 return single_comp_unit_die;
3596 /* We allow a language front-end to designate a function that is to be
3597 called to "demangle" any name before it is put into a DIE. */
3599 static const char *(*demangle_name_func) (const char *);
3602 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
3604 demangle_name_func = func;
3607 /* Test if rtl node points to a pseudo register. */
3610 is_pseudo_reg (const_rtx rtl)
3612 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
3613 || (GET_CODE (rtl) == SUBREG
3614 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
3617 /* Return a reference to a type, with its const and volatile qualifiers
3621 type_main_variant (tree type)
3623 type = TYPE_MAIN_VARIANT (type);
3625 /* ??? There really should be only one main variant among any group of
3626 variants of a given type (and all of the MAIN_VARIANT values for all
3627 members of the group should point to that one type) but sometimes the C
3628 front-end messes this up for array types, so we work around that bug
3630 if (TREE_CODE (type) == ARRAY_TYPE)
3631 while (type != TYPE_MAIN_VARIANT (type))
3632 type = TYPE_MAIN_VARIANT (type);
3637 /* Return nonzero if the given type node represents a tagged type. */
3640 is_tagged_type (const_tree type)
3642 enum tree_code code = TREE_CODE (type);
3644 return (code == RECORD_TYPE || code == UNION_TYPE
3645 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
3648 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
3651 get_ref_die_offset_label (char *label, dw_die_ref ref)
3653 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
3656 /* Return die_offset of a DIE reference to a base type. */
3658 static unsigned long int
3659 get_base_type_offset (dw_die_ref ref)
3661 if (ref->die_offset)
3662 return ref->die_offset;
3663 if (comp_unit_die ()->die_abbrev)
3665 calc_base_type_die_sizes ();
3666 gcc_assert (ref->die_offset);
3668 return ref->die_offset;
3671 /* Return die_offset of a DIE reference other than base type. */
3673 static unsigned long int
3674 get_ref_die_offset (dw_die_ref ref)
3676 gcc_assert (ref->die_offset);
3677 return ref->die_offset;
3680 /* Convert a DIE tag into its string name. */
3683 dwarf_tag_name (unsigned int tag)
3685 const char *name = get_DW_TAG_name (tag);
3690 return "DW_TAG_<unknown>";
3693 /* Convert a DWARF attribute code into its string name. */
3696 dwarf_attr_name (unsigned int attr)
3702 #if VMS_DEBUGGING_INFO
3703 case DW_AT_HP_prologue:
3704 return "DW_AT_HP_prologue";
3706 case DW_AT_MIPS_loop_unroll_factor:
3707 return "DW_AT_MIPS_loop_unroll_factor";
3710 #if VMS_DEBUGGING_INFO
3711 case DW_AT_HP_epilogue:
3712 return "DW_AT_HP_epilogue";
3714 case DW_AT_MIPS_stride:
3715 return "DW_AT_MIPS_stride";
3719 name = get_DW_AT_name (attr);
3724 return "DW_AT_<unknown>";
3727 /* Convert a DWARF value form code into its string name. */
3730 dwarf_form_name (unsigned int form)
3732 const char *name = get_DW_FORM_name (form);
3737 return "DW_FORM_<unknown>";
3740 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3741 instance of an inlined instance of a decl which is local to an inline
3742 function, so we have to trace all of the way back through the origin chain
3743 to find out what sort of node actually served as the original seed for the
3747 decl_ultimate_origin (const_tree decl)
3749 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
3752 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
3753 we're trying to output the abstract instance of this function. */
3754 if (DECL_ABSTRACT_P (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
3757 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3758 most distant ancestor, this should never happen. */
3759 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
3761 return DECL_ABSTRACT_ORIGIN (decl);
3764 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3765 of a virtual function may refer to a base class, so we check the 'this'
3769 decl_class_context (tree decl)
3771 tree context = NULL_TREE;
3773 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3774 context = DECL_CONTEXT (decl);
3776 context = TYPE_MAIN_VARIANT
3777 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3779 if (context && !TYPE_P (context))
3780 context = NULL_TREE;
3785 /* Add an attribute/value pair to a DIE. */
3788 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
3790 /* Maybe this should be an assert? */
3794 vec_safe_reserve (die->die_attr, 1);
3795 vec_safe_push (die->die_attr, *attr);
3798 static inline enum dw_val_class
3799 AT_class (dw_attr_ref a)
3801 return a->dw_attr_val.val_class;
3804 /* Return the index for any attribute that will be referenced with a
3805 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
3806 are stored in dw_attr_val.v.val_str for reference counting
3809 static inline unsigned int
3810 AT_index (dw_attr_ref a)
3812 if (AT_class (a) == dw_val_class_str)
3813 return a->dw_attr_val.v.val_str->index;
3814 else if (a->dw_attr_val.val_entry != NULL)
3815 return a->dw_attr_val.val_entry->index;
3819 /* Add a flag value attribute to a DIE. */
3822 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
3826 attr.dw_attr = attr_kind;
3827 attr.dw_attr_val.val_class = dw_val_class_flag;
3828 attr.dw_attr_val.val_entry = NULL;
3829 attr.dw_attr_val.v.val_flag = flag;
3830 add_dwarf_attr (die, &attr);
3833 static inline unsigned
3834 AT_flag (dw_attr_ref a)
3836 gcc_assert (a && AT_class (a) == dw_val_class_flag);
3837 return a->dw_attr_val.v.val_flag;
3840 /* Add a signed integer attribute value to a DIE. */
3843 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
3847 attr.dw_attr = attr_kind;
3848 attr.dw_attr_val.val_class = dw_val_class_const;
3849 attr.dw_attr_val.val_entry = NULL;
3850 attr.dw_attr_val.v.val_int = int_val;
3851 add_dwarf_attr (die, &attr);
3854 static inline HOST_WIDE_INT
3855 AT_int (dw_attr_ref a)
3857 gcc_assert (a && AT_class (a) == dw_val_class_const);
3858 return a->dw_attr_val.v.val_int;
3861 /* Add an unsigned integer attribute value to a DIE. */
3864 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
3865 unsigned HOST_WIDE_INT unsigned_val)
3869 attr.dw_attr = attr_kind;
3870 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
3871 attr.dw_attr_val.val_entry = NULL;
3872 attr.dw_attr_val.v.val_unsigned = unsigned_val;
3873 add_dwarf_attr (die, &attr);
3876 static inline unsigned HOST_WIDE_INT
3877 AT_unsigned (dw_attr_ref a)
3879 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
3880 return a->dw_attr_val.v.val_unsigned;
3883 /* Add an unsigned wide integer attribute value to a DIE. */
3886 add_AT_wide (dw_die_ref die, enum dwarf_attribute attr_kind,
3891 attr.dw_attr = attr_kind;
3892 attr.dw_attr_val.val_class = dw_val_class_wide_int;
3893 attr.dw_attr_val.val_entry = NULL;
3894 attr.dw_attr_val.v.val_wide = ggc_alloc<wide_int> ();
3895 *attr.dw_attr_val.v.val_wide = w;
3896 add_dwarf_attr (die, &attr);
3899 /* Add an unsigned double integer attribute value to a DIE. */
3902 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
3903 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
3907 attr.dw_attr = attr_kind;
3908 attr.dw_attr_val.val_class = dw_val_class_const_double;
3909 attr.dw_attr_val.val_entry = NULL;
3910 attr.dw_attr_val.v.val_double.high = high;
3911 attr.dw_attr_val.v.val_double.low = low;
3912 add_dwarf_attr (die, &attr);
3915 /* Add a floating point attribute value to a DIE and return it. */
3918 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
3919 unsigned int length, unsigned int elt_size, unsigned char *array)
3923 attr.dw_attr = attr_kind;
3924 attr.dw_attr_val.val_class = dw_val_class_vec;
3925 attr.dw_attr_val.val_entry = NULL;
3926 attr.dw_attr_val.v.val_vec.length = length;
3927 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
3928 attr.dw_attr_val.v.val_vec.array = array;
3929 add_dwarf_attr (die, &attr);
3932 /* Add an 8-byte data attribute value to a DIE. */
3935 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
3936 unsigned char data8[8])
3940 attr.dw_attr = attr_kind;
3941 attr.dw_attr_val.val_class = dw_val_class_data8;
3942 attr.dw_attr_val.val_entry = NULL;
3943 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
3944 add_dwarf_attr (die, &attr);
3947 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
3948 dwarf_split_debug_info, address attributes in dies destined for the
3949 final executable have force_direct set to avoid using indexed
3953 add_AT_low_high_pc (dw_die_ref die, const char *lbl_low, const char *lbl_high,
3959 lbl_id = xstrdup (lbl_low);
3960 attr.dw_attr = DW_AT_low_pc;
3961 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
3962 attr.dw_attr_val.v.val_lbl_id = lbl_id;
3963 if (dwarf_split_debug_info && !force_direct)
3964 attr.dw_attr_val.val_entry
3965 = add_addr_table_entry (lbl_id, ate_kind_label);
3967 attr.dw_attr_val.val_entry = NULL;
3968 add_dwarf_attr (die, &attr);
3970 attr.dw_attr = DW_AT_high_pc;
3971 if (dwarf_version < 4)
3972 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
3974 attr.dw_attr_val.val_class = dw_val_class_high_pc;
3975 lbl_id = xstrdup (lbl_high);
3976 attr.dw_attr_val.v.val_lbl_id = lbl_id;
3977 if (attr.dw_attr_val.val_class == dw_val_class_lbl_id
3978 && dwarf_split_debug_info && !force_direct)
3979 attr.dw_attr_val.val_entry
3980 = add_addr_table_entry (lbl_id, ate_kind_label);
3982 attr.dw_attr_val.val_entry = NULL;
3983 add_dwarf_attr (die, &attr);
3986 /* Hash and equality functions for debug_str_hash. */
3989 indirect_string_hasher::hash (indirect_string_node *x)
3991 return htab_hash_string (x->str);
3995 indirect_string_hasher::equal (indirect_string_node *x1, const char *x2)
3997 return strcmp (x1->str, x2) == 0;
4000 /* Add STR to the given string hash table. */
4002 static struct indirect_string_node *
4003 find_AT_string_in_table (const char *str,
4004 hash_table<indirect_string_hasher> *table)
4006 struct indirect_string_node *node;
4008 indirect_string_node **slot
4009 = table->find_slot_with_hash (str, htab_hash_string (str), INSERT);
4012 node = ggc_cleared_alloc<indirect_string_node> ();
4013 node->str = ggc_strdup (str);
4023 /* Add STR to the indirect string hash table. */
4025 static struct indirect_string_node *
4026 find_AT_string (const char *str)
4028 if (! debug_str_hash)
4029 debug_str_hash = hash_table<indirect_string_hasher>::create_ggc (10);
4031 return find_AT_string_in_table (str, debug_str_hash);
4034 /* Add a string attribute value to a DIE. */
4037 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4040 struct indirect_string_node *node;
4042 node = find_AT_string (str);
4044 attr.dw_attr = attr_kind;
4045 attr.dw_attr_val.val_class = dw_val_class_str;
4046 attr.dw_attr_val.val_entry = NULL;
4047 attr.dw_attr_val.v.val_str = node;
4048 add_dwarf_attr (die, &attr);
4051 static inline const char *
4052 AT_string (dw_attr_ref a)
4054 gcc_assert (a && AT_class (a) == dw_val_class_str);
4055 return a->dw_attr_val.v.val_str->str;
4058 /* Call this function directly to bypass AT_string_form's logic to put
4059 the string inline in the die. */
4062 set_indirect_string (struct indirect_string_node *node)
4065 /* Already indirect is a no op. */
4066 if (node->form == DW_FORM_strp || node->form == DW_FORM_GNU_str_index)
4068 gcc_assert (node->label);
4071 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4072 ++dw2_string_counter;
4073 node->label = xstrdup (label);
4075 if (!dwarf_split_debug_info)
4077 node->form = DW_FORM_strp;
4078 node->index = NOT_INDEXED;
4082 node->form = DW_FORM_GNU_str_index;
4083 node->index = NO_INDEX_ASSIGNED;
4087 /* Find out whether a string should be output inline in DIE
4088 or out-of-line in .debug_str section. */
4090 static enum dwarf_form
4091 find_string_form (struct indirect_string_node *node)
4098 len = strlen (node->str) + 1;
4100 /* If the string is shorter or equal to the size of the reference, it is
4101 always better to put it inline. */
4102 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4103 return node->form = DW_FORM_string;
4105 /* If we cannot expect the linker to merge strings in .debug_str
4106 section, only put it into .debug_str if it is worth even in this
4108 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4109 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
4110 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
4111 return node->form = DW_FORM_string;
4113 set_indirect_string (node);
4118 /* Find out whether the string referenced from the attribute should be
4119 output inline in DIE or out-of-line in .debug_str section. */
4121 static enum dwarf_form
4122 AT_string_form (dw_attr_ref a)
4124 gcc_assert (a && AT_class (a) == dw_val_class_str);
4125 return find_string_form (a->dw_attr_val.v.val_str);
4128 /* Add a DIE reference attribute value to a DIE. */
4131 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
4135 #ifdef ENABLE_CHECKING
4136 gcc_assert (targ_die != NULL);
4138 /* With LTO we can end up trying to reference something we didn't create
4139 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4140 if (targ_die == NULL)
4144 attr.dw_attr = attr_kind;
4145 attr.dw_attr_val.val_class = dw_val_class_die_ref;
4146 attr.dw_attr_val.val_entry = NULL;
4147 attr.dw_attr_val.v.val_die_ref.die = targ_die;
4148 attr.dw_attr_val.v.val_die_ref.external = 0;
4149 add_dwarf_attr (die, &attr);
4152 /* Change DIE reference REF to point to NEW_DIE instead. */
4155 change_AT_die_ref (dw_attr_ref ref, dw_die_ref new_die)
4157 gcc_assert (ref->dw_attr_val.val_class == dw_val_class_die_ref);
4158 ref->dw_attr_val.v.val_die_ref.die = new_die;
4159 ref->dw_attr_val.v.val_die_ref.external = 0;
4162 /* Add an AT_specification attribute to a DIE, and also make the back
4163 pointer from the specification to the definition. */
4166 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
4168 add_AT_die_ref (die, DW_AT_specification, targ_die);
4169 gcc_assert (!targ_die->die_definition);
4170 targ_die->die_definition = die;
4173 static inline dw_die_ref
4174 AT_ref (dw_attr_ref a)
4176 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4177 return a->dw_attr_val.v.val_die_ref.die;
4181 AT_ref_external (dw_attr_ref a)
4183 if (a && AT_class (a) == dw_val_class_die_ref)
4184 return a->dw_attr_val.v.val_die_ref.external;
4190 set_AT_ref_external (dw_attr_ref a, int i)
4192 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4193 a->dw_attr_val.v.val_die_ref.external = i;
4196 /* Add an FDE reference attribute value to a DIE. */
4199 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
4203 attr.dw_attr = attr_kind;
4204 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
4205 attr.dw_attr_val.val_entry = NULL;
4206 attr.dw_attr_val.v.val_fde_index = targ_fde;
4207 add_dwarf_attr (die, &attr);
4210 /* Add a location description attribute value to a DIE. */
4213 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
4217 attr.dw_attr = attr_kind;
4218 attr.dw_attr_val.val_class = dw_val_class_loc;
4219 attr.dw_attr_val.val_entry = NULL;
4220 attr.dw_attr_val.v.val_loc = loc;
4221 add_dwarf_attr (die, &attr);
4224 static inline dw_loc_descr_ref
4225 AT_loc (dw_attr_ref a)
4227 gcc_assert (a && AT_class (a) == dw_val_class_loc);
4228 return a->dw_attr_val.v.val_loc;
4232 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
4236 attr.dw_attr = attr_kind;
4237 attr.dw_attr_val.val_class = dw_val_class_loc_list;
4238 attr.dw_attr_val.val_entry = NULL;
4239 attr.dw_attr_val.v.val_loc_list = loc_list;
4240 add_dwarf_attr (die, &attr);
4241 have_location_lists = true;
4244 static inline dw_loc_list_ref
4245 AT_loc_list (dw_attr_ref a)
4247 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4248 return a->dw_attr_val.v.val_loc_list;
4251 static inline dw_loc_list_ref *
4252 AT_loc_list_ptr (dw_attr_ref a)
4254 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4255 return &a->dw_attr_val.v.val_loc_list;
4258 struct addr_hasher : ggc_hasher<addr_table_entry *>
4260 static hashval_t hash (addr_table_entry *);
4261 static bool equal (addr_table_entry *, addr_table_entry *);
4264 /* Table of entries into the .debug_addr section. */
4266 static GTY (()) hash_table<addr_hasher> *addr_index_table;
4268 /* Hash an address_table_entry. */
4271 addr_hasher::hash (addr_table_entry *a)
4273 inchash::hash hstate;
4279 case ate_kind_rtx_dtprel:
4282 case ate_kind_label:
4283 return htab_hash_string (a->addr.label);
4287 inchash::add_rtx (a->addr.rtl, hstate);
4288 return hstate.end ();
4291 /* Determine equality for two address_table_entries. */
4294 addr_hasher::equal (addr_table_entry *a1, addr_table_entry *a2)
4296 if (a1->kind != a2->kind)
4301 case ate_kind_rtx_dtprel:
4302 return rtx_equal_p (a1->addr.rtl, a2->addr.rtl);
4303 case ate_kind_label:
4304 return strcmp (a1->addr.label, a2->addr.label) == 0;
4310 /* Initialize an addr_table_entry. */
4313 init_addr_table_entry (addr_table_entry *e, enum ate_kind kind, void *addr)
4319 case ate_kind_rtx_dtprel:
4320 e->addr.rtl = (rtx) addr;
4322 case ate_kind_label:
4323 e->addr.label = (char *) addr;
4327 e->index = NO_INDEX_ASSIGNED;
4330 /* Add attr to the address table entry to the table. Defer setting an
4331 index until output time. */
4333 static addr_table_entry *
4334 add_addr_table_entry (void *addr, enum ate_kind kind)
4336 addr_table_entry *node;
4337 addr_table_entry finder;
4339 gcc_assert (dwarf_split_debug_info);
4340 if (! addr_index_table)
4341 addr_index_table = hash_table<addr_hasher>::create_ggc (10);
4342 init_addr_table_entry (&finder, kind, addr);
4343 addr_table_entry **slot = addr_index_table->find_slot (&finder, INSERT);
4345 if (*slot == HTAB_EMPTY_ENTRY)
4347 node = ggc_cleared_alloc<addr_table_entry> ();
4348 init_addr_table_entry (node, kind, addr);
4358 /* Remove an entry from the addr table by decrementing its refcount.
4359 Strictly, decrementing the refcount would be enough, but the
4360 assertion that the entry is actually in the table has found
4364 remove_addr_table_entry (addr_table_entry *entry)
4366 gcc_assert (dwarf_split_debug_info && addr_index_table);
4367 /* After an index is assigned, the table is frozen. */
4368 gcc_assert (entry->refcount > 0 && entry->index == NO_INDEX_ASSIGNED);
4372 /* Given a location list, remove all addresses it refers to from the
4376 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr)
4378 for (; descr; descr = descr->dw_loc_next)
4379 if (descr->dw_loc_oprnd1.val_entry != NULL)
4381 gcc_assert (descr->dw_loc_oprnd1.val_entry->index == NO_INDEX_ASSIGNED);
4382 remove_addr_table_entry (descr->dw_loc_oprnd1.val_entry);
4386 /* A helper function for dwarf2out_finish called through
4387 htab_traverse. Assign an addr_table_entry its index. All entries
4388 must be collected into the table when this function is called,
4389 because the indexing code relies on htab_traverse to traverse nodes
4390 in the same order for each run. */
4393 index_addr_table_entry (addr_table_entry **h, unsigned int *index)
4395 addr_table_entry *node = *h;
4397 /* Don't index unreferenced nodes. */
4398 if (node->refcount == 0)
4401 gcc_assert (node->index == NO_INDEX_ASSIGNED);
4402 node->index = *index;
4408 /* Add an address constant attribute value to a DIE. When using
4409 dwarf_split_debug_info, address attributes in dies destined for the
4410 final executable should be direct references--setting the parameter
4411 force_direct ensures this behavior. */
4414 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr,
4419 attr.dw_attr = attr_kind;
4420 attr.dw_attr_val.val_class = dw_val_class_addr;
4421 attr.dw_attr_val.v.val_addr = addr;
4422 if (dwarf_split_debug_info && !force_direct)
4423 attr.dw_attr_val.val_entry = add_addr_table_entry (addr, ate_kind_rtx);
4425 attr.dw_attr_val.val_entry = NULL;
4426 add_dwarf_attr (die, &attr);
4429 /* Get the RTX from to an address DIE attribute. */
4432 AT_addr (dw_attr_ref a)
4434 gcc_assert (a && AT_class (a) == dw_val_class_addr);
4435 return a->dw_attr_val.v.val_addr;
4438 /* Add a file attribute value to a DIE. */
4441 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
4442 struct dwarf_file_data *fd)
4446 attr.dw_attr = attr_kind;
4447 attr.dw_attr_val.val_class = dw_val_class_file;
4448 attr.dw_attr_val.val_entry = NULL;
4449 attr.dw_attr_val.v.val_file = fd;
4450 add_dwarf_attr (die, &attr);
4453 /* Get the dwarf_file_data from a file DIE attribute. */
4455 static inline struct dwarf_file_data *
4456 AT_file (dw_attr_ref a)
4458 gcc_assert (a && AT_class (a) == dw_val_class_file);
4459 return a->dw_attr_val.v.val_file;
4462 /* Add a vms delta attribute value to a DIE. */
4465 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
4466 const char *lbl1, const char *lbl2)
4470 attr.dw_attr = attr_kind;
4471 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
4472 attr.dw_attr_val.val_entry = NULL;
4473 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
4474 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
4475 add_dwarf_attr (die, &attr);
4478 /* Add a label identifier attribute value to a DIE. */
4481 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind,
4486 attr.dw_attr = attr_kind;
4487 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
4488 attr.dw_attr_val.val_entry = NULL;
4489 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
4490 if (dwarf_split_debug_info)
4491 attr.dw_attr_val.val_entry
4492 = add_addr_table_entry (attr.dw_attr_val.v.val_lbl_id,
4494 add_dwarf_attr (die, &attr);
4497 /* Add a section offset attribute value to a DIE, an offset into the
4498 debug_line section. */
4501 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4506 attr.dw_attr = attr_kind;
4507 attr.dw_attr_val.val_class = dw_val_class_lineptr;
4508 attr.dw_attr_val.val_entry = NULL;
4509 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4510 add_dwarf_attr (die, &attr);
4513 /* Add a section offset attribute value to a DIE, an offset into the
4514 debug_macinfo section. */
4517 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
4522 attr.dw_attr = attr_kind;
4523 attr.dw_attr_val.val_class = dw_val_class_macptr;
4524 attr.dw_attr_val.val_entry = NULL;
4525 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
4526 add_dwarf_attr (die, &attr);
4529 /* Add an offset attribute value to a DIE. */
4532 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
4533 unsigned HOST_WIDE_INT offset)
4537 attr.dw_attr = attr_kind;
4538 attr.dw_attr_val.val_class = dw_val_class_offset;
4539 attr.dw_attr_val.val_entry = NULL;
4540 attr.dw_attr_val.v.val_offset = offset;
4541 add_dwarf_attr (die, &attr);
4544 /* Add a range_list attribute value to a DIE. When using
4545 dwarf_split_debug_info, address attributes in dies destined for the
4546 final executable should be direct references--setting the parameter
4547 force_direct ensures this behavior. */
4549 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4550 #define RELOCATED_OFFSET (NULL)
4553 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
4554 long unsigned int offset, bool force_direct)
4558 attr.dw_attr = attr_kind;
4559 attr.dw_attr_val.val_class = dw_val_class_range_list;
4560 /* For the range_list attribute, use val_entry to store whether the
4561 offset should follow split-debug-info or normal semantics. This
4562 value is read in output_range_list_offset. */
4563 if (dwarf_split_debug_info && !force_direct)
4564 attr.dw_attr_val.val_entry = UNRELOCATED_OFFSET;
4566 attr.dw_attr_val.val_entry = RELOCATED_OFFSET;
4567 attr.dw_attr_val.v.val_offset = offset;
4568 add_dwarf_attr (die, &attr);
4571 /* Return the start label of a delta attribute. */
4573 static inline const char *
4574 AT_vms_delta1 (dw_attr_ref a)
4576 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4577 return a->dw_attr_val.v.val_vms_delta.lbl1;
4580 /* Return the end label of a delta attribute. */
4582 static inline const char *
4583 AT_vms_delta2 (dw_attr_ref a)
4585 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
4586 return a->dw_attr_val.v.val_vms_delta.lbl2;
4589 static inline const char *
4590 AT_lbl (dw_attr_ref a)
4592 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
4593 || AT_class (a) == dw_val_class_lineptr
4594 || AT_class (a) == dw_val_class_macptr
4595 || AT_class (a) == dw_val_class_high_pc));
4596 return a->dw_attr_val.v.val_lbl_id;
4599 /* Get the attribute of type attr_kind. */
4602 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4606 dw_die_ref spec = NULL;
4611 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
4612 if (a->dw_attr == attr_kind)
4614 else if (a->dw_attr == DW_AT_specification
4615 || a->dw_attr == DW_AT_abstract_origin)
4619 return get_AT (spec, attr_kind);
4624 /* Returns the parent of the declaration of DIE. */
4627 get_die_parent (dw_die_ref die)
4634 if ((t = get_AT_ref (die, DW_AT_abstract_origin))
4635 || (t = get_AT_ref (die, DW_AT_specification)))
4638 return die->die_parent;
4641 /* Return the "low pc" attribute value, typically associated with a subprogram
4642 DIE. Return null if the "low pc" attribute is either not present, or if it
4643 cannot be represented as an assembler label identifier. */
4645 static inline const char *
4646 get_AT_low_pc (dw_die_ref die)
4648 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
4650 return a ? AT_lbl (a) : NULL;
4653 /* Return the "high pc" attribute value, typically associated with a subprogram
4654 DIE. Return null if the "high pc" attribute is either not present, or if it
4655 cannot be represented as an assembler label identifier. */
4657 static inline const char *
4658 get_AT_hi_pc (dw_die_ref die)
4660 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4662 return a ? AT_lbl (a) : NULL;
4665 /* Return the value of the string attribute designated by ATTR_KIND, or
4666 NULL if it is not present. */
4668 static inline const char *
4669 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
4671 dw_attr_ref a = get_AT (die, attr_kind);
4673 return a ? AT_string (a) : NULL;
4676 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4677 if it is not present. */
4680 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
4682 dw_attr_ref a = get_AT (die, attr_kind);
4684 return a ? AT_flag (a) : 0;
4687 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4688 if it is not present. */
4690 static inline unsigned
4691 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
4693 dw_attr_ref a = get_AT (die, attr_kind);
4695 return a ? AT_unsigned (a) : 0;
4698 static inline dw_die_ref
4699 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
4701 dw_attr_ref a = get_AT (die, attr_kind);
4703 return a ? AT_ref (a) : NULL;
4706 static inline struct dwarf_file_data *
4707 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
4709 dw_attr_ref a = get_AT (die, attr_kind);
4711 return a ? AT_file (a) : NULL;
4714 /* Return TRUE if the language is C++. */
4719 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4721 return (lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus
4722 || lang == DW_LANG_C_plus_plus_11 || lang == DW_LANG_C_plus_plus_14);
4725 /* Return TRUE if the language is Java. */
4730 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4732 return lang == DW_LANG_Java;
4735 /* Return TRUE if the language is Fortran. */
4740 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4742 return (lang == DW_LANG_Fortran77
4743 || lang == DW_LANG_Fortran90
4744 || lang == DW_LANG_Fortran95
4745 || lang == DW_LANG_Fortran03
4746 || lang == DW_LANG_Fortran08);
4749 /* Return TRUE if the language is Ada. */
4754 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
4756 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
4759 /* Remove the specified attribute if present. */
4762 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
4770 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
4771 if (a->dw_attr == attr_kind)
4773 if (AT_class (a) == dw_val_class_str)
4774 if (a->dw_attr_val.v.val_str->refcount)
4775 a->dw_attr_val.v.val_str->refcount--;
4777 /* vec::ordered_remove should help reduce the number of abbrevs
4779 die->die_attr->ordered_remove (ix);
4784 /* Remove CHILD from its parent. PREV must have the property that
4785 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
4788 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
4790 gcc_assert (child->die_parent == prev->die_parent);
4791 gcc_assert (prev->die_sib == child);
4794 gcc_assert (child->die_parent->die_child == child);
4798 prev->die_sib = child->die_sib;
4799 if (child->die_parent->die_child == child)
4800 child->die_parent->die_child = prev;
4803 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
4804 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
4807 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
4809 dw_die_ref parent = old_child->die_parent;
4811 gcc_assert (parent == prev->die_parent);
4812 gcc_assert (prev->die_sib == old_child);
4814 new_child->die_parent = parent;
4815 if (prev == old_child)
4817 gcc_assert (parent->die_child == old_child);
4818 new_child->die_sib = new_child;
4822 prev->die_sib = new_child;
4823 new_child->die_sib = old_child->die_sib;
4825 if (old_child->die_parent->die_child == old_child)
4826 old_child->die_parent->die_child = new_child;
4829 /* Move all children from OLD_PARENT to NEW_PARENT. */
4832 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
4835 new_parent->die_child = old_parent->die_child;
4836 old_parent->die_child = NULL;
4837 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
4840 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
4844 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
4850 dw_die_ref prev = c;
4852 while (c->die_tag == tag)
4854 remove_child_with_prev (c, prev);
4855 /* Might have removed every child. */
4856 if (c == c->die_sib)
4860 } while (c != die->die_child);
4863 /* Add a CHILD_DIE as the last child of DIE. */
4866 add_child_die (dw_die_ref die, dw_die_ref child_die)
4868 /* FIXME this should probably be an assert. */
4869 if (! die || ! child_die)
4871 gcc_assert (die != child_die);
4873 child_die->die_parent = die;
4876 child_die->die_sib = die->die_child->die_sib;
4877 die->die_child->die_sib = child_die;
4880 child_die->die_sib = child_die;
4881 die->die_child = child_die;
4884 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4885 is the specification, to the end of PARENT's list of children.
4886 This is done by removing and re-adding it. */
4889 splice_child_die (dw_die_ref parent, dw_die_ref child)
4893 /* We want the declaration DIE from inside the class, not the
4894 specification DIE at toplevel. */
4895 if (child->die_parent != parent)
4897 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
4903 gcc_assert (child->die_parent == parent
4904 || (child->die_parent
4905 == get_AT_ref (parent, DW_AT_specification)));
4907 for (p = child->die_parent->die_child; ; p = p->die_sib)
4908 if (p->die_sib == child)
4910 remove_child_with_prev (child, p);
4914 add_child_die (parent, child);
4917 /* Return a pointer to a newly created DIE node. */
4919 static inline dw_die_ref
4920 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
4922 dw_die_ref die = ggc_cleared_alloc<die_node> ();
4924 die->die_tag = tag_value;
4926 if (parent_die != NULL)
4927 add_child_die (parent_die, die);
4930 limbo_die_node *limbo_node;
4932 limbo_node = ggc_cleared_alloc<limbo_die_node> ();
4933 limbo_node->die = die;
4934 limbo_node->created_for = t;
4935 limbo_node->next = limbo_die_list;
4936 limbo_die_list = limbo_node;
4942 /* Return the DIE associated with the given type specifier. */
4944 static inline dw_die_ref
4945 lookup_type_die (tree type)
4947 return TYPE_SYMTAB_DIE (type);
4950 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
4951 anonymous type named by the typedef TYPE_DIE, return the DIE of the
4952 anonymous type instead the one of the naming typedef. */
4954 static inline dw_die_ref
4955 strip_naming_typedef (tree type, dw_die_ref type_die)
4958 && TREE_CODE (type) == RECORD_TYPE
4960 && type_die->die_tag == DW_TAG_typedef
4961 && is_naming_typedef_decl (TYPE_NAME (type)))
4962 type_die = get_AT_ref (type_die, DW_AT_type);
4966 /* Like lookup_type_die, but if type is an anonymous type named by a
4967 typedef[1], return the DIE of the anonymous type instead the one of
4968 the naming typedef. This is because in gen_typedef_die, we did
4969 equate the anonymous struct named by the typedef with the DIE of
4970 the naming typedef. So by default, lookup_type_die on an anonymous
4971 struct yields the DIE of the naming typedef.
4973 [1]: Read the comment of is_naming_typedef_decl to learn about what
4974 a naming typedef is. */
4976 static inline dw_die_ref
4977 lookup_type_die_strip_naming_typedef (tree type)
4979 dw_die_ref die = lookup_type_die (type);
4980 return strip_naming_typedef (type, die);
4983 /* Equate a DIE to a given type specifier. */
4986 equate_type_number_to_die (tree type, dw_die_ref type_die)
4988 TYPE_SYMTAB_DIE (type) = type_die;
4991 /* Returns a hash value for X (which really is a die_struct). */
4994 decl_die_hasher::hash (die_node *x)
4996 return (hashval_t) x->decl_id;
4999 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5002 decl_die_hasher::equal (die_node *x, tree y)
5004 return (x->decl_id == DECL_UID (y));
5007 /* Return the DIE associated with a given declaration. */
5009 static inline dw_die_ref
5010 lookup_decl_die (tree decl)
5012 return decl_die_table->find_with_hash (decl, DECL_UID (decl));
5015 /* Returns a hash value for X (which really is a var_loc_list). */
5018 decl_loc_hasher::hash (var_loc_list *x)
5020 return (hashval_t) x->decl_id;
5023 /* Return nonzero if decl_id of var_loc_list X is the same as
5027 decl_loc_hasher::equal (var_loc_list *x, const_tree y)
5029 return (x->decl_id == DECL_UID (y));
5032 /* Return the var_loc list associated with a given declaration. */
5034 static inline var_loc_list *
5035 lookup_decl_loc (const_tree decl)
5037 if (!decl_loc_table)
5039 return decl_loc_table->find_with_hash (decl, DECL_UID (decl));
5042 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5045 dw_loc_list_hasher::hash (cached_dw_loc_list *x)
5047 return (hashval_t) x->decl_id;
5050 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5054 dw_loc_list_hasher::equal (cached_dw_loc_list *x, const_tree y)
5056 return (x->decl_id == DECL_UID (y));
5059 /* Equate a DIE to a particular declaration. */
5062 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5064 unsigned int decl_id = DECL_UID (decl);
5066 *decl_die_table->find_slot_with_hash (decl, decl_id, INSERT) = decl_die;
5067 decl_die->decl_id = decl_id;
5070 /* Return how many bits covers PIECE EXPR_LIST. */
5072 static HOST_WIDE_INT
5073 decl_piece_bitsize (rtx piece)
5075 int ret = (int) GET_MODE (piece);
5078 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
5079 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
5080 return INTVAL (XEXP (XEXP (piece, 0), 0));
5083 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5086 decl_piece_varloc_ptr (rtx piece)
5088 if ((int) GET_MODE (piece))
5089 return &XEXP (piece, 0);
5091 return &XEXP (XEXP (piece, 0), 1);
5094 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5095 Next is the chain of following piece nodes. */
5097 static rtx_expr_list *
5098 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
5100 if (bitsize > 0 && bitsize <= (int) MAX_MACHINE_MODE)
5101 return alloc_EXPR_LIST (bitsize, loc_note, next);
5103 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
5108 /* Return rtx that should be stored into loc field for
5109 LOC_NOTE and BITPOS/BITSIZE. */
5112 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
5113 HOST_WIDE_INT bitsize)
5117 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
5119 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
5124 /* This function either modifies location piece list *DEST in
5125 place (if SRC and INNER is NULL), or copies location piece list
5126 *SRC to *DEST while modifying it. Location BITPOS is modified
5127 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5128 not copied and if needed some padding around it is added.
5129 When modifying in place, DEST should point to EXPR_LIST where
5130 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5131 to the start of the whole list and INNER points to the EXPR_LIST
5132 where earlier pieces cover PIECE_BITPOS bits. */
5135 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
5136 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
5137 HOST_WIDE_INT bitsize, rtx loc_note)
5140 bool copy = inner != NULL;
5144 /* First copy all nodes preceding the current bitpos. */
5145 while (src != inner)
5147 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5148 decl_piece_bitsize (*src), NULL_RTX);
5149 dest = &XEXP (*dest, 1);
5150 src = &XEXP (*src, 1);
5153 /* Add padding if needed. */
5154 if (bitpos != piece_bitpos)
5156 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
5157 copy ? NULL_RTX : *dest);
5158 dest = &XEXP (*dest, 1);
5160 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
5163 /* A piece with correct bitpos and bitsize already exist,
5164 just update the location for it and return. */
5165 *decl_piece_varloc_ptr (*dest) = loc_note;
5168 /* Add the piece that changed. */
5169 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
5170 dest = &XEXP (*dest, 1);
5171 /* Skip over pieces that overlap it. */
5172 diff = bitpos - piece_bitpos + bitsize;
5175 while (diff > 0 && *src)
5178 diff -= decl_piece_bitsize (piece);
5180 src = &XEXP (piece, 1);
5183 *src = XEXP (piece, 1);
5184 free_EXPR_LIST_node (piece);
5187 /* Add padding if needed. */
5188 if (diff < 0 && *src)
5192 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
5193 dest = &XEXP (*dest, 1);
5197 /* Finally copy all nodes following it. */
5200 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
5201 decl_piece_bitsize (*src), NULL_RTX);
5202 dest = &XEXP (*dest, 1);
5203 src = &XEXP (*src, 1);
5207 /* Add a variable location node to the linked list for DECL. */
5209 static struct var_loc_node *
5210 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label)
5212 unsigned int decl_id;
5214 struct var_loc_node *loc = NULL;
5215 HOST_WIDE_INT bitsize = -1, bitpos = -1;
5217 if (TREE_CODE (decl) == VAR_DECL
5218 && DECL_HAS_DEBUG_EXPR_P (decl))
5220 tree realdecl = DECL_DEBUG_EXPR (decl);
5221 if (handled_component_p (realdecl)
5222 || (TREE_CODE (realdecl) == MEM_REF
5223 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
5225 HOST_WIDE_INT maxsize;
5228 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize);
5229 if (!DECL_P (innerdecl)
5230 || DECL_IGNORED_P (innerdecl)
5231 || TREE_STATIC (innerdecl)
5233 || bitpos + bitsize > 256
5234 || bitsize != maxsize)
5240 decl_id = DECL_UID (decl);
5242 = decl_loc_table->find_slot_with_hash (decl, decl_id, INSERT);
5245 temp = ggc_cleared_alloc<var_loc_list> ();
5246 temp->decl_id = decl_id;
5252 /* For PARM_DECLs try to keep around the original incoming value,
5253 even if that means we'll emit a zero-range .debug_loc entry. */
5255 && temp->first == temp->last
5256 && TREE_CODE (decl) == PARM_DECL
5257 && NOTE_P (temp->first->loc)
5258 && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl
5259 && DECL_INCOMING_RTL (decl)
5260 && NOTE_VAR_LOCATION_LOC (temp->first->loc)
5261 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp->first->loc))
5262 == GET_CODE (DECL_INCOMING_RTL (decl))
5263 && prev_real_insn (temp->first->loc) == NULL_RTX
5265 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->first->loc),
5266 NOTE_VAR_LOCATION_LOC (loc_note))
5267 || (NOTE_VAR_LOCATION_STATUS (temp->first->loc)
5268 != NOTE_VAR_LOCATION_STATUS (loc_note))))
5270 loc = ggc_cleared_alloc<var_loc_node> ();
5271 temp->first->next = loc;
5273 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5275 else if (temp->last)
5277 struct var_loc_node *last = temp->last, *unused = NULL;
5278 rtx *piece_loc = NULL, last_loc_note;
5279 HOST_WIDE_INT piece_bitpos = 0;
5283 gcc_assert (last->next == NULL);
5285 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
5287 piece_loc = &last->loc;
5290 HOST_WIDE_INT cur_bitsize = decl_piece_bitsize (*piece_loc);
5291 if (piece_bitpos + cur_bitsize > bitpos)
5293 piece_bitpos += cur_bitsize;
5294 piece_loc = &XEXP (*piece_loc, 1);
5298 /* TEMP->LAST here is either pointer to the last but one or
5299 last element in the chained list, LAST is pointer to the
5301 if (label && strcmp (last->label, label) == 0)
5303 /* For SRA optimized variables if there weren't any real
5304 insns since last note, just modify the last node. */
5305 if (piece_loc != NULL)
5307 adjust_piece_list (piece_loc, NULL, NULL,
5308 bitpos, piece_bitpos, bitsize, loc_note);
5311 /* If the last note doesn't cover any instructions, remove it. */
5312 if (temp->last != last)
5314 temp->last->next = NULL;
5317 gcc_assert (strcmp (last->label, label) != 0);
5321 gcc_assert (temp->first == temp->last
5322 || (temp->first->next == temp->last
5323 && TREE_CODE (decl) == PARM_DECL));
5324 memset (temp->last, '\0', sizeof (*temp->last));
5325 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
5329 if (bitsize == -1 && NOTE_P (last->loc))
5330 last_loc_note = last->loc;
5331 else if (piece_loc != NULL
5332 && *piece_loc != NULL_RTX
5333 && piece_bitpos == bitpos
5334 && decl_piece_bitsize (*piece_loc) == bitsize)
5335 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
5337 last_loc_note = NULL_RTX;
5338 /* If the current location is the same as the end of the list,
5339 and either both or neither of the locations is uninitialized,
5340 we have nothing to do. */
5341 if (last_loc_note == NULL_RTX
5342 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
5343 NOTE_VAR_LOCATION_LOC (loc_note)))
5344 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5345 != NOTE_VAR_LOCATION_STATUS (loc_note))
5346 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
5347 == VAR_INIT_STATUS_UNINITIALIZED)
5348 || (NOTE_VAR_LOCATION_STATUS (loc_note)
5349 == VAR_INIT_STATUS_UNINITIALIZED))))
5351 /* Add LOC to the end of list and update LAST. If the last
5352 element of the list has been removed above, reuse its
5353 memory for the new node, otherwise allocate a new one. */
5357 memset (loc, '\0', sizeof (*loc));
5360 loc = ggc_cleared_alloc<var_loc_node> ();
5361 if (bitsize == -1 || piece_loc == NULL)
5362 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5364 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
5365 bitpos, piece_bitpos, bitsize, loc_note);
5367 /* Ensure TEMP->LAST will point either to the new last but one
5368 element of the chain, or to the last element in it. */
5369 if (last != temp->last)
5377 loc = ggc_cleared_alloc<var_loc_node> ();
5380 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
5385 /* Keep track of the number of spaces used to indent the
5386 output of the debugging routines that print the structure of
5387 the DIE internal representation. */
5388 static int print_indent;
5390 /* Indent the line the number of spaces given by print_indent. */
5393 print_spaces (FILE *outfile)
5395 fprintf (outfile, "%*s", print_indent, "");
5398 /* Print a type signature in hex. */
5401 print_signature (FILE *outfile, char *sig)
5405 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
5406 fprintf (outfile, "%02x", sig[i] & 0xff);
5409 static void print_loc_descr (dw_loc_descr_ref, FILE *);
5411 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
5412 RECURSE, output location descriptor operations. */
5415 print_dw_val (dw_val_node *val, bool recurse, FILE *outfile)
5417 switch (val->val_class)
5419 case dw_val_class_addr:
5420 fprintf (outfile, "address");
5422 case dw_val_class_offset:
5423 fprintf (outfile, "offset");
5425 case dw_val_class_loc:
5426 fprintf (outfile, "location descriptor");
5427 if (val->v.val_loc == NULL)
5428 fprintf (outfile, " -> <null>\n");
5431 fprintf (outfile, ":\n");
5433 print_loc_descr (val->v.val_loc, outfile);
5437 fprintf (outfile, " (%p)\n", (void *) val->v.val_loc);
5439 case dw_val_class_loc_list:
5440 fprintf (outfile, "location list -> label:%s",
5441 val->v.val_loc_list->ll_symbol);
5443 case dw_val_class_range_list:
5444 fprintf (outfile, "range list");
5446 case dw_val_class_const:
5447 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, val->v.val_int);
5449 case dw_val_class_unsigned_const:
5450 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, val->v.val_unsigned);
5452 case dw_val_class_const_double:
5453 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
5454 HOST_WIDE_INT_PRINT_UNSIGNED")",
5455 val->v.val_double.high,
5456 val->v.val_double.low);
5458 case dw_val_class_wide_int:
5460 int i = val->v.val_wide->get_len ();
5461 fprintf (outfile, "constant (");
5463 if (val->v.val_wide->elt (i - 1) == 0)
5464 fprintf (outfile, "0x");
5465 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX,
5466 val->v.val_wide->elt (--i));
5468 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX,
5469 val->v.val_wide->elt (i));
5470 fprintf (outfile, ")");
5473 case dw_val_class_vec:
5474 fprintf (outfile, "floating-point or vector constant");
5476 case dw_val_class_flag:
5477 fprintf (outfile, "%u", val->v.val_flag);
5479 case dw_val_class_die_ref:
5480 if (val->v.val_die_ref.die != NULL)
5482 dw_die_ref die = val->v.val_die_ref.die;
5484 if (die->comdat_type_p)
5486 fprintf (outfile, "die -> signature: ");
5487 print_signature (outfile,
5488 die->die_id.die_type_node->signature);
5490 else if (die->die_id.die_symbol)
5491 fprintf (outfile, "die -> label: %s", die->die_id.die_symbol);
5493 fprintf (outfile, "die -> %ld", die->die_offset);
5494 fprintf (outfile, " (%p)", (void *) die);
5497 fprintf (outfile, "die -> <null>");
5499 case dw_val_class_vms_delta:
5500 fprintf (outfile, "delta: @slotcount(%s-%s)",
5501 val->v.val_vms_delta.lbl2, val->v.val_vms_delta.lbl1);
5503 case dw_val_class_lbl_id:
5504 case dw_val_class_lineptr:
5505 case dw_val_class_macptr:
5506 case dw_val_class_high_pc:
5507 fprintf (outfile, "label: %s", val->v.val_lbl_id);
5509 case dw_val_class_str:
5510 if (val->v.val_str->str != NULL)
5511 fprintf (outfile, "\"%s\"", val->v.val_str->str);
5513 fprintf (outfile, "<null>");
5515 case dw_val_class_file:
5516 fprintf (outfile, "\"%s\" (%d)", val->v.val_file->filename,
5517 val->v.val_file->emitted_number);
5519 case dw_val_class_data8:
5523 for (i = 0; i < 8; i++)
5524 fprintf (outfile, "%02x", val->v.val_data8[i]);
5532 /* Likewise, for a DIE attribute. */
5535 print_attribute (dw_attr_ref a, bool recurse, FILE *outfile)
5537 print_dw_val (&a->dw_attr_val, recurse, outfile);
5541 /* Print the list of operands in the LOC location description to OUTFILE. This
5542 routine is a debugging aid only. */
5545 print_loc_descr (dw_loc_descr_ref loc, FILE *outfile)
5547 dw_loc_descr_ref l = loc;
5551 print_spaces (outfile);
5552 fprintf (outfile, "<null>\n");
5556 for (l = loc; l != NULL; l = l->dw_loc_next)
5558 print_spaces (outfile);
5559 fprintf (outfile, "(%p) %s",
5561 dwarf_stack_op_name (l->dw_loc_opc));
5562 if (l->dw_loc_oprnd1.val_class != dw_val_class_none)
5564 fprintf (outfile, " ");
5565 print_dw_val (&l->dw_loc_oprnd1, false, outfile);
5567 if (l->dw_loc_oprnd2.val_class != dw_val_class_none)
5569 fprintf (outfile, ", ");
5570 print_dw_val (&l->dw_loc_oprnd2, false, outfile);
5572 fprintf (outfile, "\n");
5576 /* Print the information associated with a given DIE, and its children.
5577 This routine is a debugging aid only. */
5580 print_die (dw_die_ref die, FILE *outfile)
5586 print_spaces (outfile);
5587 fprintf (outfile, "DIE %4ld: %s (%p)\n",
5588 die->die_offset, dwarf_tag_name (die->die_tag),
5590 print_spaces (outfile);
5591 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5592 fprintf (outfile, " offset: %ld", die->die_offset);
5593 fprintf (outfile, " mark: %d\n", die->die_mark);
5595 if (die->comdat_type_p)
5597 print_spaces (outfile);
5598 fprintf (outfile, " signature: ");
5599 print_signature (outfile, die->die_id.die_type_node->signature);
5600 fprintf (outfile, "\n");
5603 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5605 print_spaces (outfile);
5606 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5608 print_attribute (a, true, outfile);
5609 fprintf (outfile, "\n");
5612 if (die->die_child != NULL)
5615 FOR_EACH_CHILD (die, c, print_die (c, outfile));
5618 if (print_indent == 0)
5619 fprintf (outfile, "\n");
5622 /* Print the list of operations in the LOC location description. */
5625 debug_dwarf_loc_descr (dw_loc_descr_ref loc)
5627 print_loc_descr (loc, stderr);
5630 /* Print the information collected for a given DIE. */
5633 debug_dwarf_die (dw_die_ref die)
5635 print_die (die, stderr);
5639 debug (die_struct &ref)
5641 print_die (&ref, stderr);
5645 debug (die_struct *ptr)
5650 fprintf (stderr, "<nil>\n");
5654 /* Print all DWARF information collected for the compilation unit.
5655 This routine is a debugging aid only. */
5661 print_die (comp_unit_die (), stderr);
5664 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5665 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5666 DIE that marks the start of the DIEs for this include file. */
5669 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5671 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5672 dw_die_ref new_unit = gen_compile_unit_die (filename);
5674 new_unit->die_sib = old_unit;
5678 /* Close an include-file CU and reopen the enclosing one. */
5681 pop_compile_unit (dw_die_ref old_unit)
5683 dw_die_ref new_unit = old_unit->die_sib;
5685 old_unit->die_sib = NULL;
5689 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5690 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5691 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5693 /* Calculate the checksum of a location expression. */
5696 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5699 inchash::hash hstate;
5702 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
5704 hash_loc_operands (loc, hstate);
5705 hash = hstate.end();
5709 /* Calculate the checksum of an attribute. */
5712 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5714 dw_loc_descr_ref loc;
5717 CHECKSUM (at->dw_attr);
5719 /* We don't care that this was compiled with a different compiler
5720 snapshot; if the output is the same, that's what matters. */
5721 if (at->dw_attr == DW_AT_producer)
5724 switch (AT_class (at))
5726 case dw_val_class_const:
5727 CHECKSUM (at->dw_attr_val.v.val_int);
5729 case dw_val_class_unsigned_const:
5730 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5732 case dw_val_class_const_double:
5733 CHECKSUM (at->dw_attr_val.v.val_double);
5735 case dw_val_class_wide_int:
5736 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
5737 get_full_len (*at->dw_attr_val.v.val_wide)
5738 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
5740 case dw_val_class_vec:
5741 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
5742 (at->dw_attr_val.v.val_vec.length
5743 * at->dw_attr_val.v.val_vec.elt_size));
5745 case dw_val_class_flag:
5746 CHECKSUM (at->dw_attr_val.v.val_flag);
5748 case dw_val_class_str:
5749 CHECKSUM_STRING (AT_string (at));
5752 case dw_val_class_addr:
5754 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5755 CHECKSUM_STRING (XSTR (r, 0));
5758 case dw_val_class_offset:
5759 CHECKSUM (at->dw_attr_val.v.val_offset);
5762 case dw_val_class_loc:
5763 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5764 loc_checksum (loc, ctx);
5767 case dw_val_class_die_ref:
5768 die_checksum (AT_ref (at), ctx, mark);
5771 case dw_val_class_fde_ref:
5772 case dw_val_class_vms_delta:
5773 case dw_val_class_lbl_id:
5774 case dw_val_class_lineptr:
5775 case dw_val_class_macptr:
5776 case dw_val_class_high_pc:
5779 case dw_val_class_file:
5780 CHECKSUM_STRING (AT_file (at)->filename);
5783 case dw_val_class_data8:
5784 CHECKSUM (at->dw_attr_val.v.val_data8);
5792 /* Calculate the checksum of a DIE. */
5795 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5801 /* To avoid infinite recursion. */
5804 CHECKSUM (die->die_mark);
5807 die->die_mark = ++(*mark);
5809 CHECKSUM (die->die_tag);
5811 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5812 attr_checksum (a, ctx, mark);
5814 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
5818 #undef CHECKSUM_BLOCK
5819 #undef CHECKSUM_STRING
5821 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
5822 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5823 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
5824 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
5825 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
5826 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
5827 #define CHECKSUM_ATTR(FOO) \
5828 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
5830 /* Calculate the checksum of a number in signed LEB128 format. */
5833 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
5840 byte = (value & 0x7f);
5842 more = !((value == 0 && (byte & 0x40) == 0)
5843 || (value == -1 && (byte & 0x40) != 0));
5852 /* Calculate the checksum of a number in unsigned LEB128 format. */
5855 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
5859 unsigned char byte = (value & 0x7f);
5862 /* More bytes to follow. */
5870 /* Checksum the context of the DIE. This adds the names of any
5871 surrounding namespaces or structures to the checksum. */
5874 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
5878 int tag = die->die_tag;
5880 if (tag != DW_TAG_namespace
5881 && tag != DW_TAG_structure_type
5882 && tag != DW_TAG_class_type)
5885 name = get_AT_string (die, DW_AT_name);
5887 spec = get_AT_ref (die, DW_AT_specification);
5891 if (die->die_parent != NULL)
5892 checksum_die_context (die->die_parent, ctx);
5894 CHECKSUM_ULEB128 ('C');
5895 CHECKSUM_ULEB128 (tag);
5897 CHECKSUM_STRING (name);
5900 /* Calculate the checksum of a location expression. */
5903 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5905 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
5906 were emitted as a DW_FORM_sdata instead of a location expression. */
5907 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
5909 CHECKSUM_ULEB128 (DW_FORM_sdata);
5910 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
5914 /* Otherwise, just checksum the raw location expression. */
5917 inchash::hash hstate;
5920 CHECKSUM_ULEB128 (loc->dtprel);
5921 CHECKSUM_ULEB128 (loc->dw_loc_opc);
5922 hash_loc_operands (loc, hstate);
5923 hash = hstate.end ();
5925 loc = loc->dw_loc_next;
5929 /* Calculate the checksum of an attribute. */
5932 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
5933 struct md5_ctx *ctx, int *mark)
5935 dw_loc_descr_ref loc;
5938 if (AT_class (at) == dw_val_class_die_ref)
5940 dw_die_ref target_die = AT_ref (at);
5942 /* For pointer and reference types, we checksum only the (qualified)
5943 name of the target type (if there is a name). For friend entries,
5944 we checksum only the (qualified) name of the target type or function.
5945 This allows the checksum to remain the same whether the target type
5946 is complete or not. */
5947 if ((at->dw_attr == DW_AT_type
5948 && (tag == DW_TAG_pointer_type
5949 || tag == DW_TAG_reference_type
5950 || tag == DW_TAG_rvalue_reference_type
5951 || tag == DW_TAG_ptr_to_member_type))
5952 || (at->dw_attr == DW_AT_friend
5953 && tag == DW_TAG_friend))
5955 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
5957 if (name_attr != NULL)
5959 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5963 CHECKSUM_ULEB128 ('N');
5964 CHECKSUM_ULEB128 (at->dw_attr);
5965 if (decl->die_parent != NULL)
5966 checksum_die_context (decl->die_parent, ctx);
5967 CHECKSUM_ULEB128 ('E');
5968 CHECKSUM_STRING (AT_string (name_attr));
5973 /* For all other references to another DIE, we check to see if the
5974 target DIE has already been visited. If it has, we emit a
5975 backward reference; if not, we descend recursively. */
5976 if (target_die->die_mark > 0)
5978 CHECKSUM_ULEB128 ('R');
5979 CHECKSUM_ULEB128 (at->dw_attr);
5980 CHECKSUM_ULEB128 (target_die->die_mark);
5984 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
5988 target_die->die_mark = ++(*mark);
5989 CHECKSUM_ULEB128 ('T');
5990 CHECKSUM_ULEB128 (at->dw_attr);
5991 if (decl->die_parent != NULL)
5992 checksum_die_context (decl->die_parent, ctx);
5993 die_checksum_ordered (target_die, ctx, mark);
5998 CHECKSUM_ULEB128 ('A');
5999 CHECKSUM_ULEB128 (at->dw_attr);
6001 switch (AT_class (at))
6003 case dw_val_class_const:
6004 CHECKSUM_ULEB128 (DW_FORM_sdata);
6005 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
6008 case dw_val_class_unsigned_const:
6009 CHECKSUM_ULEB128 (DW_FORM_sdata);
6010 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
6013 case dw_val_class_const_double:
6014 CHECKSUM_ULEB128 (DW_FORM_block);
6015 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
6016 CHECKSUM (at->dw_attr_val.v.val_double);
6019 case dw_val_class_wide_int:
6020 CHECKSUM_ULEB128 (DW_FORM_block);
6021 CHECKSUM_ULEB128 (get_full_len (*at->dw_attr_val.v.val_wide)
6022 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
6023 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
6024 get_full_len (*at->dw_attr_val.v.val_wide)
6025 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
6028 case dw_val_class_vec:
6029 CHECKSUM_ULEB128 (DW_FORM_block);
6030 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_vec.length
6031 * at->dw_attr_val.v.val_vec.elt_size);
6032 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
6033 (at->dw_attr_val.v.val_vec.length
6034 * at->dw_attr_val.v.val_vec.elt_size));
6037 case dw_val_class_flag:
6038 CHECKSUM_ULEB128 (DW_FORM_flag);
6039 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
6042 case dw_val_class_str:
6043 CHECKSUM_ULEB128 (DW_FORM_string);
6044 CHECKSUM_STRING (AT_string (at));
6047 case dw_val_class_addr:
6049 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6050 CHECKSUM_ULEB128 (DW_FORM_string);
6051 CHECKSUM_STRING (XSTR (r, 0));
6054 case dw_val_class_offset:
6055 CHECKSUM_ULEB128 (DW_FORM_sdata);
6056 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
6059 case dw_val_class_loc:
6060 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6061 loc_checksum_ordered (loc, ctx);
6064 case dw_val_class_fde_ref:
6065 case dw_val_class_lbl_id:
6066 case dw_val_class_lineptr:
6067 case dw_val_class_macptr:
6068 case dw_val_class_high_pc:
6071 case dw_val_class_file:
6072 CHECKSUM_ULEB128 (DW_FORM_string);
6073 CHECKSUM_STRING (AT_file (at)->filename);
6076 case dw_val_class_data8:
6077 CHECKSUM (at->dw_attr_val.v.val_data8);
6085 struct checksum_attributes
6087 dw_attr_ref at_name;
6088 dw_attr_ref at_type;
6089 dw_attr_ref at_friend;
6090 dw_attr_ref at_accessibility;
6091 dw_attr_ref at_address_class;
6092 dw_attr_ref at_allocated;
6093 dw_attr_ref at_artificial;
6094 dw_attr_ref at_associated;
6095 dw_attr_ref at_binary_scale;
6096 dw_attr_ref at_bit_offset;
6097 dw_attr_ref at_bit_size;
6098 dw_attr_ref at_bit_stride;
6099 dw_attr_ref at_byte_size;
6100 dw_attr_ref at_byte_stride;
6101 dw_attr_ref at_const_value;
6102 dw_attr_ref at_containing_type;
6103 dw_attr_ref at_count;
6104 dw_attr_ref at_data_location;
6105 dw_attr_ref at_data_member_location;
6106 dw_attr_ref at_decimal_scale;
6107 dw_attr_ref at_decimal_sign;
6108 dw_attr_ref at_default_value;
6109 dw_attr_ref at_digit_count;
6110 dw_attr_ref at_discr;
6111 dw_attr_ref at_discr_list;
6112 dw_attr_ref at_discr_value;
6113 dw_attr_ref at_encoding;
6114 dw_attr_ref at_endianity;
6115 dw_attr_ref at_explicit;
6116 dw_attr_ref at_is_optional;
6117 dw_attr_ref at_location;
6118 dw_attr_ref at_lower_bound;
6119 dw_attr_ref at_mutable;
6120 dw_attr_ref at_ordering;
6121 dw_attr_ref at_picture_string;
6122 dw_attr_ref at_prototyped;
6123 dw_attr_ref at_small;
6124 dw_attr_ref at_segment;
6125 dw_attr_ref at_string_length;
6126 dw_attr_ref at_threads_scaled;
6127 dw_attr_ref at_upper_bound;
6128 dw_attr_ref at_use_location;
6129 dw_attr_ref at_use_UTF8;
6130 dw_attr_ref at_variable_parameter;
6131 dw_attr_ref at_virtuality;
6132 dw_attr_ref at_visibility;
6133 dw_attr_ref at_vtable_elem_location;
6136 /* Collect the attributes that we will want to use for the checksum. */
6139 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
6144 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
6155 attrs->at_friend = a;
6157 case DW_AT_accessibility:
6158 attrs->at_accessibility = a;
6160 case DW_AT_address_class:
6161 attrs->at_address_class = a;
6163 case DW_AT_allocated:
6164 attrs->at_allocated = a;
6166 case DW_AT_artificial:
6167 attrs->at_artificial = a;
6169 case DW_AT_associated:
6170 attrs->at_associated = a;
6172 case DW_AT_binary_scale:
6173 attrs->at_binary_scale = a;
6175 case DW_AT_bit_offset:
6176 attrs->at_bit_offset = a;
6178 case DW_AT_bit_size:
6179 attrs->at_bit_size = a;
6181 case DW_AT_bit_stride:
6182 attrs->at_bit_stride = a;
6184 case DW_AT_byte_size:
6185 attrs->at_byte_size = a;
6187 case DW_AT_byte_stride:
6188 attrs->at_byte_stride = a;
6190 case DW_AT_const_value:
6191 attrs->at_const_value = a;
6193 case DW_AT_containing_type:
6194 attrs->at_containing_type = a;
6197 attrs->at_count = a;
6199 case DW_AT_data_location:
6200 attrs->at_data_location = a;
6202 case DW_AT_data_member_location:
6203 attrs->at_data_member_location = a;
6205 case DW_AT_decimal_scale:
6206 attrs->at_decimal_scale = a;
6208 case DW_AT_decimal_sign:
6209 attrs->at_decimal_sign = a;
6211 case DW_AT_default_value:
6212 attrs->at_default_value = a;
6214 case DW_AT_digit_count:
6215 attrs->at_digit_count = a;
6218 attrs->at_discr = a;
6220 case DW_AT_discr_list:
6221 attrs->at_discr_list = a;
6223 case DW_AT_discr_value:
6224 attrs->at_discr_value = a;
6226 case DW_AT_encoding:
6227 attrs->at_encoding = a;
6229 case DW_AT_endianity:
6230 attrs->at_endianity = a;
6232 case DW_AT_explicit:
6233 attrs->at_explicit = a;
6235 case DW_AT_is_optional:
6236 attrs->at_is_optional = a;
6238 case DW_AT_location:
6239 attrs->at_location = a;
6241 case DW_AT_lower_bound:
6242 attrs->at_lower_bound = a;
6245 attrs->at_mutable = a;
6247 case DW_AT_ordering:
6248 attrs->at_ordering = a;
6250 case DW_AT_picture_string:
6251 attrs->at_picture_string = a;
6253 case DW_AT_prototyped:
6254 attrs->at_prototyped = a;
6257 attrs->at_small = a;
6260 attrs->at_segment = a;
6262 case DW_AT_string_length:
6263 attrs->at_string_length = a;
6265 case DW_AT_threads_scaled:
6266 attrs->at_threads_scaled = a;
6268 case DW_AT_upper_bound:
6269 attrs->at_upper_bound = a;
6271 case DW_AT_use_location:
6272 attrs->at_use_location = a;
6274 case DW_AT_use_UTF8:
6275 attrs->at_use_UTF8 = a;
6277 case DW_AT_variable_parameter:
6278 attrs->at_variable_parameter = a;
6280 case DW_AT_virtuality:
6281 attrs->at_virtuality = a;
6283 case DW_AT_visibility:
6284 attrs->at_visibility = a;
6286 case DW_AT_vtable_elem_location:
6287 attrs->at_vtable_elem_location = a;
6295 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
6298 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6302 struct checksum_attributes attrs;
6304 CHECKSUM_ULEB128 ('D');
6305 CHECKSUM_ULEB128 (die->die_tag);
6307 memset (&attrs, 0, sizeof (attrs));
6309 decl = get_AT_ref (die, DW_AT_specification);
6311 collect_checksum_attributes (&attrs, decl);
6312 collect_checksum_attributes (&attrs, die);
6314 CHECKSUM_ATTR (attrs.at_name);
6315 CHECKSUM_ATTR (attrs.at_accessibility);
6316 CHECKSUM_ATTR (attrs.at_address_class);
6317 CHECKSUM_ATTR (attrs.at_allocated);
6318 CHECKSUM_ATTR (attrs.at_artificial);
6319 CHECKSUM_ATTR (attrs.at_associated);
6320 CHECKSUM_ATTR (attrs.at_binary_scale);
6321 CHECKSUM_ATTR (attrs.at_bit_offset);
6322 CHECKSUM_ATTR (attrs.at_bit_size);
6323 CHECKSUM_ATTR (attrs.at_bit_stride);
6324 CHECKSUM_ATTR (attrs.at_byte_size);
6325 CHECKSUM_ATTR (attrs.at_byte_stride);
6326 CHECKSUM_ATTR (attrs.at_const_value);
6327 CHECKSUM_ATTR (attrs.at_containing_type);
6328 CHECKSUM_ATTR (attrs.at_count);
6329 CHECKSUM_ATTR (attrs.at_data_location);
6330 CHECKSUM_ATTR (attrs.at_data_member_location);
6331 CHECKSUM_ATTR (attrs.at_decimal_scale);
6332 CHECKSUM_ATTR (attrs.at_decimal_sign);
6333 CHECKSUM_ATTR (attrs.at_default_value);
6334 CHECKSUM_ATTR (attrs.at_digit_count);
6335 CHECKSUM_ATTR (attrs.at_discr);
6336 CHECKSUM_ATTR (attrs.at_discr_list);
6337 CHECKSUM_ATTR (attrs.at_discr_value);
6338 CHECKSUM_ATTR (attrs.at_encoding);
6339 CHECKSUM_ATTR (attrs.at_endianity);
6340 CHECKSUM_ATTR (attrs.at_explicit);
6341 CHECKSUM_ATTR (attrs.at_is_optional);
6342 CHECKSUM_ATTR (attrs.at_location);
6343 CHECKSUM_ATTR (attrs.at_lower_bound);
6344 CHECKSUM_ATTR (attrs.at_mutable);
6345 CHECKSUM_ATTR (attrs.at_ordering);
6346 CHECKSUM_ATTR (attrs.at_picture_string);
6347 CHECKSUM_ATTR (attrs.at_prototyped);
6348 CHECKSUM_ATTR (attrs.at_small);
6349 CHECKSUM_ATTR (attrs.at_segment);
6350 CHECKSUM_ATTR (attrs.at_string_length);
6351 CHECKSUM_ATTR (attrs.at_threads_scaled);
6352 CHECKSUM_ATTR (attrs.at_upper_bound);
6353 CHECKSUM_ATTR (attrs.at_use_location);
6354 CHECKSUM_ATTR (attrs.at_use_UTF8);
6355 CHECKSUM_ATTR (attrs.at_variable_parameter);
6356 CHECKSUM_ATTR (attrs.at_virtuality);
6357 CHECKSUM_ATTR (attrs.at_visibility);
6358 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
6359 CHECKSUM_ATTR (attrs.at_type);
6360 CHECKSUM_ATTR (attrs.at_friend);
6362 /* Checksum the child DIEs. */
6365 dw_attr_ref name_attr;
6368 name_attr = get_AT (c, DW_AT_name);
6369 if (is_template_instantiation (c))
6371 /* Ignore instantiations of member type and function templates. */
6373 else if (name_attr != NULL
6374 && (is_type_die (c) || c->die_tag == DW_TAG_subprogram))
6376 /* Use a shallow checksum for named nested types and member
6378 CHECKSUM_ULEB128 ('S');
6379 CHECKSUM_ULEB128 (c->die_tag);
6380 CHECKSUM_STRING (AT_string (name_attr));
6384 /* Use a deep checksum for other children. */
6385 /* Mark this DIE so it gets processed when unmarking. */
6386 if (c->die_mark == 0)
6388 die_checksum_ordered (c, ctx, mark);
6390 } while (c != die->die_child);
6392 CHECKSUM_ULEB128 (0);
6395 /* Add a type name and tag to a hash. */
6397 die_odr_checksum (int tag, const char *name, md5_ctx *ctx)
6399 CHECKSUM_ULEB128 (tag);
6400 CHECKSUM_STRING (name);
6404 #undef CHECKSUM_STRING
6405 #undef CHECKSUM_ATTR
6406 #undef CHECKSUM_LEB128
6407 #undef CHECKSUM_ULEB128
6409 /* Generate the type signature for DIE. This is computed by generating an
6410 MD5 checksum over the DIE's tag, its relevant attributes, and its
6411 children. Attributes that are references to other DIEs are processed
6412 by recursion, using the MARK field to prevent infinite recursion.
6413 If the DIE is nested inside a namespace or another type, we also
6414 need to include that context in the signature. The lower 64 bits
6415 of the resulting MD5 checksum comprise the signature. */
6418 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
6422 unsigned char checksum[16];
6427 name = get_AT_string (die, DW_AT_name);
6428 decl = get_AT_ref (die, DW_AT_specification);
6429 parent = get_die_parent (die);
6431 /* First, compute a signature for just the type name (and its surrounding
6432 context, if any. This is stored in the type unit DIE for link-time
6433 ODR (one-definition rule) checking. */
6435 if (is_cxx () && name != NULL)
6437 md5_init_ctx (&ctx);
6439 /* Checksum the names of surrounding namespaces and structures. */
6441 checksum_die_context (parent, &ctx);
6443 /* Checksum the current DIE. */
6444 die_odr_checksum (die->die_tag, name, &ctx);
6445 md5_finish_ctx (&ctx, checksum);
6447 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
6450 /* Next, compute the complete type signature. */
6452 md5_init_ctx (&ctx);
6454 die->die_mark = mark;
6456 /* Checksum the names of surrounding namespaces and structures. */
6458 checksum_die_context (parent, &ctx);
6460 /* Checksum the DIE and its children. */
6461 die_checksum_ordered (die, &ctx, &mark);
6462 unmark_all_dies (die);
6463 md5_finish_ctx (&ctx, checksum);
6465 /* Store the signature in the type node and link the type DIE and the
6466 type node together. */
6467 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
6468 DWARF_TYPE_SIGNATURE_SIZE);
6469 die->comdat_type_p = true;
6470 die->die_id.die_type_node = type_node;
6471 type_node->type_die = die;
6473 /* If the DIE is a specification, link its declaration to the type node
6477 decl->comdat_type_p = true;
6478 decl->die_id.die_type_node = type_node;
6482 /* Do the location expressions look same? */
6484 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6486 return loc1->dw_loc_opc == loc2->dw_loc_opc
6487 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6488 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6491 /* Do the values look the same? */
6493 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6495 dw_loc_descr_ref loc1, loc2;
6498 if (v1->val_class != v2->val_class)
6501 switch (v1->val_class)
6503 case dw_val_class_const:
6504 return v1->v.val_int == v2->v.val_int;
6505 case dw_val_class_unsigned_const:
6506 return v1->v.val_unsigned == v2->v.val_unsigned;
6507 case dw_val_class_const_double:
6508 return v1->v.val_double.high == v2->v.val_double.high
6509 && v1->v.val_double.low == v2->v.val_double.low;
6510 case dw_val_class_wide_int:
6511 return *v1->v.val_wide == *v2->v.val_wide;
6512 case dw_val_class_vec:
6513 if (v1->v.val_vec.length != v2->v.val_vec.length
6514 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6516 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6517 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6520 case dw_val_class_flag:
6521 return v1->v.val_flag == v2->v.val_flag;
6522 case dw_val_class_str:
6523 return !strcmp (v1->v.val_str->str, v2->v.val_str->str);
6525 case dw_val_class_addr:
6526 r1 = v1->v.val_addr;
6527 r2 = v2->v.val_addr;
6528 if (GET_CODE (r1) != GET_CODE (r2))
6530 return !rtx_equal_p (r1, r2);
6532 case dw_val_class_offset:
6533 return v1->v.val_offset == v2->v.val_offset;
6535 case dw_val_class_loc:
6536 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6538 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6539 if (!same_loc_p (loc1, loc2, mark))
6541 return !loc1 && !loc2;
6543 case dw_val_class_die_ref:
6544 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6546 case dw_val_class_fde_ref:
6547 case dw_val_class_vms_delta:
6548 case dw_val_class_lbl_id:
6549 case dw_val_class_lineptr:
6550 case dw_val_class_macptr:
6551 case dw_val_class_high_pc:
6554 case dw_val_class_file:
6555 return v1->v.val_file == v2->v.val_file;
6557 case dw_val_class_data8:
6558 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
6565 /* Do the attributes look the same? */
6568 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6570 if (at1->dw_attr != at2->dw_attr)
6573 /* We don't care that this was compiled with a different compiler
6574 snapshot; if the output is the same, that's what matters. */
6575 if (at1->dw_attr == DW_AT_producer)
6578 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6581 /* Do the dies look the same? */
6584 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6590 /* To avoid infinite recursion. */
6592 return die1->die_mark == die2->die_mark;
6593 die1->die_mark = die2->die_mark = ++(*mark);
6595 if (die1->die_tag != die2->die_tag)
6598 if (vec_safe_length (die1->die_attr) != vec_safe_length (die2->die_attr))
6601 FOR_EACH_VEC_SAFE_ELT (die1->die_attr, ix, a1)
6602 if (!same_attr_p (a1, &(*die2->die_attr)[ix], mark))
6605 c1 = die1->die_child;
6606 c2 = die2->die_child;
6615 if (!same_die_p (c1, c2, mark))
6619 if (c1 == die1->die_child)
6621 if (c2 == die2->die_child)
6631 /* Do the dies look the same? Wrapper around same_die_p. */
6634 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6637 int ret = same_die_p (die1, die2, &mark);
6639 unmark_all_dies (die1);
6640 unmark_all_dies (die2);
6645 /* The prefix to attach to symbols on DIEs in the current comdat debug
6647 static const char *comdat_symbol_id;
6649 /* The index of the current symbol within the current comdat CU. */
6650 static unsigned int comdat_symbol_number;
6652 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6653 children, and set comdat_symbol_id accordingly. */
6656 compute_section_prefix (dw_die_ref unit_die)
6658 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6659 const char *base = die_name ? lbasename (die_name) : "anonymous";
6660 char *name = XALLOCAVEC (char, strlen (base) + 64);
6663 unsigned char checksum[16];
6666 /* Compute the checksum of the DIE, then append part of it as hex digits to
6667 the name filename of the unit. */
6669 md5_init_ctx (&ctx);
6671 die_checksum (unit_die, &ctx, &mark);
6672 unmark_all_dies (unit_die);
6673 md5_finish_ctx (&ctx, checksum);
6675 sprintf (name, "%s.", base);
6676 clean_symbol_name (name);
6678 p = name + strlen (name);
6679 for (i = 0; i < 4; i++)
6681 sprintf (p, "%.2x", checksum[i]);
6685 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
6686 comdat_symbol_number = 0;
6689 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6692 is_type_die (dw_die_ref die)
6694 switch (die->die_tag)
6696 case DW_TAG_array_type:
6697 case DW_TAG_class_type:
6698 case DW_TAG_interface_type:
6699 case DW_TAG_enumeration_type:
6700 case DW_TAG_pointer_type:
6701 case DW_TAG_reference_type:
6702 case DW_TAG_rvalue_reference_type:
6703 case DW_TAG_string_type:
6704 case DW_TAG_structure_type:
6705 case DW_TAG_subroutine_type:
6706 case DW_TAG_union_type:
6707 case DW_TAG_ptr_to_member_type:
6708 case DW_TAG_set_type:
6709 case DW_TAG_subrange_type:
6710 case DW_TAG_base_type:
6711 case DW_TAG_const_type:
6712 case DW_TAG_file_type:
6713 case DW_TAG_packed_type:
6714 case DW_TAG_volatile_type:
6715 case DW_TAG_typedef:
6722 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6723 Basically, we want to choose the bits that are likely to be shared between
6724 compilations (types) and leave out the bits that are specific to individual
6725 compilations (functions). */
6728 is_comdat_die (dw_die_ref c)
6730 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6731 we do for stabs. The advantage is a greater likelihood of sharing between
6732 objects that don't include headers in the same order (and therefore would
6733 put the base types in a different comdat). jason 8/28/00 */
6735 if (c->die_tag == DW_TAG_base_type)
6738 if (c->die_tag == DW_TAG_pointer_type
6739 || c->die_tag == DW_TAG_reference_type
6740 || c->die_tag == DW_TAG_rvalue_reference_type
6741 || c->die_tag == DW_TAG_const_type
6742 || c->die_tag == DW_TAG_volatile_type)
6744 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6746 return t ? is_comdat_die (t) : 0;
6749 return is_type_die (c);
6752 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6753 compilation unit. */
6756 is_symbol_die (dw_die_ref c)
6758 return (is_type_die (c)
6759 || is_declaration_die (c)
6760 || c->die_tag == DW_TAG_namespace
6761 || c->die_tag == DW_TAG_module);
6764 /* Returns true iff C is a compile-unit DIE. */
6767 is_cu_die (dw_die_ref c)
6769 return c && c->die_tag == DW_TAG_compile_unit;
6772 /* Returns true iff C is a unit DIE of some sort. */
6775 is_unit_die (dw_die_ref c)
6777 return c && (c->die_tag == DW_TAG_compile_unit
6778 || c->die_tag == DW_TAG_partial_unit
6779 || c->die_tag == DW_TAG_type_unit);
6782 /* Returns true iff C is a namespace DIE. */
6785 is_namespace_die (dw_die_ref c)
6787 return c && c->die_tag == DW_TAG_namespace;
6790 /* Returns true iff C is a class or structure DIE. */
6793 is_class_die (dw_die_ref c)
6795 return c && (c->die_tag == DW_TAG_class_type
6796 || c->die_tag == DW_TAG_structure_type);
6799 /* Return non-zero if this DIE is a template parameter. */
6802 is_template_parameter (dw_die_ref die)
6804 switch (die->die_tag)
6806 case DW_TAG_template_type_param:
6807 case DW_TAG_template_value_param:
6808 case DW_TAG_GNU_template_template_param:
6809 case DW_TAG_GNU_template_parameter_pack:
6816 /* Return non-zero if this DIE represents a template instantiation. */
6819 is_template_instantiation (dw_die_ref die)
6823 if (!is_type_die (die) && die->die_tag != DW_TAG_subprogram)
6825 FOR_EACH_CHILD (die, c, if (is_template_parameter (c)) return true);
6830 gen_internal_sym (const char *prefix)
6834 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6835 return xstrdup (buf);
6838 /* Assign symbols to all worthy DIEs under DIE. */
6841 assign_symbol_names (dw_die_ref die)
6845 if (is_symbol_die (die) && !die->comdat_type_p)
6847 if (comdat_symbol_id)
6849 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
6851 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6852 comdat_symbol_id, comdat_symbol_number++);
6853 die->die_id.die_symbol = xstrdup (p);
6856 die->die_id.die_symbol = gen_internal_sym ("LDIE");
6859 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6862 struct cu_hash_table_entry
6865 unsigned min_comdat_num, max_comdat_num;
6866 struct cu_hash_table_entry *next;
6869 /* Helpers to manipulate hash table of CUs. */
6871 struct cu_hash_table_entry_hasher
6873 typedef cu_hash_table_entry value_type;
6874 typedef die_struct compare_type;
6875 static inline hashval_t hash (const value_type *);
6876 static inline bool equal (const value_type *, const compare_type *);
6877 static inline void remove (value_type *);
6881 cu_hash_table_entry_hasher::hash (const value_type *entry)
6883 return htab_hash_string (entry->cu->die_id.die_symbol);
6887 cu_hash_table_entry_hasher::equal (const value_type *entry1,
6888 const compare_type *entry2)
6890 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
6894 cu_hash_table_entry_hasher::remove (value_type *entry)
6896 struct cu_hash_table_entry *next;
6906 typedef hash_table<cu_hash_table_entry_hasher> cu_hash_type;
6908 /* Check whether we have already seen this CU and set up SYM_NUM
6911 check_duplicate_cu (dw_die_ref cu, cu_hash_type *htable, unsigned int *sym_num)
6913 struct cu_hash_table_entry dummy;
6914 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6916 dummy.max_comdat_num = 0;
6918 slot = htable->find_slot_with_hash (cu,
6919 htab_hash_string (cu->die_id.die_symbol),
6923 for (; entry; last = entry, entry = entry->next)
6925 if (same_die_p_wrap (cu, entry->cu))
6931 *sym_num = entry->min_comdat_num;
6935 entry = XCNEW (struct cu_hash_table_entry);
6937 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6938 entry->next = *slot;
6944 /* Record SYM_NUM to record of CU in HTABLE. */
6946 record_comdat_symbol_number (dw_die_ref cu, cu_hash_type *htable,
6947 unsigned int sym_num)
6949 struct cu_hash_table_entry **slot, *entry;
6951 slot = htable->find_slot_with_hash (cu,
6952 htab_hash_string (cu->die_id.die_symbol),
6956 entry->max_comdat_num = sym_num;
6959 /* Traverse the DIE (which is always comp_unit_die), and set up
6960 additional compilation units for each of the include files we see
6961 bracketed by BINCL/EINCL. */
6964 break_out_includes (dw_die_ref die)
6967 dw_die_ref unit = NULL;
6968 limbo_die_node *node, **pnode;
6972 dw_die_ref prev = c;
6974 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6975 || (unit && is_comdat_die (c)))
6977 dw_die_ref next = c->die_sib;
6979 /* This DIE is for a secondary CU; remove it from the main one. */
6980 remove_child_with_prev (c, prev);
6982 if (c->die_tag == DW_TAG_GNU_BINCL)
6983 unit = push_new_compile_unit (unit, c);
6984 else if (c->die_tag == DW_TAG_GNU_EINCL)
6985 unit = pop_compile_unit (unit);
6987 add_child_die (unit, c);
6989 if (c == die->die_child)
6992 } while (c != die->die_child);
6995 /* We can only use this in debugging, since the frontend doesn't check
6996 to make sure that we leave every include file we enter. */
7000 assign_symbol_names (die);
7001 cu_hash_type cu_hash_table (10);
7002 for (node = limbo_die_list, pnode = &limbo_die_list;
7008 compute_section_prefix (node->die);
7009 is_dupl = check_duplicate_cu (node->die, &cu_hash_table,
7010 &comdat_symbol_number);
7011 assign_symbol_names (node->die);
7013 *pnode = node->next;
7016 pnode = &node->next;
7017 record_comdat_symbol_number (node->die, &cu_hash_table,
7018 comdat_symbol_number);
7023 /* Return non-zero if this DIE is a declaration. */
7026 is_declaration_die (dw_die_ref die)
7031 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7032 if (a->dw_attr == DW_AT_declaration)
7038 /* Return non-zero if this DIE is nested inside a subprogram. */
7041 is_nested_in_subprogram (dw_die_ref die)
7043 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
7047 return local_scope_p (decl);
7050 /* Return non-zero if this DIE contains a defining declaration of a
7054 contains_subprogram_definition (dw_die_ref die)
7058 if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die))
7060 FOR_EACH_CHILD (die, c, if (contains_subprogram_definition (c)) return 1);
7064 /* Return non-zero if this is a type DIE that should be moved to a
7065 COMDAT .debug_types section. */
7068 should_move_die_to_comdat (dw_die_ref die)
7070 switch (die->die_tag)
7072 case DW_TAG_class_type:
7073 case DW_TAG_structure_type:
7074 case DW_TAG_enumeration_type:
7075 case DW_TAG_union_type:
7076 /* Don't move declarations, inlined instances, types nested in a
7077 subprogram, or types that contain subprogram definitions. */
7078 if (is_declaration_die (die)
7079 || get_AT (die, DW_AT_abstract_origin)
7080 || is_nested_in_subprogram (die)
7081 || contains_subprogram_definition (die))
7084 case DW_TAG_array_type:
7085 case DW_TAG_interface_type:
7086 case DW_TAG_pointer_type:
7087 case DW_TAG_reference_type:
7088 case DW_TAG_rvalue_reference_type:
7089 case DW_TAG_string_type:
7090 case DW_TAG_subroutine_type:
7091 case DW_TAG_ptr_to_member_type:
7092 case DW_TAG_set_type:
7093 case DW_TAG_subrange_type:
7094 case DW_TAG_base_type:
7095 case DW_TAG_const_type:
7096 case DW_TAG_file_type:
7097 case DW_TAG_packed_type:
7098 case DW_TAG_volatile_type:
7099 case DW_TAG_typedef:
7105 /* Make a clone of DIE. */
7108 clone_die (dw_die_ref die)
7114 clone = ggc_cleared_alloc<die_node> ();
7115 clone->die_tag = die->die_tag;
7117 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7118 add_dwarf_attr (clone, a);
7123 /* Make a clone of the tree rooted at DIE. */
7126 clone_tree (dw_die_ref die)
7129 dw_die_ref clone = clone_die (die);
7131 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree (c)));
7136 /* Make a clone of DIE as a declaration. */
7139 clone_as_declaration (dw_die_ref die)
7146 /* If the DIE is already a declaration, just clone it. */
7147 if (is_declaration_die (die))
7148 return clone_die (die);
7150 /* If the DIE is a specification, just clone its declaration DIE. */
7151 decl = get_AT_ref (die, DW_AT_specification);
7154 clone = clone_die (decl);
7155 if (die->comdat_type_p)
7156 add_AT_die_ref (clone, DW_AT_signature, die);
7160 clone = ggc_cleared_alloc<die_node> ();
7161 clone->die_tag = die->die_tag;
7163 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7165 /* We don't want to copy over all attributes.
7166 For example we don't want DW_AT_byte_size because otherwise we will no
7167 longer have a declaration and GDB will treat it as a definition. */
7171 case DW_AT_abstract_origin:
7172 case DW_AT_artificial:
7173 case DW_AT_containing_type:
7174 case DW_AT_external:
7177 case DW_AT_virtuality:
7178 case DW_AT_linkage_name:
7179 case DW_AT_MIPS_linkage_name:
7180 add_dwarf_attr (clone, a);
7182 case DW_AT_byte_size:
7188 if (die->comdat_type_p)
7189 add_AT_die_ref (clone, DW_AT_signature, die);
7191 add_AT_flag (clone, DW_AT_declaration, 1);
7196 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7198 struct decl_table_entry
7204 /* Helpers to manipulate hash table of copied declarations. */
7206 /* Hashtable helpers. */
7208 struct decl_table_entry_hasher : typed_free_remove <decl_table_entry>
7210 typedef decl_table_entry value_type;
7211 typedef die_struct compare_type;
7212 static inline hashval_t hash (const value_type *);
7213 static inline bool equal (const value_type *, const compare_type *);
7217 decl_table_entry_hasher::hash (const value_type *entry)
7219 return htab_hash_pointer (entry->orig);
7223 decl_table_entry_hasher::equal (const value_type *entry1,
7224 const compare_type *entry2)
7226 return entry1->orig == entry2;
7229 typedef hash_table<decl_table_entry_hasher> decl_hash_type;
7231 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7232 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7233 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7234 to check if the ancestor has already been copied into UNIT. */
7237 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die,
7238 decl_hash_type *decl_table)
7240 dw_die_ref parent = die->die_parent;
7241 dw_die_ref new_parent = unit;
7243 decl_table_entry **slot = NULL;
7244 struct decl_table_entry *entry = NULL;
7248 /* Check if the entry has already been copied to UNIT. */
7249 slot = decl_table->find_slot_with_hash (die, htab_hash_pointer (die),
7251 if (*slot != HTAB_EMPTY_ENTRY)
7257 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7258 entry = XCNEW (struct decl_table_entry);
7266 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
7269 if (!is_unit_die (parent))
7270 new_parent = copy_ancestor_tree (unit, parent, decl_table);
7273 copy = clone_as_declaration (die);
7274 add_child_die (new_parent, copy);
7278 /* Record the pointer to the copy. */
7284 /* Copy the declaration context to the new type unit DIE. This includes
7285 any surrounding namespace or type declarations. If the DIE has an
7286 AT_specification attribute, it also includes attributes and children
7287 attached to the specification, and returns a pointer to the original
7288 parent of the declaration DIE. Returns NULL otherwise. */
7291 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
7294 dw_die_ref new_decl;
7295 dw_die_ref orig_parent = NULL;
7297 decl = get_AT_ref (die, DW_AT_specification);
7306 /* The original DIE will be changed to a declaration, and must
7307 be moved to be a child of the original declaration DIE. */
7308 orig_parent = decl->die_parent;
7310 /* Copy the type node pointer from the new DIE to the original
7311 declaration DIE so we can forward references later. */
7312 decl->comdat_type_p = true;
7313 decl->die_id.die_type_node = die->die_id.die_type_node;
7315 remove_AT (die, DW_AT_specification);
7317 FOR_EACH_VEC_SAFE_ELT (decl->die_attr, ix, a)
7319 if (a->dw_attr != DW_AT_name
7320 && a->dw_attr != DW_AT_declaration
7321 && a->dw_attr != DW_AT_external)
7322 add_dwarf_attr (die, a);
7325 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree (c)));
7328 if (decl->die_parent != NULL
7329 && !is_unit_die (decl->die_parent))
7331 new_decl = copy_ancestor_tree (unit, decl, NULL);
7332 if (new_decl != NULL)
7334 remove_AT (new_decl, DW_AT_signature);
7335 add_AT_specification (die, new_decl);
7342 /* Generate the skeleton ancestor tree for the given NODE, then clone
7343 the DIE and add the clone into the tree. */
7346 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
7348 if (node->new_die != NULL)
7351 node->new_die = clone_as_declaration (node->old_die);
7353 if (node->parent != NULL)
7355 generate_skeleton_ancestor_tree (node->parent);
7356 add_child_die (node->parent->new_die, node->new_die);
7360 /* Generate a skeleton tree of DIEs containing any declarations that are
7361 found in the original tree. We traverse the tree looking for declaration
7362 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7365 generate_skeleton_bottom_up (skeleton_chain_node *parent)
7367 skeleton_chain_node node;
7370 dw_die_ref prev = NULL;
7371 dw_die_ref next = NULL;
7373 node.parent = parent;
7375 first = c = parent->old_die->die_child;
7379 if (prev == NULL || prev->die_sib == c)
7382 next = (c == first ? NULL : c->die_sib);
7384 node.new_die = NULL;
7385 if (is_declaration_die (c))
7387 if (is_template_instantiation (c))
7389 /* Instantiated templates do not need to be cloned into the
7390 type unit. Just move the DIE and its children back to
7391 the skeleton tree (in the main CU). */
7392 remove_child_with_prev (c, prev);
7393 add_child_die (parent->new_die, c);
7398 /* Clone the existing DIE, move the original to the skeleton
7399 tree (which is in the main CU), and put the clone, with
7400 all the original's children, where the original came from
7401 (which is about to be moved to the type unit). */
7402 dw_die_ref clone = clone_die (c);
7403 move_all_children (c, clone);
7405 /* If the original has a DW_AT_object_pointer attribute,
7406 it would now point to a child DIE just moved to the
7407 cloned tree, so we need to remove that attribute from
7409 remove_AT (c, DW_AT_object_pointer);
7411 replace_child (c, clone, prev);
7412 generate_skeleton_ancestor_tree (parent);
7413 add_child_die (parent->new_die, c);
7418 generate_skeleton_bottom_up (&node);
7419 } while (next != NULL);
7422 /* Wrapper function for generate_skeleton_bottom_up. */
7425 generate_skeleton (dw_die_ref die)
7427 skeleton_chain_node node;
7430 node.new_die = NULL;
7433 /* If this type definition is nested inside another type,
7434 and is not an instantiation of a template, always leave
7435 at least a declaration in its place. */
7436 if (die->die_parent != NULL
7437 && is_type_die (die->die_parent)
7438 && !is_template_instantiation (die))
7439 node.new_die = clone_as_declaration (die);
7441 generate_skeleton_bottom_up (&node);
7442 return node.new_die;
7445 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
7446 declaration. The original DIE is moved to a new compile unit so that
7447 existing references to it follow it to the new location. If any of the
7448 original DIE's descendants is a declaration, we need to replace the
7449 original DIE with a skeleton tree and move the declarations back into the
7453 remove_child_or_replace_with_skeleton (dw_die_ref unit, dw_die_ref child,
7456 dw_die_ref skeleton, orig_parent;
7458 /* Copy the declaration context to the type unit DIE. If the returned
7459 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
7461 orig_parent = copy_declaration_context (unit, child);
7463 skeleton = generate_skeleton (child);
7464 if (skeleton == NULL)
7465 remove_child_with_prev (child, prev);
7468 skeleton->comdat_type_p = true;
7469 skeleton->die_id.die_type_node = child->die_id.die_type_node;
7471 /* If the original DIE was a specification, we need to put
7472 the skeleton under the parent DIE of the declaration.
7473 This leaves the original declaration in the tree, but
7474 it will be pruned later since there are no longer any
7475 references to it. */
7476 if (orig_parent != NULL)
7478 remove_child_with_prev (child, prev);
7479 add_child_die (orig_parent, skeleton);
7482 replace_child (child, skeleton, prev);
7488 /* Traverse the DIE and set up additional .debug_types sections for each
7489 type worthy of being placed in a COMDAT section. */
7492 break_out_comdat_types (dw_die_ref die)
7496 dw_die_ref prev = NULL;
7497 dw_die_ref next = NULL;
7498 dw_die_ref unit = NULL;
7500 first = c = die->die_child;
7504 if (prev == NULL || prev->die_sib == c)
7507 next = (c == first ? NULL : c->die_sib);
7508 if (should_move_die_to_comdat (c))
7510 dw_die_ref replacement;
7511 comdat_type_node_ref type_node;
7513 /* Break out nested types into their own type units. */
7514 break_out_comdat_types (c);
7516 /* Create a new type unit DIE as the root for the new tree, and
7517 add it to the list of comdat types. */
7518 unit = new_die (DW_TAG_type_unit, NULL, NULL);
7519 add_AT_unsigned (unit, DW_AT_language,
7520 get_AT_unsigned (comp_unit_die (), DW_AT_language));
7521 type_node = ggc_cleared_alloc<comdat_type_node> ();
7522 type_node->root_die = unit;
7523 type_node->next = comdat_type_list;
7524 comdat_type_list = type_node;
7526 /* Generate the type signature. */
7527 generate_type_signature (c, type_node);
7529 /* Copy the declaration context, attributes, and children of the
7530 declaration into the new type unit DIE, then remove this DIE
7531 from the main CU (or replace it with a skeleton if necessary). */
7532 replacement = remove_child_or_replace_with_skeleton (unit, c, prev);
7533 type_node->skeleton_die = replacement;
7535 /* Add the DIE to the new compunit. */
7536 add_child_die (unit, c);
7538 if (replacement != NULL)
7541 else if (c->die_tag == DW_TAG_namespace
7542 || c->die_tag == DW_TAG_class_type
7543 || c->die_tag == DW_TAG_structure_type
7544 || c->die_tag == DW_TAG_union_type)
7546 /* Look for nested types that can be broken out. */
7547 break_out_comdat_types (c);
7549 } while (next != NULL);
7552 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
7553 Enter all the cloned children into the hash table decl_table. */
7556 clone_tree_partial (dw_die_ref die, decl_hash_type *decl_table)
7560 struct decl_table_entry *entry;
7561 decl_table_entry **slot;
7563 if (die->die_tag == DW_TAG_subprogram)
7564 clone = clone_as_declaration (die);
7566 clone = clone_die (die);
7568 slot = decl_table->find_slot_with_hash (die,
7569 htab_hash_pointer (die), INSERT);
7571 /* Assert that DIE isn't in the hash table yet. If it would be there
7572 before, the ancestors would be necessarily there as well, therefore
7573 clone_tree_partial wouldn't be called. */
7574 gcc_assert (*slot == HTAB_EMPTY_ENTRY);
7576 entry = XCNEW (struct decl_table_entry);
7578 entry->copy = clone;
7581 if (die->die_tag != DW_TAG_subprogram)
7582 FOR_EACH_CHILD (die, c,
7583 add_child_die (clone, clone_tree_partial (c, decl_table)));
7588 /* Walk the DIE and its children, looking for references to incomplete
7589 or trivial types that are unmarked (i.e., that are not in the current
7593 copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type *decl_table)
7599 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7601 if (AT_class (a) == dw_val_class_die_ref)
7603 dw_die_ref targ = AT_ref (a);
7604 decl_table_entry **slot;
7605 struct decl_table_entry *entry;
7607 if (targ->die_mark != 0 || targ->comdat_type_p)
7610 slot = decl_table->find_slot_with_hash (targ,
7611 htab_hash_pointer (targ),
7614 if (*slot != HTAB_EMPTY_ENTRY)
7616 /* TARG has already been copied, so we just need to
7617 modify the reference to point to the copy. */
7619 a->dw_attr_val.v.val_die_ref.die = entry->copy;
7623 dw_die_ref parent = unit;
7624 dw_die_ref copy = clone_die (targ);
7626 /* Record in DECL_TABLE that TARG has been copied.
7627 Need to do this now, before the recursive call,
7628 because DECL_TABLE may be expanded and SLOT
7629 would no longer be a valid pointer. */
7630 entry = XCNEW (struct decl_table_entry);
7635 /* If TARG is not a declaration DIE, we need to copy its
7637 if (!is_declaration_die (targ))
7641 add_child_die (copy,
7642 clone_tree_partial (c, decl_table)));
7645 /* Make sure the cloned tree is marked as part of the
7649 /* If TARG has surrounding context, copy its ancestor tree
7650 into the new type unit. */
7651 if (targ->die_parent != NULL
7652 && !is_unit_die (targ->die_parent))
7653 parent = copy_ancestor_tree (unit, targ->die_parent,
7656 add_child_die (parent, copy);
7657 a->dw_attr_val.v.val_die_ref.die = copy;
7659 /* Make sure the newly-copied DIE is walked. If it was
7660 installed in a previously-added context, it won't
7661 get visited otherwise. */
7664 /* Find the highest point of the newly-added tree,
7665 mark each node along the way, and walk from there. */
7666 parent->die_mark = 1;
7667 while (parent->die_parent
7668 && parent->die_parent->die_mark == 0)
7670 parent = parent->die_parent;
7671 parent->die_mark = 1;
7673 copy_decls_walk (unit, parent, decl_table);
7679 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
7682 /* Copy declarations for "unworthy" types into the new comdat section.
7683 Incomplete types, modified types, and certain other types aren't broken
7684 out into comdat sections of their own, so they don't have a signature,
7685 and we need to copy the declaration into the same section so that we
7686 don't have an external reference. */
7689 copy_decls_for_unworthy_types (dw_die_ref unit)
7692 decl_hash_type decl_table (10);
7693 copy_decls_walk (unit, unit, &decl_table);
7697 /* Traverse the DIE and add a sibling attribute if it may have the
7698 effect of speeding up access to siblings. To save some space,
7699 avoid generating sibling attributes for DIE's without children. */
7702 add_sibling_attributes (dw_die_ref die)
7706 if (! die->die_child)
7709 if (die->die_parent && die != die->die_parent->die_child)
7710 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7712 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7715 /* Output all location lists for the DIE and its children. */
7718 output_location_lists (dw_die_ref die)
7724 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7725 if (AT_class (a) == dw_val_class_loc_list)
7726 output_loc_list (AT_loc_list (a));
7728 FOR_EACH_CHILD (die, c, output_location_lists (c));
7731 /* We want to limit the number of external references, because they are
7732 larger than local references: a relocation takes multiple words, and
7733 even a sig8 reference is always eight bytes, whereas a local reference
7734 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
7735 So if we encounter multiple external references to the same type DIE, we
7736 make a local typedef stub for it and redirect all references there.
7738 This is the element of the hash table for keeping track of these
7748 /* Hashtable helpers. */
7750 struct external_ref_hasher : typed_free_remove <external_ref>
7752 typedef external_ref value_type;
7753 typedef external_ref compare_type;
7754 static inline hashval_t hash (const value_type *);
7755 static inline bool equal (const value_type *, const compare_type *);
7759 external_ref_hasher::hash (const value_type *r)
7761 dw_die_ref die = r->type;
7764 /* We can't use the address of the DIE for hashing, because
7765 that will make the order of the stub DIEs non-deterministic. */
7766 if (! die->comdat_type_p)
7767 /* We have a symbol; use it to compute a hash. */
7768 h = htab_hash_string (die->die_id.die_symbol);
7771 /* We have a type signature; use a subset of the bits as the hash.
7772 The 8-byte signature is at least as large as hashval_t. */
7773 comdat_type_node_ref type_node = die->die_id.die_type_node;
7774 memcpy (&h, type_node->signature, sizeof (h));
7780 external_ref_hasher::equal (const value_type *r1, const compare_type *r2)
7782 return r1->type == r2->type;
7785 typedef hash_table<external_ref_hasher> external_ref_hash_type;
7787 /* Return a pointer to the external_ref for references to DIE. */
7789 static struct external_ref *
7790 lookup_external_ref (external_ref_hash_type *map, dw_die_ref die)
7792 struct external_ref ref, *ref_p;
7793 external_ref **slot;
7796 slot = map->find_slot (&ref, INSERT);
7797 if (*slot != HTAB_EMPTY_ENTRY)
7800 ref_p = XCNEW (struct external_ref);
7806 /* Subroutine of optimize_external_refs, below.
7808 If we see a type skeleton, record it as our stub. If we see external
7809 references, remember how many we've seen. */
7812 optimize_external_refs_1 (dw_die_ref die, external_ref_hash_type *map)
7817 struct external_ref *ref_p;
7819 if (is_type_die (die)
7820 && (c = get_AT_ref (die, DW_AT_signature)))
7822 /* This is a local skeleton; use it for local references. */
7823 ref_p = lookup_external_ref (map, c);
7827 /* Scan the DIE references, and remember any that refer to DIEs from
7828 other CUs (i.e. those which are not marked). */
7829 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7830 if (AT_class (a) == dw_val_class_die_ref
7831 && (c = AT_ref (a))->die_mark == 0
7834 ref_p = lookup_external_ref (map, c);
7838 FOR_EACH_CHILD (die, c, optimize_external_refs_1 (c, map));
7841 /* htab_traverse callback function for optimize_external_refs, below. SLOT
7842 points to an external_ref, DATA is the CU we're processing. If we don't
7843 already have a local stub, and we have multiple refs, build a stub. */
7846 dwarf2_build_local_stub (external_ref **slot, dw_die_ref data)
7848 struct external_ref *ref_p = *slot;
7850 if (ref_p->stub == NULL && ref_p->n_refs > 1 && !dwarf_strict)
7852 /* We have multiple references to this type, so build a small stub.
7853 Both of these forms are a bit dodgy from the perspective of the
7854 DWARF standard, since technically they should have names. */
7855 dw_die_ref cu = data;
7856 dw_die_ref type = ref_p->type;
7857 dw_die_ref stub = NULL;
7859 if (type->comdat_type_p)
7861 /* If we refer to this type via sig8, use AT_signature. */
7862 stub = new_die (type->die_tag, cu, NULL_TREE);
7863 add_AT_die_ref (stub, DW_AT_signature, type);
7867 /* Otherwise, use a typedef with no name. */
7868 stub = new_die (DW_TAG_typedef, cu, NULL_TREE);
7869 add_AT_die_ref (stub, DW_AT_type, type);
7878 /* DIE is a unit; look through all the DIE references to see if there are
7879 any external references to types, and if so, create local stubs for
7880 them which will be applied in build_abbrev_table. This is useful because
7881 references to local DIEs are smaller. */
7883 static external_ref_hash_type *
7884 optimize_external_refs (dw_die_ref die)
7886 external_ref_hash_type *map = new external_ref_hash_type (10);
7887 optimize_external_refs_1 (die, map);
7888 map->traverse <dw_die_ref, dwarf2_build_local_stub> (die);
7892 /* The format of each DIE (and its attribute value pairs) is encoded in an
7893 abbreviation table. This routine builds the abbreviation table and assigns
7894 a unique abbreviation id for each abbreviation entry. The children of each
7895 die are visited recursively. */
7898 build_abbrev_table (dw_die_ref die, external_ref_hash_type *extern_map)
7900 unsigned long abbrev_id;
7901 unsigned int n_alloc;
7906 /* Scan the DIE references, and replace any that refer to
7907 DIEs from other CUs (i.e. those which are not marked) with
7908 the local stubs we built in optimize_external_refs. */
7909 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7910 if (AT_class (a) == dw_val_class_die_ref
7911 && (c = AT_ref (a))->die_mark == 0)
7913 struct external_ref *ref_p;
7914 gcc_assert (AT_ref (a)->comdat_type_p || AT_ref (a)->die_id.die_symbol);
7916 ref_p = lookup_external_ref (extern_map, c);
7917 if (ref_p->stub && ref_p->stub != die)
7918 change_AT_die_ref (a, ref_p->stub);
7920 /* We aren't changing this reference, so mark it external. */
7921 set_AT_ref_external (a, 1);
7924 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7926 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7927 dw_attr_ref die_a, abbrev_a;
7931 if (abbrev->die_tag != die->die_tag)
7933 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7936 if (vec_safe_length (abbrev->die_attr) != vec_safe_length (die->die_attr))
7939 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, die_a)
7941 abbrev_a = &(*abbrev->die_attr)[ix];
7942 if ((abbrev_a->dw_attr != die_a->dw_attr)
7943 || (value_format (abbrev_a) != value_format (die_a)))
7953 if (abbrev_id >= abbrev_die_table_in_use)
7955 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7957 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7958 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7961 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7962 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7963 abbrev_die_table_allocated = n_alloc;
7966 ++abbrev_die_table_in_use;
7967 abbrev_die_table[abbrev_id] = die;
7970 die->die_abbrev = abbrev_id;
7971 FOR_EACH_CHILD (die, c, build_abbrev_table (c, extern_map));
7974 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7977 constant_size (unsigned HOST_WIDE_INT value)
7984 log = floor_log2 (value);
7987 log = 1 << (floor_log2 (log) + 1);
7992 /* Return the size of a DIE as it is represented in the
7993 .debug_info section. */
7995 static unsigned long
7996 size_of_die (dw_die_ref die)
7998 unsigned long size = 0;
8001 enum dwarf_form form;
8003 size += size_of_uleb128 (die->die_abbrev);
8004 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8006 switch (AT_class (a))
8008 case dw_val_class_addr:
8009 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8011 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8012 size += size_of_uleb128 (AT_index (a));
8015 size += DWARF2_ADDR_SIZE;
8017 case dw_val_class_offset:
8018 size += DWARF_OFFSET_SIZE;
8020 case dw_val_class_loc:
8022 unsigned long lsize = size_of_locs (AT_loc (a));
8025 if (dwarf_version >= 4)
8026 size += size_of_uleb128 (lsize);
8028 size += constant_size (lsize);
8032 case dw_val_class_loc_list:
8033 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8035 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8036 size += size_of_uleb128 (AT_index (a));
8039 size += DWARF_OFFSET_SIZE;
8041 case dw_val_class_range_list:
8042 size += DWARF_OFFSET_SIZE;
8044 case dw_val_class_const:
8045 size += size_of_sleb128 (AT_int (a));
8047 case dw_val_class_unsigned_const:
8049 int csize = constant_size (AT_unsigned (a));
8050 if (dwarf_version == 3
8051 && a->dw_attr == DW_AT_data_member_location
8053 size += size_of_uleb128 (AT_unsigned (a));
8058 case dw_val_class_const_double:
8059 size += HOST_BITS_PER_DOUBLE_INT / HOST_BITS_PER_CHAR;
8060 if (HOST_BITS_PER_WIDE_INT >= 64)
8063 case dw_val_class_wide_int:
8064 size += (get_full_len (*a->dw_attr_val.v.val_wide)
8065 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
8066 if (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT
8070 case dw_val_class_vec:
8071 size += constant_size (a->dw_attr_val.v.val_vec.length
8072 * a->dw_attr_val.v.val_vec.elt_size)
8073 + a->dw_attr_val.v.val_vec.length
8074 * a->dw_attr_val.v.val_vec.elt_size; /* block */
8076 case dw_val_class_flag:
8077 if (dwarf_version >= 4)
8078 /* Currently all add_AT_flag calls pass in 1 as last argument,
8079 so DW_FORM_flag_present can be used. If that ever changes,
8080 we'll need to use DW_FORM_flag and have some optimization
8081 in build_abbrev_table that will change those to
8082 DW_FORM_flag_present if it is set to 1 in all DIEs using
8083 the same abbrev entry. */
8084 gcc_assert (a->dw_attr_val.v.val_flag == 1);
8088 case dw_val_class_die_ref:
8089 if (AT_ref_external (a))
8091 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
8092 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
8093 is sized by target address length, whereas in DWARF3
8094 it's always sized as an offset. */
8095 if (use_debug_types)
8096 size += DWARF_TYPE_SIGNATURE_SIZE;
8097 else if (dwarf_version == 2)
8098 size += DWARF2_ADDR_SIZE;
8100 size += DWARF_OFFSET_SIZE;
8103 size += DWARF_OFFSET_SIZE;
8105 case dw_val_class_fde_ref:
8106 size += DWARF_OFFSET_SIZE;
8108 case dw_val_class_lbl_id:
8109 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8111 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
8112 size += size_of_uleb128 (AT_index (a));
8115 size += DWARF2_ADDR_SIZE;
8117 case dw_val_class_lineptr:
8118 case dw_val_class_macptr:
8119 size += DWARF_OFFSET_SIZE;
8121 case dw_val_class_str:
8122 form = AT_string_form (a);
8123 if (form == DW_FORM_strp)
8124 size += DWARF_OFFSET_SIZE;
8125 else if (form == DW_FORM_GNU_str_index)
8126 size += size_of_uleb128 (AT_index (a));
8128 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
8130 case dw_val_class_file:
8131 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
8133 case dw_val_class_data8:
8136 case dw_val_class_vms_delta:
8137 size += DWARF_OFFSET_SIZE;
8139 case dw_val_class_high_pc:
8140 size += DWARF2_ADDR_SIZE;
8150 /* Size the debugging information associated with a given DIE. Visits the
8151 DIE's children recursively. Updates the global variable next_die_offset, on
8152 each time through. Uses the current value of next_die_offset to update the
8153 die_offset field in each DIE. */
8156 calc_die_sizes (dw_die_ref die)
8160 gcc_assert (die->die_offset == 0
8161 || (unsigned long int) die->die_offset == next_die_offset);
8162 die->die_offset = next_die_offset;
8163 next_die_offset += size_of_die (die);
8165 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
8167 if (die->die_child != NULL)
8168 /* Count the null byte used to terminate sibling lists. */
8169 next_die_offset += 1;
8172 /* Size just the base type children at the start of the CU.
8173 This is needed because build_abbrev needs to size locs
8174 and sizing of type based stack ops needs to know die_offset
8175 values for the base types. */
8178 calc_base_type_die_sizes (void)
8180 unsigned long die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8182 dw_die_ref base_type;
8183 #if ENABLE_ASSERT_CHECKING
8184 dw_die_ref prev = comp_unit_die ()->die_child;
8187 die_offset += size_of_die (comp_unit_die ());
8188 for (i = 0; base_types.iterate (i, &base_type); i++)
8190 #if ENABLE_ASSERT_CHECKING
8191 gcc_assert (base_type->die_offset == 0
8192 && prev->die_sib == base_type
8193 && base_type->die_child == NULL
8194 && base_type->die_abbrev);
8197 base_type->die_offset = die_offset;
8198 die_offset += size_of_die (base_type);
8202 /* Set the marks for a die and its children. We do this so
8203 that we know whether or not a reference needs to use FORM_ref_addr; only
8204 DIEs in the same CU will be marked. We used to clear out the offset
8205 and use that as the flag, but ran into ordering problems. */
8208 mark_dies (dw_die_ref die)
8212 gcc_assert (!die->die_mark);
8215 FOR_EACH_CHILD (die, c, mark_dies (c));
8218 /* Clear the marks for a die and its children. */
8221 unmark_dies (dw_die_ref die)
8225 if (! use_debug_types)
8226 gcc_assert (die->die_mark);
8229 FOR_EACH_CHILD (die, c, unmark_dies (c));
8232 /* Clear the marks for a die, its children and referred dies. */
8235 unmark_all_dies (dw_die_ref die)
8245 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
8247 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8248 if (AT_class (a) == dw_val_class_die_ref)
8249 unmark_all_dies (AT_ref (a));
8252 /* Calculate if the entry should appear in the final output file. It may be
8253 from a pruned a type. */
8256 include_pubname_in_output (vec<pubname_entry, va_gc> *table, pubname_entry *p)
8258 /* By limiting gnu pubnames to definitions only, gold can generate a
8259 gdb index without entries for declarations, which don't include
8260 enough information to be useful. */
8261 if (debug_generate_pub_sections == 2 && is_declaration_die (p->die))
8264 if (table == pubname_table)
8266 /* Enumerator names are part of the pubname table, but the
8267 parent DW_TAG_enumeration_type die may have been pruned.
8268 Don't output them if that is the case. */
8269 if (p->die->die_tag == DW_TAG_enumerator &&
8270 (p->die->die_parent == NULL
8271 || !p->die->die_parent->die_perennial_p))
8274 /* Everything else in the pubname table is included. */
8278 /* The pubtypes table shouldn't include types that have been
8280 return (p->die->die_offset != 0
8281 || !flag_eliminate_unused_debug_types);
8284 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8285 generated for the compilation unit. */
8287 static unsigned long
8288 size_of_pubnames (vec<pubname_entry, va_gc> *names)
8293 int space_for_flags = (debug_generate_pub_sections == 2) ? 1 : 0;
8295 size = DWARF_PUBNAMES_HEADER_SIZE;
8296 FOR_EACH_VEC_ELT (*names, i, p)
8297 if (include_pubname_in_output (names, p))
8298 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1 + space_for_flags;
8300 size += DWARF_OFFSET_SIZE;
8304 /* Return the size of the information in the .debug_aranges section. */
8306 static unsigned long
8307 size_of_aranges (void)
8311 size = DWARF_ARANGES_HEADER_SIZE;
8313 /* Count the address/length pair for this compilation unit. */
8314 if (text_section_used)
8315 size += 2 * DWARF2_ADDR_SIZE;
8316 if (cold_text_section_used)
8317 size += 2 * DWARF2_ADDR_SIZE;
8318 if (have_multiple_function_sections)
8323 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
8325 if (DECL_IGNORED_P (fde->decl))
8327 if (!fde->in_std_section)
8328 size += 2 * DWARF2_ADDR_SIZE;
8329 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
8330 size += 2 * DWARF2_ADDR_SIZE;
8334 /* Count the two zero words used to terminated the address range table. */
8335 size += 2 * DWARF2_ADDR_SIZE;
8339 /* Select the encoding of an attribute value. */
8341 static enum dwarf_form
8342 value_format (dw_attr_ref a)
8344 switch (AT_class (a))
8346 case dw_val_class_addr:
8347 /* Only very few attributes allow DW_FORM_addr. */
8352 case DW_AT_entry_pc:
8353 case DW_AT_trampoline:
8354 return (AT_index (a) == NOT_INDEXED
8355 ? DW_FORM_addr : DW_FORM_GNU_addr_index);
8359 switch (DWARF2_ADDR_SIZE)
8362 return DW_FORM_data1;
8364 return DW_FORM_data2;
8366 return DW_FORM_data4;
8368 return DW_FORM_data8;
8372 case dw_val_class_range_list:
8373 case dw_val_class_loc_list:
8374 if (dwarf_version >= 4)
8375 return DW_FORM_sec_offset;
8377 case dw_val_class_vms_delta:
8378 case dw_val_class_offset:
8379 switch (DWARF_OFFSET_SIZE)
8382 return DW_FORM_data4;
8384 return DW_FORM_data8;
8388 case dw_val_class_loc:
8389 if (dwarf_version >= 4)
8390 return DW_FORM_exprloc;
8391 switch (constant_size (size_of_locs (AT_loc (a))))
8394 return DW_FORM_block1;
8396 return DW_FORM_block2;
8398 return DW_FORM_block4;
8402 case dw_val_class_const:
8403 return DW_FORM_sdata;
8404 case dw_val_class_unsigned_const:
8405 switch (constant_size (AT_unsigned (a)))
8408 return DW_FORM_data1;
8410 return DW_FORM_data2;
8412 /* In DWARF3 DW_AT_data_member_location with
8413 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
8414 constant, so we need to use DW_FORM_udata if we need
8415 a large constant. */
8416 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
8417 return DW_FORM_udata;
8418 return DW_FORM_data4;
8420 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
8421 return DW_FORM_udata;
8422 return DW_FORM_data8;
8426 case dw_val_class_const_double:
8427 switch (HOST_BITS_PER_WIDE_INT)
8430 return DW_FORM_data2;
8432 return DW_FORM_data4;
8434 return DW_FORM_data8;
8437 return DW_FORM_block1;
8439 case dw_val_class_wide_int:
8440 switch (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT)
8443 return DW_FORM_data1;
8445 return DW_FORM_data2;
8447 return DW_FORM_data4;
8449 return DW_FORM_data8;
8451 return DW_FORM_block1;
8453 case dw_val_class_vec:
8454 switch (constant_size (a->dw_attr_val.v.val_vec.length
8455 * a->dw_attr_val.v.val_vec.elt_size))
8458 return DW_FORM_block1;
8460 return DW_FORM_block2;
8462 return DW_FORM_block4;
8466 case dw_val_class_flag:
8467 if (dwarf_version >= 4)
8469 /* Currently all add_AT_flag calls pass in 1 as last argument,
8470 so DW_FORM_flag_present can be used. If that ever changes,
8471 we'll need to use DW_FORM_flag and have some optimization
8472 in build_abbrev_table that will change those to
8473 DW_FORM_flag_present if it is set to 1 in all DIEs using
8474 the same abbrev entry. */
8475 gcc_assert (a->dw_attr_val.v.val_flag == 1);
8476 return DW_FORM_flag_present;
8478 return DW_FORM_flag;
8479 case dw_val_class_die_ref:
8480 if (AT_ref_external (a))
8481 return use_debug_types ? DW_FORM_ref_sig8 : DW_FORM_ref_addr;
8484 case dw_val_class_fde_ref:
8485 return DW_FORM_data;
8486 case dw_val_class_lbl_id:
8487 return (AT_index (a) == NOT_INDEXED
8488 ? DW_FORM_addr : DW_FORM_GNU_addr_index);
8489 case dw_val_class_lineptr:
8490 case dw_val_class_macptr:
8491 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
8492 case dw_val_class_str:
8493 return AT_string_form (a);
8494 case dw_val_class_file:
8495 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
8498 return DW_FORM_data1;
8500 return DW_FORM_data2;
8502 return DW_FORM_data4;
8507 case dw_val_class_data8:
8508 return DW_FORM_data8;
8510 case dw_val_class_high_pc:
8511 switch (DWARF2_ADDR_SIZE)
8514 return DW_FORM_data1;
8516 return DW_FORM_data2;
8518 return DW_FORM_data4;
8520 return DW_FORM_data8;
8530 /* Output the encoding of an attribute value. */
8533 output_value_format (dw_attr_ref a)
8535 enum dwarf_form form = value_format (a);
8537 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
8540 /* Given a die and id, produce the appropriate abbreviations. */
8543 output_die_abbrevs (unsigned long abbrev_id, dw_die_ref abbrev)
8548 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
8549 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
8550 dwarf_tag_name (abbrev->die_tag));
8552 if (abbrev->die_child != NULL)
8553 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
8555 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
8557 for (ix = 0; vec_safe_iterate (abbrev->die_attr, ix, &a_attr); ix++)
8559 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
8560 dwarf_attr_name (a_attr->dw_attr));
8561 output_value_format (a_attr);
8564 dw2_asm_output_data (1, 0, NULL);
8565 dw2_asm_output_data (1, 0, NULL);
8569 /* Output the .debug_abbrev section which defines the DIE abbreviation
8573 output_abbrev_section (void)
8575 unsigned long abbrev_id;
8577 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8578 output_die_abbrevs (abbrev_id, abbrev_die_table[abbrev_id]);
8580 /* Terminate the table. */
8581 dw2_asm_output_data (1, 0, NULL);
8584 /* Output a symbol we can use to refer to this DIE from another CU. */
8587 output_die_symbol (dw_die_ref die)
8589 const char *sym = die->die_id.die_symbol;
8591 gcc_assert (!die->comdat_type_p);
8596 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
8597 /* We make these global, not weak; if the target doesn't support
8598 .linkonce, it doesn't support combining the sections, so debugging
8600 targetm.asm_out.globalize_label (asm_out_file, sym);
8602 ASM_OUTPUT_LABEL (asm_out_file, sym);
8605 /* Return a new location list, given the begin and end range, and the
8608 static inline dw_loc_list_ref
8609 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
8610 const char *section)
8612 dw_loc_list_ref retlist = ggc_cleared_alloc<dw_loc_list_node> ();
8614 retlist->begin = begin;
8615 retlist->begin_entry = NULL;
8617 retlist->expr = expr;
8618 retlist->section = section;
8623 /* Generate a new internal symbol for this location list node, if it
8624 hasn't got one yet. */
8627 gen_llsym (dw_loc_list_ref list)
8629 gcc_assert (!list->ll_symbol);
8630 list->ll_symbol = gen_internal_sym ("LLST");
8633 /* Output the location list given to us. */
8636 output_loc_list (dw_loc_list_ref list_head)
8638 dw_loc_list_ref curr = list_head;
8640 if (list_head->emitted)
8642 list_head->emitted = true;
8644 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
8646 /* Walk the location list, and output each range + expression. */
8647 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
8650 /* Don't output an entry that starts and ends at the same address. */
8651 if (strcmp (curr->begin, curr->end) == 0 && !curr->force)
8653 size = size_of_locs (curr->expr);
8654 /* If the expression is too large, drop it on the floor. We could
8655 perhaps put it into DW_TAG_dwarf_procedure and refer to that
8656 in the expression, but >= 64KB expressions for a single value
8657 in a single range are unlikely very useful. */
8660 if (dwarf_split_debug_info)
8662 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry,
8663 "Location list start/length entry (%s)",
8664 list_head->ll_symbol);
8665 dw2_asm_output_data_uleb128 (curr->begin_entry->index,
8666 "Location list range start index (%s)",
8668 /* The length field is 4 bytes. If we ever need to support
8669 an 8-byte length, we can add a new DW_LLE code or fall back
8670 to DW_LLE_GNU_start_end_entry. */
8671 dw2_asm_output_delta (4, curr->end, curr->begin,
8672 "Location list range length (%s)",
8673 list_head->ll_symbol);
8675 else if (!have_multiple_function_sections)
8677 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
8678 "Location list begin address (%s)",
8679 list_head->ll_symbol);
8680 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
8681 "Location list end address (%s)",
8682 list_head->ll_symbol);
8686 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
8687 "Location list begin address (%s)",
8688 list_head->ll_symbol);
8689 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
8690 "Location list end address (%s)",
8691 list_head->ll_symbol);
8694 /* Output the block length for this list of location operations. */
8695 gcc_assert (size <= 0xffff);
8696 dw2_asm_output_data (2, size, "%s", "Location expression size");
8698 output_loc_sequence (curr->expr, -1);
8701 if (dwarf_split_debug_info)
8702 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry,
8703 "Location list terminator (%s)",
8704 list_head->ll_symbol);
8707 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8708 "Location list terminator begin (%s)",
8709 list_head->ll_symbol);
8710 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8711 "Location list terminator end (%s)",
8712 list_head->ll_symbol);
8716 /* Output a range_list offset into the debug_range section. Emit a
8717 relocated reference if val_entry is NULL, otherwise, emit an
8718 indirect reference. */
8721 output_range_list_offset (dw_attr_ref a)
8723 const char *name = dwarf_attr_name (a->dw_attr);
8725 if (a->dw_attr_val.val_entry == RELOCATED_OFFSET)
8727 char *p = strchr (ranges_section_label, '\0');
8728 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX, a->dw_attr_val.v.val_offset);
8729 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8730 debug_ranges_section, "%s", name);
8734 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8735 "%s (offset from %s)", name, ranges_section_label);
8738 /* Output the offset into the debug_loc section. */
8741 output_loc_list_offset (dw_attr_ref a)
8743 char *sym = AT_loc_list (a)->ll_symbol;
8746 if (dwarf_split_debug_info)
8747 dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym, loc_section_label,
8748 "%s", dwarf_attr_name (a->dw_attr));
8750 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8751 "%s", dwarf_attr_name (a->dw_attr));
8754 /* Output an attribute's index or value appropriately. */
8757 output_attr_index_or_value (dw_attr_ref a)
8759 const char *name = dwarf_attr_name (a->dw_attr);
8761 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
8763 dw2_asm_output_data_uleb128 (AT_index (a), "%s", name);
8766 switch (AT_class (a))
8768 case dw_val_class_addr:
8769 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8771 case dw_val_class_high_pc:
8772 case dw_val_class_lbl_id:
8773 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8775 case dw_val_class_loc_list:
8776 output_loc_list_offset (a);
8783 /* Output a type signature. */
8786 output_signature (const char *sig, const char *name)
8790 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8791 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
8794 /* Output the DIE and its attributes. Called recursively to generate
8795 the definitions of each child DIE. */
8798 output_die (dw_die_ref die)
8805 /* If someone in another CU might refer to us, set up a symbol for
8806 them to point to. */
8807 if (! die->comdat_type_p && die->die_id.die_symbol)
8808 output_die_symbol (die);
8810 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
8811 (unsigned long)die->die_offset,
8812 dwarf_tag_name (die->die_tag));
8814 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8816 const char *name = dwarf_attr_name (a->dw_attr);
8818 switch (AT_class (a))
8820 case dw_val_class_addr:
8821 output_attr_index_or_value (a);
8824 case dw_val_class_offset:
8825 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8829 case dw_val_class_range_list:
8830 output_range_list_offset (a);
8833 case dw_val_class_loc:
8834 size = size_of_locs (AT_loc (a));
8836 /* Output the block length for this list of location operations. */
8837 if (dwarf_version >= 4)
8838 dw2_asm_output_data_uleb128 (size, "%s", name);
8840 dw2_asm_output_data (constant_size (size), size, "%s", name);
8842 output_loc_sequence (AT_loc (a), -1);
8845 case dw_val_class_const:
8846 /* ??? It would be slightly more efficient to use a scheme like is
8847 used for unsigned constants below, but gdb 4.x does not sign
8848 extend. Gdb 5.x does sign extend. */
8849 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8852 case dw_val_class_unsigned_const:
8854 int csize = constant_size (AT_unsigned (a));
8855 if (dwarf_version == 3
8856 && a->dw_attr == DW_AT_data_member_location
8858 dw2_asm_output_data_uleb128 (AT_unsigned (a), "%s", name);
8860 dw2_asm_output_data (csize, AT_unsigned (a), "%s", name);
8864 case dw_val_class_const_double:
8866 unsigned HOST_WIDE_INT first, second;
8868 if (HOST_BITS_PER_WIDE_INT >= 64)
8869 dw2_asm_output_data (1,
8870 HOST_BITS_PER_DOUBLE_INT
8871 / HOST_BITS_PER_CHAR,
8874 if (WORDS_BIG_ENDIAN)
8876 first = a->dw_attr_val.v.val_double.high;
8877 second = a->dw_attr_val.v.val_double.low;
8881 first = a->dw_attr_val.v.val_double.low;
8882 second = a->dw_attr_val.v.val_double.high;
8885 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8887 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8892 case dw_val_class_wide_int:
8895 int len = get_full_len (*a->dw_attr_val.v.val_wide);
8896 int l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
8897 if (len * HOST_BITS_PER_WIDE_INT > 64)
8898 dw2_asm_output_data (1, get_full_len (*a->dw_attr_val.v.val_wide) * l,
8901 if (WORDS_BIG_ENDIAN)
8902 for (i = len - 1; i >= 0; --i)
8904 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
8909 for (i = 0; i < len; ++i)
8911 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
8918 case dw_val_class_vec:
8920 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8921 unsigned int len = a->dw_attr_val.v.val_vec.length;
8925 dw2_asm_output_data (constant_size (len * elt_size),
8926 len * elt_size, "%s", name);
8927 if (elt_size > sizeof (HOST_WIDE_INT))
8932 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8935 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8936 "fp or vector constant word %u", i);
8940 case dw_val_class_flag:
8941 if (dwarf_version >= 4)
8943 /* Currently all add_AT_flag calls pass in 1 as last argument,
8944 so DW_FORM_flag_present can be used. If that ever changes,
8945 we'll need to use DW_FORM_flag and have some optimization
8946 in build_abbrev_table that will change those to
8947 DW_FORM_flag_present if it is set to 1 in all DIEs using
8948 the same abbrev entry. */
8949 gcc_assert (AT_flag (a) == 1);
8951 fprintf (asm_out_file, "\t\t\t%s %s\n",
8952 ASM_COMMENT_START, name);
8955 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8958 case dw_val_class_loc_list:
8959 output_attr_index_or_value (a);
8962 case dw_val_class_die_ref:
8963 if (AT_ref_external (a))
8965 if (AT_ref (a)->comdat_type_p)
8967 comdat_type_node_ref type_node =
8968 AT_ref (a)->die_id.die_type_node;
8970 gcc_assert (type_node);
8971 output_signature (type_node->signature, name);
8975 const char *sym = AT_ref (a)->die_id.die_symbol;
8979 /* In DWARF2, DW_FORM_ref_addr is sized by target address
8980 length, whereas in DWARF3 it's always sized as an
8982 if (dwarf_version == 2)
8983 size = DWARF2_ADDR_SIZE;
8985 size = DWARF_OFFSET_SIZE;
8986 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
8992 gcc_assert (AT_ref (a)->die_offset);
8993 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8998 case dw_val_class_fde_ref:
9002 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
9003 a->dw_attr_val.v.val_fde_index * 2);
9004 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
9009 case dw_val_class_vms_delta:
9010 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
9011 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
9012 AT_vms_delta2 (a), AT_vms_delta1 (a),
9015 dw2_asm_output_delta (DWARF_OFFSET_SIZE,
9016 AT_vms_delta2 (a), AT_vms_delta1 (a),
9021 case dw_val_class_lbl_id:
9022 output_attr_index_or_value (a);
9025 case dw_val_class_lineptr:
9026 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9027 debug_line_section, "%s", name);
9030 case dw_val_class_macptr:
9031 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9032 debug_macinfo_section, "%s", name);
9035 case dw_val_class_str:
9036 if (a->dw_attr_val.v.val_str->form == DW_FORM_strp)
9037 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
9038 a->dw_attr_val.v.val_str->label,
9040 "%s: \"%s\"", name, AT_string (a));
9041 else if (a->dw_attr_val.v.val_str->form == DW_FORM_GNU_str_index)
9042 dw2_asm_output_data_uleb128 (AT_index (a),
9043 "%s: \"%s\"", name, AT_string (a));
9045 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
9048 case dw_val_class_file:
9050 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
9052 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
9053 a->dw_attr_val.v.val_file->filename);
9057 case dw_val_class_data8:
9061 for (i = 0; i < 8; i++)
9062 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
9063 i == 0 ? "%s" : NULL, name);
9067 case dw_val_class_high_pc:
9068 dw2_asm_output_delta (DWARF2_ADDR_SIZE, AT_lbl (a),
9069 get_AT_low_pc (die), "DW_AT_high_pc");
9077 FOR_EACH_CHILD (die, c, output_die (c));
9079 /* Add null byte to terminate sibling list. */
9080 if (die->die_child != NULL)
9081 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
9082 (unsigned long) die->die_offset);
9085 /* Output the compilation unit that appears at the beginning of the
9086 .debug_info section, and precedes the DIE descriptions. */
9089 output_compilation_unit_header (void)
9091 /* We don't support actual DWARFv5 units yet, we just use some
9092 DWARFv5 draft DIE tags in DWARFv4 format. */
9093 int ver = dwarf_version < 5 ? dwarf_version : 4;
9095 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9096 dw2_asm_output_data (4, 0xffffffff,
9097 "Initial length escape value indicating 64-bit DWARF extension");
9098 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9099 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
9100 "Length of Compilation Unit Info");
9101 dw2_asm_output_data (2, ver, "DWARF version number");
9102 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
9103 debug_abbrev_section,
9104 "Offset Into Abbrev. Section");
9105 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9108 /* Output the compilation unit DIE and its children. */
9111 output_comp_unit (dw_die_ref die, int output_if_empty)
9113 const char *secname, *oldsym;
9116 /* Unless we are outputting main CU, we may throw away empty ones. */
9117 if (!output_if_empty && die->die_child == NULL)
9120 /* Even if there are no children of this DIE, we must output the information
9121 about the compilation unit. Otherwise, on an empty translation unit, we
9122 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
9123 will then complain when examining the file. First mark all the DIEs in
9124 this CU so we know which get local refs. */
9127 external_ref_hash_type *extern_map = optimize_external_refs (die);
9129 build_abbrev_table (die, extern_map);
9133 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9134 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
9135 calc_die_sizes (die);
9137 oldsym = die->die_id.die_symbol;
9140 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
9142 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
9144 die->die_id.die_symbol = NULL;
9145 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9149 switch_to_section (debug_info_section);
9150 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
9151 info_section_emitted = true;
9154 /* Output debugging information. */
9155 output_compilation_unit_header ();
9158 /* Leave the marks on the main CU, so we can check them in
9163 die->die_id.die_symbol = oldsym;
9167 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
9168 and .debug_pubtypes. This is configured per-target, but can be
9169 overridden by the -gpubnames or -gno-pubnames options. */
9172 want_pubnames (void)
9174 if (debug_info_level <= DINFO_LEVEL_TERSE)
9176 if (debug_generate_pub_sections != -1)
9177 return debug_generate_pub_sections;
9178 return targetm.want_debug_pub_sections;
9181 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
9184 add_AT_pubnames (dw_die_ref die)
9186 if (want_pubnames ())
9187 add_AT_flag (die, DW_AT_GNU_pubnames, 1);
9190 /* Add a string attribute value to a skeleton DIE. */
9193 add_skeleton_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind,
9197 struct indirect_string_node *node;
9199 if (! skeleton_debug_str_hash)
9200 skeleton_debug_str_hash
9201 = hash_table<indirect_string_hasher>::create_ggc (10);
9203 node = find_AT_string_in_table (str, skeleton_debug_str_hash);
9204 find_string_form (node);
9205 if (node->form == DW_FORM_GNU_str_index)
9206 node->form = DW_FORM_strp;
9208 attr.dw_attr = attr_kind;
9209 attr.dw_attr_val.val_class = dw_val_class_str;
9210 attr.dw_attr_val.val_entry = NULL;
9211 attr.dw_attr_val.v.val_str = node;
9212 add_dwarf_attr (die, &attr);
9215 /* Helper function to generate top-level dies for skeleton debug_info and
9219 add_top_level_skeleton_die_attrs (dw_die_ref die)
9221 const char *dwo_file_name = concat (aux_base_name, ".dwo", NULL);
9222 const char *comp_dir = comp_dir_string ();
9224 add_skeleton_AT_string (die, DW_AT_GNU_dwo_name, dwo_file_name);
9225 if (comp_dir != NULL)
9226 add_skeleton_AT_string (die, DW_AT_comp_dir, comp_dir);
9227 add_AT_pubnames (die);
9228 add_AT_lineptr (die, DW_AT_GNU_addr_base, debug_addr_section_label);
9231 /* Output skeleton debug sections that point to the dwo file. */
9234 output_skeleton_debug_sections (dw_die_ref comp_unit)
9236 /* We don't support actual DWARFv5 units yet, we just use some
9237 DWARFv5 draft DIE tags in DWARFv4 format. */
9238 int ver = dwarf_version < 5 ? dwarf_version : 4;
9240 /* These attributes will be found in the full debug_info section. */
9241 remove_AT (comp_unit, DW_AT_producer);
9242 remove_AT (comp_unit, DW_AT_language);
9244 switch_to_section (debug_skeleton_info_section);
9245 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_info_section_label);
9247 /* Produce the skeleton compilation-unit header. This one differs enough from
9248 a normal CU header that it's better not to call output_compilation_unit
9250 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9251 dw2_asm_output_data (4, 0xffffffff,
9252 "Initial length escape value indicating 64-bit DWARF extension");
9254 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9255 DWARF_COMPILE_UNIT_HEADER_SIZE
9256 - DWARF_INITIAL_LENGTH_SIZE
9257 + size_of_die (comp_unit),
9258 "Length of Compilation Unit Info");
9259 dw2_asm_output_data (2, ver, "DWARF version number");
9260 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_abbrev_section_label,
9261 debug_abbrev_section,
9262 "Offset Into Abbrev. Section");
9263 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9265 comp_unit->die_abbrev = SKELETON_COMP_DIE_ABBREV;
9266 output_die (comp_unit);
9268 /* Build the skeleton debug_abbrev section. */
9269 switch_to_section (debug_skeleton_abbrev_section);
9270 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_abbrev_section_label);
9272 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV, comp_unit);
9274 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
9277 /* Output a comdat type unit DIE and its children. */
9280 output_comdat_type_unit (comdat_type_node *node)
9282 const char *secname;
9285 #if defined (OBJECT_FORMAT_ELF)
9289 /* First mark all the DIEs in this CU so we know which get local refs. */
9290 mark_dies (node->root_die);
9292 external_ref_hash_type *extern_map = optimize_external_refs (node->root_die);
9294 build_abbrev_table (node->root_die, extern_map);
9299 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9300 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
9301 calc_die_sizes (node->root_die);
9303 #if defined (OBJECT_FORMAT_ELF)
9304 if (!dwarf_split_debug_info)
9305 secname = ".debug_types";
9307 secname = ".debug_types.dwo";
9309 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
9310 sprintf (tmp, "wt.");
9311 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
9312 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
9313 comdat_key = get_identifier (tmp);
9314 targetm.asm_out.named_section (secname,
9315 SECTION_DEBUG | SECTION_LINKONCE,
9318 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
9319 sprintf (tmp, ".gnu.linkonce.wt.");
9320 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
9321 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
9323 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9326 /* Output debugging information. */
9327 output_compilation_unit_header ();
9328 output_signature (node->signature, "Type Signature");
9329 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
9330 "Offset to Type DIE");
9331 output_die (node->root_die);
9333 unmark_dies (node->root_die);
9336 /* Return the DWARF2/3 pubname associated with a decl. */
9339 dwarf2_name (tree decl, int scope)
9341 if (DECL_NAMELESS (decl))
9343 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
9346 /* Add a new entry to .debug_pubnames if appropriate. */
9349 add_pubname_string (const char *str, dw_die_ref die)
9354 e.name = xstrdup (str);
9355 vec_safe_push (pubname_table, e);
9359 add_pubname (tree decl, dw_die_ref die)
9361 if (!want_pubnames ())
9364 /* Don't add items to the table when we expect that the consumer will have
9365 just read the enclosing die. For example, if the consumer is looking at a
9366 class_member, it will either be inside the class already, or will have just
9367 looked up the class to find the member. Either way, searching the class is
9368 faster than searching the index. */
9369 if ((TREE_PUBLIC (decl) && !class_scope_p (die->die_parent))
9370 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
9372 const char *name = dwarf2_name (decl, 1);
9375 add_pubname_string (name, die);
9379 /* Add an enumerator to the pubnames section. */
9382 add_enumerator_pubname (const char *scope_name, dw_die_ref die)
9386 gcc_assert (scope_name);
9387 e.name = concat (scope_name, get_AT_string (die, DW_AT_name), NULL);
9389 vec_safe_push (pubname_table, e);
9392 /* Add a new entry to .debug_pubtypes if appropriate. */
9395 add_pubtype (tree decl, dw_die_ref die)
9399 if (!want_pubnames ())
9402 if ((TREE_PUBLIC (decl)
9403 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
9404 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
9407 const char *scope_name = "";
9408 const char *sep = is_cxx () ? "::" : ".";
9411 scope = TYPE_P (decl) ? TYPE_CONTEXT (decl) : NULL;
9412 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
9414 scope_name = lang_hooks.dwarf_name (scope, 1);
9415 if (scope_name != NULL && scope_name[0] != '\0')
9416 scope_name = concat (scope_name, sep, NULL);
9422 name = type_tag (decl);
9424 name = lang_hooks.dwarf_name (decl, 1);
9426 /* If we don't have a name for the type, there's no point in adding
9428 if (name != NULL && name[0] != '\0')
9431 e.name = concat (scope_name, name, NULL);
9432 vec_safe_push (pubtype_table, e);
9435 /* Although it might be more consistent to add the pubinfo for the
9436 enumerators as their dies are created, they should only be added if the
9437 enum type meets the criteria above. So rather than re-check the parent
9438 enum type whenever an enumerator die is created, just output them all
9439 here. This isn't protected by the name conditional because anonymous
9440 enums don't have names. */
9441 if (die->die_tag == DW_TAG_enumeration_type)
9445 FOR_EACH_CHILD (die, c, add_enumerator_pubname (scope_name, c));
9450 /* Output a single entry in the pubnames table. */
9453 output_pubname (dw_offset die_offset, pubname_entry *entry)
9455 dw_die_ref die = entry->die;
9456 int is_static = get_AT_flag (die, DW_AT_external) ? 0 : 1;
9458 dw2_asm_output_data (DWARF_OFFSET_SIZE, die_offset, "DIE offset");
9460 if (debug_generate_pub_sections == 2)
9462 /* This logic follows gdb's method for determining the value of the flag
9464 uint32_t flags = GDB_INDEX_SYMBOL_KIND_NONE;
9465 switch (die->die_tag)
9467 case DW_TAG_typedef:
9468 case DW_TAG_base_type:
9469 case DW_TAG_subrange_type:
9470 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9471 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9473 case DW_TAG_enumerator:
9474 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9475 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9476 if (!is_cxx () && !is_java ())
9477 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9479 case DW_TAG_subprogram:
9480 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9481 GDB_INDEX_SYMBOL_KIND_FUNCTION);
9483 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9485 case DW_TAG_constant:
9486 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9487 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9488 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9490 case DW_TAG_variable:
9491 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
9492 GDB_INDEX_SYMBOL_KIND_VARIABLE);
9493 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
9495 case DW_TAG_namespace:
9496 case DW_TAG_imported_declaration:
9497 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9499 case DW_TAG_class_type:
9500 case DW_TAG_interface_type:
9501 case DW_TAG_structure_type:
9502 case DW_TAG_union_type:
9503 case DW_TAG_enumeration_type:
9504 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
9505 if (!is_cxx () && !is_java ())
9506 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
9509 /* An unusual tag. Leave the flag-byte empty. */
9512 dw2_asm_output_data (1, flags >> GDB_INDEX_CU_BITSIZE,
9516 dw2_asm_output_nstring (entry->name, -1, "external name");
9520 /* Output the public names table used to speed up access to externally
9521 visible names; or the public types table used to find type definitions. */
9524 output_pubnames (vec<pubname_entry, va_gc> *names)
9527 unsigned long pubnames_length = size_of_pubnames (names);
9530 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9531 dw2_asm_output_data (4, 0xffffffff,
9532 "Initial length escape value indicating 64-bit DWARF extension");
9533 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, "Pub Info Length");
9535 /* Version number for pubnames/pubtypes is independent of dwarf version. */
9536 dw2_asm_output_data (2, 2, "DWARF Version");
9538 if (dwarf_split_debug_info)
9539 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
9540 debug_skeleton_info_section,
9541 "Offset of Compilation Unit Info");
9543 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9545 "Offset of Compilation Unit Info");
9546 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
9547 "Compilation Unit Length");
9549 FOR_EACH_VEC_ELT (*names, i, pub)
9551 if (include_pubname_in_output (names, pub))
9553 dw_offset die_offset = pub->die->die_offset;
9555 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9556 if (names == pubname_table && pub->die->die_tag != DW_TAG_enumerator)
9557 gcc_assert (pub->die->die_mark);
9559 /* If we're putting types in their own .debug_types sections,
9560 the .debug_pubtypes table will still point to the compile
9561 unit (not the type unit), so we want to use the offset of
9562 the skeleton DIE (if there is one). */
9563 if (pub->die->comdat_type_p && names == pubtype_table)
9565 comdat_type_node_ref type_node = pub->die->die_id.die_type_node;
9567 if (type_node != NULL)
9568 die_offset = (type_node->skeleton_die != NULL
9569 ? type_node->skeleton_die->die_offset
9570 : comp_unit_die ()->die_offset);
9573 output_pubname (die_offset, pub);
9577 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
9580 /* Output public names and types tables if necessary. */
9583 output_pubtables (void)
9585 if (!want_pubnames () || !info_section_emitted)
9588 switch_to_section (debug_pubnames_section);
9589 output_pubnames (pubname_table);
9590 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
9591 It shouldn't hurt to emit it always, since pure DWARF2 consumers
9592 simply won't look for the section. */
9593 switch_to_section (debug_pubtypes_section);
9594 output_pubnames (pubtype_table);
9598 /* Output the information that goes into the .debug_aranges table.
9599 Namely, define the beginning and ending address range of the
9600 text section generated for this compilation unit. */
9603 output_aranges (unsigned long aranges_length)
9607 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9608 dw2_asm_output_data (4, 0xffffffff,
9609 "Initial length escape value indicating 64-bit DWARF extension");
9610 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
9611 "Length of Address Ranges Info");
9612 /* Version number for aranges is still 2, even up to DWARF5. */
9613 dw2_asm_output_data (2, 2, "DWARF Version");
9614 if (dwarf_split_debug_info)
9615 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
9616 debug_skeleton_info_section,
9617 "Offset of Compilation Unit Info");
9619 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9621 "Offset of Compilation Unit Info");
9622 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
9623 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9625 /* We need to align to twice the pointer size here. */
9626 if (DWARF_ARANGES_PAD_SIZE)
9628 /* Pad using a 2 byte words so that padding is correct for any
9630 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9631 2 * DWARF2_ADDR_SIZE);
9632 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
9633 dw2_asm_output_data (2, 0, NULL);
9636 /* It is necessary not to output these entries if the sections were
9637 not used; if the sections were not used, the length will be 0 and
9638 the address may end up as 0 if the section is discarded by ld
9639 --gc-sections, leaving an invalid (0, 0) entry that can be
9640 confused with the terminator. */
9641 if (text_section_used)
9643 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
9644 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
9645 text_section_label, "Length");
9647 if (cold_text_section_used)
9649 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
9651 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
9652 cold_text_section_label, "Length");
9655 if (have_multiple_function_sections)
9660 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
9662 if (DECL_IGNORED_P (fde->decl))
9664 if (!fde->in_std_section)
9666 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
9668 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end,
9669 fde->dw_fde_begin, "Length");
9671 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
9673 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_second_begin,
9675 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_second_end,
9676 fde->dw_fde_second_begin, "Length");
9681 /* Output the terminator words. */
9682 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9683 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9686 /* Add a new entry to .debug_ranges. Return the offset at which it
9690 add_ranges_num (int num)
9692 unsigned int in_use = ranges_table_in_use;
9694 if (in_use == ranges_table_allocated)
9696 ranges_table_allocated += RANGES_TABLE_INCREMENT;
9697 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
9698 ranges_table_allocated);
9699 memset (ranges_table + ranges_table_in_use, 0,
9700 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
9703 ranges_table[in_use].num = num;
9704 ranges_table_in_use = in_use + 1;
9706 return in_use * 2 * DWARF2_ADDR_SIZE;
9709 /* Add a new entry to .debug_ranges corresponding to a block, or a
9710 range terminator if BLOCK is NULL. */
9713 add_ranges (const_tree block)
9715 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
9718 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
9719 When using dwarf_split_debug_info, address attributes in dies destined
9720 for the final executable should be direct references--setting the
9721 parameter force_direct ensures this behavior. */
9724 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
9725 bool *added, bool force_direct)
9727 unsigned int in_use = ranges_by_label_in_use;
9728 unsigned int offset;
9730 if (in_use == ranges_by_label_allocated)
9732 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
9733 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
9735 ranges_by_label_allocated);
9736 memset (ranges_by_label + ranges_by_label_in_use, 0,
9737 RANGES_TABLE_INCREMENT
9738 * sizeof (struct dw_ranges_by_label_struct));
9741 ranges_by_label[in_use].begin = begin;
9742 ranges_by_label[in_use].end = end;
9743 ranges_by_label_in_use = in_use + 1;
9745 offset = add_ranges_num (-(int)in_use - 1);
9748 add_AT_range_list (die, DW_AT_ranges, offset, force_direct);
9754 output_ranges (void)
9757 static const char *const start_fmt = "Offset %#x";
9758 const char *fmt = start_fmt;
9760 for (i = 0; i < ranges_table_in_use; i++)
9762 int block_num = ranges_table[i].num;
9766 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
9767 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
9769 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
9770 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
9772 /* If all code is in the text section, then the compilation
9773 unit base address defaults to DW_AT_low_pc, which is the
9774 base of the text section. */
9775 if (!have_multiple_function_sections)
9777 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
9779 fmt, i * 2 * DWARF2_ADDR_SIZE);
9780 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
9781 text_section_label, NULL);
9784 /* Otherwise, the compilation unit base address is zero,
9785 which allows us to use absolute addresses, and not worry
9786 about whether the target supports cross-section
9790 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
9791 fmt, i * 2 * DWARF2_ADDR_SIZE);
9792 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
9798 /* Negative block_num stands for an index into ranges_by_label. */
9799 else if (block_num < 0)
9801 int lab_idx = - block_num - 1;
9803 if (!have_multiple_function_sections)
9807 /* If we ever use add_ranges_by_labels () for a single
9808 function section, all we have to do is to take out
9810 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9811 ranges_by_label[lab_idx].begin,
9813 fmt, i * 2 * DWARF2_ADDR_SIZE);
9814 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9815 ranges_by_label[lab_idx].end,
9816 text_section_label, NULL);
9821 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9822 ranges_by_label[lab_idx].begin,
9823 fmt, i * 2 * DWARF2_ADDR_SIZE);
9824 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9825 ranges_by_label[lab_idx].end,
9831 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9832 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9838 /* Data structure containing information about input files. */
9841 const char *path; /* Complete file name. */
9842 const char *fname; /* File name part. */
9843 int length; /* Length of entire string. */
9844 struct dwarf_file_data * file_idx; /* Index in input file table. */
9845 int dir_idx; /* Index in directory table. */
9848 /* Data structure containing information about directories with source
9852 const char *path; /* Path including directory name. */
9853 int length; /* Path length. */
9854 int prefix; /* Index of directory entry which is a prefix. */
9855 int count; /* Number of files in this directory. */
9856 int dir_idx; /* Index of directory used as base. */
9859 /* Callback function for file_info comparison. We sort by looking at
9860 the directories in the path. */
9863 file_info_cmp (const void *p1, const void *p2)
9865 const struct file_info *const s1 = (const struct file_info *) p1;
9866 const struct file_info *const s2 = (const struct file_info *) p2;
9867 const unsigned char *cp1;
9868 const unsigned char *cp2;
9870 /* Take care of file names without directories. We need to make sure that
9871 we return consistent values to qsort since some will get confused if
9872 we return the same value when identical operands are passed in opposite
9873 orders. So if neither has a directory, return 0 and otherwise return
9874 1 or -1 depending on which one has the directory. */
9875 if ((s1->path == s1->fname || s2->path == s2->fname))
9876 return (s2->path == s2->fname) - (s1->path == s1->fname);
9878 cp1 = (const unsigned char *) s1->path;
9879 cp2 = (const unsigned char *) s2->path;
9885 /* Reached the end of the first path? If so, handle like above. */
9886 if ((cp1 == (const unsigned char *) s1->fname)
9887 || (cp2 == (const unsigned char *) s2->fname))
9888 return ((cp2 == (const unsigned char *) s2->fname)
9889 - (cp1 == (const unsigned char *) s1->fname));
9891 /* Character of current path component the same? */
9892 else if (*cp1 != *cp2)
9897 struct file_name_acquire_data
9899 struct file_info *files;
9904 /* Traversal function for the hash table. */
9907 file_name_acquire (dwarf_file_data **slot, file_name_acquire_data *fnad)
9909 struct dwarf_file_data *d = *slot;
9910 struct file_info *fi;
9913 gcc_assert (fnad->max_files >= d->emitted_number);
9915 if (! d->emitted_number)
9918 gcc_assert (fnad->max_files != fnad->used_files);
9920 fi = fnad->files + fnad->used_files++;
9922 /* Skip all leading "./". */
9924 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
9927 /* Create a new array entry. */
9929 fi->length = strlen (f);
9932 /* Search for the file name part. */
9933 f = strrchr (f, DIR_SEPARATOR);
9934 #if defined (DIR_SEPARATOR_2)
9936 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
9940 if (f == NULL || f < g)
9946 fi->fname = f == NULL ? fi->path : f + 1;
9950 /* Output the directory table and the file name table. We try to minimize
9951 the total amount of memory needed. A heuristic is used to avoid large
9952 slowdowns with many input files. */
9955 output_file_names (void)
9957 struct file_name_acquire_data fnad;
9959 struct file_info *files;
9960 struct dir_info *dirs;
9968 if (!last_emitted_file)
9970 dw2_asm_output_data (1, 0, "End directory table");
9971 dw2_asm_output_data (1, 0, "End file name table");
9975 numfiles = last_emitted_file->emitted_number;
9977 /* Allocate the various arrays we need. */
9978 files = XALLOCAVEC (struct file_info, numfiles);
9979 dirs = XALLOCAVEC (struct dir_info, numfiles);
9982 fnad.used_files = 0;
9983 fnad.max_files = numfiles;
9984 file_table->traverse<file_name_acquire_data *, file_name_acquire> (&fnad);
9985 gcc_assert (fnad.used_files == fnad.max_files);
9987 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
9989 /* Find all the different directories used. */
9990 dirs[0].path = files[0].path;
9991 dirs[0].length = files[0].fname - files[0].path;
9992 dirs[0].prefix = -1;
9994 dirs[0].dir_idx = 0;
9995 files[0].dir_idx = 0;
9998 for (i = 1; i < numfiles; i++)
9999 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
10000 && memcmp (dirs[ndirs - 1].path, files[i].path,
10001 dirs[ndirs - 1].length) == 0)
10003 /* Same directory as last entry. */
10004 files[i].dir_idx = ndirs - 1;
10005 ++dirs[ndirs - 1].count;
10011 /* This is a new directory. */
10012 dirs[ndirs].path = files[i].path;
10013 dirs[ndirs].length = files[i].fname - files[i].path;
10014 dirs[ndirs].count = 1;
10015 dirs[ndirs].dir_idx = ndirs;
10016 files[i].dir_idx = ndirs;
10018 /* Search for a prefix. */
10019 dirs[ndirs].prefix = -1;
10020 for (j = 0; j < ndirs; j++)
10021 if (dirs[j].length < dirs[ndirs].length
10022 && dirs[j].length > 1
10023 && (dirs[ndirs].prefix == -1
10024 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
10025 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
10026 dirs[ndirs].prefix = j;
10031 /* Now to the actual work. We have to find a subset of the directories which
10032 allow expressing the file name using references to the directory table
10033 with the least amount of characters. We do not do an exhaustive search
10034 where we would have to check out every combination of every single
10035 possible prefix. Instead we use a heuristic which provides nearly optimal
10036 results in most cases and never is much off. */
10037 saved = XALLOCAVEC (int, ndirs);
10038 savehere = XALLOCAVEC (int, ndirs);
10040 memset (saved, '\0', ndirs * sizeof (saved[0]));
10041 for (i = 0; i < ndirs; i++)
10046 /* We can always save some space for the current directory. But this
10047 does not mean it will be enough to justify adding the directory. */
10048 savehere[i] = dirs[i].length;
10049 total = (savehere[i] - saved[i]) * dirs[i].count;
10051 for (j = i + 1; j < ndirs; j++)
10054 if (saved[j] < dirs[i].length)
10056 /* Determine whether the dirs[i] path is a prefix of the
10060 k = dirs[j].prefix;
10061 while (k != -1 && k != (int) i)
10062 k = dirs[k].prefix;
10066 /* Yes it is. We can possibly save some memory by
10067 writing the filenames in dirs[j] relative to
10069 savehere[j] = dirs[i].length;
10070 total += (savehere[j] - saved[j]) * dirs[j].count;
10075 /* Check whether we can save enough to justify adding the dirs[i]
10077 if (total > dirs[i].length + 1)
10079 /* It's worthwhile adding. */
10080 for (j = i; j < ndirs; j++)
10081 if (savehere[j] > 0)
10083 /* Remember how much we saved for this directory so far. */
10084 saved[j] = savehere[j];
10086 /* Remember the prefix directory. */
10087 dirs[j].dir_idx = i;
10092 /* Emit the directory name table. */
10093 idx_offset = dirs[0].length > 0 ? 1 : 0;
10094 for (i = 1 - idx_offset; i < ndirs; i++)
10095 dw2_asm_output_nstring (dirs[i].path,
10097 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
10098 "Directory Entry: %#x", i + idx_offset);
10100 dw2_asm_output_data (1, 0, "End directory table");
10102 /* We have to emit them in the order of emitted_number since that's
10103 used in the debug info generation. To do this efficiently we
10104 generate a back-mapping of the indices first. */
10105 backmap = XALLOCAVEC (int, numfiles);
10106 for (i = 0; i < numfiles; i++)
10107 backmap[files[i].file_idx->emitted_number - 1] = i;
10109 /* Now write all the file names. */
10110 for (i = 0; i < numfiles; i++)
10112 int file_idx = backmap[i];
10113 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
10115 #ifdef VMS_DEBUGGING_INFO
10116 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
10118 /* Setting these fields can lead to debugger miscomparisons,
10119 but VMS Debug requires them to be set correctly. */
10124 int maxfilelen = strlen (files[file_idx].path)
10125 + dirs[dir_idx].length
10126 + MAX_VMS_VERSION_LEN + 1;
10127 char *filebuf = XALLOCAVEC (char, maxfilelen);
10129 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
10130 snprintf (filebuf, maxfilelen, "%s;%d",
10131 files[file_idx].path + dirs[dir_idx].length, ver);
10133 dw2_asm_output_nstring
10134 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1);
10136 /* Include directory index. */
10137 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
10139 /* Modification time. */
10140 dw2_asm_output_data_uleb128
10141 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
10145 /* File length in bytes. */
10146 dw2_asm_output_data_uleb128
10147 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
10151 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
10152 "File Entry: %#x", (unsigned) i + 1);
10154 /* Include directory index. */
10155 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
10157 /* Modification time. */
10158 dw2_asm_output_data_uleb128 (0, NULL);
10160 /* File length in bytes. */
10161 dw2_asm_output_data_uleb128 (0, NULL);
10162 #endif /* VMS_DEBUGGING_INFO */
10165 dw2_asm_output_data (1, 0, "End file name table");
10169 /* Output one line number table into the .debug_line section. */
10172 output_one_line_info_table (dw_line_info_table *table)
10174 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
10175 unsigned int current_line = 1;
10176 bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
10177 dw_line_info_entry *ent;
10180 FOR_EACH_VEC_SAFE_ELT (table->entries, i, ent)
10182 switch (ent->opcode)
10184 case LI_set_address:
10185 /* ??? Unfortunately, we have little choice here currently, and
10186 must always use the most general form. GCC does not know the
10187 address delta itself, so we can't use DW_LNS_advance_pc. Many
10188 ports do have length attributes which will give an upper bound
10189 on the address range. We could perhaps use length attributes
10190 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
10191 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
10193 /* This can handle any delta. This takes
10194 4+DWARF2_ADDR_SIZE bytes. */
10195 dw2_asm_output_data (1, 0, "set address %s", line_label);
10196 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10197 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10198 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10202 if (ent->val == current_line)
10204 /* We still need to start a new row, so output a copy insn. */
10205 dw2_asm_output_data (1, DW_LNS_copy,
10206 "copy line %u", current_line);
10210 int line_offset = ent->val - current_line;
10211 int line_delta = line_offset - DWARF_LINE_BASE;
10213 current_line = ent->val;
10214 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
10216 /* This can handle deltas from -10 to 234, using the current
10217 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
10218 This takes 1 byte. */
10219 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
10220 "line %u", current_line);
10224 /* This can handle any delta. This takes at least 4 bytes,
10225 depending on the value being encoded. */
10226 dw2_asm_output_data (1, DW_LNS_advance_line,
10227 "advance to line %u", current_line);
10228 dw2_asm_output_data_sleb128 (line_offset, NULL);
10229 dw2_asm_output_data (1, DW_LNS_copy, NULL);
10235 dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val);
10236 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
10239 case LI_set_column:
10240 dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val);
10241 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
10244 case LI_negate_stmt:
10245 current_is_stmt = !current_is_stmt;
10246 dw2_asm_output_data (1, DW_LNS_negate_stmt,
10247 "is_stmt %d", current_is_stmt);
10250 case LI_set_prologue_end:
10251 dw2_asm_output_data (1, DW_LNS_set_prologue_end,
10252 "set prologue end");
10255 case LI_set_epilogue_begin:
10256 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin,
10257 "set epilogue begin");
10260 case LI_set_discriminator:
10261 dw2_asm_output_data (1, 0, "discriminator %u", ent->val);
10262 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL);
10263 dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL);
10264 dw2_asm_output_data_uleb128 (ent->val, NULL);
10269 /* Emit debug info for the address of the end of the table. */
10270 dw2_asm_output_data (1, 0, "set address %s", table->end_label);
10271 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10272 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10273 dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL);
10275 dw2_asm_output_data (1, 0, "end sequence");
10276 dw2_asm_output_data_uleb128 (1, NULL);
10277 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
10280 /* Output the source line number correspondence information. This
10281 information goes into the .debug_line section. */
10284 output_line_info (bool prologue_only)
10286 char l1[20], l2[20], p1[20], p2[20];
10287 /* We don't support DWARFv5 line tables yet. */
10288 int ver = dwarf_version < 5 ? dwarf_version : 4;
10289 bool saw_one = false;
10292 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
10293 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
10294 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
10295 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
10297 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
10298 dw2_asm_output_data (4, 0xffffffff,
10299 "Initial length escape value indicating 64-bit DWARF extension");
10300 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
10301 "Length of Source Line Info");
10302 ASM_OUTPUT_LABEL (asm_out_file, l1);
10304 dw2_asm_output_data (2, ver, "DWARF Version");
10305 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
10306 ASM_OUTPUT_LABEL (asm_out_file, p1);
10308 /* Define the architecture-dependent minimum instruction length (in bytes).
10309 In this implementation of DWARF, this field is used for information
10310 purposes only. Since GCC generates assembly language, we have no
10311 a priori knowledge of how many instruction bytes are generated for each
10312 source line, and therefore can use only the DW_LNE_set_address and
10313 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
10314 this as '1', which is "correct enough" for all architectures,
10315 and don't let the target override. */
10316 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
10319 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
10320 "Maximum Operations Per Instruction");
10321 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
10322 "Default is_stmt_start flag");
10323 dw2_asm_output_data (1, DWARF_LINE_BASE,
10324 "Line Base Value (Special Opcodes)");
10325 dw2_asm_output_data (1, DWARF_LINE_RANGE,
10326 "Line Range Value (Special Opcodes)");
10327 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
10328 "Special Opcode Base");
10330 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
10335 case DW_LNS_advance_pc:
10336 case DW_LNS_advance_line:
10337 case DW_LNS_set_file:
10338 case DW_LNS_set_column:
10339 case DW_LNS_fixed_advance_pc:
10340 case DW_LNS_set_isa:
10348 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
10352 /* Write out the information about the files we use. */
10353 output_file_names ();
10354 ASM_OUTPUT_LABEL (asm_out_file, p2);
10357 /* Output the marker for the end of the line number info. */
10358 ASM_OUTPUT_LABEL (asm_out_file, l2);
10362 if (separate_line_info)
10364 dw_line_info_table *table;
10367 FOR_EACH_VEC_ELT (*separate_line_info, i, table)
10370 output_one_line_info_table (table);
10374 if (cold_text_section_line_info && cold_text_section_line_info->in_use)
10376 output_one_line_info_table (cold_text_section_line_info);
10380 /* ??? Some Darwin linkers crash on a .debug_line section with no
10381 sequences. Further, merely a DW_LNE_end_sequence entry is not
10382 sufficient -- the address column must also be initialized.
10383 Make sure to output at least one set_address/end_sequence pair,
10384 choosing .text since that section is always present. */
10385 if (text_section_line_info->in_use || !saw_one)
10386 output_one_line_info_table (text_section_line_info);
10388 /* Output the marker for the end of the line number info. */
10389 ASM_OUTPUT_LABEL (asm_out_file, l2);
10392 /* Given a pointer to a tree node for some base type, return a pointer to
10393 a DIE that describes the given type.
10395 This routine must only be called for GCC type nodes that correspond to
10396 Dwarf base (fundamental) types. */
10399 base_type_die (tree type)
10401 dw_die_ref base_type_result;
10402 enum dwarf_type encoding;
10404 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
10407 /* If this is a subtype that should not be emitted as a subrange type,
10408 use the base type. See subrange_type_for_debug_p. */
10409 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
10410 type = TREE_TYPE (type);
10412 switch (TREE_CODE (type))
10415 if ((dwarf_version >= 4 || !dwarf_strict)
10416 && TYPE_NAME (type)
10417 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
10418 && DECL_IS_BUILTIN (TYPE_NAME (type))
10419 && DECL_NAME (TYPE_NAME (type)))
10421 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
10422 if (strcmp (name, "char16_t") == 0
10423 || strcmp (name, "char32_t") == 0)
10425 encoding = DW_ATE_UTF;
10429 if (TYPE_STRING_FLAG (type))
10431 if (TYPE_UNSIGNED (type))
10432 encoding = DW_ATE_unsigned_char;
10434 encoding = DW_ATE_signed_char;
10436 else if (TYPE_UNSIGNED (type))
10437 encoding = DW_ATE_unsigned;
10439 encoding = DW_ATE_signed;
10443 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
10445 if (dwarf_version >= 3 || !dwarf_strict)
10446 encoding = DW_ATE_decimal_float;
10448 encoding = DW_ATE_lo_user;
10451 encoding = DW_ATE_float;
10454 case FIXED_POINT_TYPE:
10455 if (!(dwarf_version >= 3 || !dwarf_strict))
10456 encoding = DW_ATE_lo_user;
10457 else if (TYPE_UNSIGNED (type))
10458 encoding = DW_ATE_unsigned_fixed;
10460 encoding = DW_ATE_signed_fixed;
10463 /* Dwarf2 doesn't know anything about complex ints, so use
10464 a user defined type for it. */
10466 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
10467 encoding = DW_ATE_complex_float;
10469 encoding = DW_ATE_lo_user;
10473 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10474 encoding = DW_ATE_boolean;
10478 /* No other TREE_CODEs are Dwarf fundamental types. */
10479 gcc_unreachable ();
10482 base_type_result = new_die (DW_TAG_base_type, comp_unit_die (), type);
10484 add_AT_unsigned (base_type_result, DW_AT_byte_size,
10485 int_size_in_bytes (type));
10486 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
10487 add_pubtype (type, base_type_result);
10489 return base_type_result;
10492 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
10493 named 'auto' in its type: return true for it, false otherwise. */
10496 is_cxx_auto (tree type)
10500 tree name = TYPE_IDENTIFIER (type);
10501 if (name == get_identifier ("auto")
10502 || name == get_identifier ("decltype(auto)"))
10508 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10509 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10512 is_base_type (tree type)
10514 switch (TREE_CODE (type))
10520 case FIXED_POINT_TYPE:
10523 case POINTER_BOUNDS_TYPE:
10529 case QUAL_UNION_TYPE:
10530 case ENUMERAL_TYPE:
10531 case FUNCTION_TYPE:
10534 case REFERENCE_TYPE:
10542 if (is_cxx_auto (type))
10544 gcc_unreachable ();
10550 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10551 node, return the size in bits for the type if it is a constant, or else
10552 return the alignment for the type if the type's size is not constant, or
10553 else return BITS_PER_WORD if the type actually turns out to be an
10554 ERROR_MARK node. */
10556 static inline unsigned HOST_WIDE_INT
10557 simple_type_size_in_bits (const_tree type)
10559 if (TREE_CODE (type) == ERROR_MARK)
10560 return BITS_PER_WORD;
10561 else if (TYPE_SIZE (type) == NULL_TREE)
10563 else if (tree_fits_uhwi_p (TYPE_SIZE (type)))
10564 return tree_to_uhwi (TYPE_SIZE (type));
10566 return TYPE_ALIGN (type);
10569 /* Similarly, but return an offset_int instead of UHWI. */
10571 static inline offset_int
10572 offset_int_type_size_in_bits (const_tree type)
10574 if (TREE_CODE (type) == ERROR_MARK)
10575 return BITS_PER_WORD;
10576 else if (TYPE_SIZE (type) == NULL_TREE)
10578 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
10579 return wi::to_offset (TYPE_SIZE (type));
10581 return TYPE_ALIGN (type);
10584 /* Given a pointer to a tree node for a subrange type, return a pointer
10585 to a DIE that describes the given type. */
10588 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
10590 dw_die_ref subrange_die;
10591 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
10593 if (context_die == NULL)
10594 context_die = comp_unit_die ();
10596 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
10598 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
10600 /* The size of the subrange type and its base type do not match,
10601 so we need to generate a size attribute for the subrange type. */
10602 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
10606 add_bound_info (subrange_die, DW_AT_lower_bound, low, NULL);
10608 add_bound_info (subrange_die, DW_AT_upper_bound, high, NULL);
10610 return subrange_die;
10613 /* Returns the (const and/or volatile) cv_qualifiers associated with
10614 the decl node. This will normally be augmented with the
10615 cv_qualifiers of the underlying type in add_type_attribute. */
10618 decl_quals (const_tree decl)
10620 return ((TREE_READONLY (decl)
10621 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED)
10622 | (TREE_THIS_VOLATILE (decl)
10623 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED));
10626 /* Determine the TYPE whose qualifiers match the largest strict subset
10627 of the given TYPE_QUALS, and return its qualifiers. Ignore all
10628 qualifiers outside QUAL_MASK. */
10631 get_nearest_type_subqualifiers (tree type, int type_quals, int qual_mask)
10634 int best_rank = 0, best_qual = 0, max_rank;
10636 type_quals &= qual_mask;
10637 max_rank = popcount_hwi (type_quals) - 1;
10639 for (t = TYPE_MAIN_VARIANT (type); t && best_rank < max_rank;
10640 t = TYPE_NEXT_VARIANT (t))
10642 int q = TYPE_QUALS (t) & qual_mask;
10644 if ((q & type_quals) == q && q != type_quals
10645 && check_base_type (t, type))
10647 int rank = popcount_hwi (q);
10649 if (rank > best_rank)
10660 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10661 entry that chains various modifiers in front of the given type. */
10664 modified_type_die (tree type, int cv_quals, dw_die_ref context_die)
10666 enum tree_code code = TREE_CODE (type);
10667 dw_die_ref mod_type_die;
10668 dw_die_ref sub_die = NULL;
10669 tree item_type = NULL;
10670 tree qualified_type;
10671 tree name, low, high;
10672 dw_die_ref mod_scope;
10673 /* Only these cv-qualifiers are currently handled. */
10674 const int cv_qual_mask = (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE
10675 | TYPE_QUAL_RESTRICT | TYPE_QUAL_ATOMIC);
10677 if (code == ERROR_MARK)
10680 cv_quals &= cv_qual_mask;
10682 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
10683 tag modifier (and not an attribute) old consumers won't be able
10685 if (dwarf_version < 3)
10686 cv_quals &= ~TYPE_QUAL_RESTRICT;
10688 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
10689 if (dwarf_version < 5)
10690 cv_quals &= ~TYPE_QUAL_ATOMIC;
10692 /* See if we already have the appropriately qualified variant of
10694 qualified_type = get_qualified_type (type, cv_quals);
10696 if (qualified_type == sizetype
10697 && TYPE_NAME (qualified_type)
10698 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
10700 tree t = TREE_TYPE (TYPE_NAME (qualified_type));
10702 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE
10703 && TYPE_PRECISION (t)
10704 == TYPE_PRECISION (qualified_type)
10705 && TYPE_UNSIGNED (t)
10706 == TYPE_UNSIGNED (qualified_type));
10707 qualified_type = t;
10710 /* If we do, then we can just use its DIE, if it exists. */
10711 if (qualified_type)
10713 mod_type_die = lookup_type_die (qualified_type);
10715 return mod_type_die;
10718 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
10720 /* Handle C typedef types. */
10721 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)
10722 && !DECL_ARTIFICIAL (name))
10724 tree dtype = TREE_TYPE (name);
10726 if (qualified_type == dtype)
10728 /* For a named type, use the typedef. */
10729 gen_type_die (qualified_type, context_die);
10730 return lookup_type_die (qualified_type);
10734 int dquals = TYPE_QUALS_NO_ADDR_SPACE (dtype);
10735 dquals &= cv_qual_mask;
10736 if ((dquals & ~cv_quals) != TYPE_UNQUALIFIED
10737 || (cv_quals == dquals && DECL_ORIGINAL_TYPE (name) != type))
10738 /* cv-unqualified version of named type. Just use
10739 the unnamed type to which it refers. */
10740 return modified_type_die (DECL_ORIGINAL_TYPE (name),
10741 cv_quals, context_die);
10742 /* Else cv-qualified version of named type; fall through. */
10746 mod_scope = scope_die_for (type, context_die);
10750 struct qual_info { int q; enum dwarf_tag t; };
10751 static const struct qual_info qual_info[] =
10753 { TYPE_QUAL_ATOMIC, DW_TAG_atomic_type },
10754 { TYPE_QUAL_RESTRICT, DW_TAG_restrict_type },
10755 { TYPE_QUAL_VOLATILE, DW_TAG_volatile_type },
10756 { TYPE_QUAL_CONST, DW_TAG_const_type },
10761 /* Determine a lesser qualified type that most closely matches
10762 this one. Then generate DW_TAG_* entries for the remaining
10764 sub_quals = get_nearest_type_subqualifiers (type, cv_quals,
10766 mod_type_die = modified_type_die (type, sub_quals, context_die);
10768 for (i = 0; i < sizeof (qual_info) / sizeof (qual_info[0]); i++)
10769 if (qual_info[i].q & cv_quals & ~sub_quals)
10771 dw_die_ref d = new_die (qual_info[i].t, mod_scope, type);
10773 add_AT_die_ref (d, DW_AT_type, mod_type_die);
10777 else if (code == POINTER_TYPE)
10779 mod_type_die = new_die (DW_TAG_pointer_type, mod_scope, type);
10780 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10781 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10782 item_type = TREE_TYPE (type);
10783 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
10784 add_AT_unsigned (mod_type_die, DW_AT_address_class,
10785 TYPE_ADDR_SPACE (item_type));
10787 else if (code == REFERENCE_TYPE)
10789 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
10790 mod_type_die = new_die (DW_TAG_rvalue_reference_type, mod_scope,
10793 mod_type_die = new_die (DW_TAG_reference_type, mod_scope, type);
10794 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10795 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10796 item_type = TREE_TYPE (type);
10797 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
10798 add_AT_unsigned (mod_type_die, DW_AT_address_class,
10799 TYPE_ADDR_SPACE (item_type));
10801 else if (code == INTEGER_TYPE
10802 && TREE_TYPE (type) != NULL_TREE
10803 && subrange_type_for_debug_p (type, &low, &high))
10805 mod_type_die = subrange_type_die (type, low, high, context_die);
10806 item_type = TREE_TYPE (type);
10808 else if (is_base_type (type))
10809 mod_type_die = base_type_die (type);
10812 gen_type_die (type, context_die);
10814 /* We have to get the type_main_variant here (and pass that to the
10815 `lookup_type_die' routine) because the ..._TYPE node we have
10816 might simply be a *copy* of some original type node (where the
10817 copy was created to help us keep track of typedef names) and
10818 that copy might have a different TYPE_UID from the original
10820 if (TREE_CODE (type) != VECTOR_TYPE)
10821 return lookup_type_die (type_main_variant (type));
10823 /* Vectors have the debugging information in the type,
10824 not the main variant. */
10825 return lookup_type_die (type);
10828 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10829 don't output a DW_TAG_typedef, since there isn't one in the
10830 user's program; just attach a DW_AT_name to the type.
10831 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
10832 if the base type already has the same name. */
10834 && ((TREE_CODE (name) != TYPE_DECL
10835 && (qualified_type == TYPE_MAIN_VARIANT (type)
10836 || (cv_quals == TYPE_UNQUALIFIED)))
10837 || (TREE_CODE (name) == TYPE_DECL
10838 && TREE_TYPE (name) == qualified_type
10839 && DECL_NAME (name))))
10841 if (TREE_CODE (name) == TYPE_DECL)
10842 /* Could just call add_name_and_src_coords_attributes here,
10843 but since this is a builtin type it doesn't have any
10844 useful source coordinates anyway. */
10845 name = DECL_NAME (name);
10846 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
10848 /* This probably indicates a bug. */
10849 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
10851 name = TYPE_IDENTIFIER (type);
10852 add_name_attribute (mod_type_die,
10853 name ? IDENTIFIER_POINTER (name) : "__unknown__");
10856 if (qualified_type)
10857 equate_type_number_to_die (qualified_type, mod_type_die);
10860 /* We must do this after the equate_type_number_to_die call, in case
10861 this is a recursive type. This ensures that the modified_type_die
10862 recursion will terminate even if the type is recursive. Recursive
10863 types are possible in Ada. */
10864 sub_die = modified_type_die (item_type,
10865 TYPE_QUALS_NO_ADDR_SPACE (item_type),
10868 if (sub_die != NULL)
10869 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
10871 add_gnat_descriptive_type_attribute (mod_type_die, type, context_die);
10872 if (TYPE_ARTIFICIAL (type))
10873 add_AT_flag (mod_type_die, DW_AT_artificial, 1);
10875 return mod_type_die;
10878 /* Generate DIEs for the generic parameters of T.
10879 T must be either a generic type or a generic function.
10880 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10883 gen_generic_params_dies (tree t)
10887 dw_die_ref die = NULL;
10890 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
10894 die = lookup_type_die (t);
10895 else if (DECL_P (t))
10896 die = lookup_decl_die (t);
10900 parms = lang_hooks.get_innermost_generic_parms (t);
10902 /* T has no generic parameter. It means T is neither a generic type
10903 or function. End of story. */
10906 parms_num = TREE_VEC_LENGTH (parms);
10907 args = lang_hooks.get_innermost_generic_args (t);
10908 if (TREE_CHAIN (args) && TREE_CODE (TREE_CHAIN (args)) == INTEGER_CST)
10909 non_default = int_cst_value (TREE_CHAIN (args));
10911 non_default = TREE_VEC_LENGTH (args);
10912 for (i = 0; i < parms_num; i++)
10914 tree parm, arg, arg_pack_elems;
10915 dw_die_ref parm_die;
10917 parm = TREE_VEC_ELT (parms, i);
10918 arg = TREE_VEC_ELT (args, i);
10919 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
10920 gcc_assert (parm && TREE_VALUE (parm) && arg);
10922 if (parm && TREE_VALUE (parm) && arg)
10924 /* If PARM represents a template parameter pack,
10925 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
10926 by DW_TAG_template_*_parameter DIEs for the argument
10927 pack elements of ARG. Note that ARG would then be
10928 an argument pack. */
10929 if (arg_pack_elems)
10930 parm_die = template_parameter_pack_die (TREE_VALUE (parm),
10934 parm_die = generic_parameter_die (TREE_VALUE (parm), arg,
10935 true /* emit name */, die);
10936 if (i >= non_default)
10937 add_AT_flag (parm_die, DW_AT_default_value, 1);
10942 /* Create and return a DIE for PARM which should be
10943 the representation of a generic type parameter.
10944 For instance, in the C++ front end, PARM would be a template parameter.
10945 ARG is the argument to PARM.
10946 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
10948 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10949 as a child node. */
10952 generic_parameter_die (tree parm, tree arg,
10954 dw_die_ref parent_die)
10956 dw_die_ref tmpl_die = NULL;
10957 const char *name = NULL;
10959 if (!parm || !DECL_NAME (parm) || !arg)
10962 /* We support non-type generic parameters and arguments,
10963 type generic parameters and arguments, as well as
10964 generic generic parameters (a.k.a. template template parameters in C++)
10966 if (TREE_CODE (parm) == PARM_DECL)
10967 /* PARM is a nontype generic parameter */
10968 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
10969 else if (TREE_CODE (parm) == TYPE_DECL)
10970 /* PARM is a type generic parameter. */
10971 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
10972 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10973 /* PARM is a generic generic parameter.
10974 Its DIE is a GNU extension. It shall have a
10975 DW_AT_name attribute to represent the name of the template template
10976 parameter, and a DW_AT_GNU_template_name attribute to represent the
10977 name of the template template argument. */
10978 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
10981 gcc_unreachable ();
10987 /* If PARM is a generic parameter pack, it means we are
10988 emitting debug info for a template argument pack element.
10989 In other terms, ARG is a template argument pack element.
10990 In that case, we don't emit any DW_AT_name attribute for
10994 name = IDENTIFIER_POINTER (DECL_NAME (parm));
10996 add_AT_string (tmpl_die, DW_AT_name, name);
10999 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
11001 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
11002 TMPL_DIE should have a child DW_AT_type attribute that is set
11003 to the type of the argument to PARM, which is ARG.
11004 If PARM is a type generic parameter, TMPL_DIE should have a
11005 child DW_AT_type that is set to ARG. */
11006 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
11007 add_type_attribute (tmpl_die, tmpl_type,
11008 (TREE_THIS_VOLATILE (tmpl_type)
11009 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED),
11014 /* So TMPL_DIE is a DIE representing a
11015 a generic generic template parameter, a.k.a template template
11016 parameter in C++ and arg is a template. */
11018 /* The DW_AT_GNU_template_name attribute of the DIE must be set
11019 to the name of the argument. */
11020 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
11022 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
11025 if (TREE_CODE (parm) == PARM_DECL)
11026 /* So PARM is a non-type generic parameter.
11027 DWARF3 5.6.8 says we must set a DW_AT_const_value child
11028 attribute of TMPL_DIE which value represents the value
11030 We must be careful here:
11031 The value of ARG might reference some function decls.
11032 We might currently be emitting debug info for a generic
11033 type and types are emitted before function decls, we don't
11034 know if the function decls referenced by ARG will actually be
11035 emitted after cgraph computations.
11036 So must defer the generation of the DW_AT_const_value to
11037 after cgraph is ready. */
11038 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
11044 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
11045 PARM_PACK must be a template parameter pack. The returned DIE
11046 will be child DIE of PARENT_DIE. */
11049 template_parameter_pack_die (tree parm_pack,
11050 tree parm_pack_args,
11051 dw_die_ref parent_die)
11056 gcc_assert (parent_die && parm_pack);
11058 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
11059 add_name_and_src_coords_attributes (die, parm_pack);
11060 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
11061 generic_parameter_die (parm_pack,
11062 TREE_VEC_ELT (parm_pack_args, j),
11063 false /* Don't emit DW_AT_name */,
11068 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
11069 an enumerated type. */
11072 type_is_enum (const_tree type)
11074 return TREE_CODE (type) == ENUMERAL_TYPE;
11077 /* Return the DBX register number described by a given RTL node. */
11079 static unsigned int
11080 dbx_reg_number (const_rtx rtl)
11082 unsigned regno = REGNO (rtl);
11084 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
11086 #ifdef LEAF_REG_REMAP
11087 if (crtl->uses_only_leaf_regs)
11089 int leaf_reg = LEAF_REG_REMAP (regno);
11090 if (leaf_reg != -1)
11091 regno = (unsigned) leaf_reg;
11095 regno = DBX_REGISTER_NUMBER (regno);
11096 gcc_assert (regno != INVALID_REGNUM);
11100 /* Optionally add a DW_OP_piece term to a location description expression.
11101 DW_OP_piece is only added if the location description expression already
11102 doesn't end with DW_OP_piece. */
11105 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
11107 dw_loc_descr_ref loc;
11109 if (*list_head != NULL)
11111 /* Find the end of the chain. */
11112 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
11115 if (loc->dw_loc_opc != DW_OP_piece)
11116 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
11120 /* Return a location descriptor that designates a machine register or
11121 zero if there is none. */
11123 static dw_loc_descr_ref
11124 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
11128 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
11131 /* We only use "frame base" when we're sure we're talking about the
11132 post-prologue local stack frame. We do this by *not* running
11133 register elimination until this point, and recognizing the special
11134 argument pointer and soft frame pointer rtx's.
11135 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
11136 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
11137 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
11139 dw_loc_descr_ref result = NULL;
11141 if (dwarf_version >= 4 || !dwarf_strict)
11143 result = mem_loc_descriptor (rtl, GET_MODE (rtl), VOIDmode,
11146 add_loc_descr (&result,
11147 new_loc_descr (DW_OP_stack_value, 0, 0));
11152 regs = targetm.dwarf_register_span (rtl);
11154 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
11155 return multiple_reg_loc_descriptor (rtl, regs, initialized);
11158 unsigned int dbx_regnum = dbx_reg_number (rtl);
11159 if (dbx_regnum == IGNORED_DWARF_REGNUM)
11161 return one_reg_loc_descriptor (dbx_regnum, initialized);
11165 /* Return a location descriptor that designates a machine register for
11166 a given hard register number. */
11168 static dw_loc_descr_ref
11169 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
11171 dw_loc_descr_ref reg_loc_descr;
11175 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
11177 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
11179 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11180 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11182 return reg_loc_descr;
11185 /* Given an RTL of a register, return a location descriptor that
11186 designates a value that spans more than one register. */
11188 static dw_loc_descr_ref
11189 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
11190 enum var_init_status initialized)
11193 dw_loc_descr_ref loc_result = NULL;
11195 /* Simple, contiguous registers. */
11196 if (regs == NULL_RTX)
11198 unsigned reg = REGNO (rtl);
11201 #ifdef LEAF_REG_REMAP
11202 if (crtl->uses_only_leaf_regs)
11204 int leaf_reg = LEAF_REG_REMAP (reg);
11205 if (leaf_reg != -1)
11206 reg = (unsigned) leaf_reg;
11210 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
11211 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
11213 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
11218 dw_loc_descr_ref t;
11220 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
11221 VAR_INIT_STATUS_INITIALIZED);
11222 add_loc_descr (&loc_result, t);
11223 add_loc_descr_op_piece (&loc_result, size);
11229 /* Now onto stupid register sets in non contiguous locations. */
11231 gcc_assert (GET_CODE (regs) == PARALLEL);
11233 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
11236 for (i = 0; i < XVECLEN (regs, 0); ++i)
11238 dw_loc_descr_ref t;
11240 t = one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs, 0, i)),
11241 VAR_INIT_STATUS_INITIALIZED);
11242 add_loc_descr (&loc_result, t);
11243 add_loc_descr_op_piece (&loc_result, size);
11246 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
11247 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11251 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT);
11253 /* Return a location descriptor that designates a constant i,
11254 as a compound operation from constant (i >> shift), constant shift
11257 static dw_loc_descr_ref
11258 int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
11260 dw_loc_descr_ref ret = int_loc_descriptor (i >> shift);
11261 add_loc_descr (&ret, int_loc_descriptor (shift));
11262 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
11266 /* Return a location descriptor that designates a constant. */
11268 static dw_loc_descr_ref
11269 int_loc_descriptor (HOST_WIDE_INT i)
11271 enum dwarf_location_atom op;
11273 /* Pick the smallest representation of a constant, rather than just
11274 defaulting to the LEB encoding. */
11277 int clz = clz_hwi (i);
11278 int ctz = ctz_hwi (i);
11280 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
11281 else if (i <= 0xff)
11282 op = DW_OP_const1u;
11283 else if (i <= 0xffff)
11284 op = DW_OP_const2u;
11285 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
11286 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
11287 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
11288 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
11289 while DW_OP_const4u is 5 bytes. */
11290 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 5);
11291 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11292 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
11293 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
11294 while DW_OP_const4u is 5 bytes. */
11295 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
11296 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
11297 op = DW_OP_const4u;
11298 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11299 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
11300 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes,
11301 while DW_OP_constu of constant >= 0x100000000 takes at least
11303 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
11304 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
11305 && clz + 16 + (size_of_uleb128 (i) > 5 ? 255 : 31)
11306 >= HOST_BITS_PER_WIDE_INT)
11307 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
11308 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes,
11309 while DW_OP_constu takes in this case at least 6 bytes. */
11310 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 16);
11311 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
11312 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
11313 && size_of_uleb128 (i) > 6)
11314 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
11315 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 32);
11322 op = DW_OP_const1s;
11323 else if (i >= -0x8000)
11324 op = DW_OP_const2s;
11325 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
11327 if (size_of_int_loc_descriptor (i) < 5)
11329 dw_loc_descr_ref ret = int_loc_descriptor (-i);
11330 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11333 op = DW_OP_const4s;
11337 if (size_of_int_loc_descriptor (i)
11338 < (unsigned long) 1 + size_of_sleb128 (i))
11340 dw_loc_descr_ref ret = int_loc_descriptor (-i);
11341 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
11348 return new_loc_descr (op, i, 0);
11351 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
11352 without actually allocating it. */
11354 static unsigned long
11355 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
11357 return size_of_int_loc_descriptor (i >> shift)
11358 + size_of_int_loc_descriptor (shift)
11362 /* Return size_of_locs (int_loc_descriptor (i)) without
11363 actually allocating it. */
11365 static unsigned long
11366 size_of_int_loc_descriptor (HOST_WIDE_INT i)
11375 else if (i <= 0xff)
11377 else if (i <= 0xffff)
11381 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
11382 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
11383 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11385 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11386 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
11387 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11389 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
11391 s = size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
11392 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
11393 && clz + 8 + 255 >= 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 - 16
11397 && clz + 16 + (s > 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT)
11398 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11400 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
11401 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
11403 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
11412 else if (i >= -0x8000)
11414 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
11416 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
11418 s = size_of_int_loc_descriptor (-i) + 1;
11426 unsigned long r = 1 + size_of_sleb128 (i);
11427 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
11429 s = size_of_int_loc_descriptor (-i) + 1;
11438 /* Return loc description representing "address" of integer value.
11439 This can appear only as toplevel expression. */
11441 static dw_loc_descr_ref
11442 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
11445 dw_loc_descr_ref loc_result = NULL;
11447 if (!(dwarf_version >= 4 || !dwarf_strict))
11450 litsize = size_of_int_loc_descriptor (i);
11451 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11452 is more compact. For DW_OP_stack_value we need:
11453 litsize + 1 (DW_OP_stack_value)
11454 and for DW_OP_implicit_value:
11455 1 (DW_OP_implicit_value) + 1 (length) + size. */
11456 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
11458 loc_result = int_loc_descriptor (i);
11459 add_loc_descr (&loc_result,
11460 new_loc_descr (DW_OP_stack_value, 0, 0));
11464 loc_result = new_loc_descr (DW_OP_implicit_value,
11466 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
11467 loc_result->dw_loc_oprnd2.v.val_int = i;
11471 /* Return a location descriptor that designates a base+offset location. */
11473 static dw_loc_descr_ref
11474 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
11475 enum var_init_status initialized)
11477 unsigned int regno;
11478 dw_loc_descr_ref result;
11479 dw_fde_ref fde = cfun->fde;
11481 /* We only use "frame base" when we're sure we're talking about the
11482 post-prologue local stack frame. We do this by *not* running
11483 register elimination until this point, and recognizing the special
11484 argument pointer and soft frame pointer rtx's. */
11485 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
11487 rtx elim = (ira_use_lra_p
11488 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
11489 : eliminate_regs (reg, VOIDmode, NULL_RTX));
11493 if (GET_CODE (elim) == PLUS)
11495 offset += INTVAL (XEXP (elim, 1));
11496 elim = XEXP (elim, 0);
11498 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
11499 && (elim == hard_frame_pointer_rtx
11500 || elim == stack_pointer_rtx))
11501 || elim == (frame_pointer_needed
11502 ? hard_frame_pointer_rtx
11503 : stack_pointer_rtx));
11505 /* If drap register is used to align stack, use frame
11506 pointer + offset to access stack variables. If stack
11507 is aligned without drap, use stack pointer + offset to
11508 access stack variables. */
11509 if (crtl->stack_realign_tried
11510 && reg == frame_pointer_rtx)
11513 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
11514 ? HARD_FRAME_POINTER_REGNUM
11516 return new_reg_loc_descr (base_reg, offset);
11519 gcc_assert (frame_pointer_fb_offset_valid);
11520 offset += frame_pointer_fb_offset;
11521 return new_loc_descr (DW_OP_fbreg, offset, 0);
11525 regno = REGNO (reg);
11526 #ifdef LEAF_REG_REMAP
11527 if (crtl->uses_only_leaf_regs)
11529 int leaf_reg = LEAF_REG_REMAP (regno);
11530 if (leaf_reg != -1)
11531 regno = (unsigned) leaf_reg;
11534 regno = DWARF_FRAME_REGNUM (regno);
11536 if (!optimize && fde
11537 && (fde->drap_reg == regno || fde->vdrap_reg == regno))
11539 /* Use cfa+offset to represent the location of arguments passed
11540 on the stack when drap is used to align stack.
11541 Only do this when not optimizing, for optimized code var-tracking
11542 is supposed to track where the arguments live and the register
11543 used as vdrap or drap in some spot might be used for something
11544 else in other part of the routine. */
11545 return new_loc_descr (DW_OP_fbreg, offset, 0);
11549 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
11552 result = new_loc_descr (DW_OP_bregx, regno, offset);
11554 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11555 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11560 /* Return true if this RTL expression describes a base+offset calculation. */
11563 is_based_loc (const_rtx rtl)
11565 return (GET_CODE (rtl) == PLUS
11566 && ((REG_P (XEXP (rtl, 0))
11567 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
11568 && CONST_INT_P (XEXP (rtl, 1)))));
11571 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11574 static dw_loc_descr_ref
11575 tls_mem_loc_descriptor (rtx mem)
11578 dw_loc_descr_ref loc_result;
11580 if (MEM_EXPR (mem) == NULL_TREE || !MEM_OFFSET_KNOWN_P (mem))
11583 base = get_base_address (MEM_EXPR (mem));
11585 || TREE_CODE (base) != VAR_DECL
11586 || !DECL_THREAD_LOCAL_P (base))
11589 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1, NULL);
11590 if (loc_result == NULL)
11593 if (MEM_OFFSET (mem))
11594 loc_descr_plus_const (&loc_result, MEM_OFFSET (mem));
11599 /* Output debug info about reason why we failed to expand expression as dwarf
11603 expansion_failed (tree expr, rtx rtl, char const *reason)
11605 if (dump_file && (dump_flags & TDF_DETAILS))
11607 fprintf (dump_file, "Failed to expand as dwarf: ");
11609 print_generic_expr (dump_file, expr, dump_flags);
11612 fprintf (dump_file, "\n");
11613 print_rtl (dump_file, rtl);
11615 fprintf (dump_file, "\nReason: %s\n", reason);
11619 /* Helper function for const_ok_for_output. */
11622 const_ok_for_output_1 (rtx rtl)
11624 if (GET_CODE (rtl) == UNSPEC)
11626 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
11627 we can't express it in the debug info. */
11628 #ifdef ENABLE_CHECKING
11629 /* Don't complain about TLS UNSPECs, those are just too hard to
11630 delegitimize. Note this could be a non-decl SYMBOL_REF such as
11631 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
11632 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
11633 if (XVECLEN (rtl, 0) == 0
11634 || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
11635 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE)
11636 inform (current_function_decl
11637 ? DECL_SOURCE_LOCATION (current_function_decl)
11638 : UNKNOWN_LOCATION,
11639 #if NUM_UNSPEC_VALUES > 0
11640 "non-delegitimized UNSPEC %s (%d) found in variable location",
11641 ((XINT (rtl, 1) >= 0 && XINT (rtl, 1) < NUM_UNSPEC_VALUES)
11642 ? unspec_strings[XINT (rtl, 1)] : "unknown"),
11645 "non-delegitimized UNSPEC %d found in variable location",
11649 expansion_failed (NULL_TREE, rtl,
11650 "UNSPEC hasn't been delegitimized.\n");
11654 if (targetm.const_not_ok_for_debug_p (rtl))
11656 expansion_failed (NULL_TREE, rtl,
11657 "Expression rejected for debug by the backend.\n");
11661 /* FIXME: Refer to PR60655. It is possible for simplification
11662 of rtl expressions in var tracking to produce such expressions.
11663 We should really identify / validate expressions
11664 enclosed in CONST that can be handled by assemblers on various
11665 targets and only handle legitimate cases here. */
11666 if (GET_CODE (rtl) != SYMBOL_REF)
11668 if (GET_CODE (rtl) == NOT)
11673 if (CONSTANT_POOL_ADDRESS_P (rtl))
11676 get_pool_constant_mark (rtl, &marked);
11677 /* If all references to this pool constant were optimized away,
11678 it was not output and thus we can't represent it. */
11681 expansion_failed (NULL_TREE, rtl,
11682 "Constant was removed from constant pool.\n");
11687 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11690 /* Avoid references to external symbols in debug info, on several targets
11691 the linker might even refuse to link when linking a shared library,
11692 and in many other cases the relocations for .debug_info/.debug_loc are
11693 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
11694 to be defined within the same shared library or executable are fine. */
11695 if (SYMBOL_REF_EXTERNAL_P (rtl))
11697 tree decl = SYMBOL_REF_DECL (rtl);
11699 if (decl == NULL || !targetm.binds_local_p (decl))
11701 expansion_failed (NULL_TREE, rtl,
11702 "Symbol not defined in current TU.\n");
11710 /* Return true if constant RTL can be emitted in DW_OP_addr or
11711 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
11712 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
11715 const_ok_for_output (rtx rtl)
11717 if (GET_CODE (rtl) == SYMBOL_REF)
11718 return const_ok_for_output_1 (rtl);
11720 if (GET_CODE (rtl) == CONST)
11722 subrtx_var_iterator::array_type array;
11723 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 0), ALL)
11724 if (!const_ok_for_output_1 (*iter))
11732 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
11733 if possible, NULL otherwise. */
11736 base_type_for_mode (machine_mode mode, bool unsignedp)
11738 dw_die_ref type_die;
11739 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
11743 switch (TREE_CODE (type))
11751 type_die = lookup_type_die (type);
11753 type_die = modified_type_die (type, TYPE_UNQUALIFIED, comp_unit_die ());
11754 if (type_die == NULL || type_die->die_tag != DW_TAG_base_type)
11759 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
11760 type matching MODE, or, if MODE is narrower than or as wide as
11761 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
11764 static dw_loc_descr_ref
11765 convert_descriptor_to_mode (machine_mode mode, dw_loc_descr_ref op)
11767 machine_mode outer_mode = mode;
11768 dw_die_ref type_die;
11769 dw_loc_descr_ref cvt;
11771 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
11773 add_loc_descr (&op, new_loc_descr (DW_OP_GNU_convert, 0, 0));
11776 type_die = base_type_for_mode (outer_mode, 1);
11777 if (type_die == NULL)
11779 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11780 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11781 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11782 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11783 add_loc_descr (&op, cvt);
11787 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
11789 static dw_loc_descr_ref
11790 compare_loc_descriptor (enum dwarf_location_atom op, dw_loc_descr_ref op0,
11791 dw_loc_descr_ref op1)
11793 dw_loc_descr_ref ret = op0;
11794 add_loc_descr (&ret, op1);
11795 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
11796 if (STORE_FLAG_VALUE != 1)
11798 add_loc_descr (&ret, int_loc_descriptor (STORE_FLAG_VALUE));
11799 add_loc_descr (&ret, new_loc_descr (DW_OP_mul, 0, 0));
11804 /* Return location descriptor for signed comparison OP RTL. */
11806 static dw_loc_descr_ref
11807 scompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
11808 machine_mode mem_mode)
11810 machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
11811 dw_loc_descr_ref op0, op1;
11814 if (op_mode == VOIDmode)
11815 op_mode = GET_MODE (XEXP (rtl, 1));
11816 if (op_mode == VOIDmode)
11820 && (GET_MODE_CLASS (op_mode) != MODE_INT
11821 || GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE))
11824 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
11825 VAR_INIT_STATUS_INITIALIZED);
11826 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
11827 VAR_INIT_STATUS_INITIALIZED);
11829 if (op0 == NULL || op1 == NULL)
11832 if (GET_MODE_CLASS (op_mode) != MODE_INT
11833 || GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
11834 return compare_loc_descriptor (op, op0, op1);
11836 if (GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
11838 dw_die_ref type_die = base_type_for_mode (op_mode, 0);
11839 dw_loc_descr_ref cvt;
11841 if (type_die == NULL)
11843 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11844 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11845 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11846 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11847 add_loc_descr (&op0, cvt);
11848 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
11849 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
11850 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
11851 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
11852 add_loc_descr (&op1, cvt);
11853 return compare_loc_descriptor (op, op0, op1);
11856 shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode)) * BITS_PER_UNIT;
11857 /* For eq/ne, if the operands are known to be zero-extended,
11858 there is no need to do the fancy shifting up. */
11859 if (op == DW_OP_eq || op == DW_OP_ne)
11861 dw_loc_descr_ref last0, last1;
11862 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
11864 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
11866 /* deref_size zero extends, and for constants we can check
11867 whether they are zero extended or not. */
11868 if (((last0->dw_loc_opc == DW_OP_deref_size
11869 && last0->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
11870 || (CONST_INT_P (XEXP (rtl, 0))
11871 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
11872 == (INTVAL (XEXP (rtl, 0)) & GET_MODE_MASK (op_mode))))
11873 && ((last1->dw_loc_opc == DW_OP_deref_size
11874 && last1->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
11875 || (CONST_INT_P (XEXP (rtl, 1))
11876 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 1))
11877 == (INTVAL (XEXP (rtl, 1)) & GET_MODE_MASK (op_mode)))))
11878 return compare_loc_descriptor (op, op0, op1);
11880 /* EQ/NE comparison against constant in narrower type than
11881 DWARF2_ADDR_SIZE can be performed either as
11882 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
11885 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
11886 DW_OP_{eq,ne}. Pick whatever is shorter. */
11887 if (CONST_INT_P (XEXP (rtl, 1))
11888 && GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
11889 && (size_of_int_loc_descriptor (shift) + 1
11890 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift)
11891 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode)) + 1
11892 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1))
11893 & GET_MODE_MASK (op_mode))))
11895 add_loc_descr (&op0, int_loc_descriptor (GET_MODE_MASK (op_mode)));
11896 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11897 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1))
11898 & GET_MODE_MASK (op_mode));
11899 return compare_loc_descriptor (op, op0, op1);
11902 add_loc_descr (&op0, int_loc_descriptor (shift));
11903 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11904 if (CONST_INT_P (XEXP (rtl, 1)))
11905 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
11908 add_loc_descr (&op1, int_loc_descriptor (shift));
11909 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11911 return compare_loc_descriptor (op, op0, op1);
11914 /* Return location descriptor for unsigned comparison OP RTL. */
11916 static dw_loc_descr_ref
11917 ucompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
11918 machine_mode mem_mode)
11920 machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
11921 dw_loc_descr_ref op0, op1;
11923 if (op_mode == VOIDmode)
11924 op_mode = GET_MODE (XEXP (rtl, 1));
11925 if (op_mode == VOIDmode)
11927 if (GET_MODE_CLASS (op_mode) != MODE_INT)
11930 if (dwarf_strict && GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
11933 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
11934 VAR_INIT_STATUS_INITIALIZED);
11935 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
11936 VAR_INIT_STATUS_INITIALIZED);
11938 if (op0 == NULL || op1 == NULL)
11941 if (GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
11943 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
11944 dw_loc_descr_ref last0, last1;
11945 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
11947 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
11949 if (CONST_INT_P (XEXP (rtl, 0)))
11950 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
11951 /* deref_size zero extends, so no need to mask it again. */
11952 else if (last0->dw_loc_opc != DW_OP_deref_size
11953 || last0->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
11955 add_loc_descr (&op0, int_loc_descriptor (mask));
11956 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11958 if (CONST_INT_P (XEXP (rtl, 1)))
11959 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
11960 /* deref_size zero extends, so no need to mask it again. */
11961 else if (last1->dw_loc_opc != DW_OP_deref_size
11962 || last1->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
11964 add_loc_descr (&op1, int_loc_descriptor (mask));
11965 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
11968 else if (GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
11970 HOST_WIDE_INT bias = 1;
11971 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
11972 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11973 if (CONST_INT_P (XEXP (rtl, 1)))
11974 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
11975 + INTVAL (XEXP (rtl, 1)));
11977 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
11980 return compare_loc_descriptor (op, op0, op1);
11983 /* Return location descriptor for {U,S}{MIN,MAX}. */
11985 static dw_loc_descr_ref
11986 minmax_loc_descriptor (rtx rtl, machine_mode mode,
11987 machine_mode mem_mode)
11989 enum dwarf_location_atom op;
11990 dw_loc_descr_ref op0, op1, ret;
11991 dw_loc_descr_ref bra_node, drop_node;
11994 && (GET_MODE_CLASS (mode) != MODE_INT
11995 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE))
11998 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
11999 VAR_INIT_STATUS_INITIALIZED);
12000 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12001 VAR_INIT_STATUS_INITIALIZED);
12003 if (op0 == NULL || op1 == NULL)
12006 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
12007 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
12008 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
12009 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
12011 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12013 HOST_WIDE_INT mask = GET_MODE_MASK (mode);
12014 add_loc_descr (&op0, int_loc_descriptor (mask));
12015 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
12016 add_loc_descr (&op1, int_loc_descriptor (mask));
12017 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
12019 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
12021 HOST_WIDE_INT bias = 1;
12022 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
12023 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
12024 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
12027 else if (GET_MODE_CLASS (mode) == MODE_INT
12028 && GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12030 int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (mode)) * BITS_PER_UNIT;
12031 add_loc_descr (&op0, int_loc_descriptor (shift));
12032 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
12033 add_loc_descr (&op1, int_loc_descriptor (shift));
12034 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
12036 else if (GET_MODE_CLASS (mode) == MODE_INT
12037 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12039 dw_die_ref type_die = base_type_for_mode (mode, 0);
12040 dw_loc_descr_ref cvt;
12041 if (type_die == NULL)
12043 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12044 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12045 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12046 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12047 add_loc_descr (&op0, cvt);
12048 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12049 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12050 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12051 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12052 add_loc_descr (&op1, cvt);
12055 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
12060 add_loc_descr (&ret, op1);
12061 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
12062 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
12063 add_loc_descr (&ret, bra_node);
12064 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12065 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
12066 add_loc_descr (&ret, drop_node);
12067 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12068 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
12069 if ((GET_CODE (rtl) == SMIN || GET_CODE (rtl) == SMAX)
12070 && GET_MODE_CLASS (mode) == MODE_INT
12071 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12072 ret = convert_descriptor_to_mode (mode, ret);
12076 /* Helper function for mem_loc_descriptor. Perform OP binary op,
12077 but after converting arguments to type_die, afterwards
12078 convert back to unsigned. */
12080 static dw_loc_descr_ref
12081 typed_binop (enum dwarf_location_atom op, rtx rtl, dw_die_ref type_die,
12082 machine_mode mode, machine_mode mem_mode)
12084 dw_loc_descr_ref cvt, op0, op1;
12086 if (type_die == NULL)
12088 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12089 VAR_INIT_STATUS_INITIALIZED);
12090 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12091 VAR_INIT_STATUS_INITIALIZED);
12092 if (op0 == NULL || op1 == NULL)
12094 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12095 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12096 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12097 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12098 add_loc_descr (&op0, cvt);
12099 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12100 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12101 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12102 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12103 add_loc_descr (&op1, cvt);
12104 add_loc_descr (&op0, op1);
12105 add_loc_descr (&op0, new_loc_descr (op, 0, 0));
12106 return convert_descriptor_to_mode (mode, op0);
12109 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
12110 const0 is DW_OP_lit0 or corresponding typed constant,
12111 const1 is DW_OP_lit1 or corresponding typed constant
12112 and constMSB is constant with just the MSB bit set
12114 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12115 L1: const0 DW_OP_swap
12116 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
12117 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12122 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
12123 L1: const0 DW_OP_swap
12124 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12125 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12130 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
12131 L1: const1 DW_OP_swap
12132 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
12133 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
12137 static dw_loc_descr_ref
12138 clz_loc_descriptor (rtx rtl, machine_mode mode,
12139 machine_mode mem_mode)
12141 dw_loc_descr_ref op0, ret, tmp;
12142 HOST_WIDE_INT valv;
12143 dw_loc_descr_ref l1jump, l1label;
12144 dw_loc_descr_ref l2jump, l2label;
12145 dw_loc_descr_ref l3jump, l3label;
12146 dw_loc_descr_ref l4jump, l4label;
12149 if (GET_MODE_CLASS (mode) != MODE_INT
12150 || GET_MODE (XEXP (rtl, 0)) != mode)
12153 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12154 VAR_INIT_STATUS_INITIALIZED);
12158 if (GET_CODE (rtl) == CLZ)
12160 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode, valv))
12161 valv = GET_MODE_BITSIZE (mode);
12163 else if (GET_CODE (rtl) == FFS)
12165 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode, valv))
12166 valv = GET_MODE_BITSIZE (mode);
12167 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12168 l1jump = new_loc_descr (DW_OP_bra, 0, 0);
12169 add_loc_descr (&ret, l1jump);
12170 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
12171 tmp = mem_loc_descriptor (GEN_INT (valv), mode, mem_mode,
12172 VAR_INIT_STATUS_INITIALIZED);
12175 add_loc_descr (&ret, tmp);
12176 l4jump = new_loc_descr (DW_OP_skip, 0, 0);
12177 add_loc_descr (&ret, l4jump);
12178 l1label = mem_loc_descriptor (GET_CODE (rtl) == FFS
12179 ? const1_rtx : const0_rtx,
12181 VAR_INIT_STATUS_INITIALIZED);
12182 if (l1label == NULL)
12184 add_loc_descr (&ret, l1label);
12185 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12186 l2label = new_loc_descr (DW_OP_dup, 0, 0);
12187 add_loc_descr (&ret, l2label);
12188 if (GET_CODE (rtl) != CLZ)
12190 else if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
12191 msb = GEN_INT ((unsigned HOST_WIDE_INT) 1
12192 << (GET_MODE_BITSIZE (mode) - 1));
12194 msb = immed_wide_int_const
12195 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode) - 1,
12196 GET_MODE_PRECISION (mode)), mode);
12197 if (GET_CODE (msb) == CONST_INT && INTVAL (msb) < 0)
12198 tmp = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
12199 ? DW_OP_const4u : HOST_BITS_PER_WIDE_INT == 64
12200 ? DW_OP_const8u : DW_OP_constu, INTVAL (msb), 0);
12202 tmp = mem_loc_descriptor (msb, mode, mem_mode,
12203 VAR_INIT_STATUS_INITIALIZED);
12206 add_loc_descr (&ret, tmp);
12207 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12208 l3jump = new_loc_descr (DW_OP_bra, 0, 0);
12209 add_loc_descr (&ret, l3jump);
12210 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12211 VAR_INIT_STATUS_INITIALIZED);
12214 add_loc_descr (&ret, tmp);
12215 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == CLZ
12216 ? DW_OP_shl : DW_OP_shr, 0, 0));
12217 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12218 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 1, 0));
12219 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12220 l2jump = new_loc_descr (DW_OP_skip, 0, 0);
12221 add_loc_descr (&ret, l2jump);
12222 l3label = new_loc_descr (DW_OP_drop, 0, 0);
12223 add_loc_descr (&ret, l3label);
12224 l4label = new_loc_descr (DW_OP_nop, 0, 0);
12225 add_loc_descr (&ret, l4label);
12226 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12227 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12228 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12229 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12230 l3jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12231 l3jump->dw_loc_oprnd1.v.val_loc = l3label;
12232 l4jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12233 l4jump->dw_loc_oprnd1.v.val_loc = l4label;
12237 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
12238 const1 is DW_OP_lit1 or corresponding typed constant):
12240 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12241 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12245 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
12246 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
12249 static dw_loc_descr_ref
12250 popcount_loc_descriptor (rtx rtl, machine_mode mode,
12251 machine_mode mem_mode)
12253 dw_loc_descr_ref op0, ret, tmp;
12254 dw_loc_descr_ref l1jump, l1label;
12255 dw_loc_descr_ref l2jump, l2label;
12257 if (GET_MODE_CLASS (mode) != MODE_INT
12258 || GET_MODE (XEXP (rtl, 0)) != mode)
12261 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12262 VAR_INIT_STATUS_INITIALIZED);
12266 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12267 VAR_INIT_STATUS_INITIALIZED);
12270 add_loc_descr (&ret, tmp);
12271 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12272 l1label = new_loc_descr (DW_OP_dup, 0, 0);
12273 add_loc_descr (&ret, l1label);
12274 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
12275 add_loc_descr (&ret, l2jump);
12276 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12277 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
12278 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12279 VAR_INIT_STATUS_INITIALIZED);
12282 add_loc_descr (&ret, tmp);
12283 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12284 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == POPCOUNT
12285 ? DW_OP_plus : DW_OP_xor, 0, 0));
12286 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12287 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
12288 VAR_INIT_STATUS_INITIALIZED);
12289 add_loc_descr (&ret, tmp);
12290 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12291 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
12292 add_loc_descr (&ret, l1jump);
12293 l2label = new_loc_descr (DW_OP_drop, 0, 0);
12294 add_loc_descr (&ret, l2label);
12295 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12296 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12297 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12298 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12302 /* BSWAP (constS is initial shift count, either 56 or 24):
12304 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
12305 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
12306 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
12307 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
12308 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
12310 static dw_loc_descr_ref
12311 bswap_loc_descriptor (rtx rtl, machine_mode mode,
12312 machine_mode mem_mode)
12314 dw_loc_descr_ref op0, ret, tmp;
12315 dw_loc_descr_ref l1jump, l1label;
12316 dw_loc_descr_ref l2jump, l2label;
12318 if (GET_MODE_CLASS (mode) != MODE_INT
12319 || BITS_PER_UNIT != 8
12320 || (GET_MODE_BITSIZE (mode) != 32
12321 && GET_MODE_BITSIZE (mode) != 64))
12324 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12325 VAR_INIT_STATUS_INITIALIZED);
12330 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
12332 VAR_INIT_STATUS_INITIALIZED);
12335 add_loc_descr (&ret, tmp);
12336 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12337 VAR_INIT_STATUS_INITIALIZED);
12340 add_loc_descr (&ret, tmp);
12341 l1label = new_loc_descr (DW_OP_pick, 2, 0);
12342 add_loc_descr (&ret, l1label);
12343 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
12345 VAR_INIT_STATUS_INITIALIZED);
12346 add_loc_descr (&ret, tmp);
12347 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 3, 0));
12348 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
12349 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12350 tmp = mem_loc_descriptor (GEN_INT (255), mode, mem_mode,
12351 VAR_INIT_STATUS_INITIALIZED);
12354 add_loc_descr (&ret, tmp);
12355 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
12356 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 2, 0));
12357 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
12358 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
12359 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12360 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
12361 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
12362 VAR_INIT_STATUS_INITIALIZED);
12363 add_loc_descr (&ret, tmp);
12364 add_loc_descr (&ret, new_loc_descr (DW_OP_eq, 0, 0));
12365 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
12366 add_loc_descr (&ret, l2jump);
12367 tmp = mem_loc_descriptor (GEN_INT (8), mode, mem_mode,
12368 VAR_INIT_STATUS_INITIALIZED);
12369 add_loc_descr (&ret, tmp);
12370 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
12371 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12372 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
12373 add_loc_descr (&ret, l1jump);
12374 l2label = new_loc_descr (DW_OP_drop, 0, 0);
12375 add_loc_descr (&ret, l2label);
12376 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12377 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
12378 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12379 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
12380 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
12381 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
12385 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
12386 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12387 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
12388 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
12390 ROTATERT is similar:
12391 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
12392 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
12393 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
12395 static dw_loc_descr_ref
12396 rotate_loc_descriptor (rtx rtl, machine_mode mode,
12397 machine_mode mem_mode)
12399 rtx rtlop1 = XEXP (rtl, 1);
12400 dw_loc_descr_ref op0, op1, ret, mask[2] = { NULL, NULL };
12403 if (GET_MODE_CLASS (mode) != MODE_INT)
12406 if (GET_MODE (rtlop1) != VOIDmode
12407 && GET_MODE_BITSIZE (GET_MODE (rtlop1)) < GET_MODE_BITSIZE (mode))
12408 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
12409 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12410 VAR_INIT_STATUS_INITIALIZED);
12411 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
12412 VAR_INIT_STATUS_INITIALIZED);
12413 if (op0 == NULL || op1 == NULL)
12415 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
12416 for (i = 0; i < 2; i++)
12418 if (GET_MODE_BITSIZE (mode) < HOST_BITS_PER_WIDE_INT)
12419 mask[i] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode)),
12421 VAR_INIT_STATUS_INITIALIZED);
12422 else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
12423 mask[i] = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
12425 : HOST_BITS_PER_WIDE_INT == 64
12426 ? DW_OP_const8u : DW_OP_constu,
12427 GET_MODE_MASK (mode), 0);
12430 if (mask[i] == NULL)
12432 add_loc_descr (&mask[i], new_loc_descr (DW_OP_and, 0, 0));
12435 add_loc_descr (&ret, op1);
12436 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
12437 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
12438 if (GET_CODE (rtl) == ROTATERT)
12440 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
12441 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
12442 GET_MODE_BITSIZE (mode), 0));
12444 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
12445 if (mask[0] != NULL)
12446 add_loc_descr (&ret, mask[0]);
12447 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
12448 if (mask[1] != NULL)
12450 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12451 add_loc_descr (&ret, mask[1]);
12452 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
12454 if (GET_CODE (rtl) == ROTATE)
12456 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
12457 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
12458 GET_MODE_BITSIZE (mode), 0));
12460 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
12461 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
12465 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
12466 for DEBUG_PARAMETER_REF RTL. */
12468 static dw_loc_descr_ref
12469 parameter_ref_descriptor (rtx rtl)
12471 dw_loc_descr_ref ret;
12476 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl)) == PARM_DECL);
12477 ref = lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl));
12478 ret = new_loc_descr (DW_OP_GNU_parameter_ref, 0, 0);
12481 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12482 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
12483 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
12487 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
12488 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_PARAMETER_REF_DECL (rtl);
12493 /* The following routine converts the RTL for a variable or parameter
12494 (resident in memory) into an equivalent Dwarf representation of a
12495 mechanism for getting the address of that same variable onto the top of a
12496 hypothetical "address evaluation" stack.
12498 When creating memory location descriptors, we are effectively transforming
12499 the RTL for a memory-resident object into its Dwarf postfix expression
12500 equivalent. This routine recursively descends an RTL tree, turning
12501 it into Dwarf postfix code as it goes.
12503 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
12505 MEM_MODE is the mode of the memory reference, needed to handle some
12506 autoincrement addressing modes.
12508 Return 0 if we can't represent the location. */
12511 mem_loc_descriptor (rtx rtl, machine_mode mode,
12512 machine_mode mem_mode,
12513 enum var_init_status initialized)
12515 dw_loc_descr_ref mem_loc_result = NULL;
12516 enum dwarf_location_atom op;
12517 dw_loc_descr_ref op0, op1;
12518 rtx inner = NULL_RTX;
12520 if (mode == VOIDmode)
12521 mode = GET_MODE (rtl);
12523 /* Note that for a dynamically sized array, the location we will generate a
12524 description of here will be the lowest numbered location which is
12525 actually within the array. That's *not* necessarily the same as the
12526 zeroth element of the array. */
12528 rtl = targetm.delegitimize_address (rtl);
12530 if (mode != GET_MODE (rtl) && GET_MODE (rtl) != VOIDmode)
12533 switch (GET_CODE (rtl))
12538 return mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, initialized);
12541 /* The case of a subreg may arise when we have a local (register)
12542 variable or a formal (register) parameter which doesn't quite fill
12543 up an entire register. For now, just assume that it is
12544 legitimate to make the Dwarf info refer to the whole register which
12545 contains the given subreg. */
12546 if (!subreg_lowpart_p (rtl))
12548 inner = SUBREG_REG (rtl);
12550 if (inner == NULL_RTX)
12551 inner = XEXP (rtl, 0);
12552 if (GET_MODE_CLASS (mode) == MODE_INT
12553 && GET_MODE_CLASS (GET_MODE (inner)) == MODE_INT
12554 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12555 #ifdef POINTERS_EXTEND_UNSIGNED
12556 || (mode == Pmode && mem_mode != VOIDmode)
12559 && GET_MODE_SIZE (GET_MODE (inner)) <= DWARF2_ADDR_SIZE)
12561 mem_loc_result = mem_loc_descriptor (inner,
12563 mem_mode, initialized);
12568 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (inner)))
12570 if (GET_MODE_SIZE (mode) != GET_MODE_SIZE (GET_MODE (inner))
12571 && (GET_MODE_CLASS (mode) != MODE_INT
12572 || GET_MODE_CLASS (GET_MODE (inner)) != MODE_INT))
12576 dw_die_ref type_die;
12577 dw_loc_descr_ref cvt;
12579 mem_loc_result = mem_loc_descriptor (inner,
12581 mem_mode, initialized);
12582 if (mem_loc_result == NULL)
12584 type_die = base_type_for_mode (mode,
12585 GET_MODE_CLASS (mode) == MODE_INT);
12586 if (type_die == NULL)
12588 mem_loc_result = NULL;
12591 if (GET_MODE_SIZE (mode)
12592 != GET_MODE_SIZE (GET_MODE (inner)))
12593 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12595 cvt = new_loc_descr (DW_OP_GNU_reinterpret, 0, 0);
12596 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12597 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
12598 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12599 add_loc_descr (&mem_loc_result, cvt);
12604 if (GET_MODE_CLASS (mode) != MODE_INT
12605 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12606 && rtl != arg_pointer_rtx
12607 && rtl != frame_pointer_rtx
12608 #ifdef POINTERS_EXTEND_UNSIGNED
12609 && (mode != Pmode || mem_mode == VOIDmode)
12613 dw_die_ref type_die;
12614 unsigned int dbx_regnum;
12618 if (REGNO (rtl) > FIRST_PSEUDO_REGISTER)
12620 type_die = base_type_for_mode (mode,
12621 GET_MODE_CLASS (mode) == MODE_INT);
12622 if (type_die == NULL)
12625 dbx_regnum = dbx_reg_number (rtl);
12626 if (dbx_regnum == IGNORED_DWARF_REGNUM)
12628 mem_loc_result = new_loc_descr (DW_OP_GNU_regval_type,
12630 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
12631 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die;
12632 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0;
12635 /* Whenever a register number forms a part of the description of the
12636 method for calculating the (dynamic) address of a memory resident
12637 object, DWARF rules require the register number be referred to as
12638 a "base register". This distinction is not based in any way upon
12639 what category of register the hardware believes the given register
12640 belongs to. This is strictly DWARF terminology we're dealing with
12641 here. Note that in cases where the location of a memory-resident
12642 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12643 OP_CONST (0)) the actual DWARF location descriptor that we generate
12644 may just be OP_BASEREG (basereg). This may look deceptively like
12645 the object in question was allocated to a register (rather than in
12646 memory) so DWARF consumers need to be aware of the subtle
12647 distinction between OP_REG and OP_BASEREG. */
12648 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
12649 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
12650 else if (stack_realign_drap
12652 && crtl->args.internal_arg_pointer == rtl
12653 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
12655 /* If RTL is internal_arg_pointer, which has been optimized
12656 out, use DRAP instead. */
12657 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
12658 VAR_INIT_STATUS_INITIALIZED);
12664 if (GET_MODE_CLASS (mode) != MODE_INT)
12666 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
12667 mem_mode, VAR_INIT_STATUS_INITIALIZED);
12670 else if (GET_CODE (rtl) == ZERO_EXTEND
12671 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12672 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
12673 < HOST_BITS_PER_WIDE_INT
12674 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
12675 to expand zero extend as two shifts instead of
12677 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= 4)
12679 machine_mode imode = GET_MODE (XEXP (rtl, 0));
12680 mem_loc_result = op0;
12681 add_loc_descr (&mem_loc_result,
12682 int_loc_descriptor (GET_MODE_MASK (imode)));
12683 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_and, 0, 0));
12685 else if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
12687 int shift = DWARF2_ADDR_SIZE
12688 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
12689 shift *= BITS_PER_UNIT;
12690 if (GET_CODE (rtl) == SIGN_EXTEND)
12694 mem_loc_result = op0;
12695 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12696 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
12697 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12698 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12700 else if (!dwarf_strict)
12702 dw_die_ref type_die1, type_die2;
12703 dw_loc_descr_ref cvt;
12705 type_die1 = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
12706 GET_CODE (rtl) == ZERO_EXTEND);
12707 if (type_die1 == NULL)
12709 type_die2 = base_type_for_mode (mode, 1);
12710 if (type_die2 == NULL)
12712 mem_loc_result = op0;
12713 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12714 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12715 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die1;
12716 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12717 add_loc_descr (&mem_loc_result, cvt);
12718 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
12719 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
12720 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die2;
12721 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
12722 add_loc_descr (&mem_loc_result, cvt);
12728 rtx new_rtl = avoid_constant_pool_reference (rtl);
12729 if (new_rtl != rtl)
12731 mem_loc_result = mem_loc_descriptor (new_rtl, mode, mem_mode,
12733 if (mem_loc_result != NULL)
12734 return mem_loc_result;
12737 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0),
12738 get_address_mode (rtl), mode,
12739 VAR_INIT_STATUS_INITIALIZED);
12740 if (mem_loc_result == NULL)
12741 mem_loc_result = tls_mem_loc_descriptor (rtl);
12742 if (mem_loc_result != NULL)
12744 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12745 || GET_MODE_CLASS (mode) != MODE_INT)
12747 dw_die_ref type_die;
12748 dw_loc_descr_ref deref;
12753 = base_type_for_mode (mode, GET_MODE_CLASS (mode) == MODE_INT);
12754 if (type_die == NULL)
12756 deref = new_loc_descr (DW_OP_GNU_deref_type,
12757 GET_MODE_SIZE (mode), 0);
12758 deref->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
12759 deref->dw_loc_oprnd2.v.val_die_ref.die = type_die;
12760 deref->dw_loc_oprnd2.v.val_die_ref.external = 0;
12761 add_loc_descr (&mem_loc_result, deref);
12763 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
12764 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
12766 add_loc_descr (&mem_loc_result,
12767 new_loc_descr (DW_OP_deref_size,
12768 GET_MODE_SIZE (mode), 0));
12773 return mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, initialized);
12776 /* Some ports can transform a symbol ref into a label ref, because
12777 the symbol ref is too far away and has to be dumped into a constant
12781 if ((GET_MODE_CLASS (mode) != MODE_INT
12782 && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT)
12783 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
12784 #ifdef POINTERS_EXTEND_UNSIGNED
12785 && (mode != Pmode || mem_mode == VOIDmode)
12789 if (GET_CODE (rtl) == SYMBOL_REF
12790 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
12792 dw_loc_descr_ref temp;
12794 /* If this is not defined, we have no way to emit the data. */
12795 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
12798 temp = new_addr_loc_descr (rtl, dtprel_true);
12800 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
12801 add_loc_descr (&mem_loc_result, temp);
12806 if (!const_ok_for_output (rtl))
12810 mem_loc_result = new_addr_loc_descr (rtl, dtprel_false);
12811 vec_safe_push (used_rtx_array, rtl);
12817 case DEBUG_IMPLICIT_PTR:
12818 expansion_failed (NULL_TREE, rtl,
12819 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
12825 if (REG_P (ENTRY_VALUE_EXP (rtl)))
12827 if (GET_MODE_CLASS (mode) != MODE_INT
12828 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12829 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
12830 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12833 unsigned int dbx_regnum = dbx_reg_number (ENTRY_VALUE_EXP (rtl));
12834 if (dbx_regnum == IGNORED_DWARF_REGNUM)
12836 op0 = one_reg_loc_descriptor (dbx_regnum,
12837 VAR_INIT_STATUS_INITIALIZED);
12840 else if (MEM_P (ENTRY_VALUE_EXP (rtl))
12841 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl), 0)))
12843 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
12844 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
12845 if (op0 && op0->dw_loc_opc == DW_OP_fbreg)
12849 gcc_unreachable ();
12852 mem_loc_result = new_loc_descr (DW_OP_GNU_entry_value, 0, 0);
12853 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_loc;
12854 mem_loc_result->dw_loc_oprnd1.v.val_loc = op0;
12857 case DEBUG_PARAMETER_REF:
12858 mem_loc_result = parameter_ref_descriptor (rtl);
12862 /* Extract the PLUS expression nested inside and fall into
12863 PLUS code below. */
12864 rtl = XEXP (rtl, 1);
12869 /* Turn these into a PLUS expression and fall into the PLUS code
12871 rtl = gen_rtx_PLUS (mode, XEXP (rtl, 0),
12872 gen_int_mode (GET_CODE (rtl) == PRE_INC
12873 ? GET_MODE_UNIT_SIZE (mem_mode)
12874 : -GET_MODE_UNIT_SIZE (mem_mode),
12877 /* ... fall through ... */
12881 if (is_based_loc (rtl)
12882 && (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
12883 || XEXP (rtl, 0) == arg_pointer_rtx
12884 || XEXP (rtl, 0) == frame_pointer_rtx)
12885 && GET_MODE_CLASS (mode) == MODE_INT)
12886 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
12887 INTVAL (XEXP (rtl, 1)),
12888 VAR_INIT_STATUS_INITIALIZED);
12891 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12892 VAR_INIT_STATUS_INITIALIZED);
12893 if (mem_loc_result == 0)
12896 if (CONST_INT_P (XEXP (rtl, 1))
12897 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
12898 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
12901 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12902 VAR_INIT_STATUS_INITIALIZED);
12905 add_loc_descr (&mem_loc_result, op1);
12906 add_loc_descr (&mem_loc_result,
12907 new_loc_descr (DW_OP_plus, 0, 0));
12912 /* If a pseudo-reg is optimized away, it is possible for it to
12913 be replaced with a MEM containing a multiply or shift. */
12924 && GET_MODE_CLASS (mode) == MODE_INT
12925 && GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
12927 mem_loc_result = typed_binop (DW_OP_div, rtl,
12928 base_type_for_mode (mode, 0),
12952 if (GET_MODE_CLASS (mode) != MODE_INT)
12954 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12955 VAR_INIT_STATUS_INITIALIZED);
12957 rtx rtlop1 = XEXP (rtl, 1);
12958 if (GET_MODE (rtlop1) != VOIDmode
12959 && GET_MODE_BITSIZE (GET_MODE (rtlop1))
12960 < GET_MODE_BITSIZE (mode))
12961 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
12962 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
12963 VAR_INIT_STATUS_INITIALIZED);
12966 if (op0 == 0 || op1 == 0)
12969 mem_loc_result = op0;
12970 add_loc_descr (&mem_loc_result, op1);
12971 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
12987 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
12988 VAR_INIT_STATUS_INITIALIZED);
12989 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
12990 VAR_INIT_STATUS_INITIALIZED);
12992 if (op0 == 0 || op1 == 0)
12995 mem_loc_result = op0;
12996 add_loc_descr (&mem_loc_result, op1);
12997 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13001 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE && !dwarf_strict)
13003 mem_loc_result = typed_binop (DW_OP_mod, rtl,
13004 base_type_for_mode (mode, 0),
13009 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
13010 VAR_INIT_STATUS_INITIALIZED);
13011 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
13012 VAR_INIT_STATUS_INITIALIZED);
13014 if (op0 == 0 || op1 == 0)
13017 mem_loc_result = op0;
13018 add_loc_descr (&mem_loc_result, op1);
13019 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
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_div, 0, 0));
13022 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13023 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
13027 if (!dwarf_strict && GET_MODE_CLASS (mode) == MODE_INT)
13029 if (GET_MODE_CLASS (mode) > DWARF2_ADDR_SIZE)
13034 mem_loc_result = typed_binop (DW_OP_div, rtl,
13035 base_type_for_mode (mode, 1),
13053 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
13054 VAR_INIT_STATUS_INITIALIZED);
13059 mem_loc_result = op0;
13060 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13064 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
13065 #ifdef POINTERS_EXTEND_UNSIGNED
13067 && mem_mode != VOIDmode
13068 && trunc_int_for_mode (INTVAL (rtl), ptr_mode) == INTVAL (rtl))
13072 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13076 && (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT
13077 || GET_MODE_BITSIZE (mode) == HOST_BITS_PER_DOUBLE_INT))
13079 dw_die_ref type_die = base_type_for_mode (mode, 1);
13080 machine_mode amode;
13081 if (type_die == NULL)
13083 amode = mode_for_size (DWARF2_ADDR_SIZE * BITS_PER_UNIT,
13085 if (INTVAL (rtl) >= 0
13086 && amode != BLKmode
13087 && trunc_int_for_mode (INTVAL (rtl), amode) == INTVAL (rtl)
13088 /* const DW_OP_GNU_convert <XXX> vs.
13089 DW_OP_GNU_const_type <XXX, 1, const>. */
13090 && size_of_int_loc_descriptor (INTVAL (rtl)) + 1 + 1
13091 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (mode))
13093 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13094 op0 = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13095 op0->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13096 op0->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13097 op0->dw_loc_oprnd1.v.val_die_ref.external = 0;
13098 add_loc_descr (&mem_loc_result, op0);
13099 return mem_loc_result;
13101 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0,
13103 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13104 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13105 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13106 if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
13107 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
13110 mem_loc_result->dw_loc_oprnd2.val_class
13111 = dw_val_class_const_double;
13112 mem_loc_result->dw_loc_oprnd2.v.val_double
13113 = double_int::from_shwi (INTVAL (rtl));
13121 dw_die_ref type_die;
13123 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
13124 CONST_DOUBLE rtx could represent either a large integer
13125 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
13126 the value is always a floating point constant.
13128 When it is an integer, a CONST_DOUBLE is used whenever
13129 the constant requires 2 HWIs to be adequately represented.
13130 We output CONST_DOUBLEs as blocks. */
13131 if (mode == VOIDmode
13132 || (GET_MODE (rtl) == VOIDmode
13133 && GET_MODE_BITSIZE (mode) != HOST_BITS_PER_DOUBLE_INT))
13135 type_die = base_type_for_mode (mode,
13136 GET_MODE_CLASS (mode) == MODE_INT);
13137 if (type_die == NULL)
13139 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
13140 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13141 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13142 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13143 #if TARGET_SUPPORTS_WIDE_INT == 0
13144 if (!SCALAR_FLOAT_MODE_P (mode))
13146 mem_loc_result->dw_loc_oprnd2.val_class
13147 = dw_val_class_const_double;
13148 mem_loc_result->dw_loc_oprnd2.v.val_double
13149 = rtx_to_double_int (rtl);
13154 unsigned int length = GET_MODE_SIZE (mode);
13155 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
13157 insert_float (rtl, array);
13158 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13159 mem_loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
13160 mem_loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
13161 mem_loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13166 case CONST_WIDE_INT:
13169 dw_die_ref type_die;
13171 type_die = base_type_for_mode (mode,
13172 GET_MODE_CLASS (mode) == MODE_INT);
13173 if (type_die == NULL)
13175 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
13176 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13177 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13178 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
13179 mem_loc_result->dw_loc_oprnd2.val_class
13180 = dw_val_class_wide_int;
13181 mem_loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
13182 *mem_loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode);
13187 mem_loc_result = scompare_loc_descriptor (DW_OP_eq, rtl, mem_mode);
13191 mem_loc_result = scompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
13195 mem_loc_result = scompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
13199 mem_loc_result = scompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
13203 mem_loc_result = scompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
13207 mem_loc_result = scompare_loc_descriptor (DW_OP_ne, rtl, mem_mode);
13211 mem_loc_result = ucompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
13215 mem_loc_result = ucompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
13219 mem_loc_result = ucompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
13223 mem_loc_result = ucompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
13228 if (GET_MODE_CLASS (mode) != MODE_INT)
13233 mem_loc_result = minmax_loc_descriptor (rtl, mode, mem_mode);
13238 if (CONST_INT_P (XEXP (rtl, 1))
13239 && CONST_INT_P (XEXP (rtl, 2))
13240 && ((unsigned) INTVAL (XEXP (rtl, 1))
13241 + (unsigned) INTVAL (XEXP (rtl, 2))
13242 <= GET_MODE_BITSIZE (mode))
13243 && GET_MODE_CLASS (mode) == MODE_INT
13244 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
13245 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
13248 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
13249 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13252 if (GET_CODE (rtl) == SIGN_EXTRACT)
13256 mem_loc_result = op0;
13257 size = INTVAL (XEXP (rtl, 1));
13258 shift = INTVAL (XEXP (rtl, 2));
13259 if (BITS_BIG_ENDIAN)
13260 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
13262 if (shift + size != (int) DWARF2_ADDR_SIZE)
13264 add_loc_descr (&mem_loc_result,
13265 int_loc_descriptor (DWARF2_ADDR_SIZE
13267 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
13269 if (size != (int) DWARF2_ADDR_SIZE)
13271 add_loc_descr (&mem_loc_result,
13272 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
13273 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13280 dw_loc_descr_ref op2, bra_node, drop_node;
13281 op0 = mem_loc_descriptor (XEXP (rtl, 0),
13282 GET_MODE (XEXP (rtl, 0)) == VOIDmode
13283 ? word_mode : GET_MODE (XEXP (rtl, 0)),
13284 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13285 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
13286 VAR_INIT_STATUS_INITIALIZED);
13287 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode, mem_mode,
13288 VAR_INIT_STATUS_INITIALIZED);
13289 if (op0 == NULL || op1 == NULL || op2 == NULL)
13292 mem_loc_result = op1;
13293 add_loc_descr (&mem_loc_result, op2);
13294 add_loc_descr (&mem_loc_result, op0);
13295 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
13296 add_loc_descr (&mem_loc_result, bra_node);
13297 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
13298 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
13299 add_loc_descr (&mem_loc_result, drop_node);
13300 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
13301 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
13306 case FLOAT_TRUNCATE:
13308 case UNSIGNED_FLOAT:
13313 dw_die_ref type_die;
13314 dw_loc_descr_ref cvt;
13316 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
13317 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13320 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) == MODE_INT
13321 && (GET_CODE (rtl) == FLOAT
13322 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)))
13323 <= DWARF2_ADDR_SIZE))
13325 type_die = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
13326 GET_CODE (rtl) == UNSIGNED_FLOAT);
13327 if (type_die == NULL)
13329 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13330 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13331 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13332 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13333 add_loc_descr (&op0, cvt);
13335 type_die = base_type_for_mode (mode, GET_CODE (rtl) == UNSIGNED_FIX);
13336 if (type_die == NULL)
13338 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13339 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13340 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13341 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13342 add_loc_descr (&op0, cvt);
13343 if (GET_MODE_CLASS (mode) == MODE_INT
13344 && (GET_CODE (rtl) == FIX
13345 || GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE))
13347 op0 = convert_descriptor_to_mode (mode, op0);
13351 mem_loc_result = op0;
13358 mem_loc_result = clz_loc_descriptor (rtl, mode, mem_mode);
13363 mem_loc_result = popcount_loc_descriptor (rtl, mode, mem_mode);
13367 mem_loc_result = bswap_loc_descriptor (rtl, mode, mem_mode);
13372 mem_loc_result = rotate_loc_descriptor (rtl, mode, mem_mode);
13376 /* In theory, we could implement the above. */
13377 /* DWARF cannot represent the unsigned compare operations
13402 case FRACT_CONVERT:
13403 case UNSIGNED_FRACT_CONVERT:
13405 case UNSIGNED_SAT_FRACT:
13411 case VEC_DUPLICATE:
13415 case STRICT_LOW_PART:
13420 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13421 can't express it in the debug info. This can happen e.g. with some
13426 resolve_one_addr (&rtl);
13430 #ifdef ENABLE_CHECKING
13431 print_rtl (stderr, rtl);
13432 gcc_unreachable ();
13438 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13439 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13441 return mem_loc_result;
13444 /* Return a descriptor that describes the concatenation of two locations.
13445 This is typically a complex variable. */
13447 static dw_loc_descr_ref
13448 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
13450 dw_loc_descr_ref cc_loc_result = NULL;
13451 dw_loc_descr_ref x0_ref
13452 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13453 dw_loc_descr_ref x1_ref
13454 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13456 if (x0_ref == 0 || x1_ref == 0)
13459 cc_loc_result = x0_ref;
13460 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
13462 add_loc_descr (&cc_loc_result, x1_ref);
13463 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
13465 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13466 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13468 return cc_loc_result;
13471 /* Return a descriptor that describes the concatenation of N
13474 static dw_loc_descr_ref
13475 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
13478 dw_loc_descr_ref cc_loc_result = NULL;
13479 unsigned int n = XVECLEN (concatn, 0);
13481 for (i = 0; i < n; ++i)
13483 dw_loc_descr_ref ref;
13484 rtx x = XVECEXP (concatn, 0, i);
13486 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13490 add_loc_descr (&cc_loc_result, ref);
13491 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
13494 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13495 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13497 return cc_loc_result;
13500 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
13501 for DEBUG_IMPLICIT_PTR RTL. */
13503 static dw_loc_descr_ref
13504 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
13506 dw_loc_descr_ref ret;
13511 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
13512 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
13513 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
13514 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
13515 ret = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
13516 ret->dw_loc_oprnd2.val_class = dw_val_class_const;
13519 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13520 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
13521 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
13525 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
13526 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl);
13531 /* Output a proper Dwarf location descriptor for a variable or parameter
13532 which is either allocated in a register or in a memory location. For a
13533 register, we just generate an OP_REG and the register number. For a
13534 memory location we provide a Dwarf postfix expression describing how to
13535 generate the (dynamic) address of the object onto the address stack.
13537 MODE is mode of the decl if this loc_descriptor is going to be used in
13538 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13539 allowed, VOIDmode otherwise.
13541 If we don't know how to describe it, return 0. */
13543 static dw_loc_descr_ref
13544 loc_descriptor (rtx rtl, machine_mode mode,
13545 enum var_init_status initialized)
13547 dw_loc_descr_ref loc_result = NULL;
13549 switch (GET_CODE (rtl))
13552 /* The case of a subreg may arise when we have a local (register)
13553 variable or a formal (register) parameter which doesn't quite fill
13554 up an entire register. For now, just assume that it is
13555 legitimate to make the Dwarf info refer to the whole register which
13556 contains the given subreg. */
13557 if (REG_P (SUBREG_REG (rtl)) && subreg_lowpart_p (rtl))
13558 loc_result = loc_descriptor (SUBREG_REG (rtl),
13559 GET_MODE (SUBREG_REG (rtl)), initialized);
13565 loc_result = reg_loc_descriptor (rtl, initialized);
13569 loc_result = mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
13570 GET_MODE (rtl), initialized);
13571 if (loc_result == NULL)
13572 loc_result = tls_mem_loc_descriptor (rtl);
13573 if (loc_result == NULL)
13575 rtx new_rtl = avoid_constant_pool_reference (rtl);
13576 if (new_rtl != rtl)
13577 loc_result = loc_descriptor (new_rtl, mode, initialized);
13582 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
13587 loc_result = concatn_loc_descriptor (rtl, initialized);
13592 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
13594 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
13595 if (GET_CODE (loc) == EXPR_LIST)
13596 loc = XEXP (loc, 0);
13597 loc_result = loc_descriptor (loc, mode, initialized);
13601 rtl = XEXP (rtl, 1);
13606 rtvec par_elems = XVEC (rtl, 0);
13607 int num_elem = GET_NUM_ELEM (par_elems);
13611 /* Create the first one, so we have something to add to. */
13612 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
13613 VOIDmode, initialized);
13614 if (loc_result == NULL)
13616 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
13617 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13618 for (i = 1; i < num_elem; i++)
13620 dw_loc_descr_ref temp;
13622 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
13623 VOIDmode, initialized);
13626 add_loc_descr (&loc_result, temp);
13627 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
13628 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13634 if (mode != VOIDmode && mode != BLKmode)
13635 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
13640 if (mode == VOIDmode)
13641 mode = GET_MODE (rtl);
13643 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13645 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13647 /* Note that a CONST_DOUBLE rtx could represent either an integer
13648 or a floating-point constant. A CONST_DOUBLE is used whenever
13649 the constant requires more than one word in order to be
13650 adequately represented. We output CONST_DOUBLEs as blocks. */
13651 loc_result = new_loc_descr (DW_OP_implicit_value,
13652 GET_MODE_SIZE (mode), 0);
13653 #if TARGET_SUPPORTS_WIDE_INT == 0
13654 if (!SCALAR_FLOAT_MODE_P (mode))
13656 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
13657 loc_result->dw_loc_oprnd2.v.val_double
13658 = rtx_to_double_int (rtl);
13663 unsigned int length = GET_MODE_SIZE (mode);
13664 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
13666 insert_float (rtl, array);
13667 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13668 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
13669 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
13670 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13675 case CONST_WIDE_INT:
13676 if (mode == VOIDmode)
13677 mode = GET_MODE (rtl);
13679 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13681 loc_result = new_loc_descr (DW_OP_implicit_value,
13682 GET_MODE_SIZE (mode), 0);
13683 loc_result->dw_loc_oprnd2.val_class = dw_val_class_wide_int;
13684 loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
13685 *loc_result->dw_loc_oprnd2.v.val_wide = std::make_pair (rtl, mode);
13690 if (mode == VOIDmode)
13691 mode = GET_MODE (rtl);
13693 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13695 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
13696 unsigned int length = CONST_VECTOR_NUNITS (rtl);
13697 unsigned char *array
13698 = ggc_vec_alloc<unsigned char> (length * elt_size);
13701 machine_mode imode = GET_MODE_INNER (mode);
13703 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13704 switch (GET_MODE_CLASS (mode))
13706 case MODE_VECTOR_INT:
13707 for (i = 0, p = array; i < length; i++, p += elt_size)
13709 rtx elt = CONST_VECTOR_ELT (rtl, i);
13710 insert_wide_int (std::make_pair (elt, imode), p, elt_size);
13714 case MODE_VECTOR_FLOAT:
13715 for (i = 0, p = array; i < length; i++, p += elt_size)
13717 rtx elt = CONST_VECTOR_ELT (rtl, i);
13718 insert_float (elt, p);
13723 gcc_unreachable ();
13726 loc_result = new_loc_descr (DW_OP_implicit_value,
13727 length * elt_size, 0);
13728 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13729 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
13730 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
13731 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13736 if (mode == VOIDmode
13737 || CONST_SCALAR_INT_P (XEXP (rtl, 0))
13738 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl, 0))
13739 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
13741 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
13746 if (!const_ok_for_output (rtl))
13749 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
13750 && (dwarf_version >= 4 || !dwarf_strict))
13752 loc_result = new_addr_loc_descr (rtl, dtprel_false);
13753 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
13754 vec_safe_push (used_rtx_array, rtl);
13758 case DEBUG_IMPLICIT_PTR:
13759 loc_result = implicit_ptr_descriptor (rtl, 0);
13763 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR
13764 && CONST_INT_P (XEXP (rtl, 1)))
13767 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1)));
13773 if ((GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
13774 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
13775 && dwarf_version >= 4)
13776 || (!dwarf_strict && mode != VOIDmode && mode != BLKmode))
13778 /* Value expression. */
13779 loc_result = mem_loc_descriptor (rtl, mode, VOIDmode, initialized);
13781 add_loc_descr (&loc_result,
13782 new_loc_descr (DW_OP_stack_value, 0, 0));
13790 /* We need to figure out what section we should use as the base for the
13791 address ranges where a given location is valid.
13792 1. If this particular DECL has a section associated with it, use that.
13793 2. If this function has a section associated with it, use that.
13794 3. Otherwise, use the text section.
13795 XXX: If you split a variable across multiple sections, we won't notice. */
13797 static const char *
13798 secname_for_decl (const_tree decl)
13800 const char *secname;
13802 if (VAR_OR_FUNCTION_DECL_P (decl)
13803 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl) || TREE_STATIC (decl))
13804 && DECL_SECTION_NAME (decl))
13805 secname = DECL_SECTION_NAME (decl);
13806 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
13807 secname = DECL_SECTION_NAME (current_function_decl);
13808 else if (cfun && in_cold_section_p)
13809 secname = crtl->subsections.cold_section_label;
13811 secname = text_section_label;
13816 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13819 decl_by_reference_p (tree decl)
13821 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
13822 || TREE_CODE (decl) == VAR_DECL)
13823 && DECL_BY_REFERENCE (decl));
13826 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13829 static dw_loc_descr_ref
13830 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
13831 enum var_init_status initialized)
13833 int have_address = 0;
13834 dw_loc_descr_ref descr;
13837 if (want_address != 2)
13839 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
13841 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
13843 varloc = PAT_VAR_LOCATION_LOC (varloc);
13844 if (GET_CODE (varloc) == EXPR_LIST)
13845 varloc = XEXP (varloc, 0);
13846 mode = GET_MODE (varloc);
13847 if (MEM_P (varloc))
13849 rtx addr = XEXP (varloc, 0);
13850 descr = mem_loc_descriptor (addr, get_address_mode (varloc),
13851 mode, initialized);
13856 rtx x = avoid_constant_pool_reference (varloc);
13858 descr = mem_loc_descriptor (x, mode, VOIDmode,
13863 descr = mem_loc_descriptor (varloc, mode, VOIDmode, initialized);
13870 if (GET_CODE (varloc) == VAR_LOCATION)
13871 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
13873 mode = DECL_MODE (loc);
13874 descr = loc_descriptor (varloc, mode, initialized);
13881 if (want_address == 2 && !have_address
13882 && (dwarf_version >= 4 || !dwarf_strict))
13884 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
13886 expansion_failed (loc, NULL_RTX,
13887 "DWARF address size mismatch");
13890 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
13893 /* Show if we can't fill the request for an address. */
13894 if (want_address && !have_address)
13896 expansion_failed (loc, NULL_RTX,
13897 "Want address and only have value");
13901 /* If we've got an address and don't want one, dereference. */
13902 if (!want_address && have_address)
13904 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
13905 enum dwarf_location_atom op;
13907 if (size > DWARF2_ADDR_SIZE || size == -1)
13909 expansion_failed (loc, NULL_RTX,
13910 "DWARF address size mismatch");
13913 else if (size == DWARF2_ADDR_SIZE)
13916 op = DW_OP_deref_size;
13918 add_loc_descr (&descr, new_loc_descr (op, size, 0));
13924 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
13925 if it is not possible. */
13927 static dw_loc_descr_ref
13928 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
13930 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
13931 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
13932 else if (dwarf_version >= 3 || !dwarf_strict)
13933 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
13938 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13939 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
13941 static dw_loc_descr_ref
13942 dw_sra_loc_expr (tree decl, rtx loc)
13945 unsigned HOST_WIDE_INT padsize = 0;
13946 dw_loc_descr_ref descr, *descr_tail;
13947 unsigned HOST_WIDE_INT decl_size;
13949 enum var_init_status initialized;
13951 if (DECL_SIZE (decl) == NULL
13952 || !tree_fits_uhwi_p (DECL_SIZE (decl)))
13955 decl_size = tree_to_uhwi (DECL_SIZE (decl));
13957 descr_tail = &descr;
13959 for (p = loc; p; p = XEXP (p, 1))
13961 unsigned HOST_WIDE_INT bitsize = decl_piece_bitsize (p);
13962 rtx loc_note = *decl_piece_varloc_ptr (p);
13963 dw_loc_descr_ref cur_descr;
13964 dw_loc_descr_ref *tail, last = NULL;
13965 unsigned HOST_WIDE_INT opsize = 0;
13967 if (loc_note == NULL_RTX
13968 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
13970 padsize += bitsize;
13973 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
13974 varloc = NOTE_VAR_LOCATION (loc_note);
13975 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
13976 if (cur_descr == NULL)
13978 padsize += bitsize;
13982 /* Check that cur_descr either doesn't use
13983 DW_OP_*piece operations, or their sum is equal
13984 to bitsize. Otherwise we can't embed it. */
13985 for (tail = &cur_descr; *tail != NULL;
13986 tail = &(*tail)->dw_loc_next)
13987 if ((*tail)->dw_loc_opc == DW_OP_piece)
13989 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
13993 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
13995 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
13999 if (last != NULL && opsize != bitsize)
14001 padsize += bitsize;
14002 /* Discard the current piece of the descriptor and release any
14003 addr_table entries it uses. */
14004 remove_loc_list_addr_table_entries (cur_descr);
14008 /* If there is a hole, add DW_OP_*piece after empty DWARF
14009 expression, which means that those bits are optimized out. */
14012 if (padsize > decl_size)
14014 remove_loc_list_addr_table_entries (cur_descr);
14015 goto discard_descr;
14017 decl_size -= padsize;
14018 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
14019 if (*descr_tail == NULL)
14021 remove_loc_list_addr_table_entries (cur_descr);
14022 goto discard_descr;
14024 descr_tail = &(*descr_tail)->dw_loc_next;
14027 *descr_tail = cur_descr;
14029 if (bitsize > decl_size)
14030 goto discard_descr;
14031 decl_size -= bitsize;
14034 HOST_WIDE_INT offset = 0;
14035 if (GET_CODE (varloc) == VAR_LOCATION
14036 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
14038 varloc = PAT_VAR_LOCATION_LOC (varloc);
14039 if (GET_CODE (varloc) == EXPR_LIST)
14040 varloc = XEXP (varloc, 0);
14044 if (GET_CODE (varloc) == CONST
14045 || GET_CODE (varloc) == SIGN_EXTEND
14046 || GET_CODE (varloc) == ZERO_EXTEND)
14047 varloc = XEXP (varloc, 0);
14048 else if (GET_CODE (varloc) == SUBREG)
14049 varloc = SUBREG_REG (varloc);
14054 /* DW_OP_bit_size offset should be zero for register
14055 or implicit location descriptions and empty location
14056 descriptions, but for memory addresses needs big endian
14058 if (MEM_P (varloc))
14060 unsigned HOST_WIDE_INT memsize
14061 = MEM_SIZE (varloc) * BITS_PER_UNIT;
14062 if (memsize != bitsize)
14064 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
14065 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
14066 goto discard_descr;
14067 if (memsize < bitsize)
14068 goto discard_descr;
14069 if (BITS_BIG_ENDIAN)
14070 offset = memsize - bitsize;
14074 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
14075 if (*descr_tail == NULL)
14076 goto discard_descr;
14077 descr_tail = &(*descr_tail)->dw_loc_next;
14081 /* If there were any non-empty expressions, add padding till the end of
14083 if (descr != NULL && decl_size != 0)
14085 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
14086 if (*descr_tail == NULL)
14087 goto discard_descr;
14092 /* Discard the descriptor and release any addr_table entries it uses. */
14093 remove_loc_list_addr_table_entries (descr);
14097 /* Return the dwarf representation of the location list LOC_LIST of
14098 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14101 static dw_loc_list_ref
14102 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
14104 const char *endname, *secname;
14106 enum var_init_status initialized;
14107 struct var_loc_node *node;
14108 dw_loc_descr_ref descr;
14109 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
14110 dw_loc_list_ref list = NULL;
14111 dw_loc_list_ref *listp = &list;
14113 /* Now that we know what section we are using for a base,
14114 actually construct the list of locations.
14115 The first location information is what is passed to the
14116 function that creates the location list, and the remaining
14117 locations just get added on to that list.
14118 Note that we only know the start address for a location
14119 (IE location changes), so to build the range, we use
14120 the range [current location start, next location start].
14121 This means we have to special case the last node, and generate
14122 a range of [last location start, end of function label]. */
14124 secname = secname_for_decl (decl);
14126 for (node = loc_list->first; node; node = node->next)
14127 if (GET_CODE (node->loc) == EXPR_LIST
14128 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
14130 if (GET_CODE (node->loc) == EXPR_LIST)
14132 /* This requires DW_OP_{,bit_}piece, which is not usable
14133 inside DWARF expressions. */
14134 if (want_address != 2)
14136 descr = dw_sra_loc_expr (decl, node->loc);
14142 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14143 varloc = NOTE_VAR_LOCATION (node->loc);
14144 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
14148 bool range_across_switch = false;
14149 /* If section switch happens in between node->label
14150 and node->next->label (or end of function) and
14151 we can't emit it as a single entry list,
14152 emit two ranges, first one ending at the end
14153 of first partition and second one starting at the
14154 beginning of second partition. */
14155 if (node == loc_list->last_before_switch
14156 && (node != loc_list->first || loc_list->first->next)
14157 && current_function_decl)
14159 endname = cfun->fde->dw_fde_end;
14160 range_across_switch = true;
14162 /* The variable has a location between NODE->LABEL and
14163 NODE->NEXT->LABEL. */
14164 else if (node->next)
14165 endname = node->next->label;
14166 /* If the variable has a location at the last label
14167 it keeps its location until the end of function. */
14168 else if (!current_function_decl)
14169 endname = text_end_label;
14172 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
14173 current_function_funcdef_no);
14174 endname = ggc_strdup (label_id);
14177 *listp = new_loc_list (descr, node->label, endname, secname);
14178 if (TREE_CODE (decl) == PARM_DECL
14179 && node == loc_list->first
14180 && NOTE_P (node->loc)
14181 && strcmp (node->label, endname) == 0)
14182 (*listp)->force = true;
14183 listp = &(*listp)->dw_loc_next;
14185 if (range_across_switch)
14187 if (GET_CODE (node->loc) == EXPR_LIST)
14188 descr = dw_sra_loc_expr (decl, node->loc);
14191 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14192 varloc = NOTE_VAR_LOCATION (node->loc);
14193 descr = dw_loc_list_1 (decl, varloc, want_address,
14196 gcc_assert (descr);
14197 /* The variable has a location between NODE->LABEL and
14198 NODE->NEXT->LABEL. */
14200 endname = node->next->label;
14202 endname = cfun->fde->dw_fde_second_end;
14203 *listp = new_loc_list (descr,
14204 cfun->fde->dw_fde_second_begin,
14206 listp = &(*listp)->dw_loc_next;
14211 /* Try to avoid the overhead of a location list emitting a location
14212 expression instead, but only if we didn't have more than one
14213 location entry in the first place. If some entries were not
14214 representable, we don't want to pretend a single entry that was
14215 applies to the entire scope in which the variable is
14217 if (list && loc_list->first->next)
14223 /* Return if the loc_list has only single element and thus can be represented
14224 as location description. */
14227 single_element_loc_list_p (dw_loc_list_ref list)
14229 gcc_assert (!list->dw_loc_next || list->ll_symbol);
14230 return !list->ll_symbol;
14233 /* To each location in list LIST add loc descr REF. */
14236 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
14238 dw_loc_descr_ref copy;
14239 add_loc_descr (&list->expr, ref);
14240 list = list->dw_loc_next;
14243 copy = ggc_alloc<dw_loc_descr_node> ();
14244 memcpy (copy, ref, sizeof (dw_loc_descr_node));
14245 add_loc_descr (&list->expr, copy);
14246 while (copy->dw_loc_next)
14248 dw_loc_descr_ref new_copy = ggc_alloc<dw_loc_descr_node> ();
14249 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
14250 copy->dw_loc_next = new_copy;
14253 list = list->dw_loc_next;
14257 /* Given two lists RET and LIST
14258 produce location list that is result of adding expression in LIST
14259 to expression in RET on each position in program.
14260 Might be destructive on both RET and LIST.
14262 TODO: We handle only simple cases of RET or LIST having at most one
14263 element. General case would inolve sorting the lists in program order
14264 and merging them that will need some additional work.
14265 Adding that will improve quality of debug info especially for SRA-ed
14269 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
14278 if (!list->dw_loc_next)
14280 add_loc_descr_to_each (*ret, list->expr);
14283 if (!(*ret)->dw_loc_next)
14285 add_loc_descr_to_each (list, (*ret)->expr);
14289 expansion_failed (NULL_TREE, NULL_RTX,
14290 "Don't know how to merge two non-trivial"
14291 " location lists.\n");
14296 /* LOC is constant expression. Try a luck, look it up in constant
14297 pool and return its loc_descr of its address. */
14299 static dw_loc_descr_ref
14300 cst_pool_loc_descr (tree loc)
14302 /* Get an RTL for this, if something has been emitted. */
14303 rtx rtl = lookup_constant_def (loc);
14305 if (!rtl || !MEM_P (rtl))
14310 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
14312 /* TODO: We might get more coverage if we was actually delaying expansion
14313 of all expressions till end of compilation when constant pools are fully
14315 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
14317 expansion_failed (loc, NULL_RTX,
14318 "CST value in contant pool but not marked.");
14321 return mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
14322 GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED);
14325 /* Return dw_loc_list representing address of addr_expr LOC
14326 by looking for inner INDIRECT_REF expression and turning
14327 it into simple arithmetics.
14329 See loc_list_from_tree for the meaning of CONTEXT. */
14331 static dw_loc_list_ref
14332 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev,
14333 const loc_descr_context *context)
14336 HOST_WIDE_INT bitsize, bitpos, bytepos;
14338 int unsignedp, volatilep = 0;
14339 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14341 obj = get_inner_reference (TREE_OPERAND (loc, 0),
14342 &bitsize, &bitpos, &offset, &mode,
14343 &unsignedp, &volatilep, false);
14345 if (bitpos % BITS_PER_UNIT)
14347 expansion_failed (loc, NULL_RTX, "bitfield access");
14350 if (!INDIRECT_REF_P (obj))
14352 expansion_failed (obj,
14353 NULL_RTX, "no indirect ref in inner refrence");
14356 if (!offset && !bitpos)
14357 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1,
14360 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
14361 && (dwarf_version >= 4 || !dwarf_strict))
14363 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0, context);
14368 /* Variable offset. */
14369 list_ret1 = loc_list_from_tree (offset, 0, context);
14370 if (list_ret1 == 0)
14372 add_loc_list (&list_ret, list_ret1);
14375 add_loc_descr_to_each (list_ret,
14376 new_loc_descr (DW_OP_plus, 0, 0));
14378 bytepos = bitpos / BITS_PER_UNIT;
14380 add_loc_descr_to_each (list_ret,
14381 new_loc_descr (DW_OP_plus_uconst,
14383 else if (bytepos < 0)
14384 loc_list_plus_const (list_ret, bytepos);
14385 add_loc_descr_to_each (list_ret,
14386 new_loc_descr (DW_OP_stack_value, 0, 0));
14392 /* Helper structure for location descriptions generation. */
14393 struct loc_descr_context
14395 /* The type that is implicitly referenced by DW_OP_push_object_address, or
14396 NULL_TREE if DW_OP_push_object_address in invalid for this location
14397 description. This is used when processing PLACEHOLDER_EXPR nodes. */
14399 /* The ..._DECL node that should be translated as a
14400 DW_OP_push_object_address operation. */
14404 /* Generate Dwarf location list representing LOC.
14405 If WANT_ADDRESS is false, expression computing LOC will be computed
14406 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14407 if WANT_ADDRESS is 2, expression computing address useable in location
14408 will be returned (i.e. DW_OP_reg can be used
14409 to refer to register values).
14411 CONTEXT provides information to customize the location descriptions
14412 generation. Its context_type field specifies what type is implicitly
14413 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
14414 will not be generated.
14416 If CONTEXT is NULL, the behavior is the same as if both context_type and
14417 base_decl fields were NULL_TREE. */
14419 static dw_loc_list_ref
14420 loc_list_from_tree (tree loc, int want_address,
14421 const struct loc_descr_context *context)
14423 dw_loc_descr_ref ret = NULL, ret1 = NULL;
14424 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14425 int have_address = 0;
14426 enum dwarf_location_atom op;
14428 /* ??? Most of the time we do not take proper care for sign/zero
14429 extending the values properly. Hopefully this won't be a real
14432 if (context != NULL
14433 && context->base_decl == loc
14434 && want_address == 0)
14436 if (dwarf_version >= 3 || !dwarf_strict)
14437 return new_loc_list (new_loc_descr (DW_OP_push_object_address, 0, 0),
14443 switch (TREE_CODE (loc))
14446 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
14449 case PLACEHOLDER_EXPR:
14450 /* This case involves extracting fields from an object to determine the
14451 position of other fields. It is supposed to appear only as the first
14452 operand of COMPONENT_REF nodes and to reference precisely the type
14453 that the context allows. */
14454 if (context != NULL
14455 && TREE_TYPE (loc) == context->context_type
14456 && want_address >= 1)
14458 if (dwarf_version >= 3 || !dwarf_strict)
14460 ret = new_loc_descr (DW_OP_push_object_address, 0, 0);
14468 expansion_failed (loc, NULL_RTX,
14469 "PLACEHOLDER_EXPR for an unexpected type");
14473 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
14474 /* There are no opcodes for these operations. */
14477 case PREINCREMENT_EXPR:
14478 case PREDECREMENT_EXPR:
14479 case POSTINCREMENT_EXPR:
14480 case POSTDECREMENT_EXPR:
14481 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
14482 /* There are no opcodes for these operations. */
14486 /* If we already want an address, see if there is INDIRECT_REF inside
14487 e.g. for &this->field. */
14490 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
14491 (loc, want_address == 2, context);
14494 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
14495 && (ret = cst_pool_loc_descr (loc)))
14498 /* Otherwise, process the argument and look for the address. */
14499 if (!list_ret && !ret)
14500 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1, context);
14504 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
14510 if (DECL_THREAD_LOCAL_P (loc))
14513 enum dwarf_location_atom tls_op;
14514 enum dtprel_bool dtprel = dtprel_false;
14516 if (targetm.have_tls)
14518 /* If this is not defined, we have no way to emit the
14520 if (!targetm.asm_out.output_dwarf_dtprel)
14523 /* The way DW_OP_GNU_push_tls_address is specified, we
14524 can only look up addresses of objects in the current
14525 module. We used DW_OP_addr as first op, but that's
14526 wrong, because DW_OP_addr is relocated by the debug
14527 info consumer, while DW_OP_GNU_push_tls_address
14528 operand shouldn't be. */
14529 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
14531 dtprel = dtprel_true;
14532 tls_op = DW_OP_GNU_push_tls_address;
14536 if (!targetm.emutls.debug_form_tls_address
14537 || !(dwarf_version >= 3 || !dwarf_strict))
14539 /* We stuffed the control variable into the DECL_VALUE_EXPR
14540 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
14541 no longer appear in gimple code. We used the control
14542 variable in specific so that we could pick it up here. */
14543 loc = DECL_VALUE_EXPR (loc);
14544 tls_op = DW_OP_form_tls_address;
14547 rtl = rtl_for_decl_location (loc);
14548 if (rtl == NULL_RTX)
14553 rtl = XEXP (rtl, 0);
14554 if (! CONSTANT_P (rtl))
14557 ret = new_addr_loc_descr (rtl, dtprel);
14558 ret1 = new_loc_descr (tls_op, 0, 0);
14559 add_loc_descr (&ret, ret1);
14568 if (DECL_HAS_VALUE_EXPR_P (loc))
14569 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
14570 want_address, context);
14573 case FUNCTION_DECL:
14576 var_loc_list *loc_list = lookup_decl_loc (loc);
14578 if (loc_list && loc_list->first)
14580 list_ret = dw_loc_list (loc_list, loc, want_address);
14581 have_address = want_address != 0;
14584 rtl = rtl_for_decl_location (loc);
14585 if (rtl == NULL_RTX)
14587 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
14590 else if (CONST_INT_P (rtl))
14592 HOST_WIDE_INT val = INTVAL (rtl);
14593 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14594 val &= GET_MODE_MASK (DECL_MODE (loc));
14595 ret = int_loc_descriptor (val);
14597 else if (GET_CODE (rtl) == CONST_STRING)
14599 expansion_failed (loc, NULL_RTX, "CONST_STRING");
14602 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
14603 ret = new_addr_loc_descr (rtl, dtprel_false);
14606 machine_mode mode, mem_mode;
14608 /* Certain constructs can only be represented at top-level. */
14609 if (want_address == 2)
14611 ret = loc_descriptor (rtl, VOIDmode,
14612 VAR_INIT_STATUS_INITIALIZED);
14617 mode = GET_MODE (rtl);
14618 mem_mode = VOIDmode;
14622 mode = get_address_mode (rtl);
14623 rtl = XEXP (rtl, 0);
14626 ret = mem_loc_descriptor (rtl, mode, mem_mode,
14627 VAR_INIT_STATUS_INITIALIZED);
14630 expansion_failed (loc, rtl,
14631 "failed to produce loc descriptor for rtl");
14637 if (!integer_zerop (TREE_OPERAND (loc, 1)))
14644 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14648 case TARGET_MEM_REF:
14650 case DEBUG_EXPR_DECL:
14653 case COMPOUND_EXPR:
14654 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address, context);
14657 case VIEW_CONVERT_EXPR:
14660 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address, context);
14662 case COMPONENT_REF:
14663 case BIT_FIELD_REF:
14665 case ARRAY_RANGE_REF:
14666 case REALPART_EXPR:
14667 case IMAGPART_EXPR:
14670 HOST_WIDE_INT bitsize, bitpos, bytepos;
14672 int unsignedp, volatilep = 0;
14674 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
14675 &unsignedp, &volatilep, false);
14677 gcc_assert (obj != loc);
14679 list_ret = loc_list_from_tree (obj,
14681 && !bitpos && !offset ? 2 : 1,
14683 /* TODO: We can extract value of the small expression via shifting even
14684 for nonzero bitpos. */
14687 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
14689 expansion_failed (loc, NULL_RTX,
14690 "bitfield access");
14694 if (offset != NULL_TREE)
14696 /* Variable offset. */
14697 list_ret1 = loc_list_from_tree (offset, 0, context);
14698 if (list_ret1 == 0)
14700 add_loc_list (&list_ret, list_ret1);
14703 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
14706 bytepos = bitpos / BITS_PER_UNIT;
14708 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
14709 else if (bytepos < 0)
14710 loc_list_plus_const (list_ret, bytepos);
14717 if ((want_address || !tree_fits_shwi_p (loc))
14718 && (ret = cst_pool_loc_descr (loc)))
14720 else if (want_address == 2
14721 && tree_fits_shwi_p (loc)
14722 && (ret = address_of_int_loc_descriptor
14723 (int_size_in_bytes (TREE_TYPE (loc)),
14724 tree_to_shwi (loc))))
14726 else if (tree_fits_shwi_p (loc))
14727 ret = int_loc_descriptor (tree_to_shwi (loc));
14730 expansion_failed (loc, NULL_RTX,
14731 "Integer operand is not host integer");
14740 if ((ret = cst_pool_loc_descr (loc)))
14743 /* We can construct small constants here using int_loc_descriptor. */
14744 expansion_failed (loc, NULL_RTX,
14745 "constructor or constant not in constant pool");
14748 case TRUTH_AND_EXPR:
14749 case TRUTH_ANDIF_EXPR:
14754 case TRUTH_XOR_EXPR:
14759 case TRUTH_OR_EXPR:
14760 case TRUTH_ORIF_EXPR:
14765 case FLOOR_DIV_EXPR:
14766 case CEIL_DIV_EXPR:
14767 case ROUND_DIV_EXPR:
14768 case TRUNC_DIV_EXPR:
14769 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14778 case FLOOR_MOD_EXPR:
14779 case CEIL_MOD_EXPR:
14780 case ROUND_MOD_EXPR:
14781 case TRUNC_MOD_EXPR:
14782 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14787 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14788 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context);
14789 if (list_ret == 0 || list_ret1 == 0)
14792 add_loc_list (&list_ret, list_ret1);
14795 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
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_div, 0, 0));
14798 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
14799 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
14811 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
14814 case POINTER_PLUS_EXPR:
14817 if (tree_fits_shwi_p (TREE_OPERAND (loc, 1)))
14819 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14823 loc_list_plus_const (list_ret, tree_to_shwi (TREE_OPERAND (loc, 1)));
14831 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14838 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14845 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14852 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14867 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14868 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context);
14869 if (list_ret == 0 || list_ret1 == 0)
14872 add_loc_list (&list_ret, list_ret1);
14875 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14878 case TRUTH_NOT_EXPR:
14892 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14896 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14902 const enum tree_code code =
14903 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
14905 loc = build3 (COND_EXPR, TREE_TYPE (loc),
14906 build2 (code, integer_type_node,
14907 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
14908 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
14911 /* ... fall through ... */
14915 dw_loc_descr_ref lhs
14916 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0, context);
14917 dw_loc_list_ref rhs
14918 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0, context);
14919 dw_loc_descr_ref bra_node, jump_node, tmp;
14921 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
14922 if (list_ret == 0 || lhs == 0 || rhs == 0)
14925 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14926 add_loc_descr_to_each (list_ret, bra_node);
14928 add_loc_list (&list_ret, rhs);
14929 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
14930 add_loc_descr_to_each (list_ret, jump_node);
14932 add_loc_descr_to_each (list_ret, lhs);
14933 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14934 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
14936 /* ??? Need a node to point the skip at. Use a nop. */
14937 tmp = new_loc_descr (DW_OP_nop, 0, 0);
14938 add_loc_descr_to_each (list_ret, tmp);
14939 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14940 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
14944 case FIX_TRUNC_EXPR:
14948 /* Leave front-end specific codes as simply unknown. This comes
14949 up, for instance, with the C STMT_EXPR. */
14950 if ((unsigned int) TREE_CODE (loc)
14951 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
14953 expansion_failed (loc, NULL_RTX,
14954 "language specific tree node");
14958 #ifdef ENABLE_CHECKING
14959 /* Otherwise this is a generic code; we should just lists all of
14960 these explicitly. We forgot one. */
14961 gcc_unreachable ();
14963 /* In a release build, we want to degrade gracefully: better to
14964 generate incomplete debugging information than to crash. */
14969 if (!ret && !list_ret)
14972 if (want_address == 2 && !have_address
14973 && (dwarf_version >= 4 || !dwarf_strict))
14975 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
14977 expansion_failed (loc, NULL_RTX,
14978 "DWARF address size mismatch");
14982 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
14984 add_loc_descr_to_each (list_ret,
14985 new_loc_descr (DW_OP_stack_value, 0, 0));
14988 /* Show if we can't fill the request for an address. */
14989 if (want_address && !have_address)
14991 expansion_failed (loc, NULL_RTX,
14992 "Want address and only have value");
14996 gcc_assert (!ret || !list_ret);
14998 /* If we've got an address and don't want one, dereference. */
14999 if (!want_address && have_address)
15001 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
15003 if (size > DWARF2_ADDR_SIZE || size == -1)
15005 expansion_failed (loc, NULL_RTX,
15006 "DWARF address size mismatch");
15009 else if (size == DWARF2_ADDR_SIZE)
15012 op = DW_OP_deref_size;
15015 add_loc_descr (&ret, new_loc_descr (op, size, 0));
15017 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
15020 list_ret = new_loc_list (ret, NULL, NULL, NULL);
15025 /* Same as above but return only single location expression. */
15026 static dw_loc_descr_ref
15027 loc_descriptor_from_tree (tree loc, int want_address,
15028 const struct loc_descr_context *context)
15030 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address, context);
15033 if (ret->dw_loc_next)
15035 expansion_failed (loc, NULL_RTX,
15036 "Location list where only loc descriptor needed");
15042 /* Given a value, round it up to the lowest multiple of `boundary'
15043 which is not less than the value itself. */
15045 static inline HOST_WIDE_INT
15046 ceiling (HOST_WIDE_INT value, unsigned int boundary)
15048 return (((value + boundary - 1) / boundary) * boundary);
15051 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
15052 pointer to the declared type for the relevant field variable, or return
15053 `integer_type_node' if the given node turns out to be an
15054 ERROR_MARK node. */
15057 field_type (const_tree decl)
15061 if (TREE_CODE (decl) == ERROR_MARK)
15062 return integer_type_node;
15064 type = DECL_BIT_FIELD_TYPE (decl);
15065 if (type == NULL_TREE)
15066 type = TREE_TYPE (decl);
15071 /* Given a pointer to a tree node, return the alignment in bits for
15072 it, or else return BITS_PER_WORD if the node actually turns out to
15073 be an ERROR_MARK node. */
15075 static inline unsigned
15076 simple_type_align_in_bits (const_tree type)
15078 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
15081 static inline unsigned
15082 simple_decl_align_in_bits (const_tree decl)
15084 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
15087 /* Return the result of rounding T up to ALIGN. */
15089 static inline offset_int
15090 round_up_to_align (const offset_int &t, unsigned int align)
15092 return wi::udiv_trunc (t + align - 1, align) * align;
15095 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
15096 lowest addressed byte of the "containing object" for the given FIELD_DECL,
15097 or return 0 if we are unable to determine what that offset is, either
15098 because the argument turns out to be a pointer to an ERROR_MARK node, or
15099 because the offset is actually variable. (We can't handle the latter case
15102 static HOST_WIDE_INT
15103 field_byte_offset (const_tree decl)
15105 offset_int object_offset_in_bits;
15106 offset_int object_offset_in_bytes;
15107 offset_int bitpos_int;
15109 if (TREE_CODE (decl) == ERROR_MARK)
15112 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
15114 /* We cannot yet cope with fields whose positions are variable, so
15115 for now, when we see such things, we simply return 0. Someday, we may
15116 be able to handle such cases, but it will be damn difficult. */
15117 if (TREE_CODE (bit_position (decl)) != INTEGER_CST)
15120 bitpos_int = wi::to_offset (bit_position (decl));
15122 #ifdef PCC_BITFIELD_TYPE_MATTERS
15123 if (PCC_BITFIELD_TYPE_MATTERS)
15126 tree field_size_tree;
15127 offset_int deepest_bitpos;
15128 offset_int field_size_in_bits;
15129 unsigned int type_align_in_bits;
15130 unsigned int decl_align_in_bits;
15131 offset_int type_size_in_bits;
15133 type = field_type (decl);
15134 type_size_in_bits = offset_int_type_size_in_bits (type);
15135 type_align_in_bits = simple_type_align_in_bits (type);
15137 field_size_tree = DECL_SIZE (decl);
15139 /* The size could be unspecified if there was an error, or for
15140 a flexible array member. */
15141 if (!field_size_tree)
15142 field_size_tree = bitsize_zero_node;
15144 /* If the size of the field is not constant, use the type size. */
15145 if (TREE_CODE (field_size_tree) == INTEGER_CST)
15146 field_size_in_bits = wi::to_offset (field_size_tree);
15148 field_size_in_bits = type_size_in_bits;
15150 decl_align_in_bits = simple_decl_align_in_bits (decl);
15152 /* The GCC front-end doesn't make any attempt to keep track of the
15153 starting bit offset (relative to the start of the containing
15154 structure type) of the hypothetical "containing object" for a
15155 bit-field. Thus, when computing the byte offset value for the
15156 start of the "containing object" of a bit-field, we must deduce
15157 this information on our own. This can be rather tricky to do in
15158 some cases. For example, handling the following structure type
15159 definition when compiling for an i386/i486 target (which only
15160 aligns long long's to 32-bit boundaries) can be very tricky:
15162 struct S { int field1; long long field2:31; };
15164 Fortunately, there is a simple rule-of-thumb which can be used
15165 in such cases. When compiling for an i386/i486, GCC will
15166 allocate 8 bytes for the structure shown above. It decides to
15167 do this based upon one simple rule for bit-field allocation.
15168 GCC allocates each "containing object" for each bit-field at
15169 the first (i.e. lowest addressed) legitimate alignment boundary
15170 (based upon the required minimum alignment for the declared
15171 type of the field) which it can possibly use, subject to the
15172 condition that there is still enough available space remaining
15173 in the containing object (when allocated at the selected point)
15174 to fully accommodate all of the bits of the bit-field itself.
15176 This simple rule makes it obvious why GCC allocates 8 bytes for
15177 each object of the structure type shown above. When looking
15178 for a place to allocate the "containing object" for `field2',
15179 the compiler simply tries to allocate a 64-bit "containing
15180 object" at each successive 32-bit boundary (starting at zero)
15181 until it finds a place to allocate that 64- bit field such that
15182 at least 31 contiguous (and previously unallocated) bits remain
15183 within that selected 64 bit field. (As it turns out, for the
15184 example above, the compiler finds it is OK to allocate the
15185 "containing object" 64-bit field at bit-offset zero within the
15188 Here we attempt to work backwards from the limited set of facts
15189 we're given, and we try to deduce from those facts, where GCC
15190 must have believed that the containing object started (within
15191 the structure type). The value we deduce is then used (by the
15192 callers of this routine) to generate DW_AT_location and
15193 DW_AT_bit_offset attributes for fields (both bit-fields and, in
15194 the case of DW_AT_location, regular fields as well). */
15196 /* Figure out the bit-distance from the start of the structure to
15197 the "deepest" bit of the bit-field. */
15198 deepest_bitpos = bitpos_int + field_size_in_bits;
15200 /* This is the tricky part. Use some fancy footwork to deduce
15201 where the lowest addressed bit of the containing object must
15203 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15205 /* Round up to type_align by default. This works best for
15207 object_offset_in_bits
15208 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
15210 if (wi::gtu_p (object_offset_in_bits, bitpos_int))
15212 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15214 /* Round up to decl_align instead. */
15215 object_offset_in_bits
15216 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
15220 #endif /* PCC_BITFIELD_TYPE_MATTERS */
15221 object_offset_in_bits = bitpos_int;
15223 object_offset_in_bytes
15224 = wi::lrshift (object_offset_in_bits, LOG2_BITS_PER_UNIT);
15225 return object_offset_in_bytes.to_shwi ();
15228 /* The following routines define various Dwarf attributes and any data
15229 associated with them. */
15231 /* Add a location description attribute value to a DIE.
15233 This emits location attributes suitable for whole variables and
15234 whole parameters. Note that the location attributes for struct fields are
15235 generated by the routine `data_member_location_attribute' below. */
15238 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
15239 dw_loc_list_ref descr)
15243 if (single_element_loc_list_p (descr))
15244 add_AT_loc (die, attr_kind, descr->expr);
15246 add_AT_loc_list (die, attr_kind, descr);
15249 /* Add DW_AT_accessibility attribute to DIE if needed. */
15252 add_accessibility_attribute (dw_die_ref die, tree decl)
15254 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
15255 children, otherwise the default is DW_ACCESS_public. In DWARF2
15256 the default has always been DW_ACCESS_public. */
15257 if (TREE_PROTECTED (decl))
15258 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
15259 else if (TREE_PRIVATE (decl))
15261 if (dwarf_version == 2
15262 || die->die_parent == NULL
15263 || die->die_parent->die_tag != DW_TAG_class_type)
15264 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
15266 else if (dwarf_version > 2
15268 && die->die_parent->die_tag == DW_TAG_class_type)
15269 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
15272 /* Attach the specialized form of location attribute used for data members of
15273 struct and union types. In the special case of a FIELD_DECL node which
15274 represents a bit-field, the "offset" part of this special location
15275 descriptor must indicate the distance in bytes from the lowest-addressed
15276 byte of the containing struct or union type to the lowest-addressed byte of
15277 the "containing object" for the bit-field. (See the `field_byte_offset'
15280 For any given bit-field, the "containing object" is a hypothetical object
15281 (of some integral or enum type) within which the given bit-field lives. The
15282 type of this hypothetical "containing object" is always the same as the
15283 declared type of the individual bit-field itself (for GCC anyway... the
15284 DWARF spec doesn't actually mandate this). Note that it is the size (in
15285 bytes) of the hypothetical "containing object" which will be given in the
15286 DW_AT_byte_size attribute for this bit-field. (See the
15287 `byte_size_attribute' function below.) It is also used when calculating the
15288 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15289 function below.) */
15292 add_data_member_location_attribute (dw_die_ref die, tree decl)
15294 HOST_WIDE_INT offset;
15295 dw_loc_descr_ref loc_descr = 0;
15297 if (TREE_CODE (decl) == TREE_BINFO)
15299 /* We're working on the TAG_inheritance for a base class. */
15300 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
15302 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15303 aren't at a fixed offset from all (sub)objects of the same
15304 type. We need to extract the appropriate offset from our
15305 vtable. The following dwarf expression means
15307 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15309 This is specific to the V3 ABI, of course. */
15311 dw_loc_descr_ref tmp;
15313 /* Make a copy of the object address. */
15314 tmp = new_loc_descr (DW_OP_dup, 0, 0);
15315 add_loc_descr (&loc_descr, tmp);
15317 /* Extract the vtable address. */
15318 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15319 add_loc_descr (&loc_descr, tmp);
15321 /* Calculate the address of the offset. */
15322 offset = tree_to_shwi (BINFO_VPTR_FIELD (decl));
15323 gcc_assert (offset < 0);
15325 tmp = int_loc_descriptor (-offset);
15326 add_loc_descr (&loc_descr, tmp);
15327 tmp = new_loc_descr (DW_OP_minus, 0, 0);
15328 add_loc_descr (&loc_descr, tmp);
15330 /* Extract the offset. */
15331 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15332 add_loc_descr (&loc_descr, tmp);
15334 /* Add it to the object address. */
15335 tmp = new_loc_descr (DW_OP_plus, 0, 0);
15336 add_loc_descr (&loc_descr, tmp);
15339 offset = tree_to_shwi (BINFO_OFFSET (decl));
15342 offset = field_byte_offset (decl);
15346 if (dwarf_version > 2)
15348 /* Don't need to output a location expression, just the constant. */
15350 add_AT_int (die, DW_AT_data_member_location, offset);
15352 add_AT_unsigned (die, DW_AT_data_member_location, offset);
15357 enum dwarf_location_atom op;
15359 /* The DWARF2 standard says that we should assume that the structure
15360 address is already on the stack, so we can specify a structure
15361 field address by using DW_OP_plus_uconst. */
15362 op = DW_OP_plus_uconst;
15363 loc_descr = new_loc_descr (op, offset, 0);
15367 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
15370 /* Writes integer values to dw_vec_const array. */
15373 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
15377 *dest++ = val & 0xff;
15383 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15385 static HOST_WIDE_INT
15386 extract_int (const unsigned char *src, unsigned int size)
15388 HOST_WIDE_INT val = 0;
15394 val |= *--src & 0xff;
15400 /* Writes wide_int values to dw_vec_const array. */
15403 insert_wide_int (const wide_int &val, unsigned char *dest, int elt_size)
15407 if (elt_size <= HOST_BITS_PER_WIDE_INT/BITS_PER_UNIT)
15409 insert_int ((HOST_WIDE_INT) val.elt (0), elt_size, dest);
15413 /* We'd have to extend this code to support odd sizes. */
15414 gcc_assert (elt_size % (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT) == 0);
15416 int n = elt_size / (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
15418 if (WORDS_BIG_ENDIAN)
15419 for (i = n - 1; i >= 0; i--)
15421 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
15422 dest += sizeof (HOST_WIDE_INT);
15425 for (i = 0; i < n; i++)
15427 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
15428 dest += sizeof (HOST_WIDE_INT);
15432 /* Writes floating point values to dw_vec_const array. */
15435 insert_float (const_rtx rtl, unsigned char *array)
15437 REAL_VALUE_TYPE rv;
15441 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
15442 real_to_target (val, &rv, GET_MODE (rtl));
15444 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15445 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
15447 insert_int (val[i], 4, array);
15452 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15453 does not have a "location" either in memory or in a register. These
15454 things can arise in GNU C when a constant is passed as an actual parameter
15455 to an inlined function. They can also arise in C++ where declared
15456 constants do not necessarily get memory "homes". */
15459 add_const_value_attribute (dw_die_ref die, rtx rtl)
15461 switch (GET_CODE (rtl))
15465 HOST_WIDE_INT val = INTVAL (rtl);
15468 add_AT_int (die, DW_AT_const_value, val);
15470 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
15474 case CONST_WIDE_INT:
15476 wide_int w1 = std::make_pair (rtl, MAX_MODE_INT);
15477 unsigned int prec = MIN (wi::min_precision (w1, UNSIGNED),
15478 (unsigned int)CONST_WIDE_INT_NUNITS (rtl) * HOST_BITS_PER_WIDE_INT);
15479 wide_int w = wi::zext (w1, prec);
15480 add_AT_wide (die, DW_AT_const_value, w);
15485 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15486 floating-point constant. A CONST_DOUBLE is used whenever the
15487 constant requires more than one word in order to be adequately
15490 machine_mode mode = GET_MODE (rtl);
15492 if (TARGET_SUPPORTS_WIDE_INT == 0 && !SCALAR_FLOAT_MODE_P (mode))
15493 add_AT_double (die, DW_AT_const_value,
15494 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
15497 unsigned int length = GET_MODE_SIZE (mode);
15498 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
15500 insert_float (rtl, array);
15501 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
15508 machine_mode mode = GET_MODE (rtl);
15509 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
15510 unsigned int length = CONST_VECTOR_NUNITS (rtl);
15511 unsigned char *array
15512 = ggc_vec_alloc<unsigned char> (length * elt_size);
15515 machine_mode imode = GET_MODE_INNER (mode);
15517 switch (GET_MODE_CLASS (mode))
15519 case MODE_VECTOR_INT:
15520 for (i = 0, p = array; i < length; i++, p += elt_size)
15522 rtx elt = CONST_VECTOR_ELT (rtl, i);
15523 insert_wide_int (std::make_pair (elt, imode), p, elt_size);
15527 case MODE_VECTOR_FLOAT:
15528 for (i = 0, p = array; i < length; i++, p += elt_size)
15530 rtx elt = CONST_VECTOR_ELT (rtl, i);
15531 insert_float (elt, p);
15536 gcc_unreachable ();
15539 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
15544 if (dwarf_version >= 4 || !dwarf_strict)
15546 dw_loc_descr_ref loc_result;
15547 resolve_one_addr (&rtl);
15549 loc_result = new_addr_loc_descr (rtl, dtprel_false);
15550 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
15551 add_AT_loc (die, DW_AT_location, loc_result);
15552 vec_safe_push (used_rtx_array, rtl);
15558 if (CONSTANT_P (XEXP (rtl, 0)))
15559 return add_const_value_attribute (die, XEXP (rtl, 0));
15562 if (!const_ok_for_output (rtl))
15565 if (dwarf_version >= 4 || !dwarf_strict)
15570 /* In cases where an inlined instance of an inline function is passed
15571 the address of an `auto' variable (which is local to the caller) we
15572 can get a situation where the DECL_RTL of the artificial local
15573 variable (for the inlining) which acts as a stand-in for the
15574 corresponding formal parameter (of the inline function) will look
15575 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15576 exactly a compile-time constant expression, but it isn't the address
15577 of the (artificial) local variable either. Rather, it represents the
15578 *value* which the artificial local variable always has during its
15579 lifetime. We currently have no way to represent such quasi-constant
15580 values in Dwarf, so for now we just punt and generate nothing. */
15588 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
15589 && MEM_READONLY_P (rtl)
15590 && GET_MODE (rtl) == BLKmode)
15592 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
15598 /* No other kinds of rtx should be possible here. */
15599 gcc_unreachable ();
15604 /* Determine whether the evaluation of EXPR references any variables
15605 or functions which aren't otherwise used (and therefore may not be
15608 reference_to_unused (tree * tp, int * walk_subtrees,
15609 void * data ATTRIBUTE_UNUSED)
15611 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
15612 *walk_subtrees = 0;
15614 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
15615 && ! TREE_ASM_WRITTEN (*tp))
15617 /* ??? The C++ FE emits debug information for using decls, so
15618 putting gcc_unreachable here falls over. See PR31899. For now
15619 be conservative. */
15620 else if (!symtab->global_info_ready
15621 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
15623 else if (TREE_CODE (*tp) == VAR_DECL)
15625 varpool_node *node = varpool_node::get (*tp);
15626 if (!node || !node->definition)
15629 else if (TREE_CODE (*tp) == FUNCTION_DECL
15630 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
15632 /* The call graph machinery must have finished analyzing,
15633 optimizing and gimplifying the CU by now.
15634 So if *TP has no call graph node associated
15635 to it, it means *TP will not be emitted. */
15636 if (!cgraph_node::get (*tp))
15639 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
15645 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15646 for use in a later add_const_value_attribute call. */
15649 rtl_for_decl_init (tree init, tree type)
15651 rtx rtl = NULL_RTX;
15655 /* If a variable is initialized with a string constant without embedded
15656 zeros, build CONST_STRING. */
15657 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
15659 tree enttype = TREE_TYPE (type);
15660 tree domain = TYPE_DOMAIN (type);
15661 machine_mode mode = TYPE_MODE (enttype);
15663 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
15665 && integer_zerop (TYPE_MIN_VALUE (domain))
15666 && compare_tree_int (TYPE_MAX_VALUE (domain),
15667 TREE_STRING_LENGTH (init) - 1) == 0
15668 && ((size_t) TREE_STRING_LENGTH (init)
15669 == strlen (TREE_STRING_POINTER (init)) + 1))
15671 rtl = gen_rtx_CONST_STRING (VOIDmode,
15672 ggc_strdup (TREE_STRING_POINTER (init)));
15673 rtl = gen_rtx_MEM (BLKmode, rtl);
15674 MEM_READONLY_P (rtl) = 1;
15677 /* Other aggregates, and complex values, could be represented using
15679 else if (AGGREGATE_TYPE_P (type)
15680 || (TREE_CODE (init) == VIEW_CONVERT_EXPR
15681 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init, 0))))
15682 || TREE_CODE (type) == COMPLEX_TYPE)
15684 /* Vectors only work if their mode is supported by the target.
15685 FIXME: generic vectors ought to work too. */
15686 else if (TREE_CODE (type) == VECTOR_TYPE
15687 && !VECTOR_MODE_P (TYPE_MODE (type)))
15689 /* If the initializer is something that we know will expand into an
15690 immediate RTL constant, expand it now. We must be careful not to
15691 reference variables which won't be output. */
15692 else if (initializer_constant_valid_p (init, type)
15693 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
15695 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15697 if (TREE_CODE (type) == VECTOR_TYPE)
15698 switch (TREE_CODE (init))
15703 if (TREE_CONSTANT (init))
15705 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (init);
15706 bool constant_p = true;
15708 unsigned HOST_WIDE_INT ix;
15710 /* Even when ctor is constant, it might contain non-*_CST
15711 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15712 belong into VECTOR_CST nodes. */
15713 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
15714 if (!CONSTANT_CLASS_P (value))
15716 constant_p = false;
15722 init = build_vector_from_ctor (type, elts);
15732 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
15734 /* If expand_expr returns a MEM, it wasn't immediate. */
15735 gcc_assert (!rtl || !MEM_P (rtl));
15741 /* Generate RTL for the variable DECL to represent its location. */
15744 rtl_for_decl_location (tree decl)
15748 /* Here we have to decide where we are going to say the parameter "lives"
15749 (as far as the debugger is concerned). We only have a couple of
15750 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15752 DECL_RTL normally indicates where the parameter lives during most of the
15753 activation of the function. If optimization is enabled however, this
15754 could be either NULL or else a pseudo-reg. Both of those cases indicate
15755 that the parameter doesn't really live anywhere (as far as the code
15756 generation parts of GCC are concerned) during most of the function's
15757 activation. That will happen (for example) if the parameter is never
15758 referenced within the function.
15760 We could just generate a location descriptor here for all non-NULL
15761 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15762 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15763 where DECL_RTL is NULL or is a pseudo-reg.
15765 Note however that we can only get away with using DECL_INCOMING_RTL as
15766 a backup substitute for DECL_RTL in certain limited cases. In cases
15767 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15768 we can be sure that the parameter was passed using the same type as it is
15769 declared to have within the function, and that its DECL_INCOMING_RTL
15770 points us to a place where a value of that type is passed.
15772 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15773 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15774 because in these cases DECL_INCOMING_RTL points us to a value of some
15775 type which is *different* from the type of the parameter itself. Thus,
15776 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15777 such cases, the debugger would end up (for example) trying to fetch a
15778 `float' from a place which actually contains the first part of a
15779 `double'. That would lead to really incorrect and confusing
15780 output at debug-time.
15782 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15783 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15784 are a couple of exceptions however. On little-endian machines we can
15785 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15786 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15787 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15788 when (on a little-endian machine) a non-prototyped function has a
15789 parameter declared to be of type `short' or `char'. In such cases,
15790 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15791 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15792 passed `int' value. If the debugger then uses that address to fetch
15793 a `short' or a `char' (on a little-endian machine) the result will be
15794 the correct data, so we allow for such exceptional cases below.
15796 Note that our goal here is to describe the place where the given formal
15797 parameter lives during most of the function's activation (i.e. between the
15798 end of the prologue and the start of the epilogue). We'll do that as best
15799 as we can. Note however that if the given formal parameter is modified
15800 sometime during the execution of the function, then a stack backtrace (at
15801 debug-time) will show the function as having been called with the *new*
15802 value rather than the value which was originally passed in. This happens
15803 rarely enough that it is not a major problem, but it *is* a problem, and
15804 I'd like to fix it.
15806 A future version of dwarf2out.c may generate two additional attributes for
15807 any given DW_TAG_formal_parameter DIE which will describe the "passed
15808 type" and the "passed location" for the given formal parameter in addition
15809 to the attributes we now generate to indicate the "declared type" and the
15810 "active location" for each parameter. This additional set of attributes
15811 could be used by debuggers for stack backtraces. Separately, note that
15812 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15813 This happens (for example) for inlined-instances of inline function formal
15814 parameters which are never referenced. This really shouldn't be
15815 happening. All PARM_DECL nodes should get valid non-NULL
15816 DECL_INCOMING_RTL values. FIXME. */
15818 /* Use DECL_RTL as the "location" unless we find something better. */
15819 rtl = DECL_RTL_IF_SET (decl);
15821 /* When generating abstract instances, ignore everything except
15822 constants, symbols living in memory, and symbols living in
15823 fixed registers. */
15824 if (! reload_completed)
15827 && (CONSTANT_P (rtl)
15829 && CONSTANT_P (XEXP (rtl, 0)))
15831 && TREE_CODE (decl) == VAR_DECL
15832 && TREE_STATIC (decl))))
15834 rtl = targetm.delegitimize_address (rtl);
15839 else if (TREE_CODE (decl) == PARM_DECL)
15841 if (rtl == NULL_RTX
15842 || is_pseudo_reg (rtl)
15844 && is_pseudo_reg (XEXP (rtl, 0))
15845 && DECL_INCOMING_RTL (decl)
15846 && MEM_P (DECL_INCOMING_RTL (decl))
15847 && GET_MODE (rtl) == GET_MODE (DECL_INCOMING_RTL (decl))))
15849 tree declared_type = TREE_TYPE (decl);
15850 tree passed_type = DECL_ARG_TYPE (decl);
15851 machine_mode dmode = TYPE_MODE (declared_type);
15852 machine_mode pmode = TYPE_MODE (passed_type);
15854 /* This decl represents a formal parameter which was optimized out.
15855 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15856 all cases where (rtl == NULL_RTX) just below. */
15857 if (dmode == pmode)
15858 rtl = DECL_INCOMING_RTL (decl);
15859 else if ((rtl == NULL_RTX || is_pseudo_reg (rtl))
15860 && SCALAR_INT_MODE_P (dmode)
15861 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
15862 && DECL_INCOMING_RTL (decl))
15864 rtx inc = DECL_INCOMING_RTL (decl);
15867 else if (MEM_P (inc))
15869 if (BYTES_BIG_ENDIAN)
15870 rtl = adjust_address_nv (inc, dmode,
15871 GET_MODE_SIZE (pmode)
15872 - GET_MODE_SIZE (dmode));
15879 /* If the parm was passed in registers, but lives on the stack, then
15880 make a big endian correction if the mode of the type of the
15881 parameter is not the same as the mode of the rtl. */
15882 /* ??? This is the same series of checks that are made in dbxout.c before
15883 we reach the big endian correction code there. It isn't clear if all
15884 of these checks are necessary here, but keeping them all is the safe
15886 else if (MEM_P (rtl)
15887 && XEXP (rtl, 0) != const0_rtx
15888 && ! CONSTANT_P (XEXP (rtl, 0))
15889 /* Not passed in memory. */
15890 && !MEM_P (DECL_INCOMING_RTL (decl))
15891 /* Not passed by invisible reference. */
15892 && (!REG_P (XEXP (rtl, 0))
15893 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
15894 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
15895 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
15896 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
15899 /* Big endian correction check. */
15900 && BYTES_BIG_ENDIAN
15901 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
15902 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
15905 machine_mode addr_mode = get_address_mode (rtl);
15906 int offset = (UNITS_PER_WORD
15907 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
15909 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15910 plus_constant (addr_mode, XEXP (rtl, 0), offset));
15913 else if (TREE_CODE (decl) == VAR_DECL
15916 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
15917 && BYTES_BIG_ENDIAN)
15919 machine_mode addr_mode = get_address_mode (rtl);
15920 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
15921 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
15923 /* If a variable is declared "register" yet is smaller than
15924 a register, then if we store the variable to memory, it
15925 looks like we're storing a register-sized value, when in
15926 fact we are not. We need to adjust the offset of the
15927 storage location to reflect the actual value's bytes,
15928 else gdb will not be able to display it. */
15930 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15931 plus_constant (addr_mode, XEXP (rtl, 0),
15935 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15936 and will have been substituted directly into all expressions that use it.
15937 C does not have such a concept, but C++ and other languages do. */
15938 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
15939 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
15942 rtl = targetm.delegitimize_address (rtl);
15944 /* If we don't look past the constant pool, we risk emitting a
15945 reference to a constant pool entry that isn't referenced from
15946 code, and thus is not emitted. */
15948 rtl = avoid_constant_pool_reference (rtl);
15950 /* Try harder to get a rtl. If this symbol ends up not being emitted
15951 in the current CU, resolve_addr will remove the expression referencing
15953 if (rtl == NULL_RTX
15954 && TREE_CODE (decl) == VAR_DECL
15955 && !DECL_EXTERNAL (decl)
15956 && TREE_STATIC (decl)
15957 && DECL_NAME (decl)
15958 && !DECL_HARD_REGISTER (decl)
15959 && DECL_MODE (decl) != VOIDmode)
15961 rtl = make_decl_rtl_for_debug (decl);
15963 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
15964 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
15971 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15972 returned. If so, the decl for the COMMON block is returned, and the
15973 value is the offset into the common block for the symbol. */
15976 fortran_common (tree decl, HOST_WIDE_INT *value)
15978 tree val_expr, cvar;
15980 HOST_WIDE_INT bitsize, bitpos;
15982 int unsignedp, volatilep = 0;
15984 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15985 it does not have a value (the offset into the common area), or if it
15986 is thread local (as opposed to global) then it isn't common, and shouldn't
15987 be handled as such. */
15988 if (TREE_CODE (decl) != VAR_DECL
15989 || !TREE_STATIC (decl)
15990 || !DECL_HAS_VALUE_EXPR_P (decl)
15994 val_expr = DECL_VALUE_EXPR (decl);
15995 if (TREE_CODE (val_expr) != COMPONENT_REF)
15998 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
15999 &mode, &unsignedp, &volatilep, true);
16001 if (cvar == NULL_TREE
16002 || TREE_CODE (cvar) != VAR_DECL
16003 || DECL_ARTIFICIAL (cvar)
16004 || !TREE_PUBLIC (cvar))
16008 if (offset != NULL)
16010 if (!tree_fits_shwi_p (offset))
16012 *value = tree_to_shwi (offset);
16015 *value += bitpos / BITS_PER_UNIT;
16020 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
16021 data attribute for a variable or a parameter. We generate the
16022 DW_AT_const_value attribute only in those cases where the given variable
16023 or parameter does not have a true "location" either in memory or in a
16024 register. This can happen (for example) when a constant is passed as an
16025 actual argument in a call to an inline function. (It's possible that
16026 these things can crop up in other ways also.) Note that one type of
16027 constant value which can be passed into an inlined function is a constant
16028 pointer. This can happen for example if an actual argument in an inlined
16029 function call evaluates to a compile-time constant address.
16031 CACHE_P is true if it is worth caching the location list for DECL,
16032 so that future calls can reuse it rather than regenerate it from scratch.
16033 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
16034 since we will need to refer to them each time the function is inlined. */
16037 add_location_or_const_value_attribute (dw_die_ref die, tree decl, bool cache_p,
16038 enum dwarf_attribute attr)
16041 dw_loc_list_ref list;
16042 var_loc_list *loc_list;
16043 cached_dw_loc_list *cache;
16045 if (TREE_CODE (decl) == ERROR_MARK)
16048 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
16049 || TREE_CODE (decl) == RESULT_DECL);
16051 /* Try to get some constant RTL for this decl, and use that as the value of
16054 rtl = rtl_for_decl_location (decl);
16055 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16056 && add_const_value_attribute (die, rtl))
16059 /* See if we have single element location list that is equivalent to
16060 a constant value. That way we are better to use add_const_value_attribute
16061 rather than expanding constant value equivalent. */
16062 loc_list = lookup_decl_loc (decl);
16065 && loc_list->first->next == NULL
16066 && NOTE_P (loc_list->first->loc)
16067 && NOTE_VAR_LOCATION (loc_list->first->loc)
16068 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
16070 struct var_loc_node *node;
16072 node = loc_list->first;
16073 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
16074 if (GET_CODE (rtl) == EXPR_LIST)
16075 rtl = XEXP (rtl, 0);
16076 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16077 && add_const_value_attribute (die, rtl))
16080 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
16081 list several times. See if we've already cached the contents. */
16083 if (loc_list == NULL || cached_dw_loc_list_table == NULL)
16087 cache = cached_dw_loc_list_table->find_with_hash (decl, DECL_UID (decl));
16089 list = cache->loc_list;
16093 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2,
16095 /* It is usually worth caching this result if the decl is from
16096 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
16097 if (cache_p && list && list->dw_loc_next)
16099 cached_dw_loc_list **slot
16100 = cached_dw_loc_list_table->find_slot_with_hash (decl,
16103 cache = ggc_cleared_alloc<cached_dw_loc_list> ();
16104 cache->decl_id = DECL_UID (decl);
16105 cache->loc_list = list;
16111 add_AT_location_description (die, attr, list);
16114 /* None of that worked, so it must not really have a location;
16115 try adding a constant value attribute from the DECL_INITIAL. */
16116 return tree_add_const_value_attribute_for_decl (die, decl);
16119 /* Add VARIABLE and DIE into deferred locations list. */
16122 defer_location (tree variable, dw_die_ref die)
16124 deferred_locations entry;
16125 entry.variable = variable;
16127 vec_safe_push (deferred_locations_list, entry);
16130 /* Helper function for tree_add_const_value_attribute. Natively encode
16131 initializer INIT into an array. Return true if successful. */
16134 native_encode_initializer (tree init, unsigned char *array, int size)
16138 if (init == NULL_TREE)
16142 switch (TREE_CODE (init))
16145 type = TREE_TYPE (init);
16146 if (TREE_CODE (type) == ARRAY_TYPE)
16148 tree enttype = TREE_TYPE (type);
16149 machine_mode mode = TYPE_MODE (enttype);
16151 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
16153 if (int_size_in_bytes (type) != size)
16155 if (size > TREE_STRING_LENGTH (init))
16157 memcpy (array, TREE_STRING_POINTER (init),
16158 TREE_STRING_LENGTH (init));
16159 memset (array + TREE_STRING_LENGTH (init),
16160 '\0', size - TREE_STRING_LENGTH (init));
16163 memcpy (array, TREE_STRING_POINTER (init), size);
16168 type = TREE_TYPE (init);
16169 if (int_size_in_bytes (type) != size)
16171 if (TREE_CODE (type) == ARRAY_TYPE)
16173 HOST_WIDE_INT min_index;
16174 unsigned HOST_WIDE_INT cnt;
16175 int curpos = 0, fieldsize;
16176 constructor_elt *ce;
16178 if (TYPE_DOMAIN (type) == NULL_TREE
16179 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type))))
16182 fieldsize = int_size_in_bytes (TREE_TYPE (type));
16183 if (fieldsize <= 0)
16186 min_index = tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type)));
16187 memset (array, '\0', size);
16188 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce)
16190 tree val = ce->value;
16191 tree index = ce->index;
16193 if (index && TREE_CODE (index) == RANGE_EXPR)
16194 pos = (tree_to_shwi (TREE_OPERAND (index, 0)) - min_index)
16197 pos = (tree_to_shwi (index) - min_index) * fieldsize;
16202 if (!native_encode_initializer (val, array + pos, fieldsize))
16205 curpos = pos + fieldsize;
16206 if (index && TREE_CODE (index) == RANGE_EXPR)
16208 int count = tree_to_shwi (TREE_OPERAND (index, 1))
16209 - tree_to_shwi (TREE_OPERAND (index, 0));
16210 while (count-- > 0)
16213 memcpy (array + curpos, array + pos, fieldsize);
16214 curpos += fieldsize;
16217 gcc_assert (curpos <= size);
16221 else if (TREE_CODE (type) == RECORD_TYPE
16222 || TREE_CODE (type) == UNION_TYPE)
16224 tree field = NULL_TREE;
16225 unsigned HOST_WIDE_INT cnt;
16226 constructor_elt *ce;
16228 if (int_size_in_bytes (type) != size)
16231 if (TREE_CODE (type) == RECORD_TYPE)
16232 field = TYPE_FIELDS (type);
16234 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init), cnt, ce)
16236 tree val = ce->value;
16237 int pos, fieldsize;
16239 if (ce->index != 0)
16245 if (field == NULL_TREE || DECL_BIT_FIELD (field))
16248 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
16249 && TYPE_DOMAIN (TREE_TYPE (field))
16250 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
16252 else if (DECL_SIZE_UNIT (field) == NULL_TREE
16253 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field)))
16255 fieldsize = tree_to_shwi (DECL_SIZE_UNIT (field));
16256 pos = int_byte_position (field);
16257 gcc_assert (pos + fieldsize <= size);
16258 if (val && fieldsize != 0
16259 && !native_encode_initializer (val, array + pos, fieldsize))
16265 case VIEW_CONVERT_EXPR:
16266 case NON_LVALUE_EXPR:
16267 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
16269 return native_encode_expr (init, array, size) == size;
16273 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16274 attribute is the const value T. */
16277 tree_add_const_value_attribute (dw_die_ref die, tree t)
16280 tree type = TREE_TYPE (t);
16283 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
16287 gcc_assert (!DECL_P (init));
16289 rtl = rtl_for_decl_init (init, type);
16291 return add_const_value_attribute (die, rtl);
16292 /* If the host and target are sane, try harder. */
16293 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
16294 && initializer_constant_valid_p (init, type))
16296 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
16297 if (size > 0 && (int) size == size)
16299 unsigned char *array = ggc_cleared_vec_alloc<unsigned char> (size);
16301 if (native_encode_initializer (init, array, size))
16303 add_AT_vec (die, DW_AT_const_value, size, 1, array);
16312 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16313 attribute is the const value of T, where T is an integral constant
16314 variable with static storage duration
16315 (so it can't be a PARM_DECL or a RESULT_DECL). */
16318 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
16322 || (TREE_CODE (decl) != VAR_DECL
16323 && TREE_CODE (decl) != CONST_DECL)
16324 || (TREE_CODE (decl) == VAR_DECL
16325 && !TREE_STATIC (decl)))
16328 if (TREE_READONLY (decl)
16329 && ! TREE_THIS_VOLATILE (decl)
16330 && DECL_INITIAL (decl))
16335 /* Don't add DW_AT_const_value if abstract origin already has one. */
16336 if (get_AT (var_die, DW_AT_const_value))
16339 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
16342 /* Convert the CFI instructions for the current function into a
16343 location list. This is used for DW_AT_frame_base when we targeting
16344 a dwarf2 consumer that does not support the dwarf3
16345 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16348 static dw_loc_list_ref
16349 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
16353 dw_loc_list_ref list, *list_tail;
16355 dw_cfa_location last_cfa, next_cfa;
16356 const char *start_label, *last_label, *section;
16357 dw_cfa_location remember;
16360 gcc_assert (fde != NULL);
16362 section = secname_for_decl (current_function_decl);
16366 memset (&next_cfa, 0, sizeof (next_cfa));
16367 next_cfa.reg = INVALID_REGNUM;
16368 remember = next_cfa;
16370 start_label = fde->dw_fde_begin;
16372 /* ??? Bald assumption that the CIE opcode list does not contain
16373 advance opcodes. */
16374 FOR_EACH_VEC_ELT (*cie_cfi_vec, ix, cfi)
16375 lookup_cfa_1 (cfi, &next_cfa, &remember);
16377 last_cfa = next_cfa;
16378 last_label = start_label;
16380 if (fde->dw_fde_second_begin && fde->dw_fde_switch_cfi_index == 0)
16382 /* If the first partition contained no CFI adjustments, the
16383 CIE opcodes apply to the whole first partition. */
16384 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16385 fde->dw_fde_begin, fde->dw_fde_end, section);
16386 list_tail =&(*list_tail)->dw_loc_next;
16387 start_label = last_label = fde->dw_fde_second_begin;
16390 FOR_EACH_VEC_SAFE_ELT (fde->dw_fde_cfi, ix, cfi)
16392 switch (cfi->dw_cfi_opc)
16394 case DW_CFA_set_loc:
16395 case DW_CFA_advance_loc1:
16396 case DW_CFA_advance_loc2:
16397 case DW_CFA_advance_loc4:
16398 if (!cfa_equal_p (&last_cfa, &next_cfa))
16400 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16401 start_label, last_label, section);
16403 list_tail = &(*list_tail)->dw_loc_next;
16404 last_cfa = next_cfa;
16405 start_label = last_label;
16407 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
16410 case DW_CFA_advance_loc:
16411 /* The encoding is complex enough that we should never emit this. */
16412 gcc_unreachable ();
16415 lookup_cfa_1 (cfi, &next_cfa, &remember);
16418 if (ix + 1 == fde->dw_fde_switch_cfi_index)
16420 if (!cfa_equal_p (&last_cfa, &next_cfa))
16422 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16423 start_label, last_label, section);
16425 list_tail = &(*list_tail)->dw_loc_next;
16426 last_cfa = next_cfa;
16427 start_label = last_label;
16429 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16430 start_label, fde->dw_fde_end, section);
16431 list_tail = &(*list_tail)->dw_loc_next;
16432 start_label = last_label = fde->dw_fde_second_begin;
16436 if (!cfa_equal_p (&last_cfa, &next_cfa))
16438 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16439 start_label, last_label, section);
16440 list_tail = &(*list_tail)->dw_loc_next;
16441 start_label = last_label;
16444 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
16446 fde->dw_fde_second_begin
16447 ? fde->dw_fde_second_end : fde->dw_fde_end,
16450 if (list && list->dw_loc_next)
16456 /* Compute a displacement from the "steady-state frame pointer" to the
16457 frame base (often the same as the CFA), and store it in
16458 frame_pointer_fb_offset. OFFSET is added to the displacement
16459 before the latter is negated. */
16462 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
16466 #ifdef FRAME_POINTER_CFA_OFFSET
16467 reg = frame_pointer_rtx;
16468 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
16470 reg = arg_pointer_rtx;
16471 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
16474 elim = (ira_use_lra_p
16475 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
16476 : eliminate_regs (reg, VOIDmode, NULL_RTX));
16477 if (GET_CODE (elim) == PLUS)
16479 offset += INTVAL (XEXP (elim, 1));
16480 elim = XEXP (elim, 0);
16483 frame_pointer_fb_offset = -offset;
16485 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
16486 in which to eliminate. This is because it's stack pointer isn't
16487 directly accessible as a register within the ISA. To work around
16488 this, assume that while we cannot provide a proper value for
16489 frame_pointer_fb_offset, we won't need one either. */
16490 frame_pointer_fb_offset_valid
16491 = ((SUPPORTS_STACK_ALIGNMENT
16492 && (elim == hard_frame_pointer_rtx
16493 || elim == stack_pointer_rtx))
16494 || elim == (frame_pointer_needed
16495 ? hard_frame_pointer_rtx
16496 : stack_pointer_rtx));
16499 /* Generate a DW_AT_name attribute given some string value to be included as
16500 the value of the attribute. */
16503 add_name_attribute (dw_die_ref die, const char *name_string)
16505 if (name_string != NULL && *name_string != 0)
16507 if (demangle_name_func)
16508 name_string = (*demangle_name_func) (name_string);
16510 add_AT_string (die, DW_AT_name, name_string);
16514 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
16515 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
16516 of TYPE accordingly.
16518 ??? This is a temporary measure until after we're able to generate
16519 regular DWARF for the complex Ada type system. */
16522 add_gnat_descriptive_type_attribute (dw_die_ref die, tree type,
16523 dw_die_ref context_die)
16526 dw_die_ref dtype_die;
16528 if (!lang_hooks.types.descriptive_type)
16531 dtype = lang_hooks.types.descriptive_type (type);
16535 dtype_die = lookup_type_die (dtype);
16538 gen_type_die (dtype, context_die);
16539 dtype_die = lookup_type_die (dtype);
16540 gcc_assert (dtype_die);
16543 add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die);
16546 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
16548 static const char *
16549 comp_dir_string (void)
16553 static const char *cached_wd = NULL;
16555 if (cached_wd != NULL)
16558 wd = get_src_pwd ();
16562 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
16566 wdlen = strlen (wd);
16567 wd1 = ggc_vec_alloc<char> (wdlen + 2);
16569 wd1 [wdlen] = DIR_SEPARATOR;
16570 wd1 [wdlen + 1] = 0;
16574 cached_wd = remap_debug_filename (wd);
16578 /* Generate a DW_AT_comp_dir attribute for DIE. */
16581 add_comp_dir_attribute (dw_die_ref die)
16583 const char * wd = comp_dir_string ();
16585 add_AT_string (die, DW_AT_comp_dir, wd);
16588 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
16589 pointer computation, ...), output a representation for that bound according
16590 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
16591 loc_list_from_tree for the meaning of CONTEXT. */
16594 add_scalar_info (dw_die_ref die, enum dwarf_attribute attr, tree value,
16595 int forms, const struct loc_descr_context *context)
16597 dw_die_ref ctx, decl_die;
16598 dw_loc_list_ref list;
16600 bool strip_conversions = true;
16602 while (strip_conversions)
16603 switch (TREE_CODE (value))
16610 case VIEW_CONVERT_EXPR:
16611 value = TREE_OPERAND (value, 0);
16615 strip_conversions = false;
16619 /* If possible and permitted, output the attribute as a constant. */
16620 if ((forms & dw_scalar_form_constant) != 0
16621 && TREE_CODE (value) == INTEGER_CST)
16623 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (value));
16625 /* If HOST_WIDE_INT is big enough then represent the bound as
16626 a constant value. We need to choose a form based on
16627 whether the type is signed or unsigned. We cannot just
16628 call add_AT_unsigned if the value itself is positive
16629 (add_AT_unsigned might add the unsigned value encoded as
16630 DW_FORM_data[1248]). Some DWARF consumers will lookup the
16631 bounds type and then sign extend any unsigned values found
16632 for signed types. This is needed only for
16633 DW_AT_{lower,upper}_bound, since for most other attributes,
16634 consumers will treat DW_FORM_data[1248] as unsigned values,
16635 regardless of the underlying type. */
16636 if (prec <= HOST_BITS_PER_WIDE_INT
16637 || tree_fits_uhwi_p (value))
16639 if (TYPE_UNSIGNED (TREE_TYPE (value)))
16640 add_AT_unsigned (die, attr, TREE_INT_CST_LOW (value));
16642 add_AT_int (die, attr, TREE_INT_CST_LOW (value));
16645 /* Otherwise represent the bound as an unsigned value with
16646 the precision of its type. The precision and signedness
16647 of the type will be necessary to re-interpret it
16649 add_AT_wide (die, attr, value);
16653 /* Otherwise, if it's possible and permitted too, output a reference to
16655 if ((forms & dw_scalar_form_reference) != 0)
16657 tree decl = NULL_TREE;
16659 /* Some type attributes reference an outer type. For instance, the upper
16660 bound of an array may reference an embedding record (this happens in
16662 if (TREE_CODE (value) == COMPONENT_REF
16663 && TREE_CODE (TREE_OPERAND (value, 0)) == PLACEHOLDER_EXPR
16664 && TREE_CODE (TREE_OPERAND (value, 1)) == FIELD_DECL)
16665 decl = TREE_OPERAND (value, 1);
16667 else if (TREE_CODE (value) == VAR_DECL
16668 || TREE_CODE (value) == PARM_DECL
16669 || TREE_CODE (value) == RESULT_DECL)
16672 if (decl != NULL_TREE)
16674 dw_die_ref decl_die = lookup_decl_die (decl);
16676 /* ??? Can this happen, or should the variable have been bound
16677 first? Probably it can, since I imagine that we try to create
16678 the types of parameters in the order in which they exist in
16679 the list, and won't have created a forward reference to a
16680 later parameter. */
16681 if (decl_die != NULL)
16683 add_AT_die_ref (die, attr, decl_die);
16689 /* Last chance: try to create a stack operation procedure to evaluate the
16690 value. Do nothing if even that is not possible or permitted. */
16691 if ((forms & dw_scalar_form_exprloc) == 0)
16694 list = loc_list_from_tree (value, 2, context);
16695 if (list == NULL || single_element_loc_list_p (list))
16697 /* If this attribute is not a reference nor constant, it is
16698 a DWARF expression rather than location description. For that
16699 loc_list_from_tree (value, 0, &context) is needed. */
16700 dw_loc_list_ref list2 = loc_list_from_tree (value, 0, context);
16701 if (list2 && single_element_loc_list_p (list2))
16703 add_AT_loc (die, attr, list2->expr);
16708 /* If that failed to give a single element location list, fall back to
16709 outputting this as a reference... still if permitted. */
16710 if (list == NULL || (forms & dw_scalar_form_reference) == 0)
16713 if (current_function_decl == 0)
16714 ctx = comp_unit_die ();
16716 ctx = lookup_decl_die (current_function_decl);
16718 decl_die = new_die (DW_TAG_variable, ctx, value);
16719 add_AT_flag (decl_die, DW_AT_artificial, 1);
16720 add_type_attribute (decl_die, TREE_TYPE (value), TYPE_QUAL_CONST, ctx);
16721 add_AT_location_description (decl_die, DW_AT_location, list);
16722 add_AT_die_ref (die, attr, decl_die);
16725 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16729 lower_bound_default (void)
16731 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
16737 case DW_LANG_C_plus_plus:
16738 case DW_LANG_C_plus_plus_11:
16739 case DW_LANG_C_plus_plus_14:
16741 case DW_LANG_ObjC_plus_plus:
16744 case DW_LANG_Fortran77:
16745 case DW_LANG_Fortran90:
16746 case DW_LANG_Fortran95:
16747 case DW_LANG_Fortran03:
16748 case DW_LANG_Fortran08:
16752 case DW_LANG_Python:
16753 return dwarf_version >= 4 ? 0 : -1;
16754 case DW_LANG_Ada95:
16755 case DW_LANG_Ada83:
16756 case DW_LANG_Cobol74:
16757 case DW_LANG_Cobol85:
16758 case DW_LANG_Pascal83:
16759 case DW_LANG_Modula2:
16761 return dwarf_version >= 4 ? 1 : -1;
16767 /* Given a tree node describing an array bound (either lower or upper) output
16768 a representation for that bound. */
16771 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr,
16772 tree bound, const struct loc_descr_context *context)
16777 switch (TREE_CODE (bound))
16779 /* Strip all conversions. */
16781 case VIEW_CONVERT_EXPR:
16782 bound = TREE_OPERAND (bound, 0);
16785 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
16786 are even omitted when they are the default. */
16788 /* If the value for this bound is the default one, we can even omit the
16790 if (bound_attr == DW_AT_lower_bound
16791 && tree_fits_shwi_p (bound)
16792 && (dflt = lower_bound_default ()) != -1
16793 && tree_to_shwi (bound) == dflt)
16799 add_scalar_info (subrange_die, bound_attr, bound,
16800 dw_scalar_form_constant
16801 | dw_scalar_form_exprloc
16802 | dw_scalar_form_reference,
16808 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16809 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16810 Note that the block of subscript information for an array type also
16811 includes information about the element type of the given array type. */
16814 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
16816 unsigned dimension_number;
16818 dw_die_ref subrange_die;
16820 for (dimension_number = 0;
16821 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
16822 type = TREE_TYPE (type), dimension_number++)
16824 tree domain = TYPE_DOMAIN (type);
16826 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
16829 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16830 and (in GNU C only) variable bounds. Handle all three forms
16832 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
16835 /* We have an array type with specified bounds. */
16836 lower = TYPE_MIN_VALUE (domain);
16837 upper = TYPE_MAX_VALUE (domain);
16839 /* Define the index type. */
16840 if (TREE_TYPE (domain))
16842 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16843 TREE_TYPE field. We can't emit debug info for this
16844 because it is an unnamed integral type. */
16845 if (TREE_CODE (domain) == INTEGER_TYPE
16846 && TYPE_NAME (domain) == NULL_TREE
16847 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
16848 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
16851 add_type_attribute (subrange_die, TREE_TYPE (domain),
16852 TYPE_UNQUALIFIED, type_die);
16855 /* ??? If upper is NULL, the array has unspecified length,
16856 but it does have a lower bound. This happens with Fortran
16858 Since the debugger is definitely going to need to know N
16859 to produce useful results, go ahead and output the lower
16860 bound solo, and hope the debugger can cope. */
16862 add_bound_info (subrange_die, DW_AT_lower_bound, lower, NULL);
16864 add_bound_info (subrange_die, DW_AT_upper_bound, upper, NULL);
16867 /* Otherwise we have an array type with an unspecified length. The
16868 DWARF-2 spec does not say how to handle this; let's just leave out the
16873 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
16876 add_byte_size_attribute (dw_die_ref die, tree tree_node)
16878 dw_die_ref decl_die;
16879 HOST_WIDE_INT size;
16881 switch (TREE_CODE (tree_node))
16886 case ENUMERAL_TYPE:
16889 case QUAL_UNION_TYPE:
16890 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node)) == VAR_DECL
16891 && (decl_die = lookup_decl_die (TYPE_SIZE_UNIT (tree_node))))
16893 add_AT_die_ref (die, DW_AT_byte_size, decl_die);
16896 size = int_size_in_bytes (tree_node);
16899 /* For a data member of a struct or union, the DW_AT_byte_size is
16900 generally given as the number of bytes normally allocated for an
16901 object of the *declared* type of the member itself. This is true
16902 even for bit-fields. */
16903 size = int_size_in_bytes (field_type (tree_node));
16906 gcc_unreachable ();
16909 /* Note that `size' might be -1 when we get to this point. If it is, that
16910 indicates that the byte size of the entity in question is variable. We
16911 have no good way of expressing this fact in Dwarf at the present time,
16912 when location description was not used by the caller code instead. */
16914 add_AT_unsigned (die, DW_AT_byte_size, size);
16917 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16918 which specifies the distance in bits from the highest order bit of the
16919 "containing object" for the bit-field to the highest order bit of the
16922 For any given bit-field, the "containing object" is a hypothetical object
16923 (of some integral or enum type) within which the given bit-field lives. The
16924 type of this hypothetical "containing object" is always the same as the
16925 declared type of the individual bit-field itself. The determination of the
16926 exact location of the "containing object" for a bit-field is rather
16927 complicated. It's handled by the `field_byte_offset' function (above).
16929 Note that it is the size (in bytes) of the hypothetical "containing object"
16930 which will be given in the DW_AT_byte_size attribute for this bit-field.
16931 (See `byte_size_attribute' above). */
16934 add_bit_offset_attribute (dw_die_ref die, tree decl)
16936 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
16937 tree type = DECL_BIT_FIELD_TYPE (decl);
16938 HOST_WIDE_INT bitpos_int;
16939 HOST_WIDE_INT highest_order_object_bit_offset;
16940 HOST_WIDE_INT highest_order_field_bit_offset;
16941 HOST_WIDE_INT bit_offset;
16943 /* Must be a field and a bit field. */
16944 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
16946 /* We can't yet handle bit-fields whose offsets are variable, so if we
16947 encounter such things, just return without generating any attribute
16948 whatsoever. Likewise for variable or too large size. */
16949 if (! tree_fits_shwi_p (bit_position (decl))
16950 || ! tree_fits_uhwi_p (DECL_SIZE (decl)))
16953 bitpos_int = int_bit_position (decl);
16955 /* Note that the bit offset is always the distance (in bits) from the
16956 highest-order bit of the "containing object" to the highest-order bit of
16957 the bit-field itself. Since the "high-order end" of any object or field
16958 is different on big-endian and little-endian machines, the computation
16959 below must take account of these differences. */
16960 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
16961 highest_order_field_bit_offset = bitpos_int;
16963 if (! BYTES_BIG_ENDIAN)
16965 highest_order_field_bit_offset += tree_to_shwi (DECL_SIZE (decl));
16966 highest_order_object_bit_offset += simple_type_size_in_bits (type);
16970 = (! BYTES_BIG_ENDIAN
16971 ? highest_order_object_bit_offset - highest_order_field_bit_offset
16972 : highest_order_field_bit_offset - highest_order_object_bit_offset);
16974 if (bit_offset < 0)
16975 add_AT_int (die, DW_AT_bit_offset, bit_offset);
16977 add_AT_unsigned (die, DW_AT_bit_offset, (unsigned HOST_WIDE_INT) bit_offset);
16980 /* For a FIELD_DECL node which represents a bit field, output an attribute
16981 which specifies the length in bits of the given field. */
16984 add_bit_size_attribute (dw_die_ref die, tree decl)
16986 /* Must be a field and a bit field. */
16987 gcc_assert (TREE_CODE (decl) == FIELD_DECL
16988 && DECL_BIT_FIELD_TYPE (decl));
16990 if (tree_fits_uhwi_p (DECL_SIZE (decl)))
16991 add_AT_unsigned (die, DW_AT_bit_size, tree_to_uhwi (DECL_SIZE (decl)));
16994 /* If the compiled language is ANSI C, then add a 'prototyped'
16995 attribute, if arg types are given for the parameters of a function. */
16998 add_prototyped_attribute (dw_die_ref die, tree func_type)
17000 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
17007 if (prototype_p (func_type))
17008 add_AT_flag (die, DW_AT_prototyped, 1);
17015 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
17016 by looking in either the type declaration or object declaration
17019 static inline dw_die_ref
17020 add_abstract_origin_attribute (dw_die_ref die, tree origin)
17022 dw_die_ref origin_die = NULL;
17024 if (TREE_CODE (origin) != FUNCTION_DECL)
17026 /* We may have gotten separated from the block for the inlined
17027 function, if we're in an exception handler or some such; make
17028 sure that the abstract function has been written out.
17030 Doing this for nested functions is wrong, however; functions are
17031 distinct units, and our context might not even be inline. */
17035 fn = TYPE_STUB_DECL (fn);
17037 fn = decl_function_context (fn);
17039 dwarf2out_abstract_function (fn);
17042 if (DECL_P (origin))
17043 origin_die = lookup_decl_die (origin);
17044 else if (TYPE_P (origin))
17045 origin_die = lookup_type_die (origin);
17047 /* XXX: Functions that are never lowered don't always have correct block
17048 trees (in the case of java, they simply have no block tree, in some other
17049 languages). For these functions, there is nothing we can really do to
17050 output correct debug info for inlined functions in all cases. Rather
17051 than die, we'll just produce deficient debug info now, in that we will
17052 have variables without a proper abstract origin. In the future, when all
17053 functions are lowered, we should re-add a gcc_assert (origin_die)
17057 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
17061 /* We do not currently support the pure_virtual attribute. */
17064 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
17066 if (DECL_VINDEX (func_decl))
17068 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
17070 if (tree_fits_shwi_p (DECL_VINDEX (func_decl)))
17071 add_AT_loc (die, DW_AT_vtable_elem_location,
17072 new_loc_descr (DW_OP_constu,
17073 tree_to_shwi (DECL_VINDEX (func_decl)),
17076 /* GNU extension: Record what type this method came from originally. */
17077 if (debug_info_level > DINFO_LEVEL_TERSE
17078 && DECL_CONTEXT (func_decl))
17079 add_AT_die_ref (die, DW_AT_containing_type,
17080 lookup_type_die (DECL_CONTEXT (func_decl)));
17084 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
17085 given decl. This used to be a vendor extension until after DWARF 4
17086 standardized it. */
17089 add_linkage_attr (dw_die_ref die, tree decl)
17091 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
17093 /* Mimic what assemble_name_raw does with a leading '*'. */
17094 if (name[0] == '*')
17097 if (dwarf_version >= 4)
17098 add_AT_string (die, DW_AT_linkage_name, name);
17100 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
17103 /* Add source coordinate attributes for the given decl. */
17106 add_src_coords_attributes (dw_die_ref die, tree decl)
17108 expanded_location s;
17110 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl)) == UNKNOWN_LOCATION)
17112 s = expand_location (DECL_SOURCE_LOCATION (decl));
17113 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
17114 add_AT_unsigned (die, DW_AT_decl_line, s.line);
17117 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
17120 add_linkage_name (dw_die_ref die, tree decl)
17122 if (debug_info_level > DINFO_LEVEL_NONE
17123 && (TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
17124 && TREE_PUBLIC (decl)
17125 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
17126 && die->die_tag != DW_TAG_member)
17128 /* Defer until we have an assembler name set. */
17129 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
17131 limbo_die_node *asm_name;
17133 asm_name = ggc_cleared_alloc<limbo_die_node> ();
17134 asm_name->die = die;
17135 asm_name->created_for = decl;
17136 asm_name->next = deferred_asm_name;
17137 deferred_asm_name = asm_name;
17139 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
17140 add_linkage_attr (die, decl);
17144 /* Add a DW_AT_name attribute and source coordinate attribute for the
17145 given decl, but only if it actually has a name. */
17148 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
17152 decl_name = DECL_NAME (decl);
17153 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
17155 const char *name = dwarf2_name (decl, 0);
17157 add_name_attribute (die, name);
17158 if (! DECL_ARTIFICIAL (decl))
17159 add_src_coords_attributes (die, decl);
17161 add_linkage_name (die, decl);
17164 #ifdef VMS_DEBUGGING_INFO
17165 /* Get the function's name, as described by its RTL. This may be different
17166 from the DECL_NAME name used in the source file. */
17167 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
17169 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
17170 XEXP (DECL_RTL (decl), 0), false);
17171 vec_safe_push (used_rtx_array, XEXP (DECL_RTL (decl), 0));
17173 #endif /* VMS_DEBUGGING_INFO */
17176 #ifdef VMS_DEBUGGING_INFO
17177 /* Output the debug main pointer die for VMS */
17180 dwarf2out_vms_debug_main_pointer (void)
17182 char label[MAX_ARTIFICIAL_LABEL_BYTES];
17185 /* Allocate the VMS debug main subprogram die. */
17186 die = ggc_cleared_alloc<die_node> ();
17187 die->die_tag = DW_TAG_subprogram;
17188 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
17189 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
17190 current_function_funcdef_no);
17191 add_AT_lbl_id (die, DW_AT_entry_pc, label);
17193 /* Make it the first child of comp_unit_die (). */
17194 die->die_parent = comp_unit_die ();
17195 if (comp_unit_die ()->die_child)
17197 die->die_sib = comp_unit_die ()->die_child->die_sib;
17198 comp_unit_die ()->die_child->die_sib = die;
17202 die->die_sib = die;
17203 comp_unit_die ()->die_child = die;
17206 #endif /* VMS_DEBUGGING_INFO */
17208 /* Push a new declaration scope. */
17211 push_decl_scope (tree scope)
17213 vec_safe_push (decl_scope_table, scope);
17216 /* Pop a declaration scope. */
17219 pop_decl_scope (void)
17221 decl_scope_table->pop ();
17224 /* walk_tree helper function for uses_local_type, below. */
17227 uses_local_type_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
17230 *walk_subtrees = 0;
17233 tree name = TYPE_NAME (*tp);
17234 if (name && DECL_P (name) && decl_function_context (name))
17240 /* If TYPE involves a function-local type (including a local typedef to a
17241 non-local type), returns that type; otherwise returns NULL_TREE. */
17244 uses_local_type (tree type)
17246 tree used = walk_tree_without_duplicates (&type, uses_local_type_r, NULL);
17250 /* Return the DIE for the scope that immediately contains this type.
17251 Non-named types that do not involve a function-local type get global
17252 scope. Named types nested in namespaces or other types get their
17253 containing scope. All other types (i.e. function-local named types) get
17254 the current active scope. */
17257 scope_die_for (tree t, dw_die_ref context_die)
17259 dw_die_ref scope_die = NULL;
17260 tree containing_scope;
17262 /* Non-types always go in the current scope. */
17263 gcc_assert (TYPE_P (t));
17265 /* Use the scope of the typedef, rather than the scope of the type
17267 if (TYPE_NAME (t) && DECL_P (TYPE_NAME (t)))
17268 containing_scope = DECL_CONTEXT (TYPE_NAME (t));
17270 containing_scope = TYPE_CONTEXT (t);
17272 /* Use the containing namespace if there is one. */
17273 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
17275 if (context_die == lookup_decl_die (containing_scope))
17277 else if (debug_info_level > DINFO_LEVEL_TERSE)
17278 context_die = get_context_die (containing_scope);
17280 containing_scope = NULL_TREE;
17283 /* Ignore function type "scopes" from the C frontend. They mean that
17284 a tagged type is local to a parmlist of a function declarator, but
17285 that isn't useful to DWARF. */
17286 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
17287 containing_scope = NULL_TREE;
17289 if (SCOPE_FILE_SCOPE_P (containing_scope))
17291 /* If T uses a local type keep it local as well, to avoid references
17292 to function-local DIEs from outside the function. */
17293 if (current_function_decl && uses_local_type (t))
17294 scope_die = context_die;
17296 scope_die = comp_unit_die ();
17298 else if (TYPE_P (containing_scope))
17300 /* For types, we can just look up the appropriate DIE. */
17301 if (debug_info_level > DINFO_LEVEL_TERSE)
17302 scope_die = get_context_die (containing_scope);
17305 scope_die = lookup_type_die_strip_naming_typedef (containing_scope);
17306 if (scope_die == NULL)
17307 scope_die = comp_unit_die ();
17311 scope_die = context_die;
17316 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17319 local_scope_p (dw_die_ref context_die)
17321 for (; context_die; context_die = context_die->die_parent)
17322 if (context_die->die_tag == DW_TAG_inlined_subroutine
17323 || context_die->die_tag == DW_TAG_subprogram)
17329 /* Returns nonzero if CONTEXT_DIE is a class. */
17332 class_scope_p (dw_die_ref context_die)
17334 return (context_die
17335 && (context_die->die_tag == DW_TAG_structure_type
17336 || context_die->die_tag == DW_TAG_class_type
17337 || context_die->die_tag == DW_TAG_interface_type
17338 || context_die->die_tag == DW_TAG_union_type));
17341 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17342 whether or not to treat a DIE in this context as a declaration. */
17345 class_or_namespace_scope_p (dw_die_ref context_die)
17347 return (class_scope_p (context_die)
17348 || (context_die && context_die->die_tag == DW_TAG_namespace));
17351 /* Many forms of DIEs require a "type description" attribute. This
17352 routine locates the proper "type descriptor" die for the type given
17353 by 'type' plus any additional qualifiers given by 'cv_quals', and
17354 adds a DW_AT_type attribute below the given die. */
17357 add_type_attribute (dw_die_ref object_die, tree type, int cv_quals,
17358 dw_die_ref context_die)
17360 enum tree_code code = TREE_CODE (type);
17361 dw_die_ref type_die = NULL;
17363 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17364 or fixed-point type, use the inner type. This is because we have no
17365 support for unnamed types in base_type_die. This can happen if this is
17366 an Ada subrange type. Correct solution is emit a subrange type die. */
17367 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
17368 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
17369 type = TREE_TYPE (type), code = TREE_CODE (type);
17371 if (code == ERROR_MARK
17372 /* Handle a special case. For functions whose return type is void, we
17373 generate *no* type attribute. (Note that no object may have type
17374 `void', so this only applies to function return types). */
17375 || code == VOID_TYPE)
17378 type_die = modified_type_die (type,
17379 cv_quals | TYPE_QUALS_NO_ADDR_SPACE (type),
17382 if (type_die != NULL)
17383 add_AT_die_ref (object_die, DW_AT_type, type_die);
17386 /* Given an object die, add the calling convention attribute for the
17387 function call type. */
17389 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
17391 enum dwarf_calling_convention value = DW_CC_normal;
17393 value = ((enum dwarf_calling_convention)
17394 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
17397 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
17399 /* DWARF 2 doesn't provide a way to identify a program's source-level
17400 entry point. DW_AT_calling_convention attributes are only meant
17401 to describe functions' calling conventions. However, lacking a
17402 better way to signal the Fortran main program, we used this for
17403 a long time, following existing custom. Now, DWARF 4 has
17404 DW_AT_main_subprogram, which we add below, but some tools still
17405 rely on the old way, which we thus keep. */
17406 value = DW_CC_program;
17408 if (dwarf_version >= 4 || !dwarf_strict)
17409 add_AT_flag (subr_die, DW_AT_main_subprogram, 1);
17412 /* Only add the attribute if the backend requests it, and
17413 is not DW_CC_normal. */
17414 if (value && (value != DW_CC_normal))
17415 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
17418 /* Given a tree pointer to a struct, class, union, or enum type node, return
17419 a pointer to the (string) tag name for the given type, or zero if the type
17420 was declared without a tag. */
17422 static const char *
17423 type_tag (const_tree type)
17425 const char *name = 0;
17427 if (TYPE_NAME (type) != 0)
17431 /* Find the IDENTIFIER_NODE for the type name. */
17432 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
17433 && !TYPE_NAMELESS (type))
17434 t = TYPE_NAME (type);
17436 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17437 a TYPE_DECL node, regardless of whether or not a `typedef' was
17439 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
17440 && ! DECL_IGNORED_P (TYPE_NAME (type)))
17442 /* We want to be extra verbose. Don't call dwarf_name if
17443 DECL_NAME isn't set. The default hook for decl_printable_name
17444 doesn't like that, and in this context it's correct to return
17445 0, instead of "<anonymous>" or the like. */
17446 if (DECL_NAME (TYPE_NAME (type))
17447 && !DECL_NAMELESS (TYPE_NAME (type)))
17448 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
17451 /* Now get the name as a string, or invent one. */
17452 if (!name && t != 0)
17453 name = IDENTIFIER_POINTER (t);
17456 return (name == 0 || *name == '\0') ? 0 : name;
17459 /* Return the type associated with a data member, make a special check
17460 for bit field types. */
17463 member_declared_type (const_tree member)
17465 return (DECL_BIT_FIELD_TYPE (member)
17466 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
17469 /* Get the decl's label, as described by its RTL. This may be different
17470 from the DECL_NAME name used in the source file. */
17473 static const char *
17474 decl_start_label (tree decl)
17477 const char *fnname;
17479 x = DECL_RTL (decl);
17480 gcc_assert (MEM_P (x));
17483 gcc_assert (GET_CODE (x) == SYMBOL_REF);
17485 fnname = XSTR (x, 0);
17490 /* These routines generate the internal representation of the DIE's for
17491 the compilation unit. Debugging information is collected by walking
17492 the declaration trees passed in from dwarf2out_decl(). */
17495 gen_array_type_die (tree type, dw_die_ref context_die)
17497 dw_die_ref scope_die = scope_die_for (type, context_die);
17498 dw_die_ref array_die;
17500 /* GNU compilers represent multidimensional array types as sequences of one
17501 dimensional array types whose element types are themselves array types.
17502 We sometimes squish that down to a single array_type DIE with multiple
17503 subscripts in the Dwarf debugging info. The draft Dwarf specification
17504 say that we are allowed to do this kind of compression in C, because
17505 there is no difference between an array of arrays and a multidimensional
17506 array. We don't do this for Ada to remain as close as possible to the
17507 actual representation, which is especially important against the language
17508 flexibilty wrt arrays of variable size. */
17510 bool collapse_nested_arrays = !is_ada ();
17513 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17514 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17515 if (TYPE_STRING_FLAG (type)
17516 && TREE_CODE (type) == ARRAY_TYPE
17518 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
17520 HOST_WIDE_INT size;
17522 array_die = new_die (DW_TAG_string_type, scope_die, type);
17523 add_name_attribute (array_die, type_tag (type));
17524 equate_type_number_to_die (type, array_die);
17525 size = int_size_in_bytes (type);
17527 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17528 else if (TYPE_DOMAIN (type) != NULL_TREE
17529 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
17530 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
17532 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
17533 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2, NULL);
17535 size = int_size_in_bytes (TREE_TYPE (szdecl));
17536 if (loc && size > 0)
17538 add_AT_location_description (array_die, DW_AT_string_length, loc);
17539 if (size != DWARF2_ADDR_SIZE)
17540 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17546 array_die = new_die (DW_TAG_array_type, scope_die, type);
17547 add_name_attribute (array_die, type_tag (type));
17548 equate_type_number_to_die (type, array_die);
17550 if (TREE_CODE (type) == VECTOR_TYPE)
17551 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
17553 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17555 && TREE_CODE (type) == ARRAY_TYPE
17556 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
17557 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
17558 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17561 /* We default the array ordering. SDB will probably do
17562 the right things even if DW_AT_ordering is not present. It's not even
17563 an issue until we start to get into multidimensional arrays anyway. If
17564 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17565 then we'll have to put the DW_AT_ordering attribute back in. (But if
17566 and when we find out that we need to put these in, we will only do so
17567 for multidimensional arrays. */
17568 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17571 if (TREE_CODE (type) == VECTOR_TYPE)
17573 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
17574 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
17575 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node, NULL);
17576 add_bound_info (subrange_die, DW_AT_upper_bound,
17577 size_int (TYPE_VECTOR_SUBPARTS (type) - 1), NULL);
17580 add_subscript_info (array_die, type, collapse_nested_arrays);
17582 /* Add representation of the type of the elements of this array type and
17583 emit the corresponding DIE if we haven't done it already. */
17584 element_type = TREE_TYPE (type);
17585 if (collapse_nested_arrays)
17586 while (TREE_CODE (element_type) == ARRAY_TYPE)
17588 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
17590 element_type = TREE_TYPE (element_type);
17593 add_type_attribute (array_die, element_type, TYPE_UNQUALIFIED, context_die);
17595 add_gnat_descriptive_type_attribute (array_die, type, context_die);
17596 if (TYPE_ARTIFICIAL (type))
17597 add_AT_flag (array_die, DW_AT_artificial, 1);
17599 if (get_AT (array_die, DW_AT_name))
17600 add_pubtype (type, array_die);
17603 /* This routine generates DIE for array with hidden descriptor, details
17604 are filled into *info by a langhook. */
17607 gen_descr_array_type_die (tree type, struct array_descr_info *info,
17608 dw_die_ref context_die)
17610 const dw_die_ref scope_die = scope_die_for (type, context_die);
17611 const dw_die_ref array_die = new_die (DW_TAG_array_type, scope_die, type);
17612 const struct loc_descr_context context = { type, info->base_decl };
17615 add_name_attribute (array_die, type_tag (type));
17616 equate_type_number_to_die (type, array_die);
17618 if (info->ndimensions > 1)
17619 switch (info->ordering)
17621 case array_descr_ordering_row_major:
17622 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17624 case array_descr_ordering_column_major:
17625 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17631 if (dwarf_version >= 3 || !dwarf_strict)
17633 if (info->data_location)
17634 add_scalar_info (array_die, DW_AT_data_location, info->data_location,
17635 dw_scalar_form_exprloc, &context);
17636 if (info->associated)
17637 add_scalar_info (array_die, DW_AT_associated, info->associated,
17638 dw_scalar_form_constant
17639 | dw_scalar_form_exprloc
17640 | dw_scalar_form_reference, &context);
17641 if (info->allocated)
17642 add_scalar_info (array_die, DW_AT_allocated, info->allocated,
17643 dw_scalar_form_constant
17644 | dw_scalar_form_exprloc
17645 | dw_scalar_form_reference, &context);
17648 add_gnat_descriptive_type_attribute (array_die, type, context_die);
17650 for (dim = 0; dim < info->ndimensions; dim++)
17652 dw_die_ref subrange_die
17653 = new_die (DW_TAG_subrange_type, array_die, NULL);
17655 if (info->dimen[dim].bounds_type)
17656 add_type_attribute (subrange_die,
17657 info->dimen[dim].bounds_type, 0,
17659 if (info->dimen[dim].lower_bound)
17660 add_bound_info (subrange_die, DW_AT_lower_bound,
17661 info->dimen[dim].lower_bound, &context);
17662 if (info->dimen[dim].upper_bound)
17663 add_bound_info (subrange_die, DW_AT_upper_bound,
17664 info->dimen[dim].upper_bound, &context);
17665 if ((dwarf_version >= 3 || !dwarf_strict) && info->dimen[dim].stride)
17666 add_scalar_info (subrange_die, DW_AT_byte_stride,
17667 info->dimen[dim].stride,
17668 dw_scalar_form_constant
17669 | dw_scalar_form_exprloc
17670 | dw_scalar_form_reference,
17674 gen_type_die (info->element_type, context_die);
17675 add_type_attribute (array_die, info->element_type, TYPE_UNQUALIFIED,
17678 if (get_AT (array_die, DW_AT_name))
17679 add_pubtype (type, array_die);
17684 gen_entry_point_die (tree decl, dw_die_ref context_die)
17686 tree origin = decl_ultimate_origin (decl);
17687 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
17689 if (origin != NULL)
17690 add_abstract_origin_attribute (decl_die, origin);
17693 add_name_and_src_coords_attributes (decl_die, decl);
17694 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
17695 TYPE_UNQUALIFIED, context_die);
17698 if (DECL_ABSTRACT_P (decl))
17699 equate_decl_number_to_die (decl, decl_die);
17701 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
17705 /* Walk through the list of incomplete types again, trying once more to
17706 emit full debugging info for them. */
17709 retry_incomplete_types (void)
17713 for (i = vec_safe_length (incomplete_types) - 1; i >= 0; i--)
17714 if (should_emit_struct_debug ((*incomplete_types)[i], DINFO_USAGE_DIR_USE))
17715 gen_type_die ((*incomplete_types)[i], comp_unit_die ());
17718 /* Determine what tag to use for a record type. */
17720 static enum dwarf_tag
17721 record_type_tag (tree type)
17723 if (! lang_hooks.types.classify_record)
17724 return DW_TAG_structure_type;
17726 switch (lang_hooks.types.classify_record (type))
17728 case RECORD_IS_STRUCT:
17729 return DW_TAG_structure_type;
17731 case RECORD_IS_CLASS:
17732 return DW_TAG_class_type;
17734 case RECORD_IS_INTERFACE:
17735 if (dwarf_version >= 3 || !dwarf_strict)
17736 return DW_TAG_interface_type;
17737 return DW_TAG_structure_type;
17740 gcc_unreachable ();
17744 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17745 include all of the information about the enumeration values also. Each
17746 enumerated type name/value is listed as a child of the enumerated type
17750 gen_enumeration_type_die (tree type, dw_die_ref context_die)
17752 dw_die_ref type_die = lookup_type_die (type);
17754 if (type_die == NULL)
17756 type_die = new_die (DW_TAG_enumeration_type,
17757 scope_die_for (type, context_die), type);
17758 equate_type_number_to_die (type, type_die);
17759 add_name_attribute (type_die, type_tag (type));
17760 if (dwarf_version >= 4 || !dwarf_strict)
17762 if (ENUM_IS_SCOPED (type))
17763 add_AT_flag (type_die, DW_AT_enum_class, 1);
17764 if (ENUM_IS_OPAQUE (type))
17765 add_AT_flag (type_die, DW_AT_declaration, 1);
17768 else if (! TYPE_SIZE (type))
17771 remove_AT (type_die, DW_AT_declaration);
17773 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17774 given enum type is incomplete, do not generate the DW_AT_byte_size
17775 attribute or the DW_AT_element_list attribute. */
17776 if (TYPE_SIZE (type))
17780 TREE_ASM_WRITTEN (type) = 1;
17781 add_byte_size_attribute (type_die, type);
17782 if (dwarf_version >= 3 || !dwarf_strict)
17784 tree underlying = lang_hooks.types.enum_underlying_base_type (type);
17785 add_type_attribute (type_die, underlying, TYPE_UNQUALIFIED,
17788 if (TYPE_STUB_DECL (type) != NULL_TREE)
17790 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
17791 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
17794 /* If the first reference to this type was as the return type of an
17795 inline function, then it may not have a parent. Fix this now. */
17796 if (type_die->die_parent == NULL)
17797 add_child_die (scope_die_for (type, context_die), type_die);
17799 for (link = TYPE_VALUES (type);
17800 link != NULL; link = TREE_CHAIN (link))
17802 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
17803 tree value = TREE_VALUE (link);
17805 add_name_attribute (enum_die,
17806 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
17808 if (TREE_CODE (value) == CONST_DECL)
17809 value = DECL_INITIAL (value);
17811 if (simple_type_size_in_bits (TREE_TYPE (value))
17812 <= HOST_BITS_PER_WIDE_INT || tree_fits_shwi_p (value))
17814 /* For constant forms created by add_AT_unsigned DWARF
17815 consumers (GDB, elfutils, etc.) always zero extend
17816 the value. Only when the actual value is negative
17817 do we need to use add_AT_int to generate a constant
17818 form that can represent negative values. */
17819 HOST_WIDE_INT val = TREE_INT_CST_LOW (value);
17820 if (TYPE_UNSIGNED (TREE_TYPE (value)) || val >= 0)
17821 add_AT_unsigned (enum_die, DW_AT_const_value,
17822 (unsigned HOST_WIDE_INT) val);
17824 add_AT_int (enum_die, DW_AT_const_value, val);
17827 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
17828 that here. TODO: This should be re-worked to use correct
17829 signed/unsigned double tags for all cases. */
17830 add_AT_wide (enum_die, DW_AT_const_value, value);
17833 add_gnat_descriptive_type_attribute (type_die, type, context_die);
17834 if (TYPE_ARTIFICIAL (type))
17835 add_AT_flag (type_die, DW_AT_artificial, 1);
17838 add_AT_flag (type_die, DW_AT_declaration, 1);
17840 add_pubtype (type, type_die);
17845 /* Generate a DIE to represent either a real live formal parameter decl or to
17846 represent just the type of some formal parameter position in some function
17849 Note that this routine is a bit unusual because its argument may be a
17850 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17851 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17852 node. If it's the former then this function is being called to output a
17853 DIE to represent a formal parameter object (or some inlining thereof). If
17854 it's the latter, then this function is only being called to output a
17855 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17856 argument type of some subprogram type.
17857 If EMIT_NAME_P is true, name and source coordinate attributes
17861 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
17862 dw_die_ref context_die)
17864 tree node_or_origin = node ? node : origin;
17865 tree ultimate_origin;
17866 dw_die_ref parm_die
17867 = new_die (DW_TAG_formal_parameter, context_die, node);
17869 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
17871 case tcc_declaration:
17872 ultimate_origin = decl_ultimate_origin (node_or_origin);
17873 if (node || ultimate_origin)
17874 origin = ultimate_origin;
17875 if (origin != NULL)
17876 add_abstract_origin_attribute (parm_die, origin);
17877 else if (emit_name_p)
17878 add_name_and_src_coords_attributes (parm_die, node);
17880 || (! DECL_ABSTRACT_P (node_or_origin)
17881 && variably_modified_type_p (TREE_TYPE (node_or_origin),
17882 decl_function_context
17883 (node_or_origin))))
17885 tree type = TREE_TYPE (node_or_origin);
17886 if (decl_by_reference_p (node_or_origin))
17887 add_type_attribute (parm_die, TREE_TYPE (type),
17888 TYPE_UNQUALIFIED, context_die);
17890 add_type_attribute (parm_die, type,
17891 decl_quals (node_or_origin),
17894 if (origin == NULL && DECL_ARTIFICIAL (node))
17895 add_AT_flag (parm_die, DW_AT_artificial, 1);
17897 if (node && node != origin)
17898 equate_decl_number_to_die (node, parm_die);
17899 if (! DECL_ABSTRACT_P (node_or_origin))
17900 add_location_or_const_value_attribute (parm_die, node_or_origin,
17901 node == NULL, DW_AT_location);
17906 /* We were called with some kind of a ..._TYPE node. */
17907 add_type_attribute (parm_die, node_or_origin, TYPE_UNQUALIFIED,
17912 gcc_unreachable ();
17918 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17919 children DW_TAG_formal_parameter DIEs representing the arguments of the
17922 PARM_PACK must be a function parameter pack.
17923 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17924 must point to the subsequent arguments of the function PACK_ARG belongs to.
17925 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17926 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17927 following the last one for which a DIE was generated. */
17930 gen_formal_parameter_pack_die (tree parm_pack,
17932 dw_die_ref subr_die,
17936 dw_die_ref parm_pack_die;
17938 gcc_assert (parm_pack
17939 && lang_hooks.function_parameter_pack_p (parm_pack)
17942 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
17943 add_src_coords_attributes (parm_pack_die, parm_pack);
17945 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg))
17947 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
17950 gen_formal_parameter_die (arg, NULL,
17951 false /* Don't emit name attribute. */,
17956 return parm_pack_die;
17959 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17960 at the end of an (ANSI prototyped) formal parameters list. */
17963 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
17965 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
17968 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17969 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17970 parameters as specified in some function type specification (except for
17971 those which appear as part of a function *definition*). */
17974 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
17977 tree formal_type = NULL;
17978 tree first_parm_type;
17981 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
17983 arg = DECL_ARGUMENTS (function_or_method_type);
17984 function_or_method_type = TREE_TYPE (function_or_method_type);
17989 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
17991 /* Make our first pass over the list of formal parameter types and output a
17992 DW_TAG_formal_parameter DIE for each one. */
17993 for (link = first_parm_type; link; )
17995 dw_die_ref parm_die;
17997 formal_type = TREE_VALUE (link);
17998 if (formal_type == void_type_node)
18001 /* Output a (nameless) DIE to represent the formal parameter itself. */
18002 if (!POINTER_BOUNDS_TYPE_P (formal_type))
18004 parm_die = gen_formal_parameter_die (formal_type, NULL,
18005 true /* Emit name attribute. */,
18007 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
18008 && link == first_parm_type)
18010 add_AT_flag (parm_die, DW_AT_artificial, 1);
18011 if (dwarf_version >= 3 || !dwarf_strict)
18012 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die);
18014 else if (arg && DECL_ARTIFICIAL (arg))
18015 add_AT_flag (parm_die, DW_AT_artificial, 1);
18018 link = TREE_CHAIN (link);
18020 arg = DECL_CHAIN (arg);
18023 /* If this function type has an ellipsis, add a
18024 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
18025 if (formal_type != void_type_node)
18026 gen_unspecified_parameters_die (function_or_method_type, context_die);
18028 /* Make our second (and final) pass over the list of formal parameter types
18029 and output DIEs to represent those types (as necessary). */
18030 for (link = TYPE_ARG_TYPES (function_or_method_type);
18031 link && TREE_VALUE (link);
18032 link = TREE_CHAIN (link))
18033 gen_type_die (TREE_VALUE (link), context_die);
18036 /* We want to generate the DIE for TYPE so that we can generate the
18037 die for MEMBER, which has been defined; we will need to refer back
18038 to the member declaration nested within TYPE. If we're trying to
18039 generate minimal debug info for TYPE, processing TYPE won't do the
18040 trick; we need to attach the member declaration by hand. */
18043 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
18045 gen_type_die (type, context_die);
18047 /* If we're trying to avoid duplicate debug info, we may not have
18048 emitted the member decl for this function. Emit it now. */
18049 if (TYPE_STUB_DECL (type)
18050 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
18051 && ! lookup_decl_die (member))
18053 dw_die_ref type_die;
18054 gcc_assert (!decl_ultimate_origin (member));
18056 push_decl_scope (type);
18057 type_die = lookup_type_die_strip_naming_typedef (type);
18058 if (TREE_CODE (member) == FUNCTION_DECL)
18059 gen_subprogram_die (member, type_die);
18060 else if (TREE_CODE (member) == FIELD_DECL)
18062 /* Ignore the nameless fields that are used to skip bits but handle
18063 C++ anonymous unions and structs. */
18064 if (DECL_NAME (member) != NULL_TREE
18065 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
18066 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
18068 gen_type_die (member_declared_type (member), type_die);
18069 gen_field_die (member, type_die);
18073 gen_variable_die (member, NULL_TREE, type_die);
18079 /* Forward declare these functions, because they are mutually recursive
18080 with their set_block_* pairing functions. */
18081 static void set_decl_origin_self (tree);
18082 static void set_decl_abstract_flags (tree, vec<tree> &);
18084 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
18085 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
18086 that it points to the node itself, thus indicating that the node is its
18087 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
18088 the given node is NULL, recursively descend the decl/block tree which
18089 it is the root of, and for each other ..._DECL or BLOCK node contained
18090 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
18091 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
18092 values to point to themselves. */
18095 set_block_origin_self (tree stmt)
18097 if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
18099 BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
18104 for (local_decl = BLOCK_VARS (stmt);
18105 local_decl != NULL_TREE;
18106 local_decl = DECL_CHAIN (local_decl))
18107 /* Do not recurse on nested functions since the inlining status
18108 of parent and child can be different as per the DWARF spec. */
18109 if (TREE_CODE (local_decl) != FUNCTION_DECL
18110 && !DECL_EXTERNAL (local_decl))
18111 set_decl_origin_self (local_decl);
18117 for (subblock = BLOCK_SUBBLOCKS (stmt);
18118 subblock != NULL_TREE;
18119 subblock = BLOCK_CHAIN (subblock))
18120 set_block_origin_self (subblock); /* Recurse. */
18125 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
18126 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
18127 node to so that it points to the node itself, thus indicating that the
18128 node represents its own (abstract) origin. Additionally, if the
18129 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
18130 the decl/block tree of which the given node is the root of, and for
18131 each other ..._DECL or BLOCK node contained therein whose
18132 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
18133 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
18134 point to themselves. */
18137 set_decl_origin_self (tree decl)
18139 if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
18141 DECL_ABSTRACT_ORIGIN (decl) = decl;
18142 if (TREE_CODE (decl) == FUNCTION_DECL)
18146 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
18147 DECL_ABSTRACT_ORIGIN (arg) = arg;
18148 if (DECL_INITIAL (decl) != NULL_TREE
18149 && DECL_INITIAL (decl) != error_mark_node)
18150 set_block_origin_self (DECL_INITIAL (decl));
18155 /* Given a pointer to some BLOCK node, set the BLOCK_ABSTRACT flag to 1
18156 and if it wasn't 1 before, push it to abstract_vec vector.
18157 For all local decls and all local sub-blocks (recursively) do it
18161 set_block_abstract_flags (tree stmt, vec<tree> &abstract_vec)
18167 if (!BLOCK_ABSTRACT (stmt))
18169 abstract_vec.safe_push (stmt);
18170 BLOCK_ABSTRACT (stmt) = 1;
18173 for (local_decl = BLOCK_VARS (stmt);
18174 local_decl != NULL_TREE;
18175 local_decl = DECL_CHAIN (local_decl))
18176 if (! DECL_EXTERNAL (local_decl))
18177 set_decl_abstract_flags (local_decl, abstract_vec);
18179 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
18181 local_decl = BLOCK_NONLOCALIZED_VAR (stmt, i);
18182 if ((TREE_CODE (local_decl) == VAR_DECL && !TREE_STATIC (local_decl))
18183 || TREE_CODE (local_decl) == PARM_DECL)
18184 set_decl_abstract_flags (local_decl, abstract_vec);
18187 for (subblock = BLOCK_SUBBLOCKS (stmt);
18188 subblock != NULL_TREE;
18189 subblock = BLOCK_CHAIN (subblock))
18190 set_block_abstract_flags (subblock, abstract_vec);
18193 /* Given a pointer to some ..._DECL node, set DECL_ABSTRACT_P flag on it
18194 to 1 and if it wasn't 1 before, push to abstract_vec vector.
18195 In the case where the decl is a FUNCTION_DECL also set the abstract
18196 flags for all of the parameters, local vars, local
18197 blocks and sub-blocks (recursively). */
18200 set_decl_abstract_flags (tree decl, vec<tree> &abstract_vec)
18202 if (!DECL_ABSTRACT_P (decl))
18204 abstract_vec.safe_push (decl);
18205 DECL_ABSTRACT_P (decl) = 1;
18208 if (TREE_CODE (decl) == FUNCTION_DECL)
18212 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
18213 if (!DECL_ABSTRACT_P (arg))
18215 abstract_vec.safe_push (arg);
18216 DECL_ABSTRACT_P (arg) = 1;
18218 if (DECL_INITIAL (decl) != NULL_TREE
18219 && DECL_INITIAL (decl) != error_mark_node)
18220 set_block_abstract_flags (DECL_INITIAL (decl), abstract_vec);
18224 /* Generate the DWARF2 info for the "abstract" instance of a function which we
18225 may later generate inlined and/or out-of-line instances of. */
18228 dwarf2out_abstract_function (tree decl)
18230 dw_die_ref old_die;
18233 hash_table<decl_loc_hasher> *old_decl_loc_table;
18234 hash_table<dw_loc_list_hasher> *old_cached_dw_loc_list_table;
18235 int old_call_site_count, old_tail_call_site_count;
18236 struct call_arg_loc_node *old_call_arg_locations;
18238 /* Make sure we have the actual abstract inline, not a clone. */
18239 decl = DECL_ORIGIN (decl);
18241 old_die = lookup_decl_die (decl);
18242 if (old_die && get_AT (old_die, DW_AT_inline))
18243 /* We've already generated the abstract instance. */
18246 /* We can be called while recursively when seeing block defining inlined subroutine
18247 DIE. Be sure to not clobber the outer location table nor use it or we would
18248 get locations in abstract instantces. */
18249 old_decl_loc_table = decl_loc_table;
18250 decl_loc_table = NULL;
18251 old_cached_dw_loc_list_table = cached_dw_loc_list_table;
18252 cached_dw_loc_list_table = NULL;
18253 old_call_arg_locations = call_arg_locations;
18254 call_arg_locations = NULL;
18255 old_call_site_count = call_site_count;
18256 call_site_count = -1;
18257 old_tail_call_site_count = tail_call_site_count;
18258 tail_call_site_count = -1;
18260 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
18261 we don't get confused by DECL_ABSTRACT_P. */
18262 if (debug_info_level > DINFO_LEVEL_TERSE)
18264 context = decl_class_context (decl);
18266 gen_type_die_for_member
18267 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ());
18270 /* Pretend we've just finished compiling this function. */
18271 save_fn = current_function_decl;
18272 current_function_decl = decl;
18274 auto_vec<tree, 64> abstract_vec;
18275 set_decl_abstract_flags (decl, abstract_vec);
18276 dwarf2out_decl (decl);
18279 FOR_EACH_VEC_ELT (abstract_vec, i, t)
18280 if (TREE_CODE (t) == BLOCK)
18281 BLOCK_ABSTRACT (t) = 0;
18283 DECL_ABSTRACT_P (t) = 0;
18285 current_function_decl = save_fn;
18286 decl_loc_table = old_decl_loc_table;
18287 cached_dw_loc_list_table = old_cached_dw_loc_list_table;
18288 call_arg_locations = old_call_arg_locations;
18289 call_site_count = old_call_site_count;
18290 tail_call_site_count = old_tail_call_site_count;
18293 /* Helper function of premark_used_types() which gets called through
18296 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18297 marked as unused by prune_unused_types. */
18300 premark_used_types_helper (tree const &type, void *)
18304 die = lookup_type_die (type);
18306 die->die_perennial_p = 1;
18310 /* Helper function of premark_types_used_by_global_vars which gets called
18311 through htab_traverse.
18313 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18314 marked as unused by prune_unused_types. The DIE of the type is marked
18315 only if the global variable using the type will actually be emitted. */
18318 premark_types_used_by_global_vars_helper (types_used_by_vars_entry **slot,
18321 struct types_used_by_vars_entry *entry;
18324 entry = (struct types_used_by_vars_entry *) *slot;
18325 gcc_assert (entry->type != NULL
18326 && entry->var_decl != NULL);
18327 die = lookup_type_die (entry->type);
18330 /* Ask cgraph if the global variable really is to be emitted.
18331 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18332 varpool_node *node = varpool_node::get (entry->var_decl);
18333 if (node && node->definition)
18335 die->die_perennial_p = 1;
18336 /* Keep the parent DIEs as well. */
18337 while ((die = die->die_parent) && die->die_perennial_p == 0)
18338 die->die_perennial_p = 1;
18344 /* Mark all members of used_types_hash as perennial. */
18347 premark_used_types (struct function *fun)
18349 if (fun && fun->used_types_hash)
18350 fun->used_types_hash->traverse<void *, premark_used_types_helper> (NULL);
18353 /* Mark all members of types_used_by_vars_entry as perennial. */
18356 premark_types_used_by_global_vars (void)
18358 if (types_used_by_vars_hash)
18359 types_used_by_vars_hash
18360 ->traverse<void *, premark_types_used_by_global_vars_helper> (NULL);
18363 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
18364 for CA_LOC call arg loc node. */
18367 gen_call_site_die (tree decl, dw_die_ref subr_die,
18368 struct call_arg_loc_node *ca_loc)
18370 dw_die_ref stmt_die = NULL, die;
18371 tree block = ca_loc->block;
18374 && block != DECL_INITIAL (decl)
18375 && TREE_CODE (block) == BLOCK)
18377 if (block_map.length () > BLOCK_NUMBER (block))
18378 stmt_die = block_map[BLOCK_NUMBER (block)];
18381 block = BLOCK_SUPERCONTEXT (block);
18383 if (stmt_die == NULL)
18384 stmt_die = subr_die;
18385 die = new_die (DW_TAG_GNU_call_site, stmt_die, NULL_TREE);
18386 add_AT_lbl_id (die, DW_AT_low_pc, ca_loc->label);
18387 if (ca_loc->tail_call_p)
18388 add_AT_flag (die, DW_AT_GNU_tail_call, 1);
18389 if (ca_loc->symbol_ref)
18391 dw_die_ref tdie = lookup_decl_die (SYMBOL_REF_DECL (ca_loc->symbol_ref));
18393 add_AT_die_ref (die, DW_AT_abstract_origin, tdie);
18395 add_AT_addr (die, DW_AT_abstract_origin, ca_loc->symbol_ref, false);
18400 /* Generate a DIE to represent a declared function (either file-scope or
18404 gen_subprogram_die (tree decl, dw_die_ref context_die)
18406 tree origin = decl_ultimate_origin (decl);
18407 dw_die_ref subr_die;
18409 dw_die_ref old_die = lookup_decl_die (decl);
18410 int declaration = (current_function_decl != decl
18411 || class_or_namespace_scope_p (context_die));
18413 premark_used_types (DECL_STRUCT_FUNCTION (decl));
18415 /* It is possible to have both DECL_ABSTRACT_P and DECLARATION be true if we
18416 started to generate the abstract instance of an inline, decided to output
18417 its containing class, and proceeded to emit the declaration of the inline
18418 from the member list for the class. If so, DECLARATION takes priority;
18419 we'll get back to the abstract instance when done with the class. */
18421 /* The class-scope declaration DIE must be the primary DIE. */
18422 if (origin && declaration && class_or_namespace_scope_p (context_die))
18425 gcc_assert (!old_die);
18428 /* Now that the C++ front end lazily declares artificial member fns, we
18429 might need to retrofit the declaration into its class. */
18430 if (!declaration && !origin && !old_die
18431 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
18432 && !class_or_namespace_scope_p (context_die)
18433 && debug_info_level > DINFO_LEVEL_TERSE)
18434 old_die = force_decl_die (decl);
18436 if (origin != NULL)
18438 gcc_assert (!declaration || local_scope_p (context_die));
18440 /* Fixup die_parent for the abstract instance of a nested
18441 inline function. */
18442 if (old_die && old_die->die_parent == NULL)
18443 add_child_die (context_die, old_die);
18445 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18446 add_abstract_origin_attribute (subr_die, origin);
18447 /* This is where the actual code for a cloned function is.
18448 Let's emit linkage name attribute for it. This helps
18449 debuggers to e.g, set breakpoints into
18450 constructors/destructors when the user asks "break
18452 add_linkage_name (subr_die, decl);
18456 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
18457 struct dwarf_file_data * file_index = lookup_filename (s.file);
18459 if (!get_AT_flag (old_die, DW_AT_declaration)
18460 /* We can have a normal definition following an inline one in the
18461 case of redefinition of GNU C extern inlines.
18462 It seems reasonable to use AT_specification in this case. */
18463 && !get_AT (old_die, DW_AT_inline))
18465 /* Detect and ignore this case, where we are trying to output
18466 something we have already output. */
18470 /* If the definition comes from the same place as the declaration,
18471 maybe use the old DIE. We always want the DIE for this function
18472 that has the *_pc attributes to be under comp_unit_die so the
18473 debugger can find it. We also need to do this for abstract
18474 instances of inlines, since the spec requires the out-of-line copy
18475 to have the same parent. For local class methods, this doesn't
18476 apply; we just use the old DIE. */
18477 if ((is_cu_die (old_die->die_parent) || context_die == NULL)
18478 && (DECL_ARTIFICIAL (decl)
18479 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
18480 && (get_AT_unsigned (old_die, DW_AT_decl_line)
18481 == (unsigned) s.line))))
18483 subr_die = old_die;
18485 /* Clear out the declaration attribute and the formal parameters.
18486 Do not remove all children, because it is possible that this
18487 declaration die was forced using force_decl_die(). In such
18488 cases die that forced declaration die (e.g. TAG_imported_module)
18489 is one of the children that we do not want to remove. */
18490 remove_AT (subr_die, DW_AT_declaration);
18491 remove_AT (subr_die, DW_AT_object_pointer);
18492 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
18496 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18497 add_AT_specification (subr_die, old_die);
18498 add_pubname (decl, subr_die);
18499 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
18500 add_AT_file (subr_die, DW_AT_decl_file, file_index);
18501 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
18502 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
18504 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
18505 emit the real type on the definition die. */
18506 if (is_cxx() && debug_info_level > DINFO_LEVEL_TERSE)
18508 dw_die_ref die = get_AT_ref (old_die, DW_AT_type);
18509 if (die == auto_die || die == decltype_auto_die)
18510 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18511 TYPE_UNQUALIFIED, context_die);
18517 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18519 if (TREE_PUBLIC (decl))
18520 add_AT_flag (subr_die, DW_AT_external, 1);
18522 add_name_and_src_coords_attributes (subr_die, decl);
18523 add_pubname (decl, subr_die);
18524 if (debug_info_level > DINFO_LEVEL_TERSE)
18526 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
18527 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18528 TYPE_UNQUALIFIED, context_die);
18531 add_pure_or_virtual_attribute (subr_die, decl);
18532 if (DECL_ARTIFICIAL (decl))
18533 add_AT_flag (subr_die, DW_AT_artificial, 1);
18535 if (TREE_THIS_VOLATILE (decl) && (dwarf_version >= 5 || !dwarf_strict))
18536 add_AT_flag (subr_die, DW_AT_noreturn, 1);
18538 add_accessibility_attribute (subr_die, decl);
18543 if (!old_die || !get_AT (old_die, DW_AT_inline))
18545 add_AT_flag (subr_die, DW_AT_declaration, 1);
18547 /* If this is an explicit function declaration then generate
18548 a DW_AT_explicit attribute. */
18549 if (lang_hooks.decls.function_decl_explicit_p (decl)
18550 && (dwarf_version >= 3 || !dwarf_strict))
18551 add_AT_flag (subr_die, DW_AT_explicit, 1);
18553 /* If this is a C++11 deleted special function member then generate
18554 a DW_AT_GNU_deleted attribute. */
18555 if (lang_hooks.decls.function_decl_deleted_p (decl)
18556 && (! dwarf_strict))
18557 add_AT_flag (subr_die, DW_AT_GNU_deleted, 1);
18559 /* The first time we see a member function, it is in the context of
18560 the class to which it belongs. We make sure of this by emitting
18561 the class first. The next time is the definition, which is
18562 handled above. The two may come from the same source text.
18564 Note that force_decl_die() forces function declaration die. It is
18565 later reused to represent definition. */
18566 equate_decl_number_to_die (decl, subr_die);
18569 else if (DECL_ABSTRACT_P (decl))
18571 if (DECL_DECLARED_INLINE_P (decl))
18573 if (cgraph_function_possibly_inlined_p (decl))
18574 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
18576 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
18580 if (cgraph_function_possibly_inlined_p (decl))
18581 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
18583 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
18586 if (DECL_DECLARED_INLINE_P (decl)
18587 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
18588 add_AT_flag (subr_die, DW_AT_artificial, 1);
18590 equate_decl_number_to_die (decl, subr_die);
18592 else if (!DECL_EXTERNAL (decl))
18594 HOST_WIDE_INT cfa_fb_offset;
18595 struct function *fun = DECL_STRUCT_FUNCTION (decl);
18597 if (!old_die || !get_AT (old_die, DW_AT_inline))
18598 equate_decl_number_to_die (decl, subr_die);
18600 gcc_checking_assert (fun);
18601 if (!flag_reorder_blocks_and_partition)
18603 dw_fde_ref fde = fun->fde;
18604 if (fde->dw_fde_begin)
18606 /* We have already generated the labels. */
18607 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
18608 fde->dw_fde_end, false);
18612 /* Create start/end labels and add the range. */
18613 char label_id_low[MAX_ARTIFICIAL_LABEL_BYTES];
18614 char label_id_high[MAX_ARTIFICIAL_LABEL_BYTES];
18615 ASM_GENERATE_INTERNAL_LABEL (label_id_low, FUNC_BEGIN_LABEL,
18616 current_function_funcdef_no);
18617 ASM_GENERATE_INTERNAL_LABEL (label_id_high, FUNC_END_LABEL,
18618 current_function_funcdef_no);
18619 add_AT_low_high_pc (subr_die, label_id_low, label_id_high,
18623 #if VMS_DEBUGGING_INFO
18624 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18625 Section 2.3 Prologue and Epilogue Attributes:
18626 When a breakpoint is set on entry to a function, it is generally
18627 desirable for execution to be suspended, not on the very first
18628 instruction of the function, but rather at a point after the
18629 function's frame has been set up, after any language defined local
18630 declaration processing has been completed, and before execution of
18631 the first statement of the function begins. Debuggers generally
18632 cannot properly determine where this point is. Similarly for a
18633 breakpoint set on exit from a function. The prologue and epilogue
18634 attributes allow a compiler to communicate the location(s) to use. */
18637 if (fde->dw_fde_vms_end_prologue)
18638 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
18639 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
18641 if (fde->dw_fde_vms_begin_epilogue)
18642 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
18643 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
18650 /* Generate pubnames entries for the split function code ranges. */
18651 dw_fde_ref fde = fun->fde;
18653 if (fde->dw_fde_second_begin)
18655 if (dwarf_version >= 3 || !dwarf_strict)
18657 /* We should use ranges for non-contiguous code section
18658 addresses. Use the actual code range for the initial
18659 section, since the HOT/COLD labels might precede an
18660 alignment offset. */
18661 bool range_list_added = false;
18662 add_ranges_by_labels (subr_die, fde->dw_fde_begin,
18663 fde->dw_fde_end, &range_list_added,
18665 add_ranges_by_labels (subr_die, fde->dw_fde_second_begin,
18666 fde->dw_fde_second_end,
18667 &range_list_added, false);
18668 if (range_list_added)
18673 /* There is no real support in DW2 for this .. so we make
18674 a work-around. First, emit the pub name for the segment
18675 containing the function label. Then make and emit a
18676 simplified subprogram DIE for the second segment with the
18677 name pre-fixed by __hot/cold_sect_of_. We use the same
18678 linkage name for the second die so that gdb will find both
18679 sections when given "b foo". */
18680 const char *name = NULL;
18681 tree decl_name = DECL_NAME (decl);
18682 dw_die_ref seg_die;
18684 /* Do the 'primary' section. */
18685 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
18686 fde->dw_fde_end, false);
18688 /* Build a minimal DIE for the secondary section. */
18689 seg_die = new_die (DW_TAG_subprogram,
18690 subr_die->die_parent, decl);
18692 if (TREE_PUBLIC (decl))
18693 add_AT_flag (seg_die, DW_AT_external, 1);
18695 if (decl_name != NULL
18696 && IDENTIFIER_POINTER (decl_name) != NULL)
18698 name = dwarf2_name (decl, 1);
18699 if (! DECL_ARTIFICIAL (decl))
18700 add_src_coords_attributes (seg_die, decl);
18702 add_linkage_name (seg_die, decl);
18704 gcc_assert (name != NULL);
18705 add_pure_or_virtual_attribute (seg_die, decl);
18706 if (DECL_ARTIFICIAL (decl))
18707 add_AT_flag (seg_die, DW_AT_artificial, 1);
18709 name = concat ("__second_sect_of_", name, NULL);
18710 add_AT_low_high_pc (seg_die, fde->dw_fde_second_begin,
18711 fde->dw_fde_second_end, false);
18712 add_name_attribute (seg_die, name);
18713 if (want_pubnames ())
18714 add_pubname_string (name, seg_die);
18718 add_AT_low_high_pc (subr_die, fde->dw_fde_begin, fde->dw_fde_end,
18722 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
18724 /* We define the "frame base" as the function's CFA. This is more
18725 convenient for several reasons: (1) It's stable across the prologue
18726 and epilogue, which makes it better than just a frame pointer,
18727 (2) With dwarf3, there exists a one-byte encoding that allows us
18728 to reference the .debug_frame data by proxy, but failing that,
18729 (3) We can at least reuse the code inspection and interpretation
18730 code that determines the CFA position at various points in the
18732 if (dwarf_version >= 3 && targetm.debug_unwind_info () == UI_DWARF2)
18734 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
18735 add_AT_loc (subr_die, DW_AT_frame_base, op);
18739 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
18740 if (list->dw_loc_next)
18741 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
18743 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
18746 /* Compute a displacement from the "steady-state frame pointer" to
18747 the CFA. The former is what all stack slots and argument slots
18748 will reference in the rtl; the latter is what we've told the
18749 debugger about. We'll need to adjust all frame_base references
18750 by this displacement. */
18751 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
18753 if (fun->static_chain_decl)
18754 add_AT_location_description (subr_die, DW_AT_static_link,
18755 loc_list_from_tree (fun->static_chain_decl, 2, NULL));
18758 /* Generate child dies for template paramaters. */
18759 if (debug_info_level > DINFO_LEVEL_TERSE)
18760 gen_generic_params_dies (decl);
18762 /* Now output descriptions of the arguments for this function. This gets
18763 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18764 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18765 `...' at the end of the formal parameter list. In order to find out if
18766 there was a trailing ellipsis or not, we must instead look at the type
18767 associated with the FUNCTION_DECL. This will be a node of type
18768 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18769 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18770 an ellipsis at the end. */
18772 /* In the case where we are describing a mere function declaration, all we
18773 need to do here (and all we *can* do here) is to describe the *types* of
18774 its formal parameters. */
18775 if (debug_info_level <= DINFO_LEVEL_TERSE)
18777 else if (declaration)
18778 gen_formal_types_die (decl, subr_die);
18781 /* Generate DIEs to represent all known formal parameters. */
18782 tree parm = DECL_ARGUMENTS (decl);
18783 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
18784 tree generic_decl_parm = generic_decl
18785 ? DECL_ARGUMENTS (generic_decl)
18788 /* Now we want to walk the list of parameters of the function and
18789 emit their relevant DIEs.
18791 We consider the case of DECL being an instance of a generic function
18792 as well as it being a normal function.
18794 If DECL is an instance of a generic function we walk the
18795 parameters of the generic function declaration _and_ the parameters of
18796 DECL itself. This is useful because we want to emit specific DIEs for
18797 function parameter packs and those are declared as part of the
18798 generic function declaration. In that particular case,
18799 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18800 That DIE has children DIEs representing the set of arguments
18801 of the pack. Note that the set of pack arguments can be empty.
18802 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18805 Otherwise, we just consider the parameters of DECL. */
18806 while (generic_decl_parm || parm)
18808 if (generic_decl_parm
18809 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
18810 gen_formal_parameter_pack_die (generic_decl_parm,
18813 else if (parm && !POINTER_BOUNDS_P (parm))
18815 dw_die_ref parm_die = gen_decl_die (parm, NULL, subr_die);
18817 if (parm == DECL_ARGUMENTS (decl)
18818 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
18820 && (dwarf_version >= 3 || !dwarf_strict))
18821 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die);
18823 parm = DECL_CHAIN (parm);
18826 parm = DECL_CHAIN (parm);
18828 if (generic_decl_parm)
18829 generic_decl_parm = DECL_CHAIN (generic_decl_parm);
18832 /* Decide whether we need an unspecified_parameters DIE at the end.
18833 There are 2 more cases to do this for: 1) the ansi ... declaration -
18834 this is detectable when the end of the arg list is not a
18835 void_type_node 2) an unprototyped function declaration (not a
18836 definition). This just means that we have no info about the
18837 parameters at all. */
18838 if (prototype_p (TREE_TYPE (decl)))
18840 /* This is the prototyped case, check for.... */
18841 if (stdarg_p (TREE_TYPE (decl)))
18842 gen_unspecified_parameters_die (decl, subr_die);
18844 else if (DECL_INITIAL (decl) == NULL_TREE)
18845 gen_unspecified_parameters_die (decl, subr_die);
18848 /* Output Dwarf info for all of the stuff within the body of the function
18849 (if it has one - it may be just a declaration). */
18850 outer_scope = DECL_INITIAL (decl);
18852 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18853 a function. This BLOCK actually represents the outermost binding contour
18854 for the function, i.e. the contour in which the function's formal
18855 parameters and labels get declared. Curiously, it appears that the front
18856 end doesn't actually put the PARM_DECL nodes for the current function onto
18857 the BLOCK_VARS list for this outer scope, but are strung off of the
18858 DECL_ARGUMENTS list for the function instead.
18860 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18861 the LABEL_DECL nodes for the function however, and we output DWARF info
18862 for those in decls_for_scope. Just within the `outer_scope' there will be
18863 a BLOCK node representing the function's outermost pair of curly braces,
18864 and any blocks used for the base and member initializers of a C++
18865 constructor function. */
18866 if (! declaration && outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
18868 int call_site_note_count = 0;
18869 int tail_call_site_note_count = 0;
18871 /* Emit a DW_TAG_variable DIE for a named return value. */
18872 if (DECL_NAME (DECL_RESULT (decl)))
18873 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
18875 decls_for_scope (outer_scope, subr_die);
18877 if (call_arg_locations && !dwarf_strict)
18879 struct call_arg_loc_node *ca_loc;
18880 for (ca_loc = call_arg_locations; ca_loc; ca_loc = ca_loc->next)
18882 dw_die_ref die = NULL;
18883 rtx tloc = NULL_RTX, tlocc = NULL_RTX;
18886 for (arg = NOTE_VAR_LOCATION (ca_loc->call_arg_loc_note);
18887 arg; arg = next_arg)
18889 dw_loc_descr_ref reg, val;
18890 machine_mode mode = GET_MODE (XEXP (XEXP (arg, 0), 1));
18891 dw_die_ref cdie, tdie = NULL;
18893 next_arg = XEXP (arg, 1);
18894 if (REG_P (XEXP (XEXP (arg, 0), 0))
18896 && MEM_P (XEXP (XEXP (next_arg, 0), 0))
18897 && REG_P (XEXP (XEXP (XEXP (next_arg, 0), 0), 0))
18898 && REGNO (XEXP (XEXP (arg, 0), 0))
18899 == REGNO (XEXP (XEXP (XEXP (next_arg, 0), 0), 0)))
18900 next_arg = XEXP (next_arg, 1);
18901 if (mode == VOIDmode)
18903 mode = GET_MODE (XEXP (XEXP (arg, 0), 0));
18904 if (mode == VOIDmode)
18905 mode = GET_MODE (XEXP (arg, 0));
18907 if (mode == VOIDmode || mode == BLKmode)
18909 if (XEXP (XEXP (arg, 0), 0) == pc_rtx)
18911 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
18912 tloc = XEXP (XEXP (arg, 0), 1);
18915 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) == CLOBBER
18916 && XEXP (XEXP (XEXP (arg, 0), 0), 0) == pc_rtx)
18918 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
18919 tlocc = XEXP (XEXP (arg, 0), 1);
18923 if (REG_P (XEXP (XEXP (arg, 0), 0)))
18924 reg = reg_loc_descriptor (XEXP (XEXP (arg, 0), 0),
18925 VAR_INIT_STATUS_INITIALIZED);
18926 else if (MEM_P (XEXP (XEXP (arg, 0), 0)))
18928 rtx mem = XEXP (XEXP (arg, 0), 0);
18929 reg = mem_loc_descriptor (XEXP (mem, 0),
18930 get_address_mode (mem),
18932 VAR_INIT_STATUS_INITIALIZED);
18934 else if (GET_CODE (XEXP (XEXP (arg, 0), 0))
18935 == DEBUG_PARAMETER_REF)
18938 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg, 0), 0));
18939 tdie = lookup_decl_die (tdecl);
18946 && GET_CODE (XEXP (XEXP (arg, 0), 0))
18947 != DEBUG_PARAMETER_REF)
18949 val = mem_loc_descriptor (XEXP (XEXP (arg, 0), 1), mode,
18951 VAR_INIT_STATUS_INITIALIZED);
18955 die = gen_call_site_die (decl, subr_die, ca_loc);
18956 cdie = new_die (DW_TAG_GNU_call_site_parameter, die,
18959 add_AT_loc (cdie, DW_AT_location, reg);
18960 else if (tdie != NULL)
18961 add_AT_die_ref (cdie, DW_AT_abstract_origin, tdie);
18962 add_AT_loc (cdie, DW_AT_GNU_call_site_value, val);
18963 if (next_arg != XEXP (arg, 1))
18965 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 1));
18966 if (mode == VOIDmode)
18967 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 0));
18968 val = mem_loc_descriptor (XEXP (XEXP (XEXP (arg, 1),
18971 VAR_INIT_STATUS_INITIALIZED);
18973 add_AT_loc (cdie, DW_AT_GNU_call_site_data_value, val);
18977 && (ca_loc->symbol_ref || tloc))
18978 die = gen_call_site_die (decl, subr_die, ca_loc);
18979 if (die != NULL && (tloc != NULL_RTX || tlocc != NULL_RTX))
18981 dw_loc_descr_ref tval = NULL;
18983 if (tloc != NULL_RTX)
18984 tval = mem_loc_descriptor (tloc,
18985 GET_MODE (tloc) == VOIDmode
18986 ? Pmode : GET_MODE (tloc),
18988 VAR_INIT_STATUS_INITIALIZED);
18990 add_AT_loc (die, DW_AT_GNU_call_site_target, tval);
18991 else if (tlocc != NULL_RTX)
18993 tval = mem_loc_descriptor (tlocc,
18994 GET_MODE (tlocc) == VOIDmode
18995 ? Pmode : GET_MODE (tlocc),
18997 VAR_INIT_STATUS_INITIALIZED);
18999 add_AT_loc (die, DW_AT_GNU_call_site_target_clobbered,
19005 call_site_note_count++;
19006 if (ca_loc->tail_call_p)
19007 tail_call_site_note_count++;
19011 call_arg_locations = NULL;
19012 call_arg_loc_last = NULL;
19013 if (tail_call_site_count >= 0
19014 && tail_call_site_count == tail_call_site_note_count
19017 if (call_site_count >= 0
19018 && call_site_count == call_site_note_count)
19019 add_AT_flag (subr_die, DW_AT_GNU_all_call_sites, 1);
19021 add_AT_flag (subr_die, DW_AT_GNU_all_tail_call_sites, 1);
19023 call_site_count = -1;
19024 tail_call_site_count = -1;
19027 if (subr_die != old_die)
19028 /* Add the calling convention attribute if requested. */
19029 add_calling_convention_attribute (subr_die, decl);
19032 /* Returns a hash value for X (which really is a die_struct). */
19035 block_die_hasher::hash (die_struct *d)
19037 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
19040 /* Return nonzero if decl_id and die_parent of die_struct X is the same
19041 as decl_id and die_parent of die_struct Y. */
19044 block_die_hasher::equal (die_struct *x, die_struct *y)
19046 return x->decl_id == y->decl_id && x->die_parent == y->die_parent;
19049 /* Generate a DIE to represent a declared data object.
19050 Either DECL or ORIGIN must be non-null. */
19053 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
19055 HOST_WIDE_INT off = 0;
19057 tree decl_or_origin = decl ? decl : origin;
19058 tree ultimate_origin;
19059 dw_die_ref var_die;
19060 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
19061 dw_die_ref origin_die;
19062 bool declaration = (DECL_EXTERNAL (decl_or_origin)
19063 || class_or_namespace_scope_p (context_die));
19064 bool specialization_p = false;
19066 ultimate_origin = decl_ultimate_origin (decl_or_origin);
19067 if (decl || ultimate_origin)
19068 origin = ultimate_origin;
19069 com_decl = fortran_common (decl_or_origin, &off);
19071 /* Symbol in common gets emitted as a child of the common block, in the form
19072 of a data member. */
19075 dw_die_ref com_die;
19076 dw_loc_list_ref loc;
19077 die_node com_die_arg;
19079 var_die = lookup_decl_die (decl_or_origin);
19082 if (get_AT (var_die, DW_AT_location) == NULL)
19084 loc = loc_list_from_tree (com_decl, off ? 1 : 2, NULL);
19089 /* Optimize the common case. */
19090 if (single_element_loc_list_p (loc)
19091 && loc->expr->dw_loc_opc == DW_OP_addr
19092 && loc->expr->dw_loc_next == NULL
19093 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
19096 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
19097 loc->expr->dw_loc_oprnd1.v.val_addr
19098 = plus_constant (GET_MODE (x), x , off);
19101 loc_list_plus_const (loc, off);
19103 add_AT_location_description (var_die, DW_AT_location, loc);
19104 remove_AT (var_die, DW_AT_declaration);
19110 if (common_block_die_table == NULL)
19111 common_block_die_table = hash_table<block_die_hasher>::create_ggc (10);
19113 com_die_arg.decl_id = DECL_UID (com_decl);
19114 com_die_arg.die_parent = context_die;
19115 com_die = common_block_die_table->find (&com_die_arg);
19116 loc = loc_list_from_tree (com_decl, 2, NULL);
19117 if (com_die == NULL)
19120 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
19123 com_die = new_die (DW_TAG_common_block, context_die, decl);
19124 add_name_and_src_coords_attributes (com_die, com_decl);
19127 add_AT_location_description (com_die, DW_AT_location, loc);
19128 /* Avoid sharing the same loc descriptor between
19129 DW_TAG_common_block and DW_TAG_variable. */
19130 loc = loc_list_from_tree (com_decl, 2, NULL);
19132 else if (DECL_EXTERNAL (decl_or_origin))
19133 add_AT_flag (com_die, DW_AT_declaration, 1);
19134 if (want_pubnames ())
19135 add_pubname_string (cnam, com_die); /* ??? needed? */
19136 com_die->decl_id = DECL_UID (com_decl);
19137 slot = common_block_die_table->find_slot (com_die, INSERT);
19140 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
19142 add_AT_location_description (com_die, DW_AT_location, loc);
19143 loc = loc_list_from_tree (com_decl, 2, NULL);
19144 remove_AT (com_die, DW_AT_declaration);
19146 var_die = new_die (DW_TAG_variable, com_die, decl);
19147 add_name_and_src_coords_attributes (var_die, decl_or_origin);
19148 add_type_attribute (var_die, TREE_TYPE (decl_or_origin),
19149 decl_quals (decl_or_origin), context_die);
19150 add_AT_flag (var_die, DW_AT_external, 1);
19155 /* Optimize the common case. */
19156 if (single_element_loc_list_p (loc)
19157 && loc->expr->dw_loc_opc == DW_OP_addr
19158 && loc->expr->dw_loc_next == NULL
19159 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
19161 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
19162 loc->expr->dw_loc_oprnd1.v.val_addr
19163 = plus_constant (GET_MODE (x), x, off);
19166 loc_list_plus_const (loc, off);
19168 add_AT_location_description (var_die, DW_AT_location, loc);
19170 else if (DECL_EXTERNAL (decl_or_origin))
19171 add_AT_flag (var_die, DW_AT_declaration, 1);
19173 equate_decl_number_to_die (decl, var_die);
19177 /* If the compiler emitted a definition for the DECL declaration
19178 and if we already emitted a DIE for it, don't emit a second
19179 DIE for it again. Allow re-declarations of DECLs that are
19180 inside functions, though. */
19181 if (old_die && declaration && !local_scope_p (context_die))
19184 /* For static data members, the declaration in the class is supposed
19185 to have DW_TAG_member tag; the specification should still be
19186 DW_TAG_variable referencing the DW_TAG_member DIE. */
19187 if (declaration && class_scope_p (context_die))
19188 var_die = new_die (DW_TAG_member, context_die, decl);
19190 var_die = new_die (DW_TAG_variable, context_die, decl);
19193 if (origin != NULL)
19194 origin_die = add_abstract_origin_attribute (var_die, origin);
19196 /* Loop unrolling can create multiple blocks that refer to the same
19197 static variable, so we must test for the DW_AT_declaration flag.
19199 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
19200 copy decls and set the DECL_ABSTRACT_P flag on them instead of
19203 ??? Duplicated blocks have been rewritten to use .debug_ranges.
19205 ??? The declare_in_namespace support causes us to get two DIEs for one
19206 variable, both of which are declarations. We want to avoid considering
19207 one to be a specification, so we must test that this DIE is not a
19209 else if (old_die && TREE_STATIC (decl) && ! declaration
19210 && get_AT_flag (old_die, DW_AT_declaration) == 1)
19212 /* This is a definition of a C++ class level static. */
19213 add_AT_specification (var_die, old_die);
19214 specialization_p = true;
19215 if (DECL_NAME (decl))
19217 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
19218 struct dwarf_file_data * file_index = lookup_filename (s.file);
19220 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
19221 add_AT_file (var_die, DW_AT_decl_file, file_index);
19223 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
19224 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
19226 if (old_die->die_tag == DW_TAG_member)
19227 add_linkage_name (var_die, decl);
19231 add_name_and_src_coords_attributes (var_die, decl);
19233 if ((origin == NULL && !specialization_p)
19235 && !DECL_ABSTRACT_P (decl_or_origin)
19236 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
19237 decl_function_context
19238 (decl_or_origin))))
19240 tree type = TREE_TYPE (decl_or_origin);
19242 if (decl_by_reference_p (decl_or_origin))
19243 add_type_attribute (var_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19246 add_type_attribute (var_die, type, decl_quals (decl_or_origin),
19250 if (origin == NULL && !specialization_p)
19252 if (TREE_PUBLIC (decl))
19253 add_AT_flag (var_die, DW_AT_external, 1);
19255 if (DECL_ARTIFICIAL (decl))
19256 add_AT_flag (var_die, DW_AT_artificial, 1);
19258 add_accessibility_attribute (var_die, decl);
19262 add_AT_flag (var_die, DW_AT_declaration, 1);
19264 if (decl && (DECL_ABSTRACT_P (decl) || declaration || old_die == NULL))
19265 equate_decl_number_to_die (decl, var_die);
19268 && (! DECL_ABSTRACT_P (decl_or_origin)
19269 /* Local static vars are shared between all clones/inlines,
19270 so emit DW_AT_location on the abstract DIE if DECL_RTL is
19272 || (TREE_CODE (decl_or_origin) == VAR_DECL
19273 && TREE_STATIC (decl_or_origin)
19274 && DECL_RTL_SET_P (decl_or_origin)))
19275 /* When abstract origin already has DW_AT_location attribute, no need
19276 to add it again. */
19277 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
19279 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
19280 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
19281 defer_location (decl_or_origin, var_die);
19283 add_location_or_const_value_attribute (var_die, decl_or_origin,
19284 decl == NULL, DW_AT_location);
19285 add_pubname (decl_or_origin, var_die);
19288 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
19291 /* Generate a DIE to represent a named constant. */
19294 gen_const_die (tree decl, dw_die_ref context_die)
19296 dw_die_ref const_die;
19297 tree type = TREE_TYPE (decl);
19299 const_die = new_die (DW_TAG_constant, context_die, decl);
19300 add_name_and_src_coords_attributes (const_die, decl);
19301 add_type_attribute (const_die, type, TYPE_QUAL_CONST, context_die);
19302 if (TREE_PUBLIC (decl))
19303 add_AT_flag (const_die, DW_AT_external, 1);
19304 if (DECL_ARTIFICIAL (decl))
19305 add_AT_flag (const_die, DW_AT_artificial, 1);
19306 tree_add_const_value_attribute_for_decl (const_die, decl);
19309 /* Generate a DIE to represent a label identifier. */
19312 gen_label_die (tree decl, dw_die_ref context_die)
19314 tree origin = decl_ultimate_origin (decl);
19315 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
19317 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19319 if (origin != NULL)
19320 add_abstract_origin_attribute (lbl_die, origin);
19322 add_name_and_src_coords_attributes (lbl_die, decl);
19324 if (DECL_ABSTRACT_P (decl))
19325 equate_decl_number_to_die (decl, lbl_die);
19328 insn = DECL_RTL_IF_SET (decl);
19330 /* Deleted labels are programmer specified labels which have been
19331 eliminated because of various optimizations. We still emit them
19332 here so that it is possible to put breakpoints on them. */
19336 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
19338 /* When optimization is enabled (via -O) some parts of the compiler
19339 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19340 represent source-level labels which were explicitly declared by
19341 the user. This really shouldn't be happening though, so catch
19342 it if it ever does happen. */
19343 gcc_assert (!as_a<rtx_insn *> (insn)->deleted ());
19345 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
19346 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19350 && NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL
19351 && CODE_LABEL_NUMBER (insn) != -1)
19353 ASM_GENERATE_INTERNAL_LABEL (label, "LDL", CODE_LABEL_NUMBER (insn));
19354 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19359 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19360 attributes to the DIE for a block STMT, to describe where the inlined
19361 function was called from. This is similar to add_src_coords_attributes. */
19364 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
19366 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
19368 if (dwarf_version >= 3 || !dwarf_strict)
19370 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
19371 add_AT_unsigned (die, DW_AT_call_line, s.line);
19376 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19377 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19380 add_high_low_attributes (tree stmt, dw_die_ref die)
19382 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19384 if (BLOCK_FRAGMENT_CHAIN (stmt)
19385 && (dwarf_version >= 3 || !dwarf_strict))
19387 tree chain, superblock = NULL_TREE;
19389 dw_attr_ref attr = NULL;
19391 if (inlined_function_outer_scope_p (stmt))
19393 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19394 BLOCK_NUMBER (stmt));
19395 add_AT_lbl_id (die, DW_AT_entry_pc, label);
19398 /* Optimize duplicate .debug_ranges lists or even tails of
19399 lists. If this BLOCK has same ranges as its supercontext,
19400 lookup DW_AT_ranges attribute in the supercontext (and
19401 recursively so), verify that the ranges_table contains the
19402 right values and use it instead of adding a new .debug_range. */
19403 for (chain = stmt, pdie = die;
19404 BLOCK_SAME_RANGE (chain);
19405 chain = BLOCK_SUPERCONTEXT (chain))
19407 dw_attr_ref new_attr;
19409 pdie = pdie->die_parent;
19412 if (BLOCK_SUPERCONTEXT (chain) == NULL_TREE)
19414 new_attr = get_AT (pdie, DW_AT_ranges);
19415 if (new_attr == NULL
19416 || new_attr->dw_attr_val.val_class != dw_val_class_range_list)
19419 superblock = BLOCK_SUPERCONTEXT (chain);
19422 && (ranges_table[attr->dw_attr_val.v.val_offset
19423 / 2 / DWARF2_ADDR_SIZE].num
19424 == BLOCK_NUMBER (superblock))
19425 && BLOCK_FRAGMENT_CHAIN (superblock))
19427 unsigned long off = attr->dw_attr_val.v.val_offset
19428 / 2 / DWARF2_ADDR_SIZE;
19429 unsigned long supercnt = 0, thiscnt = 0;
19430 for (chain = BLOCK_FRAGMENT_CHAIN (superblock);
19431 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
19434 gcc_checking_assert (ranges_table[off + supercnt].num
19435 == BLOCK_NUMBER (chain));
19437 gcc_checking_assert (ranges_table[off + supercnt + 1].num == 0);
19438 for (chain = BLOCK_FRAGMENT_CHAIN (stmt);
19439 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
19441 gcc_assert (supercnt >= thiscnt);
19442 add_AT_range_list (die, DW_AT_ranges,
19443 ((off + supercnt - thiscnt)
19444 * 2 * DWARF2_ADDR_SIZE),
19449 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt), false);
19451 chain = BLOCK_FRAGMENT_CHAIN (stmt);
19454 add_ranges (chain);
19455 chain = BLOCK_FRAGMENT_CHAIN (chain);
19462 char label_high[MAX_ARTIFICIAL_LABEL_BYTES];
19463 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19464 BLOCK_NUMBER (stmt));
19465 ASM_GENERATE_INTERNAL_LABEL (label_high, BLOCK_END_LABEL,
19466 BLOCK_NUMBER (stmt));
19467 add_AT_low_high_pc (die, label, label_high, false);
19471 /* Generate a DIE for a lexical block. */
19474 gen_lexical_block_die (tree stmt, dw_die_ref context_die)
19476 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
19478 if (call_arg_locations)
19480 if (block_map.length () <= BLOCK_NUMBER (stmt))
19481 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1);
19482 block_map[BLOCK_NUMBER (stmt)] = stmt_die;
19485 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
19486 add_high_low_attributes (stmt, stmt_die);
19488 decls_for_scope (stmt, stmt_die);
19491 /* Generate a DIE for an inlined subprogram. */
19494 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die)
19498 /* The instance of function that is effectively being inlined shall not
19500 gcc_assert (! BLOCK_ABSTRACT (stmt));
19502 decl = block_ultimate_origin (stmt);
19504 /* Emit info for the abstract instance first, if we haven't yet. We
19505 must emit this even if the block is abstract, otherwise when we
19506 emit the block below (or elsewhere), we may end up trying to emit
19507 a die whose origin die hasn't been emitted, and crashing. */
19508 dwarf2out_abstract_function (decl);
19510 if (! BLOCK_ABSTRACT (stmt))
19512 dw_die_ref subr_die
19513 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
19515 if (call_arg_locations)
19517 if (block_map.length () <= BLOCK_NUMBER (stmt))
19518 block_map.safe_grow_cleared (BLOCK_NUMBER (stmt) + 1);
19519 block_map[BLOCK_NUMBER (stmt)] = subr_die;
19521 add_abstract_origin_attribute (subr_die, decl);
19522 if (TREE_ASM_WRITTEN (stmt))
19523 add_high_low_attributes (stmt, subr_die);
19524 add_call_src_coords_attributes (stmt, subr_die);
19526 decls_for_scope (stmt, subr_die);
19530 /* Generate a DIE for a field in a record, or structure. */
19533 gen_field_die (tree decl, dw_die_ref context_die)
19535 dw_die_ref decl_die;
19537 if (TREE_TYPE (decl) == error_mark_node)
19540 decl_die = new_die (DW_TAG_member, context_die, decl);
19541 add_name_and_src_coords_attributes (decl_die, decl);
19542 add_type_attribute (decl_die, member_declared_type (decl),
19543 decl_quals (decl), context_die);
19545 if (DECL_BIT_FIELD_TYPE (decl))
19547 add_byte_size_attribute (decl_die, decl);
19548 add_bit_size_attribute (decl_die, decl);
19549 add_bit_offset_attribute (decl_die, decl);
19552 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
19553 add_data_member_location_attribute (decl_die, decl);
19555 if (DECL_ARTIFICIAL (decl))
19556 add_AT_flag (decl_die, DW_AT_artificial, 1);
19558 add_accessibility_attribute (decl_die, decl);
19560 /* Equate decl number to die, so that we can look up this decl later on. */
19561 equate_decl_number_to_die (decl, decl_die);
19565 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19566 Use modified_type_die instead.
19567 We keep this code here just in case these types of DIEs may be needed to
19568 represent certain things in other languages (e.g. Pascal) someday. */
19571 gen_pointer_type_die (tree type, dw_die_ref context_die)
19574 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
19576 equate_type_number_to_die (type, ptr_die);
19577 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19579 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19582 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19583 Use modified_type_die instead.
19584 We keep this code here just in case these types of DIEs may be needed to
19585 represent certain things in other languages (e.g. Pascal) someday. */
19588 gen_reference_type_die (tree type, dw_die_ref context_die)
19590 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die);
19592 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
19593 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type);
19595 ref_die = new_die (DW_TAG_reference_type, scope_die, type);
19597 equate_type_number_to_die (type, ref_die);
19598 add_type_attribute (ref_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19600 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19604 /* Generate a DIE for a pointer to a member type. */
19607 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
19610 = new_die (DW_TAG_ptr_to_member_type,
19611 scope_die_for (type, context_die), type);
19613 equate_type_number_to_die (type, ptr_die);
19614 add_AT_die_ref (ptr_die, DW_AT_containing_type,
19615 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
19616 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED,
19620 typedef const char *dchar_p; /* For DEF_VEC_P. */
19622 static char *producer_string;
19624 /* Return a heap allocated producer string including command line options
19625 if -grecord-gcc-switches. */
19628 gen_producer_string (void)
19631 auto_vec<dchar_p> switches;
19632 const char *language_string = lang_hooks.name;
19633 char *producer, *tail;
19635 size_t len = dwarf_record_gcc_switches ? 0 : 3;
19636 size_t plen = strlen (language_string) + 1 + strlen (version_string);
19638 for (j = 1; dwarf_record_gcc_switches && j < save_decoded_options_count; j++)
19639 switch (save_decoded_options[j].opt_index)
19646 case OPT_auxbase_strip:
19655 case OPT_SPECIAL_unknown:
19656 case OPT_SPECIAL_ignore:
19657 case OPT_SPECIAL_program_name:
19658 case OPT_SPECIAL_input_file:
19659 case OPT_grecord_gcc_switches:
19660 case OPT_gno_record_gcc_switches:
19661 case OPT__output_pch_:
19662 case OPT_fdiagnostics_show_location_:
19663 case OPT_fdiagnostics_show_option:
19664 case OPT_fdiagnostics_show_caret:
19665 case OPT_fdiagnostics_color_:
19666 case OPT_fverbose_asm:
19668 case OPT__sysroot_:
19670 case OPT_nostdinc__:
19671 case OPT_fpreprocessed:
19672 case OPT_fltrans_output_list_:
19673 case OPT_fresolution_:
19674 /* Ignore these. */
19677 if (cl_options[save_decoded_options[j].opt_index].flags
19678 & CL_NO_DWARF_RECORD)
19680 gcc_checking_assert (save_decoded_options[j].canonical_option[0][0]
19682 switch (save_decoded_options[j].canonical_option[0][1])
19689 if (strncmp (save_decoded_options[j].canonical_option[0] + 2,
19696 switches.safe_push (save_decoded_options[j].orig_option_with_args_text);
19697 len += strlen (save_decoded_options[j].orig_option_with_args_text) + 1;
19701 producer = XNEWVEC (char, plen + 1 + len + 1);
19703 sprintf (tail, "%s %s", language_string, version_string);
19706 FOR_EACH_VEC_ELT (switches, j, p)
19710 memcpy (tail + 1, p, len);
19718 /* Given a C and/or C++ language/version string return the "highest".
19719 C++ is assumed to be "higher" than C in this case. Used for merging
19720 LTO translation unit languages. */
19721 static const char *
19722 highest_c_language (const char *lang1, const char *lang2)
19724 if (strcmp ("GNU C++14", lang1) == 0 || strcmp ("GNU C++14", lang2) == 0)
19725 return "GNU C++14";
19726 if (strcmp ("GNU C++11", lang1) == 0 || strcmp ("GNU C++11", lang2) == 0)
19727 return "GNU C++11";
19728 if (strcmp ("GNU C++98", lang1) == 0 || strcmp ("GNU C++98", lang2) == 0)
19729 return "GNU C++98";
19731 if (strcmp ("GNU C11", lang1) == 0 || strcmp ("GNU C11", lang2) == 0)
19733 if (strcmp ("GNU C99", lang1) == 0 || strcmp ("GNU C99", lang2) == 0)
19735 if (strcmp ("GNU C89", lang1) == 0 || strcmp ("GNU C89", lang2) == 0)
19738 gcc_unreachable ();
19742 /* Generate the DIE for the compilation unit. */
19745 gen_compile_unit_die (const char *filename)
19748 const char *language_string = lang_hooks.name;
19751 die = new_die (DW_TAG_compile_unit, NULL, NULL);
19755 add_name_attribute (die, filename);
19756 /* Don't add cwd for <built-in>. */
19757 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
19758 add_comp_dir_attribute (die);
19761 add_AT_string (die, DW_AT_producer, producer_string ? producer_string : "");
19763 /* If our producer is LTO try to figure out a common language to use
19764 from the global list of translation units. */
19765 if (strcmp (language_string, "GNU GIMPLE") == 0)
19769 const char *common_lang = NULL;
19771 FOR_EACH_VEC_SAFE_ELT (all_translation_units, i, t)
19773 if (!TRANSLATION_UNIT_LANGUAGE (t))
19776 common_lang = TRANSLATION_UNIT_LANGUAGE (t);
19777 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
19779 else if (strncmp (common_lang, "GNU C", 5) == 0
19780 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
19781 /* Mixing C and C++ is ok, use C++ in that case. */
19782 common_lang = highest_c_language (common_lang,
19783 TRANSLATION_UNIT_LANGUAGE (t));
19786 /* Fall back to C. */
19787 common_lang = NULL;
19793 language_string = common_lang;
19796 language = DW_LANG_C;
19797 if (strncmp (language_string, "GNU C", 5) == 0
19798 && ISDIGIT (language_string[5]))
19800 language = DW_LANG_C89;
19801 if (dwarf_version >= 3 || !dwarf_strict)
19803 if (strcmp (language_string, "GNU C89") != 0)
19804 language = DW_LANG_C99;
19806 if (dwarf_version >= 5 /* || !dwarf_strict */)
19807 if (strcmp (language_string, "GNU C11") == 0)
19808 language = DW_LANG_C11;
19811 else if (strncmp (language_string, "GNU C++", 7) == 0)
19813 language = DW_LANG_C_plus_plus;
19814 if (dwarf_version >= 5 /* || !dwarf_strict */)
19816 if (strcmp (language_string, "GNU C++11") == 0)
19817 language = DW_LANG_C_plus_plus_11;
19818 else if (strcmp (language_string, "GNU C++14") == 0)
19819 language = DW_LANG_C_plus_plus_14;
19822 else if (strcmp (language_string, "GNU F77") == 0)
19823 language = DW_LANG_Fortran77;
19824 else if (strcmp (language_string, "GNU Pascal") == 0)
19825 language = DW_LANG_Pascal83;
19826 else if (dwarf_version >= 3 || !dwarf_strict)
19828 if (strcmp (language_string, "GNU Ada") == 0)
19829 language = DW_LANG_Ada95;
19830 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
19832 language = DW_LANG_Fortran95;
19833 if (dwarf_version >= 5 /* || !dwarf_strict */)
19835 if (strcmp (language_string, "GNU Fortran2003") == 0)
19836 language = DW_LANG_Fortran03;
19837 else if (strcmp (language_string, "GNU Fortran2008") == 0)
19838 language = DW_LANG_Fortran08;
19841 else if (strcmp (language_string, "GNU Java") == 0)
19842 language = DW_LANG_Java;
19843 else if (strcmp (language_string, "GNU Objective-C") == 0)
19844 language = DW_LANG_ObjC;
19845 else if (strcmp (language_string, "GNU Objective-C++") == 0)
19846 language = DW_LANG_ObjC_plus_plus;
19847 else if (dwarf_version >= 5 || !dwarf_strict)
19849 if (strcmp (language_string, "GNU Go") == 0)
19850 language = DW_LANG_Go;
19853 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
19854 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
19855 language = DW_LANG_Fortran90;
19857 add_AT_unsigned (die, DW_AT_language, language);
19861 case DW_LANG_Fortran77:
19862 case DW_LANG_Fortran90:
19863 case DW_LANG_Fortran95:
19864 case DW_LANG_Fortran03:
19865 case DW_LANG_Fortran08:
19866 /* Fortran has case insensitive identifiers and the front-end
19867 lowercases everything. */
19868 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
19871 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19877 /* Generate the DIE for a base class. */
19880 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
19882 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
19884 add_type_attribute (die, BINFO_TYPE (binfo), TYPE_UNQUALIFIED, context_die);
19885 add_data_member_location_attribute (die, binfo);
19887 if (BINFO_VIRTUAL_P (binfo))
19888 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
19890 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19891 children, otherwise the default is DW_ACCESS_public. In DWARF2
19892 the default has always been DW_ACCESS_private. */
19893 if (access == access_public_node)
19895 if (dwarf_version == 2
19896 || context_die->die_tag == DW_TAG_class_type)
19897 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
19899 else if (access == access_protected_node)
19900 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
19901 else if (dwarf_version > 2
19902 && context_die->die_tag != DW_TAG_class_type)
19903 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
19906 /* Generate a DIE for a class member. */
19909 gen_member_die (tree type, dw_die_ref context_die)
19912 tree binfo = TYPE_BINFO (type);
19915 /* If this is not an incomplete type, output descriptions of each of its
19916 members. Note that as we output the DIEs necessary to represent the
19917 members of this record or union type, we will also be trying to output
19918 DIEs to represent the *types* of those members. However the `type'
19919 function (above) will specifically avoid generating type DIEs for member
19920 types *within* the list of member DIEs for this (containing) type except
19921 for those types (of members) which are explicitly marked as also being
19922 members of this (containing) type themselves. The g++ front- end can
19923 force any given type to be treated as a member of some other (containing)
19924 type by setting the TYPE_CONTEXT of the given (member) type to point to
19925 the TREE node representing the appropriate (containing) type. */
19927 /* First output info about the base classes. */
19930 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
19934 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
19935 gen_inheritance_die (base,
19936 (accesses ? (*accesses)[i] : access_public_node),
19940 /* Now output info about the data members and type members. */
19941 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
19943 /* If we thought we were generating minimal debug info for TYPE
19944 and then changed our minds, some of the member declarations
19945 may have already been defined. Don't define them again, but
19946 do put them in the right order. */
19948 child = lookup_decl_die (member);
19950 splice_child_die (context_die, child);
19952 gen_decl_die (member, NULL, context_die);
19955 /* Now output info about the function members (if any). */
19956 for (member = TYPE_METHODS (type); member; member = DECL_CHAIN (member))
19958 /* Don't include clones in the member list. */
19959 if (DECL_ABSTRACT_ORIGIN (member))
19962 child = lookup_decl_die (member);
19964 splice_child_die (context_die, child);
19966 gen_decl_die (member, NULL, context_die);
19970 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19971 is set, we pretend that the type was never defined, so we only get the
19972 member DIEs needed by later specification DIEs. */
19975 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
19976 enum debug_info_usage usage)
19978 dw_die_ref type_die = lookup_type_die (type);
19979 dw_die_ref scope_die = 0;
19981 int complete = (TYPE_SIZE (type)
19982 && (! TYPE_STUB_DECL (type)
19983 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
19984 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
19985 complete = complete && should_emit_struct_debug (type, usage);
19987 if (type_die && ! complete)
19990 if (TYPE_CONTEXT (type) != NULL_TREE
19991 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
19992 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
19995 scope_die = scope_die_for (type, context_die);
19997 /* Generate child dies for template paramaters. */
19998 if (!type_die && debug_info_level > DINFO_LEVEL_TERSE)
19999 schedule_generic_params_dies_gen (type);
20001 if (! type_die || (nested && is_cu_die (scope_die)))
20002 /* First occurrence of type or toplevel definition of nested class. */
20004 dw_die_ref old_die = type_die;
20006 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
20007 ? record_type_tag (type) : DW_TAG_union_type,
20009 equate_type_number_to_die (type, type_die);
20011 add_AT_specification (type_die, old_die);
20013 add_name_attribute (type_die, type_tag (type));
20016 remove_AT (type_die, DW_AT_declaration);
20018 /* If this type has been completed, then give it a byte_size attribute and
20019 then give a list of members. */
20020 if (complete && !ns_decl)
20022 /* Prevent infinite recursion in cases where the type of some member of
20023 this type is expressed in terms of this type itself. */
20024 TREE_ASM_WRITTEN (type) = 1;
20025 add_byte_size_attribute (type_die, type);
20026 if (TYPE_STUB_DECL (type) != NULL_TREE)
20028 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
20029 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
20032 /* If the first reference to this type was as the return type of an
20033 inline function, then it may not have a parent. Fix this now. */
20034 if (type_die->die_parent == NULL)
20035 add_child_die (scope_die, type_die);
20037 push_decl_scope (type);
20038 gen_member_die (type, type_die);
20041 add_gnat_descriptive_type_attribute (type_die, type, context_die);
20042 if (TYPE_ARTIFICIAL (type))
20043 add_AT_flag (type_die, DW_AT_artificial, 1);
20045 /* GNU extension: Record what type our vtable lives in. */
20046 if (TYPE_VFIELD (type))
20048 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
20050 gen_type_die (vtype, context_die);
20051 add_AT_die_ref (type_die, DW_AT_containing_type,
20052 lookup_type_die (vtype));
20057 add_AT_flag (type_die, DW_AT_declaration, 1);
20059 /* We don't need to do this for function-local types. */
20060 if (TYPE_STUB_DECL (type)
20061 && ! decl_function_context (TYPE_STUB_DECL (type)))
20062 vec_safe_push (incomplete_types, type);
20065 if (get_AT (type_die, DW_AT_name))
20066 add_pubtype (type, type_die);
20069 /* Generate a DIE for a subroutine _type_. */
20072 gen_subroutine_type_die (tree type, dw_die_ref context_die)
20074 tree return_type = TREE_TYPE (type);
20075 dw_die_ref subr_die
20076 = new_die (DW_TAG_subroutine_type,
20077 scope_die_for (type, context_die), type);
20079 equate_type_number_to_die (type, subr_die);
20080 add_prototyped_attribute (subr_die, type);
20081 add_type_attribute (subr_die, return_type, TYPE_UNQUALIFIED, context_die);
20082 gen_formal_types_die (type, subr_die);
20084 if (get_AT (subr_die, DW_AT_name))
20085 add_pubtype (type, subr_die);
20088 /* Generate a DIE for a type definition. */
20091 gen_typedef_die (tree decl, dw_die_ref context_die)
20093 dw_die_ref type_die;
20096 if (TREE_ASM_WRITTEN (decl))
20099 TREE_ASM_WRITTEN (decl) = 1;
20100 type_die = new_die (DW_TAG_typedef, context_die, decl);
20101 origin = decl_ultimate_origin (decl);
20102 if (origin != NULL)
20103 add_abstract_origin_attribute (type_die, origin);
20108 add_name_and_src_coords_attributes (type_die, decl);
20109 if (DECL_ORIGINAL_TYPE (decl))
20111 type = DECL_ORIGINAL_TYPE (decl);
20113 gcc_assert (type != TREE_TYPE (decl));
20114 equate_type_number_to_die (TREE_TYPE (decl), type_die);
20118 type = TREE_TYPE (decl);
20120 if (is_naming_typedef_decl (TYPE_NAME (type)))
20122 /* Here, we are in the case of decl being a typedef naming
20123 an anonymous type, e.g:
20124 typedef struct {...} foo;
20125 In that case TREE_TYPE (decl) is not a typedef variant
20126 type and TYPE_NAME of the anonymous type is set to the
20127 TYPE_DECL of the typedef. This construct is emitted by
20130 TYPE is the anonymous struct named by the typedef
20131 DECL. As we need the DW_AT_type attribute of the
20132 DW_TAG_typedef to point to the DIE of TYPE, let's
20133 generate that DIE right away. add_type_attribute
20134 called below will then pick (via lookup_type_die) that
20135 anonymous struct DIE. */
20136 if (!TREE_ASM_WRITTEN (type))
20137 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
20139 /* This is a GNU Extension. We are adding a
20140 DW_AT_linkage_name attribute to the DIE of the
20141 anonymous struct TYPE. The value of that attribute
20142 is the name of the typedef decl naming the anonymous
20143 struct. This greatly eases the work of consumers of
20144 this debug info. */
20145 add_linkage_attr (lookup_type_die (type), decl);
20149 add_type_attribute (type_die, type, decl_quals (decl), context_die);
20151 if (is_naming_typedef_decl (decl))
20152 /* We want that all subsequent calls to lookup_type_die with
20153 TYPE in argument yield the DW_TAG_typedef we have just
20155 equate_type_number_to_die (type, type_die);
20157 add_accessibility_attribute (type_die, decl);
20160 if (DECL_ABSTRACT_P (decl))
20161 equate_decl_number_to_die (decl, type_die);
20163 if (get_AT (type_die, DW_AT_name))
20164 add_pubtype (decl, type_die);
20167 /* Generate a DIE for a struct, class, enum or union type. */
20170 gen_tagged_type_die (tree type,
20171 dw_die_ref context_die,
20172 enum debug_info_usage usage)
20176 if (type == NULL_TREE
20177 || !is_tagged_type (type))
20180 /* If this is a nested type whose containing class hasn't been written
20181 out yet, writing it out will cover this one, too. This does not apply
20182 to instantiations of member class templates; they need to be added to
20183 the containing class as they are generated. FIXME: This hurts the
20184 idea of combining type decls from multiple TUs, since we can't predict
20185 what set of template instantiations we'll get. */
20186 if (TYPE_CONTEXT (type)
20187 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
20188 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
20190 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
20192 if (TREE_ASM_WRITTEN (type))
20195 /* If that failed, attach ourselves to the stub. */
20196 push_decl_scope (TYPE_CONTEXT (type));
20197 context_die = lookup_type_die (TYPE_CONTEXT (type));
20200 else if (TYPE_CONTEXT (type) != NULL_TREE
20201 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
20203 /* If this type is local to a function that hasn't been written
20204 out yet, use a NULL context for now; it will be fixed up in
20205 decls_for_scope. */
20206 context_die = lookup_decl_die (TYPE_CONTEXT (type));
20207 /* A declaration DIE doesn't count; nested types need to go in the
20209 if (context_die && is_declaration_die (context_die))
20210 context_die = NULL;
20215 context_die = declare_in_namespace (type, context_die);
20219 if (TREE_CODE (type) == ENUMERAL_TYPE)
20221 /* This might have been written out by the call to
20222 declare_in_namespace. */
20223 if (!TREE_ASM_WRITTEN (type))
20224 gen_enumeration_type_die (type, context_die);
20227 gen_struct_or_union_type_die (type, context_die, usage);
20232 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
20233 it up if it is ever completed. gen_*_type_die will set it for us
20234 when appropriate. */
20237 /* Generate a type description DIE. */
20240 gen_type_die_with_usage (tree type, dw_die_ref context_die,
20241 enum debug_info_usage usage)
20243 struct array_descr_info info;
20245 if (type == NULL_TREE || type == error_mark_node)
20248 if (TYPE_NAME (type) != NULL_TREE
20249 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
20250 && is_redundant_typedef (TYPE_NAME (type))
20251 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
20252 /* The DECL of this type is a typedef we don't want to emit debug
20253 info for but we want debug info for its underlying typedef.
20254 This can happen for e.g, the injected-class-name of a C++
20256 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
20258 /* If TYPE is a typedef type variant, let's generate debug info
20259 for the parent typedef which TYPE is a type of. */
20260 if (typedef_variant_p (type))
20262 if (TREE_ASM_WRITTEN (type))
20265 /* Prevent broken recursion; we can't hand off to the same type. */
20266 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
20268 /* Give typedefs the right scope. */
20269 context_die = scope_die_for (type, context_die);
20271 TREE_ASM_WRITTEN (type) = 1;
20273 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20277 /* If type is an anonymous tagged type named by a typedef, let's
20278 generate debug info for the typedef. */
20279 if (is_naming_typedef_decl (TYPE_NAME (type)))
20281 /* Use the DIE of the containing namespace as the parent DIE of
20282 the type description DIE we want to generate. */
20283 if (DECL_CONTEXT (TYPE_NAME (type))
20284 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
20285 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
20287 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20291 /* We are going to output a DIE to represent the unqualified version
20292 of this type (i.e. without any const or volatile qualifiers) so
20293 get the main variant (i.e. the unqualified version) of this type
20294 now. (Vectors and arrays are special because the debugging info is in the
20295 cloned type itself). */
20296 if (TREE_CODE (type) != VECTOR_TYPE
20297 && TREE_CODE (type) != ARRAY_TYPE)
20298 type = type_main_variant (type);
20300 /* If this is an array type with hidden descriptor, handle it first. */
20301 if (!TREE_ASM_WRITTEN (type)
20302 && lang_hooks.types.get_array_descr_info)
20304 memset (&info, 0, sizeof (info));
20305 if (lang_hooks.types.get_array_descr_info (type, &info))
20307 gen_descr_array_type_die (type, &info, context_die);
20308 TREE_ASM_WRITTEN (type) = 1;
20313 if (TREE_ASM_WRITTEN (type))
20316 switch (TREE_CODE (type))
20322 case REFERENCE_TYPE:
20323 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
20324 ensures that the gen_type_die recursion will terminate even if the
20325 type is recursive. Recursive types are possible in Ada. */
20326 /* ??? We could perhaps do this for all types before the switch
20328 TREE_ASM_WRITTEN (type) = 1;
20330 /* For these types, all that is required is that we output a DIE (or a
20331 set of DIEs) to represent the "basis" type. */
20332 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20333 DINFO_USAGE_IND_USE);
20337 /* This code is used for C++ pointer-to-data-member types.
20338 Output a description of the relevant class type. */
20339 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
20340 DINFO_USAGE_IND_USE);
20342 /* Output a description of the type of the object pointed to. */
20343 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20344 DINFO_USAGE_IND_USE);
20346 /* Now output a DIE to represent this pointer-to-data-member type
20348 gen_ptr_to_mbr_type_die (type, context_die);
20351 case FUNCTION_TYPE:
20352 /* Force out return type (in case it wasn't forced out already). */
20353 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20354 DINFO_USAGE_DIR_USE);
20355 gen_subroutine_type_die (type, context_die);
20359 /* Force out return type (in case it wasn't forced out already). */
20360 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20361 DINFO_USAGE_DIR_USE);
20362 gen_subroutine_type_die (type, context_die);
20366 gen_array_type_die (type, context_die);
20370 gen_array_type_die (type, context_die);
20373 case ENUMERAL_TYPE:
20376 case QUAL_UNION_TYPE:
20377 gen_tagged_type_die (type, context_die, usage);
20383 case FIXED_POINT_TYPE:
20386 case POINTER_BOUNDS_TYPE:
20387 /* No DIEs needed for fundamental types. */
20392 /* Just use DW_TAG_unspecified_type. */
20394 dw_die_ref type_die = lookup_type_die (type);
20395 if (type_die == NULL)
20397 tree name = TYPE_IDENTIFIER (type);
20398 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (),
20400 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
20401 equate_type_number_to_die (type, type_die);
20407 if (is_cxx_auto (type))
20409 tree name = TYPE_IDENTIFIER (type);
20410 dw_die_ref *die = (name == get_identifier ("auto")
20411 ? &auto_die : &decltype_auto_die);
20414 *die = new_die (DW_TAG_unspecified_type,
20415 comp_unit_die (), NULL_TREE);
20416 add_name_attribute (*die, IDENTIFIER_POINTER (name));
20418 equate_type_number_to_die (type, *die);
20421 gcc_unreachable ();
20424 TREE_ASM_WRITTEN (type) = 1;
20428 gen_type_die (tree type, dw_die_ref context_die)
20430 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
20433 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20434 things which are local to the given block. */
20437 gen_block_die (tree stmt, dw_die_ref context_die)
20439 int must_output_die = 0;
20442 /* Ignore blocks that are NULL. */
20443 if (stmt == NULL_TREE)
20446 inlined_func = inlined_function_outer_scope_p (stmt);
20448 /* If the block is one fragment of a non-contiguous block, do not
20449 process the variables, since they will have been done by the
20450 origin block. Do process subblocks. */
20451 if (BLOCK_FRAGMENT_ORIGIN (stmt))
20455 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
20456 gen_block_die (sub, context_die);
20461 /* Determine if we need to output any Dwarf DIEs at all to represent this
20464 /* The outer scopes for inlinings *must* always be represented. We
20465 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20466 must_output_die = 1;
20469 /* Determine if this block directly contains any "significant"
20470 local declarations which we will need to output DIEs for. */
20471 if (debug_info_level > DINFO_LEVEL_TERSE)
20472 /* We are not in terse mode so *any* local declaration counts
20473 as being a "significant" one. */
20474 must_output_die = ((BLOCK_VARS (stmt) != NULL
20475 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
20476 && (TREE_USED (stmt)
20477 || TREE_ASM_WRITTEN (stmt)
20478 || BLOCK_ABSTRACT (stmt)));
20479 else if ((TREE_USED (stmt)
20480 || TREE_ASM_WRITTEN (stmt)
20481 || BLOCK_ABSTRACT (stmt))
20482 && !dwarf2out_ignore_block (stmt))
20483 must_output_die = 1;
20486 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20487 DIE for any block which contains no significant local declarations at
20488 all. Rather, in such cases we just call `decls_for_scope' so that any
20489 needed Dwarf info for any sub-blocks will get properly generated. Note
20490 that in terse mode, our definition of what constitutes a "significant"
20491 local declaration gets restricted to include only inlined function
20492 instances and local (nested) function definitions. */
20493 if (must_output_die)
20497 /* If STMT block is abstract, that means we have been called
20498 indirectly from dwarf2out_abstract_function.
20499 That function rightfully marks the descendent blocks (of
20500 the abstract function it is dealing with) as being abstract,
20501 precisely to prevent us from emitting any
20502 DW_TAG_inlined_subroutine DIE as a descendent
20503 of an abstract function instance. So in that case, we should
20504 not call gen_inlined_subroutine_die.
20506 Later though, when cgraph asks dwarf2out to emit info
20507 for the concrete instance of the function decl into which
20508 the concrete instance of STMT got inlined, the later will lead
20509 to the generation of a DW_TAG_inlined_subroutine DIE. */
20510 if (! BLOCK_ABSTRACT (stmt))
20511 gen_inlined_subroutine_die (stmt, context_die);
20514 gen_lexical_block_die (stmt, context_die);
20517 decls_for_scope (stmt, context_die);
20520 /* Process variable DECL (or variable with origin ORIGIN) within
20521 block STMT and add it to CONTEXT_DIE. */
20523 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
20526 tree decl_or_origin = decl ? decl : origin;
20528 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
20529 die = lookup_decl_die (decl_or_origin);
20530 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
20531 && TYPE_DECL_IS_STUB (decl_or_origin))
20532 die = lookup_type_die (TREE_TYPE (decl_or_origin));
20536 if (die != NULL && die->die_parent == NULL)
20537 add_child_die (context_die, die);
20538 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
20539 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
20540 stmt, context_die);
20542 gen_decl_die (decl, origin, context_die);
20545 /* Generate all of the decls declared within a given scope and (recursively)
20546 all of its sub-blocks. */
20549 decls_for_scope (tree stmt, dw_die_ref context_die)
20555 /* Ignore NULL blocks. */
20556 if (stmt == NULL_TREE)
20559 /* Output the DIEs to represent all of the data objects and typedefs
20560 declared directly within this block but not within any nested
20561 sub-blocks. Also, nested function and tag DIEs have been
20562 generated with a parent of NULL; fix that up now. We don't
20563 have to do this if we're at -g1. */
20564 if (debug_info_level > DINFO_LEVEL_TERSE)
20566 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl))
20567 process_scope_var (stmt, decl, NULL_TREE, context_die);
20568 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
20569 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
20573 /* Even if we're at -g1, we need to process the subblocks in order to get
20574 inlined call information. */
20576 /* Output the DIEs to represent all sub-blocks (and the items declared
20577 therein) of this block. */
20578 for (subblocks = BLOCK_SUBBLOCKS (stmt);
20580 subblocks = BLOCK_CHAIN (subblocks))
20581 gen_block_die (subblocks, context_die);
20584 /* Is this a typedef we can avoid emitting? */
20587 is_redundant_typedef (const_tree decl)
20589 if (TYPE_DECL_IS_STUB (decl))
20592 if (DECL_ARTIFICIAL (decl)
20593 && DECL_CONTEXT (decl)
20594 && is_tagged_type (DECL_CONTEXT (decl))
20595 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
20596 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
20597 /* Also ignore the artificial member typedef for the class name. */
20603 /* Return TRUE if TYPE is a typedef that names a type for linkage
20604 purposes. This kind of typedefs is produced by the C++ FE for
20607 typedef struct {...} foo;
20609 In that case, there is no typedef variant type produced for foo.
20610 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20614 is_naming_typedef_decl (const_tree decl)
20616 if (decl == NULL_TREE
20617 || TREE_CODE (decl) != TYPE_DECL
20618 || !is_tagged_type (TREE_TYPE (decl))
20619 || DECL_IS_BUILTIN (decl)
20620 || is_redundant_typedef (decl)
20621 /* It looks like Ada produces TYPE_DECLs that are very similar
20622 to C++ naming typedefs but that have different
20623 semantics. Let's be specific to c++ for now. */
20627 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
20628 && TYPE_NAME (TREE_TYPE (decl)) == decl
20629 && (TYPE_STUB_DECL (TREE_TYPE (decl))
20630 != TYPE_NAME (TREE_TYPE (decl))));
20633 /* Looks up the DIE for a context. */
20635 static inline dw_die_ref
20636 lookup_context_die (tree context)
20640 /* Find die that represents this context. */
20641 if (TYPE_P (context))
20643 context = TYPE_MAIN_VARIANT (context);
20644 dw_die_ref ctx = lookup_type_die (context);
20647 return strip_naming_typedef (context, ctx);
20650 return lookup_decl_die (context);
20652 return comp_unit_die ();
20655 /* Returns the DIE for a context. */
20657 static inline dw_die_ref
20658 get_context_die (tree context)
20662 /* Find die that represents this context. */
20663 if (TYPE_P (context))
20665 context = TYPE_MAIN_VARIANT (context);
20666 return strip_naming_typedef (context, force_type_die (context));
20669 return force_decl_die (context);
20671 return comp_unit_die ();
20674 /* Returns the DIE for decl. A DIE will always be returned. */
20677 force_decl_die (tree decl)
20679 dw_die_ref decl_die;
20680 unsigned saved_external_flag;
20681 tree save_fn = NULL_TREE;
20682 decl_die = lookup_decl_die (decl);
20685 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
20687 decl_die = lookup_decl_die (decl);
20691 switch (TREE_CODE (decl))
20693 case FUNCTION_DECL:
20694 /* Clear current_function_decl, so that gen_subprogram_die thinks
20695 that this is a declaration. At this point, we just want to force
20696 declaration die. */
20697 save_fn = current_function_decl;
20698 current_function_decl = NULL_TREE;
20699 gen_subprogram_die (decl, context_die);
20700 current_function_decl = save_fn;
20704 /* Set external flag to force declaration die. Restore it after
20705 gen_decl_die() call. */
20706 saved_external_flag = DECL_EXTERNAL (decl);
20707 DECL_EXTERNAL (decl) = 1;
20708 gen_decl_die (decl, NULL, context_die);
20709 DECL_EXTERNAL (decl) = saved_external_flag;
20712 case NAMESPACE_DECL:
20713 if (dwarf_version >= 3 || !dwarf_strict)
20714 dwarf2out_decl (decl);
20716 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20717 decl_die = comp_unit_die ();
20720 case TRANSLATION_UNIT_DECL:
20721 decl_die = comp_unit_die ();
20725 gcc_unreachable ();
20728 /* We should be able to find the DIE now. */
20730 decl_die = lookup_decl_die (decl);
20731 gcc_assert (decl_die);
20737 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20738 always returned. */
20741 force_type_die (tree type)
20743 dw_die_ref type_die;
20745 type_die = lookup_type_die (type);
20748 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
20750 type_die = modified_type_die (type, TYPE_QUALS_NO_ADDR_SPACE (type),
20752 gcc_assert (type_die);
20757 /* Force out any required namespaces to be able to output DECL,
20758 and return the new context_die for it, if it's changed. */
20761 setup_namespace_context (tree thing, dw_die_ref context_die)
20763 tree context = (DECL_P (thing)
20764 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
20765 if (context && TREE_CODE (context) == NAMESPACE_DECL)
20766 /* Force out the namespace. */
20767 context_die = force_decl_die (context);
20769 return context_die;
20772 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20773 type) within its namespace, if appropriate.
20775 For compatibility with older debuggers, namespace DIEs only contain
20776 declarations; all definitions are emitted at CU scope. */
20779 declare_in_namespace (tree thing, dw_die_ref context_die)
20781 dw_die_ref ns_context;
20783 if (debug_info_level <= DINFO_LEVEL_TERSE)
20784 return context_die;
20786 /* External declarations in the local scope only need to be emitted
20787 once, not once in the namespace and once in the scope.
20789 This avoids declaring the `extern' below in the
20790 namespace DIE as well as in the innermost scope:
20803 if (DECL_P (thing) && DECL_EXTERNAL (thing) && local_scope_p (context_die))
20804 return context_die;
20806 /* If this decl is from an inlined function, then don't try to emit it in its
20807 namespace, as we will get confused. It would have already been emitted
20808 when the abstract instance of the inline function was emitted anyways. */
20809 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
20810 return context_die;
20812 ns_context = setup_namespace_context (thing, context_die);
20814 if (ns_context != context_die)
20818 if (DECL_P (thing))
20819 gen_decl_die (thing, NULL, ns_context);
20821 gen_type_die (thing, ns_context);
20823 return context_die;
20826 /* Generate a DIE for a namespace or namespace alias. */
20829 gen_namespace_die (tree decl, dw_die_ref context_die)
20831 dw_die_ref namespace_die;
20833 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20834 they are an alias of. */
20835 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
20837 /* Output a real namespace or module. */
20838 context_die = setup_namespace_context (decl, comp_unit_die ());
20839 namespace_die = new_die (is_fortran ()
20840 ? DW_TAG_module : DW_TAG_namespace,
20841 context_die, decl);
20842 /* For Fortran modules defined in different CU don't add src coords. */
20843 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
20845 const char *name = dwarf2_name (decl, 0);
20847 add_name_attribute (namespace_die, name);
20850 add_name_and_src_coords_attributes (namespace_die, decl);
20851 if (DECL_EXTERNAL (decl))
20852 add_AT_flag (namespace_die, DW_AT_declaration, 1);
20853 equate_decl_number_to_die (decl, namespace_die);
20857 /* Output a namespace alias. */
20859 /* Force out the namespace we are an alias of, if necessary. */
20860 dw_die_ref origin_die
20861 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
20863 if (DECL_FILE_SCOPE_P (decl)
20864 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
20865 context_die = setup_namespace_context (decl, comp_unit_die ());
20866 /* Now create the namespace alias DIE. */
20867 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
20868 add_name_and_src_coords_attributes (namespace_die, decl);
20869 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
20870 equate_decl_number_to_die (decl, namespace_die);
20872 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
20873 if (want_pubnames ())
20874 add_pubname_string (lang_hooks.dwarf_name (decl, 1), namespace_die);
20877 /* Generate Dwarf debug information for a decl described by DECL.
20878 The return value is currently only meaningful for PARM_DECLs,
20879 for all other decls it returns NULL. */
20882 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
20884 tree decl_or_origin = decl ? decl : origin;
20885 tree class_origin = NULL, ultimate_origin;
20887 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
20890 /* Ignore pointer bounds decls. */
20891 if (DECL_P (decl_or_origin)
20892 && TREE_TYPE (decl_or_origin)
20893 && POINTER_BOUNDS_P (decl_or_origin))
20896 switch (TREE_CODE (decl_or_origin))
20902 if (!is_fortran () && !is_ada ())
20904 /* The individual enumerators of an enum type get output when we output
20905 the Dwarf representation of the relevant enum type itself. */
20909 /* Emit its type. */
20910 gen_type_die (TREE_TYPE (decl), context_die);
20912 /* And its containing namespace. */
20913 context_die = declare_in_namespace (decl, context_die);
20915 gen_const_die (decl, context_die);
20918 case FUNCTION_DECL:
20919 /* Don't output any DIEs to represent mere function declarations,
20920 unless they are class members or explicit block externs. */
20921 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
20922 && DECL_FILE_SCOPE_P (decl_or_origin)
20923 && (current_function_decl == NULL_TREE
20924 || DECL_ARTIFICIAL (decl_or_origin)))
20929 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20930 on local redeclarations of global functions. That seems broken. */
20931 if (current_function_decl != decl)
20932 /* This is only a declaration. */;
20935 /* If we're emitting a clone, emit info for the abstract instance. */
20936 if (origin || DECL_ORIGIN (decl) != decl)
20937 dwarf2out_abstract_function (origin
20938 ? DECL_ORIGIN (origin)
20939 : DECL_ABSTRACT_ORIGIN (decl));
20941 /* If we're emitting an out-of-line copy of an inline function,
20942 emit info for the abstract instance and set up to refer to it. */
20943 else if (cgraph_function_possibly_inlined_p (decl)
20944 && ! DECL_ABSTRACT_P (decl)
20945 && ! class_or_namespace_scope_p (context_die)
20946 /* dwarf2out_abstract_function won't emit a die if this is just
20947 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20948 that case, because that works only if we have a die. */
20949 && DECL_INITIAL (decl) != NULL_TREE)
20951 dwarf2out_abstract_function (decl);
20952 set_decl_origin_self (decl);
20955 /* Otherwise we're emitting the primary DIE for this decl. */
20956 else if (debug_info_level > DINFO_LEVEL_TERSE)
20958 /* Before we describe the FUNCTION_DECL itself, make sure that we
20959 have its containing type. */
20961 origin = decl_class_context (decl);
20962 if (origin != NULL_TREE)
20963 gen_type_die (origin, context_die);
20965 /* And its return type. */
20966 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
20968 /* And its virtual context. */
20969 if (DECL_VINDEX (decl) != NULL_TREE)
20970 gen_type_die (DECL_CONTEXT (decl), context_die);
20972 /* Make sure we have a member DIE for decl. */
20973 if (origin != NULL_TREE)
20974 gen_type_die_for_member (origin, decl, context_die);
20976 /* And its containing namespace. */
20977 context_die = declare_in_namespace (decl, context_die);
20980 /* Now output a DIE to represent the function itself. */
20982 gen_subprogram_die (decl, context_die);
20986 /* If we are in terse mode, don't generate any DIEs to represent any
20987 actual typedefs. */
20988 if (debug_info_level <= DINFO_LEVEL_TERSE)
20991 /* In the special case of a TYPE_DECL node representing the declaration
20992 of some type tag, if the given TYPE_DECL is marked as having been
20993 instantiated from some other (original) TYPE_DECL node (e.g. one which
20994 was generated within the original definition of an inline function) we
20995 used to generate a special (abbreviated) DW_TAG_structure_type,
20996 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20997 should be actually referencing those DIEs, as variable DIEs with that
20998 type would be emitted already in the abstract origin, so it was always
20999 removed during unused type prunning. Don't add anything in this
21001 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
21004 if (is_redundant_typedef (decl))
21005 gen_type_die (TREE_TYPE (decl), context_die);
21007 /* Output a DIE to represent the typedef itself. */
21008 gen_typedef_die (decl, context_die);
21012 if (debug_info_level >= DINFO_LEVEL_NORMAL)
21013 gen_label_die (decl, context_die);
21018 /* If we are in terse mode, don't generate any DIEs to represent any
21019 variable declarations or definitions. */
21020 if (debug_info_level <= DINFO_LEVEL_TERSE)
21023 /* Output any DIEs that are needed to specify the type of this data
21025 if (decl_by_reference_p (decl_or_origin))
21026 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
21028 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
21030 /* And its containing type. */
21031 class_origin = decl_class_context (decl_or_origin);
21032 if (class_origin != NULL_TREE)
21033 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
21035 /* And its containing namespace. */
21036 context_die = declare_in_namespace (decl_or_origin, context_die);
21038 /* Now output the DIE to represent the data object itself. This gets
21039 complicated because of the possibility that the VAR_DECL really
21040 represents an inlined instance of a formal parameter for an inline
21042 ultimate_origin = decl_ultimate_origin (decl_or_origin);
21043 if (ultimate_origin != NULL_TREE
21044 && TREE_CODE (ultimate_origin) == PARM_DECL)
21045 gen_formal_parameter_die (decl, origin,
21046 true /* Emit name attribute. */,
21049 gen_variable_die (decl, origin, context_die);
21053 /* Ignore the nameless fields that are used to skip bits but handle C++
21054 anonymous unions and structs. */
21055 if (DECL_NAME (decl) != NULL_TREE
21056 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
21057 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
21059 gen_type_die (member_declared_type (decl), context_die);
21060 gen_field_die (decl, context_die);
21065 if (DECL_BY_REFERENCE (decl_or_origin))
21066 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
21068 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
21069 return gen_formal_parameter_die (decl, origin,
21070 true /* Emit name attribute. */,
21073 case NAMESPACE_DECL:
21074 case IMPORTED_DECL:
21075 if (dwarf_version >= 3 || !dwarf_strict)
21076 gen_namespace_die (decl, context_die);
21079 case NAMELIST_DECL:
21080 gen_namelist_decl (DECL_NAME (decl), context_die,
21081 NAMELIST_DECL_ASSOCIATED_DECL (decl));
21085 /* Probably some frontend-internal decl. Assume we don't care. */
21086 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
21093 /* Output debug information for global decl DECL. Called from toplev.c after
21094 compilation proper has finished. */
21097 dwarf2out_global_decl (tree decl)
21099 /* Output DWARF2 information for file-scope tentative data object
21100 declarations, file-scope (extern) function declarations (which
21101 had no corresponding body) and file-scope tagged type declarations
21102 and definitions which have not yet been forced out. */
21103 if ((TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
21104 && !POINTER_BOUNDS_P (decl))
21105 dwarf2out_decl (decl);
21108 /* Output debug information for type decl DECL. Called from toplev.c
21109 and from language front ends (to record built-in types). */
21111 dwarf2out_type_decl (tree decl, int local)
21114 dwarf2out_decl (decl);
21117 /* Output debug information for imported module or decl DECL.
21118 NAME is non-NULL name in the lexical block if the decl has been renamed.
21119 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
21120 that DECL belongs to.
21121 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
21123 dwarf2out_imported_module_or_decl_1 (tree decl,
21125 tree lexical_block,
21126 dw_die_ref lexical_block_die)
21128 expanded_location xloc;
21129 dw_die_ref imported_die = NULL;
21130 dw_die_ref at_import_die;
21132 if (TREE_CODE (decl) == IMPORTED_DECL)
21134 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
21135 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
21139 xloc = expand_location (input_location);
21141 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
21143 at_import_die = force_type_die (TREE_TYPE (decl));
21144 /* For namespace N { typedef void T; } using N::T; base_type_die
21145 returns NULL, but DW_TAG_imported_declaration requires
21146 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
21147 if (!at_import_die)
21149 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
21150 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
21151 at_import_die = lookup_type_die (TREE_TYPE (decl));
21152 gcc_assert (at_import_die);
21157 at_import_die = lookup_decl_die (decl);
21158 if (!at_import_die)
21160 /* If we're trying to avoid duplicate debug info, we may not have
21161 emitted the member decl for this field. Emit it now. */
21162 if (TREE_CODE (decl) == FIELD_DECL)
21164 tree type = DECL_CONTEXT (decl);
21166 if (TYPE_CONTEXT (type)
21167 && TYPE_P (TYPE_CONTEXT (type))
21168 && !should_emit_struct_debug (TYPE_CONTEXT (type),
21169 DINFO_USAGE_DIR_USE))
21171 gen_type_die_for_member (type, decl,
21172 get_context_die (TYPE_CONTEXT (type)));
21174 if (TREE_CODE (decl) == NAMELIST_DECL)
21175 at_import_die = gen_namelist_decl (DECL_NAME (decl),
21176 get_context_die (DECL_CONTEXT (decl)),
21179 at_import_die = force_decl_die (decl);
21183 if (TREE_CODE (decl) == NAMESPACE_DECL)
21185 if (dwarf_version >= 3 || !dwarf_strict)
21186 imported_die = new_die (DW_TAG_imported_module,
21193 imported_die = new_die (DW_TAG_imported_declaration,
21197 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
21198 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
21200 add_AT_string (imported_die, DW_AT_name,
21201 IDENTIFIER_POINTER (name));
21202 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
21205 /* Output debug information for imported module or decl DECL.
21206 NAME is non-NULL name in context if the decl has been renamed.
21207 CHILD is true if decl is one of the renamed decls as part of
21208 importing whole module. */
21211 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
21214 /* dw_die_ref at_import_die; */
21215 dw_die_ref scope_die;
21217 if (debug_info_level <= DINFO_LEVEL_TERSE)
21222 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
21223 We need decl DIE for reference and scope die. First, get DIE for the decl
21226 /* Get the scope die for decl context. Use comp_unit_die for global module
21227 or decl. If die is not found for non globals, force new die. */
21229 && TYPE_P (context)
21230 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
21233 if (!(dwarf_version >= 3 || !dwarf_strict))
21236 scope_die = get_context_die (context);
21240 gcc_assert (scope_die->die_child);
21241 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
21242 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
21243 scope_die = scope_die->die_child;
21246 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
21247 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
21251 /* Output debug information for namelists. */
21254 gen_namelist_decl (tree name, dw_die_ref scope_die, tree item_decls)
21256 dw_die_ref nml_die, nml_item_die, nml_item_ref_die;
21260 if (debug_info_level <= DINFO_LEVEL_TERSE)
21263 gcc_assert (scope_die != NULL);
21264 nml_die = new_die (DW_TAG_namelist, scope_die, NULL);
21265 add_AT_string (nml_die, DW_AT_name, IDENTIFIER_POINTER (name));
21267 /* If there are no item_decls, we have a nondefining namelist, e.g.
21268 with USE association; hence, set DW_AT_declaration. */
21269 if (item_decls == NULL_TREE)
21271 add_AT_flag (nml_die, DW_AT_declaration, 1);
21275 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls), i, value)
21277 nml_item_ref_die = lookup_decl_die (value);
21278 if (!nml_item_ref_die)
21279 nml_item_ref_die = force_decl_die (value);
21281 nml_item_die = new_die (DW_TAG_namelist_item, nml_die, NULL);
21282 add_AT_die_ref (nml_item_die, DW_AT_namelist_items, nml_item_ref_die);
21288 /* Write the debugging output for DECL. */
21291 dwarf2out_decl (tree decl)
21293 dw_die_ref context_die = comp_unit_die ();
21295 switch (TREE_CODE (decl))
21300 case FUNCTION_DECL:
21301 /* What we would really like to do here is to filter out all mere
21302 file-scope declarations of file-scope functions which are never
21303 referenced later within this translation unit (and keep all of ones
21304 that *are* referenced later on) but we aren't clairvoyant, so we have
21305 no idea which functions will be referenced in the future (i.e. later
21306 on within the current translation unit). So here we just ignore all
21307 file-scope function declarations which are not also definitions. If
21308 and when the debugger needs to know something about these functions,
21309 it will have to hunt around and find the DWARF information associated
21310 with the definition of the function.
21312 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
21313 nodes represent definitions and which ones represent mere
21314 declarations. We have to check DECL_INITIAL instead. That's because
21315 the C front-end supports some weird semantics for "extern inline"
21316 function definitions. These can get inlined within the current
21317 translation unit (and thus, we need to generate Dwarf info for their
21318 abstract instances so that the Dwarf info for the concrete inlined
21319 instances can have something to refer to) but the compiler never
21320 generates any out-of-lines instances of such things (despite the fact
21321 that they *are* definitions).
21323 The important point is that the C front-end marks these "extern
21324 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
21325 them anyway. Note that the C++ front-end also plays some similar games
21326 for inline function definitions appearing within include files which
21327 also contain `#pragma interface' pragmas.
21329 If we are called from dwarf2out_abstract_function output a DIE
21330 anyway. We can end up here this way with early inlining and LTO
21331 where the inlined function is output in a different LTRANS unit
21333 if (DECL_INITIAL (decl) == NULL_TREE
21334 && ! DECL_ABSTRACT_P (decl))
21337 /* If we're a nested function, initially use a parent of NULL; if we're
21338 a plain function, this will be fixed up in decls_for_scope. If
21339 we're a method, it will be ignored, since we already have a DIE. */
21340 if (decl_function_context (decl)
21341 /* But if we're in terse mode, we don't care about scope. */
21342 && debug_info_level > DINFO_LEVEL_TERSE)
21343 context_die = NULL;
21347 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
21348 declaration and if the declaration was never even referenced from
21349 within this entire compilation unit. We suppress these DIEs in
21350 order to save space in the .debug section (by eliminating entries
21351 which are probably useless). Note that we must not suppress
21352 block-local extern declarations (whether used or not) because that
21353 would screw-up the debugger's name lookup mechanism and cause it to
21354 miss things which really ought to be in scope at a given point. */
21355 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
21358 /* For local statics lookup proper context die. */
21359 if (TREE_STATIC (decl)
21360 && DECL_CONTEXT (decl)
21361 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
21362 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21364 /* If we are in terse mode, don't generate any DIEs to represent any
21365 variable declarations or definitions. */
21366 if (debug_info_level <= DINFO_LEVEL_TERSE)
21371 if (debug_info_level <= DINFO_LEVEL_TERSE)
21373 if (!is_fortran () && !is_ada ())
21375 if (TREE_STATIC (decl) && decl_function_context (decl))
21376 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21379 case NAMESPACE_DECL:
21380 case IMPORTED_DECL:
21381 if (debug_info_level <= DINFO_LEVEL_TERSE)
21383 if (lookup_decl_die (decl) != NULL)
21388 /* Don't emit stubs for types unless they are needed by other DIEs. */
21389 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
21392 /* Don't bother trying to generate any DIEs to represent any of the
21393 normal built-in types for the language we are compiling. */
21394 if (DECL_IS_BUILTIN (decl))
21397 /* If we are in terse mode, don't generate any DIEs for types. */
21398 if (debug_info_level <= DINFO_LEVEL_TERSE)
21401 /* If we're a function-scope tag, initially use a parent of NULL;
21402 this will be fixed up in decls_for_scope. */
21403 if (decl_function_context (decl))
21404 context_die = NULL;
21408 case NAMELIST_DECL:
21415 gen_decl_die (decl, NULL, context_die);
21418 /* Write the debugging output for DECL. */
21421 dwarf2out_function_decl (tree decl)
21423 dwarf2out_decl (decl);
21424 call_arg_locations = NULL;
21425 call_arg_loc_last = NULL;
21426 call_site_count = -1;
21427 tail_call_site_count = -1;
21428 block_map.release ();
21429 decl_loc_table->empty ();
21430 cached_dw_loc_list_table->empty ();
21433 /* Output a marker (i.e. a label) for the beginning of the generated code for
21434 a lexical block. */
21437 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
21438 unsigned int blocknum)
21440 switch_to_section (current_function_section ());
21441 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
21444 /* Output a marker (i.e. a label) for the end of the generated code for a
21448 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
21450 switch_to_section (current_function_section ());
21451 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
21454 /* Returns nonzero if it is appropriate not to emit any debugging
21455 information for BLOCK, because it doesn't contain any instructions.
21457 Don't allow this for blocks with nested functions or local classes
21458 as we would end up with orphans, and in the presence of scheduling
21459 we may end up calling them anyway. */
21462 dwarf2out_ignore_block (const_tree block)
21467 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
21468 if (TREE_CODE (decl) == FUNCTION_DECL
21469 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21471 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
21473 decl = BLOCK_NONLOCALIZED_VAR (block, i);
21474 if (TREE_CODE (decl) == FUNCTION_DECL
21475 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21482 /* Hash table routines for file_hash. */
21485 dwarf_file_hasher::equal (dwarf_file_data *p1, const char *p2)
21487 return filename_cmp (p1->filename, p2) == 0;
21491 dwarf_file_hasher::hash (dwarf_file_data *p)
21493 return htab_hash_string (p->filename);
21496 /* Lookup FILE_NAME (in the list of filenames that we know about here in
21497 dwarf2out.c) and return its "index". The index of each (known) filename is
21498 just a unique number which is associated with only that one filename. We
21499 need such numbers for the sake of generating labels (in the .debug_sfnames
21500 section) and references to those files numbers (in the .debug_srcinfo
21501 and.debug_macinfo sections). If the filename given as an argument is not
21502 found in our current list, add it to the list and assign it the next
21503 available unique index number. In order to speed up searches, we remember
21504 the index of the filename was looked up last. This handles the majority of
21507 static struct dwarf_file_data *
21508 lookup_filename (const char *file_name)
21510 struct dwarf_file_data * created;
21512 /* Check to see if the file name that was searched on the previous
21513 call matches this file name. If so, return the index. */
21514 if (file_table_last_lookup
21515 && (file_name == file_table_last_lookup->filename
21516 || filename_cmp (file_table_last_lookup->filename, file_name) == 0))
21517 return file_table_last_lookup;
21519 /* Didn't match the previous lookup, search the table. */
21520 dwarf_file_data **slot
21521 = file_table->find_slot_with_hash (file_name, htab_hash_string (file_name),
21526 created = ggc_alloc<dwarf_file_data> ();
21527 created->filename = file_name;
21528 created->emitted_number = 0;
21533 /* If the assembler will construct the file table, then translate the compiler
21534 internal file table number into the assembler file table number, and emit
21535 a .file directive if we haven't already emitted one yet. The file table
21536 numbers are different because we prune debug info for unused variables and
21537 types, which may include filenames. */
21540 maybe_emit_file (struct dwarf_file_data * fd)
21542 if (! fd->emitted_number)
21544 if (last_emitted_file)
21545 fd->emitted_number = last_emitted_file->emitted_number + 1;
21547 fd->emitted_number = 1;
21548 last_emitted_file = fd;
21550 if (DWARF2_ASM_LINE_DEBUG_INFO)
21552 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
21553 output_quoted_string (asm_out_file,
21554 remap_debug_filename (fd->filename));
21555 fputc ('\n', asm_out_file);
21559 return fd->emitted_number;
21562 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21563 That generation should happen after function debug info has been
21564 generated. The value of the attribute is the constant value of ARG. */
21567 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
21569 die_arg_entry entry;
21574 if (!tmpl_value_parm_die_table)
21575 vec_alloc (tmpl_value_parm_die_table, 32);
21579 vec_safe_push (tmpl_value_parm_die_table, entry);
21582 /* Return TRUE if T is an instance of generic type, FALSE
21586 generic_type_p (tree t)
21588 if (t == NULL_TREE || !TYPE_P (t))
21590 return lang_hooks.get_innermost_generic_parms (t) != NULL_TREE;
21593 /* Schedule the generation of the generic parameter dies for the
21594 instance of generic type T. The proper generation itself is later
21595 done by gen_scheduled_generic_parms_dies. */
21598 schedule_generic_params_dies_gen (tree t)
21600 if (!generic_type_p (t))
21603 if (!generic_type_instances)
21604 vec_alloc (generic_type_instances, 256);
21606 vec_safe_push (generic_type_instances, t);
21609 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21610 by append_entry_to_tmpl_value_parm_die_table. This function must
21611 be called after function DIEs have been generated. */
21614 gen_remaining_tmpl_value_param_die_attribute (void)
21616 if (tmpl_value_parm_die_table)
21621 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table, i, e)
21622 tree_add_const_value_attribute (e->die, e->arg);
21626 /* Generate generic parameters DIEs for instances of generic types
21627 that have been previously scheduled by
21628 schedule_generic_params_dies_gen. This function must be called
21629 after all the types of the CU have been laid out. */
21632 gen_scheduled_generic_parms_dies (void)
21637 if (!generic_type_instances)
21640 FOR_EACH_VEC_ELT (*generic_type_instances, i, t)
21641 if (COMPLETE_TYPE_P (t))
21642 gen_generic_params_dies (t);
21646 /* Replace DW_AT_name for the decl with name. */
21649 dwarf2out_set_name (tree decl, tree name)
21655 die = TYPE_SYMTAB_DIE (decl);
21659 dname = dwarf2_name (name, 0);
21663 attr = get_AT (die, DW_AT_name);
21666 struct indirect_string_node *node;
21668 node = find_AT_string (dname);
21669 /* replace the string. */
21670 attr->dw_attr_val.v.val_str = node;
21674 add_name_attribute (die, dname);
21677 /* True if before or during processing of the first function being emitted. */
21678 static bool in_first_function_p = true;
21679 /* True if loc_note during dwarf2out_var_location call might still be
21680 before first real instruction at address equal to .Ltext0. */
21681 static bool maybe_at_text_label_p = true;
21682 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
21683 static unsigned int first_loclabel_num_not_at_text_label;
21685 /* Called by the final INSN scan whenever we see a var location. We
21686 use it to drop labels in the right places, and throw the location in
21687 our lookup table. */
21690 dwarf2out_var_location (rtx_insn *loc_note)
21692 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
21693 struct var_loc_node *newloc;
21694 rtx_insn *next_real, *next_note;
21695 static const char *last_label;
21696 static const char *last_postcall_label;
21697 static bool last_in_cold_section_p;
21698 static rtx_insn *expected_next_loc_note;
21702 if (!NOTE_P (loc_note))
21704 if (CALL_P (loc_note))
21707 if (SIBLING_CALL_P (loc_note))
21708 tail_call_site_count++;
21713 var_loc_p = NOTE_KIND (loc_note) == NOTE_INSN_VAR_LOCATION;
21714 if (var_loc_p && !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
21717 /* Optimize processing a large consecutive sequence of location
21718 notes so we don't spend too much time in next_real_insn. If the
21719 next insn is another location note, remember the next_real_insn
21720 calculation for next time. */
21721 next_real = cached_next_real_insn;
21724 if (expected_next_loc_note != loc_note)
21728 next_note = NEXT_INSN (loc_note);
21730 || next_note->deleted ()
21731 || ! NOTE_P (next_note)
21732 || (NOTE_KIND (next_note) != NOTE_INSN_VAR_LOCATION
21733 && NOTE_KIND (next_note) != NOTE_INSN_CALL_ARG_LOCATION))
21737 next_real = next_real_insn (loc_note);
21741 expected_next_loc_note = next_note;
21742 cached_next_real_insn = next_real;
21745 cached_next_real_insn = NULL;
21747 /* If there are no instructions which would be affected by this note,
21748 don't do anything. */
21750 && next_real == NULL_RTX
21751 && !NOTE_DURING_CALL_P (loc_note))
21754 if (next_real == NULL_RTX)
21755 next_real = get_last_insn ();
21757 /* If there were any real insns between note we processed last time
21758 and this note (or if it is the first note), clear
21759 last_{,postcall_}label so that they are not reused this time. */
21760 if (last_var_location_insn == NULL_RTX
21761 || last_var_location_insn != next_real
21762 || last_in_cold_section_p != in_cold_section_p)
21765 last_postcall_label = NULL;
21770 decl = NOTE_VAR_LOCATION_DECL (loc_note);
21771 newloc = add_var_loc_to_decl (decl, loc_note,
21772 NOTE_DURING_CALL_P (loc_note)
21773 ? last_postcall_label : last_label);
21774 if (newloc == NULL)
21783 /* If there were no real insns between note we processed last time
21784 and this note, use the label we emitted last time. Otherwise
21785 create a new label and emit it. */
21786 if (last_label == NULL)
21788 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
21789 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
21791 last_label = ggc_strdup (loclabel);
21792 /* See if loclabel might be equal to .Ltext0. If yes,
21793 bump first_loclabel_num_not_at_text_label. */
21794 if (!have_multiple_function_sections
21795 && in_first_function_p
21796 && maybe_at_text_label_p)
21798 static rtx_insn *last_start;
21800 for (insn = loc_note; insn; insn = previous_insn (insn))
21801 if (insn == last_start)
21803 else if (!NONDEBUG_INSN_P (insn))
21807 rtx body = PATTERN (insn);
21808 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
21810 /* Inline asm could occupy zero bytes. */
21811 else if (GET_CODE (body) == ASM_INPUT
21812 || asm_noperands (body) >= 0)
21814 #ifdef HAVE_attr_length
21815 else if (get_attr_min_length (insn) == 0)
21820 /* Assume insn has non-zero length. */
21821 maybe_at_text_label_p = false;
21825 if (maybe_at_text_label_p)
21827 last_start = loc_note;
21828 first_loclabel_num_not_at_text_label = loclabel_num;
21835 struct call_arg_loc_node *ca_loc
21836 = ggc_cleared_alloc<call_arg_loc_node> ();
21837 rtx_insn *prev = prev_real_insn (loc_note);
21839 ca_loc->call_arg_loc_note = loc_note;
21840 ca_loc->next = NULL;
21841 ca_loc->label = last_label;
21844 || (NONJUMP_INSN_P (prev)
21845 && GET_CODE (PATTERN (prev)) == SEQUENCE
21846 && CALL_P (XVECEXP (PATTERN (prev), 0, 0)))));
21847 if (!CALL_P (prev))
21848 prev = as_a <rtx_sequence *> (PATTERN (prev))->insn (0);
21849 ca_loc->tail_call_p = SIBLING_CALL_P (prev);
21850 x = get_call_rtx_from (PATTERN (prev));
21853 x = XEXP (XEXP (x, 0), 0);
21854 if (GET_CODE (x) == SYMBOL_REF
21855 && SYMBOL_REF_DECL (x)
21856 && TREE_CODE (SYMBOL_REF_DECL (x)) == FUNCTION_DECL)
21857 ca_loc->symbol_ref = x;
21859 ca_loc->block = insn_scope (prev);
21860 if (call_arg_locations)
21861 call_arg_loc_last->next = ca_loc;
21863 call_arg_locations = ca_loc;
21864 call_arg_loc_last = ca_loc;
21866 else if (!NOTE_DURING_CALL_P (loc_note))
21867 newloc->label = last_label;
21870 if (!last_postcall_label)
21872 sprintf (loclabel, "%s-1", last_label);
21873 last_postcall_label = ggc_strdup (loclabel);
21875 newloc->label = last_postcall_label;
21878 last_var_location_insn = next_real;
21879 last_in_cold_section_p = in_cold_section_p;
21882 /* Note in one location list that text section has changed. */
21885 var_location_switch_text_section_1 (var_loc_list **slot, void *)
21887 var_loc_list *list = *slot;
21889 list->last_before_switch
21890 = list->last->next ? list->last->next : list->last;
21894 /* Note in all location lists that text section has changed. */
21897 var_location_switch_text_section (void)
21899 if (decl_loc_table == NULL)
21902 decl_loc_table->traverse<void *, var_location_switch_text_section_1> (NULL);
21905 /* Create a new line number table. */
21907 static dw_line_info_table *
21908 new_line_info_table (void)
21910 dw_line_info_table *table;
21912 table = ggc_cleared_alloc<dw_line_info_table_struct> ();
21913 table->file_num = 1;
21914 table->line_num = 1;
21915 table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
21920 /* Lookup the "current" table into which we emit line info, so
21921 that we don't have to do it for every source line. */
21924 set_cur_line_info_table (section *sec)
21926 dw_line_info_table *table;
21928 if (sec == text_section)
21929 table = text_section_line_info;
21930 else if (sec == cold_text_section)
21932 table = cold_text_section_line_info;
21935 cold_text_section_line_info = table = new_line_info_table ();
21936 table->end_label = cold_end_label;
21941 const char *end_label;
21943 if (flag_reorder_blocks_and_partition)
21945 if (in_cold_section_p)
21946 end_label = crtl->subsections.cold_section_end_label;
21948 end_label = crtl->subsections.hot_section_end_label;
21952 char label[MAX_ARTIFICIAL_LABEL_BYTES];
21953 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
21954 current_function_funcdef_no);
21955 end_label = ggc_strdup (label);
21958 table = new_line_info_table ();
21959 table->end_label = end_label;
21961 vec_safe_push (separate_line_info, table);
21964 if (DWARF2_ASM_LINE_DEBUG_INFO)
21965 table->is_stmt = (cur_line_info_table
21966 ? cur_line_info_table->is_stmt
21967 : DWARF_LINE_DEFAULT_IS_STMT_START);
21968 cur_line_info_table = table;
21972 /* We need to reset the locations at the beginning of each
21973 function. We can't do this in the end_function hook, because the
21974 declarations that use the locations won't have been output when
21975 that hook is called. Also compute have_multiple_function_sections here. */
21978 dwarf2out_begin_function (tree fun)
21980 section *sec = function_section (fun);
21982 if (sec != text_section)
21983 have_multiple_function_sections = true;
21985 if (flag_reorder_blocks_and_partition && !cold_text_section)
21987 gcc_assert (current_function_decl == fun);
21988 cold_text_section = unlikely_text_section ();
21989 switch_to_section (cold_text_section);
21990 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
21991 switch_to_section (sec);
21994 dwarf2out_note_section_used ();
21995 call_site_count = 0;
21996 tail_call_site_count = 0;
21998 set_cur_line_info_table (sec);
22001 /* Helper function of dwarf2out_end_function, called only after emitting
22002 the very first function into assembly. Check if some .debug_loc range
22003 might end with a .LVL* label that could be equal to .Ltext0.
22004 In that case we must force using absolute addresses in .debug_loc ranges,
22005 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
22006 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
22008 Set have_multiple_function_sections to true in that case and
22009 terminate htab traversal. */
22012 find_empty_loc_ranges_at_text_label (var_loc_list **slot, int)
22014 var_loc_list *entry = *slot;
22015 struct var_loc_node *node;
22017 node = entry->first;
22018 if (node && node->next && node->next->label)
22021 const char *label = node->next->label;
22022 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
22024 for (i = 0; i < first_loclabel_num_not_at_text_label; i++)
22026 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", i);
22027 if (strcmp (label, loclabel) == 0)
22029 have_multiple_function_sections = true;
22037 /* Hook called after emitting a function into assembly.
22038 This does something only for the very first function emitted. */
22041 dwarf2out_end_function (unsigned int)
22043 if (in_first_function_p
22044 && !have_multiple_function_sections
22045 && first_loclabel_num_not_at_text_label
22047 decl_loc_table->traverse<int, find_empty_loc_ranges_at_text_label> (0);
22048 in_first_function_p = false;
22049 maybe_at_text_label_p = false;
22052 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
22053 front-ends register a translation unit even before dwarf2out_init is
22055 static tree main_translation_unit = NULL_TREE;
22057 /* Hook called by front-ends after they built their main translation unit.
22058 Associate comp_unit_die to UNIT. */
22061 dwarf2out_register_main_translation_unit (tree unit)
22063 gcc_assert (TREE_CODE (unit) == TRANSLATION_UNIT_DECL
22064 && main_translation_unit == NULL_TREE);
22065 main_translation_unit = unit;
22066 /* If dwarf2out_init has not been called yet, it will perform the association
22067 itself looking at main_translation_unit. */
22068 if (decl_die_table != NULL)
22069 equate_decl_number_to_die (unit, comp_unit_die ());
22072 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
22075 push_dw_line_info_entry (dw_line_info_table *table,
22076 enum dw_line_info_opcode opcode, unsigned int val)
22078 dw_line_info_entry e;
22081 vec_safe_push (table->entries, e);
22084 /* Output a label to mark the beginning of a source code line entry
22085 and record information relating to this source line, in
22086 'line_info_table' for later output of the .debug_line section. */
22087 /* ??? The discriminator parameter ought to be unsigned. */
22090 dwarf2out_source_line (unsigned int line, const char *filename,
22091 int discriminator, bool is_stmt)
22093 unsigned int file_num;
22094 dw_line_info_table *table;
22096 if (debug_info_level < DINFO_LEVEL_TERSE || line == 0)
22099 /* The discriminator column was added in dwarf4. Simplify the below
22100 by simply removing it if we're not supposed to output it. */
22101 if (dwarf_version < 4 && dwarf_strict)
22104 table = cur_line_info_table;
22105 file_num = maybe_emit_file (lookup_filename (filename));
22107 /* ??? TODO: Elide duplicate line number entries. Traditionally,
22108 the debugger has used the second (possibly duplicate) line number
22109 at the beginning of the function to mark the end of the prologue.
22110 We could eliminate any other duplicates within the function. For
22111 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
22112 that second line number entry. */
22113 /* Recall that this end-of-prologue indication is *not* the same thing
22114 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
22115 to which the hook corresponds, follows the last insn that was
22116 emitted by gen_prologue. What we need is to precede the first insn
22117 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
22118 insn that corresponds to something the user wrote. These may be
22119 very different locations once scheduling is enabled. */
22121 if (0 && file_num == table->file_num
22122 && line == table->line_num
22123 && discriminator == table->discrim_num
22124 && is_stmt == table->is_stmt)
22127 switch_to_section (current_function_section ());
22129 /* If requested, emit something human-readable. */
22130 if (flag_debug_asm)
22131 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line);
22133 if (DWARF2_ASM_LINE_DEBUG_INFO)
22135 /* Emit the .loc directive understood by GNU as. */
22136 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
22137 file_num, line, is_stmt, discriminator */
22138 fputs ("\t.loc ", asm_out_file);
22139 fprint_ul (asm_out_file, file_num);
22140 putc (' ', asm_out_file);
22141 fprint_ul (asm_out_file, line);
22142 putc (' ', asm_out_file);
22143 putc ('0', asm_out_file);
22145 if (is_stmt != table->is_stmt)
22147 fputs (" is_stmt ", asm_out_file);
22148 putc (is_stmt ? '1' : '0', asm_out_file);
22150 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
22152 gcc_assert (discriminator > 0);
22153 fputs (" discriminator ", asm_out_file);
22154 fprint_ul (asm_out_file, (unsigned long) discriminator);
22156 putc ('\n', asm_out_file);
22160 unsigned int label_num = ++line_info_label_num;
22162 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num);
22164 push_dw_line_info_entry (table, LI_set_address, label_num);
22165 if (file_num != table->file_num)
22166 push_dw_line_info_entry (table, LI_set_file, file_num);
22167 if (discriminator != table->discrim_num)
22168 push_dw_line_info_entry (table, LI_set_discriminator, discriminator);
22169 if (is_stmt != table->is_stmt)
22170 push_dw_line_info_entry (table, LI_negate_stmt, 0);
22171 push_dw_line_info_entry (table, LI_set_line, line);
22174 table->file_num = file_num;
22175 table->line_num = line;
22176 table->discrim_num = discriminator;
22177 table->is_stmt = is_stmt;
22178 table->in_use = true;
22181 /* Record the beginning of a new source file. */
22184 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
22186 if (flag_eliminate_dwarf2_dups)
22188 /* Record the beginning of the file for break_out_includes. */
22189 dw_die_ref bincl_die;
22191 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die (), NULL);
22192 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
22195 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22198 e.code = DW_MACINFO_start_file;
22200 e.info = ggc_strdup (filename);
22201 vec_safe_push (macinfo_table, e);
22205 /* Record the end of a source file. */
22208 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
22210 if (flag_eliminate_dwarf2_dups)
22211 /* Record the end of the file for break_out_includes. */
22212 new_die (DW_TAG_GNU_EINCL, comp_unit_die (), NULL);
22214 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22217 e.code = DW_MACINFO_end_file;
22220 vec_safe_push (macinfo_table, e);
22224 /* Called from debug_define in toplev.c. The `buffer' parameter contains
22225 the tail part of the directive line, i.e. the part which is past the
22226 initial whitespace, #, whitespace, directive-name, whitespace part. */
22229 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
22230 const char *buffer ATTRIBUTE_UNUSED)
22232 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22235 /* Insert a dummy first entry to be able to optimize the whole
22236 predefined macro block using DW_MACRO_GNU_transparent_include. */
22237 if (macinfo_table->is_empty () && lineno <= 1)
22242 vec_safe_push (macinfo_table, e);
22244 e.code = DW_MACINFO_define;
22246 e.info = ggc_strdup (buffer);
22247 vec_safe_push (macinfo_table, e);
22251 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
22252 the tail part of the directive line, i.e. the part which is past the
22253 initial whitespace, #, whitespace, directive-name, whitespace part. */
22256 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
22257 const char *buffer ATTRIBUTE_UNUSED)
22259 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22262 /* Insert a dummy first entry to be able to optimize the whole
22263 predefined macro block using DW_MACRO_GNU_transparent_include. */
22264 if (macinfo_table->is_empty () && lineno <= 1)
22269 vec_safe_push (macinfo_table, e);
22271 e.code = DW_MACINFO_undef;
22273 e.info = ggc_strdup (buffer);
22274 vec_safe_push (macinfo_table, e);
22278 /* Helpers to manipulate hash table of CUs. */
22280 struct macinfo_entry_hasher : typed_noop_remove <macinfo_entry>
22282 typedef macinfo_entry value_type;
22283 typedef macinfo_entry compare_type;
22284 static inline hashval_t hash (const value_type *);
22285 static inline bool equal (const value_type *, const compare_type *);
22289 macinfo_entry_hasher::hash (const value_type *entry)
22291 return htab_hash_string (entry->info);
22295 macinfo_entry_hasher::equal (const value_type *entry1,
22296 const compare_type *entry2)
22298 return !strcmp (entry1->info, entry2->info);
22301 typedef hash_table<macinfo_entry_hasher> macinfo_hash_type;
22303 /* Output a single .debug_macinfo entry. */
22306 output_macinfo_op (macinfo_entry *ref)
22310 struct indirect_string_node *node;
22311 char label[MAX_ARTIFICIAL_LABEL_BYTES];
22312 struct dwarf_file_data *fd;
22316 case DW_MACINFO_start_file:
22317 fd = lookup_filename (ref->info);
22318 file_num = maybe_emit_file (fd);
22319 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
22320 dw2_asm_output_data_uleb128 (ref->lineno,
22321 "Included from line number %lu",
22322 (unsigned long) ref->lineno);
22323 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info);
22325 case DW_MACINFO_end_file:
22326 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
22328 case DW_MACINFO_define:
22329 case DW_MACINFO_undef:
22330 len = strlen (ref->info) + 1;
22332 && len > DWARF_OFFSET_SIZE
22333 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22334 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
22336 ref->code = ref->code == DW_MACINFO_define
22337 ? DW_MACRO_GNU_define_indirect
22338 : DW_MACRO_GNU_undef_indirect;
22339 output_macinfo_op (ref);
22342 dw2_asm_output_data (1, ref->code,
22343 ref->code == DW_MACINFO_define
22344 ? "Define macro" : "Undefine macro");
22345 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22346 (unsigned long) ref->lineno);
22347 dw2_asm_output_nstring (ref->info, -1, "The macro");
22349 case DW_MACRO_GNU_define_indirect:
22350 case DW_MACRO_GNU_undef_indirect:
22351 node = find_AT_string (ref->info);
22353 && ((node->form == DW_FORM_strp)
22354 || (node->form == DW_FORM_GNU_str_index)));
22355 dw2_asm_output_data (1, ref->code,
22356 ref->code == DW_MACRO_GNU_define_indirect
22357 ? "Define macro indirect"
22358 : "Undefine macro indirect");
22359 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22360 (unsigned long) ref->lineno);
22361 if (node->form == DW_FORM_strp)
22362 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
22363 debug_str_section, "The macro: \"%s\"",
22366 dw2_asm_output_data_uleb128 (node->index, "The macro: \"%s\"",
22369 case DW_MACRO_GNU_transparent_include:
22370 dw2_asm_output_data (1, ref->code, "Transparent include");
22371 ASM_GENERATE_INTERNAL_LABEL (label,
22372 DEBUG_MACRO_SECTION_LABEL, ref->lineno);
22373 dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL);
22376 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n",
22377 ASM_COMMENT_START, (unsigned long) ref->code);
22382 /* Attempt to make a sequence of define/undef macinfo ops shareable with
22383 other compilation unit .debug_macinfo sections. IDX is the first
22384 index of a define/undef, return the number of ops that should be
22385 emitted in a comdat .debug_macinfo section and emit
22386 a DW_MACRO_GNU_transparent_include entry referencing it.
22387 If the define/undef entry should be emitted normally, return 0. */
22390 optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files,
22391 macinfo_hash_type **macinfo_htab)
22393 macinfo_entry *first, *second, *cur, *inc;
22394 char linebuf[sizeof (HOST_WIDE_INT) * 3 + 1];
22395 unsigned char checksum[16];
22396 struct md5_ctx ctx;
22397 char *grp_name, *tail;
22399 unsigned int i, count, encoded_filename_len, linebuf_len;
22400 macinfo_entry **slot;
22402 first = &(*macinfo_table)[idx];
22403 second = &(*macinfo_table)[idx + 1];
22405 /* Optimize only if there are at least two consecutive define/undef ops,
22406 and either all of them are before first DW_MACINFO_start_file
22407 with lineno {0,1} (i.e. predefined macro block), or all of them are
22408 in some included header file. */
22409 if (second->code != DW_MACINFO_define && second->code != DW_MACINFO_undef)
22411 if (vec_safe_is_empty (files))
22413 if (first->lineno > 1 || second->lineno > 1)
22416 else if (first->lineno == 0)
22419 /* Find the last define/undef entry that can be grouped together
22420 with first and at the same time compute md5 checksum of their
22421 codes, linenumbers and strings. */
22422 md5_init_ctx (&ctx);
22423 for (i = idx; macinfo_table->iterate (i, &cur); i++)
22424 if (cur->code != DW_MACINFO_define && cur->code != DW_MACINFO_undef)
22426 else if (vec_safe_is_empty (files) && cur->lineno > 1)
22430 unsigned char code = cur->code;
22431 md5_process_bytes (&code, 1, &ctx);
22432 checksum_uleb128 (cur->lineno, &ctx);
22433 md5_process_bytes (cur->info, strlen (cur->info) + 1, &ctx);
22435 md5_finish_ctx (&ctx, checksum);
22438 /* From the containing include filename (if any) pick up just
22439 usable characters from its basename. */
22440 if (vec_safe_is_empty (files))
22443 base = lbasename (files->last ().info);
22444 for (encoded_filename_len = 0, i = 0; base[i]; i++)
22445 if (ISIDNUM (base[i]) || base[i] == '.')
22446 encoded_filename_len++;
22447 /* Count . at the end. */
22448 if (encoded_filename_len)
22449 encoded_filename_len++;
22451 sprintf (linebuf, HOST_WIDE_INT_PRINT_UNSIGNED, first->lineno);
22452 linebuf_len = strlen (linebuf);
22454 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
22455 grp_name = XALLOCAVEC (char, 4 + encoded_filename_len + linebuf_len + 1
22457 memcpy (grp_name, DWARF_OFFSET_SIZE == 4 ? "wm4." : "wm8.", 4);
22458 tail = grp_name + 4;
22459 if (encoded_filename_len)
22461 for (i = 0; base[i]; i++)
22462 if (ISIDNUM (base[i]) || base[i] == '.')
22466 memcpy (tail, linebuf, linebuf_len);
22467 tail += linebuf_len;
22469 for (i = 0; i < 16; i++)
22470 sprintf (tail + i * 2, "%02x", checksum[i] & 0xff);
22472 /* Construct a macinfo_entry for DW_MACRO_GNU_transparent_include
22473 in the empty vector entry before the first define/undef. */
22474 inc = &(*macinfo_table)[idx - 1];
22475 inc->code = DW_MACRO_GNU_transparent_include;
22477 inc->info = ggc_strdup (grp_name);
22478 if (!*macinfo_htab)
22479 *macinfo_htab = new macinfo_hash_type (10);
22480 /* Avoid emitting duplicates. */
22481 slot = (*macinfo_htab)->find_slot (inc, INSERT);
22486 /* If such an entry has been used before, just emit
22487 a DW_MACRO_GNU_transparent_include op. */
22489 output_macinfo_op (inc);
22490 /* And clear all macinfo_entry in the range to avoid emitting them
22491 in the second pass. */
22492 for (i = idx; macinfo_table->iterate (i, &cur) && i < idx + count; i++)
22501 inc->lineno = (*macinfo_htab)->elements ();
22502 output_macinfo_op (inc);
22507 /* Save any strings needed by the macinfo table in the debug str
22508 table. All strings must be collected into the table by the time
22509 index_string is called. */
22512 save_macinfo_strings (void)
22516 macinfo_entry *ref;
22518 for (i = 0; macinfo_table && macinfo_table->iterate (i, &ref); i++)
22522 /* Match the logic in output_macinfo_op to decide on
22523 indirect strings. */
22524 case DW_MACINFO_define:
22525 case DW_MACINFO_undef:
22526 len = strlen (ref->info) + 1;
22528 && len > DWARF_OFFSET_SIZE
22529 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
22530 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
22531 set_indirect_string (find_AT_string (ref->info));
22533 case DW_MACRO_GNU_define_indirect:
22534 case DW_MACRO_GNU_undef_indirect:
22535 set_indirect_string (find_AT_string (ref->info));
22543 /* Output macinfo section(s). */
22546 output_macinfo (void)
22549 unsigned long length = vec_safe_length (macinfo_table);
22550 macinfo_entry *ref;
22551 vec<macinfo_entry, va_gc> *files = NULL;
22552 macinfo_hash_type *macinfo_htab = NULL;
22557 /* output_macinfo* uses these interchangeably. */
22558 gcc_assert ((int) DW_MACINFO_define == (int) DW_MACRO_GNU_define
22559 && (int) DW_MACINFO_undef == (int) DW_MACRO_GNU_undef
22560 && (int) DW_MACINFO_start_file == (int) DW_MACRO_GNU_start_file
22561 && (int) DW_MACINFO_end_file == (int) DW_MACRO_GNU_end_file);
22563 /* For .debug_macro emit the section header. */
22566 dw2_asm_output_data (2, 4, "DWARF macro version number");
22567 if (DWARF_OFFSET_SIZE == 8)
22568 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
22570 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
22571 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
22572 (!dwarf_split_debug_info ? debug_line_section_label
22573 : debug_skeleton_line_section_label),
22574 debug_line_section, NULL);
22577 /* In the first loop, it emits the primary .debug_macinfo section
22578 and after each emitted op the macinfo_entry is cleared.
22579 If a longer range of define/undef ops can be optimized using
22580 DW_MACRO_GNU_transparent_include, the
22581 DW_MACRO_GNU_transparent_include op is emitted and kept in
22582 the vector before the first define/undef in the range and the
22583 whole range of define/undef ops is not emitted and kept. */
22584 for (i = 0; macinfo_table->iterate (i, &ref); i++)
22588 case DW_MACINFO_start_file:
22589 vec_safe_push (files, *ref);
22591 case DW_MACINFO_end_file:
22592 if (!vec_safe_is_empty (files))
22595 case DW_MACINFO_define:
22596 case DW_MACINFO_undef:
22598 && HAVE_COMDAT_GROUP
22599 && vec_safe_length (files) != 1
22602 && (*macinfo_table)[i - 1].code == 0)
22604 unsigned count = optimize_macinfo_range (i, files, &macinfo_htab);
22613 /* A dummy entry may be inserted at the beginning to be able
22614 to optimize the whole block of predefined macros. */
22620 output_macinfo_op (ref);
22628 delete macinfo_htab;
22629 macinfo_htab = NULL;
22631 /* If any DW_MACRO_GNU_transparent_include were used, on those
22632 DW_MACRO_GNU_transparent_include entries terminate the
22633 current chain and switch to a new comdat .debug_macinfo
22634 section and emit the define/undef entries within it. */
22635 for (i = 0; macinfo_table->iterate (i, &ref); i++)
22640 case DW_MACRO_GNU_transparent_include:
22642 char label[MAX_ARTIFICIAL_LABEL_BYTES];
22643 tree comdat_key = get_identifier (ref->info);
22644 /* Terminate the previous .debug_macinfo section. */
22645 dw2_asm_output_data (1, 0, "End compilation unit");
22646 targetm.asm_out.named_section (DEBUG_MACRO_SECTION,
22648 | SECTION_LINKONCE,
22650 ASM_GENERATE_INTERNAL_LABEL (label,
22651 DEBUG_MACRO_SECTION_LABEL,
22653 ASM_OUTPUT_LABEL (asm_out_file, label);
22656 dw2_asm_output_data (2, 4, "DWARF macro version number");
22657 if (DWARF_OFFSET_SIZE == 8)
22658 dw2_asm_output_data (1, 1, "Flags: 64-bit");
22660 dw2_asm_output_data (1, 0, "Flags: 32-bit");
22663 case DW_MACINFO_define:
22664 case DW_MACINFO_undef:
22665 output_macinfo_op (ref);
22670 gcc_unreachable ();
22674 /* Set up for Dwarf output at the start of compilation. */
22677 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
22679 /* This option is currently broken, see (PR53118 and PR46102). */
22680 if (flag_eliminate_dwarf2_dups
22681 && strstr (lang_hooks.name, "C++"))
22683 warning (0, "-feliminate-dwarf2-dups is broken for C++, ignoring");
22684 flag_eliminate_dwarf2_dups = 0;
22687 /* Allocate the file_table. */
22688 file_table = hash_table<dwarf_file_hasher>::create_ggc (50);
22690 /* Allocate the decl_die_table. */
22691 decl_die_table = hash_table<decl_die_hasher>::create_ggc (10);
22693 /* Allocate the decl_loc_table. */
22694 decl_loc_table = hash_table<decl_loc_hasher>::create_ggc (10);
22696 /* Allocate the cached_dw_loc_list_table. */
22697 cached_dw_loc_list_table = hash_table<dw_loc_list_hasher>::create_ggc (10);
22699 /* Allocate the initial hunk of the decl_scope_table. */
22700 vec_alloc (decl_scope_table, 256);
22702 /* Allocate the initial hunk of the abbrev_die_table. */
22703 abbrev_die_table = ggc_cleared_vec_alloc<dw_die_ref>
22704 (ABBREV_DIE_TABLE_INCREMENT);
22705 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
22706 /* Zero-th entry is allocated, but unused. */
22707 abbrev_die_table_in_use = 1;
22709 /* Allocate the pubtypes and pubnames vectors. */
22710 vec_alloc (pubname_table, 32);
22711 vec_alloc (pubtype_table, 32);
22713 vec_alloc (incomplete_types, 64);
22715 vec_alloc (used_rtx_array, 32);
22717 if (!dwarf_split_debug_info)
22719 debug_info_section = get_section (DEBUG_INFO_SECTION,
22720 SECTION_DEBUG, NULL);
22721 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
22722 SECTION_DEBUG, NULL);
22723 debug_loc_section = get_section (DEBUG_LOC_SECTION,
22724 SECTION_DEBUG, NULL);
22728 debug_info_section = get_section (DEBUG_DWO_INFO_SECTION,
22729 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22730 debug_abbrev_section = get_section (DEBUG_DWO_ABBREV_SECTION,
22731 SECTION_DEBUG | SECTION_EXCLUDE,
22733 debug_addr_section = get_section (DEBUG_ADDR_SECTION,
22734 SECTION_DEBUG, NULL);
22735 debug_skeleton_info_section = get_section (DEBUG_INFO_SECTION,
22736 SECTION_DEBUG, NULL);
22737 debug_skeleton_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
22738 SECTION_DEBUG, NULL);
22739 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label,
22740 DEBUG_SKELETON_ABBREV_SECTION_LABEL, 0);
22742 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections stay in
22743 the main .o, but the skeleton_line goes into the split off dwo. */
22744 debug_skeleton_line_section
22745 = get_section (DEBUG_DWO_LINE_SECTION,
22746 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22747 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label,
22748 DEBUG_SKELETON_LINE_SECTION_LABEL, 0);
22749 debug_str_offsets_section = get_section (DEBUG_STR_OFFSETS_SECTION,
22750 SECTION_DEBUG | SECTION_EXCLUDE,
22752 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label,
22753 DEBUG_SKELETON_INFO_SECTION_LABEL, 0);
22754 debug_loc_section = get_section (DEBUG_DWO_LOC_SECTION,
22755 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
22756 debug_str_dwo_section = get_section (DEBUG_STR_DWO_SECTION,
22757 DEBUG_STR_DWO_SECTION_FLAGS, NULL);
22759 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
22760 SECTION_DEBUG, NULL);
22761 debug_macinfo_section = get_section (dwarf_strict
22762 ? DEBUG_MACINFO_SECTION
22763 : DEBUG_MACRO_SECTION,
22764 DEBUG_MACRO_SECTION_FLAGS, NULL);
22765 debug_line_section = get_section (DEBUG_LINE_SECTION,
22766 SECTION_DEBUG, NULL);
22767 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
22768 SECTION_DEBUG, NULL);
22769 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
22770 SECTION_DEBUG, NULL);
22771 debug_str_section = get_section (DEBUG_STR_SECTION,
22772 DEBUG_STR_SECTION_FLAGS, NULL);
22773 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
22774 SECTION_DEBUG, NULL);
22775 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
22776 SECTION_DEBUG, NULL);
22778 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
22779 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
22780 DEBUG_ABBREV_SECTION_LABEL, 0);
22781 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
22782 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
22783 COLD_TEXT_SECTION_LABEL, 0);
22784 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
22786 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
22787 DEBUG_INFO_SECTION_LABEL, 0);
22788 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
22789 DEBUG_LINE_SECTION_LABEL, 0);
22790 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
22791 DEBUG_RANGES_SECTION_LABEL, 0);
22792 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label,
22793 DEBUG_ADDR_SECTION_LABEL, 0);
22794 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
22796 ? DEBUG_MACINFO_SECTION_LABEL
22797 : DEBUG_MACRO_SECTION_LABEL, 0);
22798 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, DEBUG_LOC_SECTION_LABEL, 0);
22800 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22801 vec_alloc (macinfo_table, 64);
22803 switch_to_section (text_section);
22804 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
22806 /* Make sure the line number table for .text always exists. */
22807 text_section_line_info = new_line_info_table ();
22808 text_section_line_info->end_label = text_end_label;
22810 /* If front-ends already registered a main translation unit but we were not
22811 ready to perform the association, do this now. */
22812 if (main_translation_unit != NULL_TREE)
22813 equate_decl_number_to_die (main_translation_unit, comp_unit_die ());
22816 /* Called before compile () starts outputtting functions, variables
22817 and toplevel asms into assembly. */
22820 dwarf2out_assembly_start (void)
22822 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
22823 && dwarf2out_do_cfi_asm ()
22824 && (!(flag_unwind_tables || flag_exceptions)
22825 || targetm_common.except_unwind_info (&global_options) != UI_DWARF2))
22826 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
22829 /* A helper function for dwarf2out_finish called through
22830 htab_traverse. Assign a string its index. All strings must be
22831 collected into the table by the time index_string is called,
22832 because the indexing code relies on htab_traverse to traverse nodes
22833 in the same order for each run. */
22836 index_string (indirect_string_node **h, unsigned int *index)
22838 indirect_string_node *node = *h;
22840 find_string_form (node);
22841 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22843 gcc_assert (node->index == NO_INDEX_ASSIGNED);
22844 node->index = *index;
22850 /* A helper function for output_indirect_strings called through
22851 htab_traverse. Output the offset to a string and update the
22855 output_index_string_offset (indirect_string_node **h, unsigned int *offset)
22857 indirect_string_node *node = *h;
22859 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22861 /* Assert that this node has been assigned an index. */
22862 gcc_assert (node->index != NO_INDEX_ASSIGNED
22863 && node->index != NOT_INDEXED);
22864 dw2_asm_output_data (DWARF_OFFSET_SIZE, *offset,
22865 "indexed string 0x%x: %s", node->index, node->str);
22866 *offset += strlen (node->str) + 1;
22871 /* A helper function for dwarf2out_finish called through
22872 htab_traverse. Output the indexed string. */
22875 output_index_string (indirect_string_node **h, unsigned int *cur_idx)
22877 struct indirect_string_node *node = *h;
22879 if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
22881 /* Assert that the strings are output in the same order as their
22882 indexes were assigned. */
22883 gcc_assert (*cur_idx == node->index);
22884 assemble_string (node->str, strlen (node->str) + 1);
22890 /* A helper function for dwarf2out_finish called through
22891 htab_traverse. Emit one queued .debug_str string. */
22894 output_indirect_string (indirect_string_node **h, void *)
22896 struct indirect_string_node *node = *h;
22898 node->form = find_string_form (node);
22899 if (node->form == DW_FORM_strp && node->refcount > 0)
22901 ASM_OUTPUT_LABEL (asm_out_file, node->label);
22902 assemble_string (node->str, strlen (node->str) + 1);
22908 /* Output the indexed string table. */
22911 output_indirect_strings (void)
22913 switch_to_section (debug_str_section);
22914 if (!dwarf_split_debug_info)
22915 debug_str_hash->traverse<void *, output_indirect_string> (NULL);
22918 unsigned int offset = 0;
22919 unsigned int cur_idx = 0;
22921 skeleton_debug_str_hash->traverse<void *, output_indirect_string> (NULL);
22923 switch_to_section (debug_str_offsets_section);
22924 debug_str_hash->traverse_noresize
22925 <unsigned int *, output_index_string_offset> (&offset);
22926 switch_to_section (debug_str_dwo_section);
22927 debug_str_hash->traverse_noresize<unsigned int *, output_index_string>
22932 /* Callback for htab_traverse to assign an index to an entry in the
22933 table, and to write that entry to the .debug_addr section. */
22936 output_addr_table_entry (addr_table_entry **slot, unsigned int *cur_index)
22938 addr_table_entry *entry = *slot;
22940 if (entry->refcount == 0)
22942 gcc_assert (entry->index == NO_INDEX_ASSIGNED
22943 || entry->index == NOT_INDEXED);
22947 gcc_assert (entry->index == *cur_index);
22950 switch (entry->kind)
22953 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, entry->addr.rtl,
22954 "0x%x", entry->index);
22956 case ate_kind_rtx_dtprel:
22957 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
22958 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
22961 fputc ('\n', asm_out_file);
22963 case ate_kind_label:
22964 dw2_asm_output_addr (DWARF2_ADDR_SIZE, entry->addr.label,
22965 "0x%x", entry->index);
22968 gcc_unreachable ();
22973 /* Produce the .debug_addr section. */
22976 output_addr_table (void)
22978 unsigned int index = 0;
22979 if (addr_index_table == NULL || addr_index_table->size () == 0)
22982 switch_to_section (debug_addr_section);
22984 ->traverse_noresize<unsigned int *, output_addr_table_entry> (&index);
22987 #if ENABLE_ASSERT_CHECKING
22988 /* Verify that all marks are clear. */
22991 verify_marks_clear (dw_die_ref die)
22995 gcc_assert (! die->die_mark);
22996 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
22998 #endif /* ENABLE_ASSERT_CHECKING */
23000 /* Clear the marks for a die and its children.
23001 Be cool if the mark isn't set. */
23004 prune_unmark_dies (dw_die_ref die)
23010 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
23013 /* Given DIE that we're marking as used, find any other dies
23014 it references as attributes and mark them as used. */
23017 prune_unused_types_walk_attribs (dw_die_ref die)
23022 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
23024 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
23026 /* A reference to another DIE.
23027 Make sure that it will get emitted.
23028 If it was broken out into a comdat group, don't follow it. */
23029 if (! AT_ref (a)->comdat_type_p
23030 || a->dw_attr == DW_AT_specification)
23031 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
23033 /* Set the string's refcount to 0 so that prune_unused_types_mark
23034 accounts properly for it. */
23035 if (AT_class (a) == dw_val_class_str)
23036 a->dw_attr_val.v.val_str->refcount = 0;
23040 /* Mark the generic parameters and arguments children DIEs of DIE. */
23043 prune_unused_types_mark_generic_parms_dies (dw_die_ref die)
23047 if (die == NULL || die->die_child == NULL)
23049 c = die->die_child;
23052 if (is_template_parameter (c))
23053 prune_unused_types_mark (c, 1);
23055 } while (c && c != die->die_child);
23058 /* Mark DIE as being used. If DOKIDS is true, then walk down
23059 to DIE's children. */
23062 prune_unused_types_mark (dw_die_ref die, int dokids)
23066 if (die->die_mark == 0)
23068 /* We haven't done this node yet. Mark it as used. */
23070 /* If this is the DIE of a generic type instantiation,
23071 mark the children DIEs that describe its generic parms and
23073 prune_unused_types_mark_generic_parms_dies (die);
23075 /* We also have to mark its parents as used.
23076 (But we don't want to mark our parent's kids due to this,
23077 unless it is a class.) */
23078 if (die->die_parent)
23079 prune_unused_types_mark (die->die_parent,
23080 class_scope_p (die->die_parent));
23082 /* Mark any referenced nodes. */
23083 prune_unused_types_walk_attribs (die);
23085 /* If this node is a specification,
23086 also mark the definition, if it exists. */
23087 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
23088 prune_unused_types_mark (die->die_definition, 1);
23091 if (dokids && die->die_mark != 2)
23093 /* We need to walk the children, but haven't done so yet.
23094 Remember that we've walked the kids. */
23097 /* If this is an array type, we need to make sure our
23098 kids get marked, even if they're types. If we're
23099 breaking out types into comdat sections, do this
23100 for all type definitions. */
23101 if (die->die_tag == DW_TAG_array_type
23102 || (use_debug_types
23103 && is_type_die (die) && ! is_declaration_die (die)))
23104 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
23106 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23110 /* For local classes, look if any static member functions were emitted
23111 and if so, mark them. */
23114 prune_unused_types_walk_local_classes (dw_die_ref die)
23118 if (die->die_mark == 2)
23121 switch (die->die_tag)
23123 case DW_TAG_structure_type:
23124 case DW_TAG_union_type:
23125 case DW_TAG_class_type:
23128 case DW_TAG_subprogram:
23129 if (!get_AT_flag (die, DW_AT_declaration)
23130 || die->die_definition != NULL)
23131 prune_unused_types_mark (die, 1);
23138 /* Mark children. */
23139 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
23142 /* Walk the tree DIE and mark types that we actually use. */
23145 prune_unused_types_walk (dw_die_ref die)
23149 /* Don't do anything if this node is already marked and
23150 children have been marked as well. */
23151 if (die->die_mark == 2)
23154 switch (die->die_tag)
23156 case DW_TAG_structure_type:
23157 case DW_TAG_union_type:
23158 case DW_TAG_class_type:
23159 if (die->die_perennial_p)
23162 for (c = die->die_parent; c; c = c->die_parent)
23163 if (c->die_tag == DW_TAG_subprogram)
23166 /* Finding used static member functions inside of classes
23167 is needed just for local classes, because for other classes
23168 static member function DIEs with DW_AT_specification
23169 are emitted outside of the DW_TAG_*_type. If we ever change
23170 it, we'd need to call this even for non-local classes. */
23172 prune_unused_types_walk_local_classes (die);
23174 /* It's a type node --- don't mark it. */
23177 case DW_TAG_const_type:
23178 case DW_TAG_packed_type:
23179 case DW_TAG_pointer_type:
23180 case DW_TAG_reference_type:
23181 case DW_TAG_rvalue_reference_type:
23182 case DW_TAG_volatile_type:
23183 case DW_TAG_typedef:
23184 case DW_TAG_array_type:
23185 case DW_TAG_interface_type:
23186 case DW_TAG_friend:
23187 case DW_TAG_variant_part:
23188 case DW_TAG_enumeration_type:
23189 case DW_TAG_subroutine_type:
23190 case DW_TAG_string_type:
23191 case DW_TAG_set_type:
23192 case DW_TAG_subrange_type:
23193 case DW_TAG_ptr_to_member_type:
23194 case DW_TAG_file_type:
23195 if (die->die_perennial_p)
23198 /* It's a type node --- don't mark it. */
23202 /* Mark everything else. */
23206 if (die->die_mark == 0)
23210 /* Now, mark any dies referenced from here. */
23211 prune_unused_types_walk_attribs (die);
23216 /* Mark children. */
23217 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23220 /* Increment the string counts on strings referred to from DIE's
23224 prune_unused_types_update_strings (dw_die_ref die)
23229 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
23230 if (AT_class (a) == dw_val_class_str)
23232 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
23234 /* Avoid unnecessarily putting strings that are used less than
23235 twice in the hash table. */
23237 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
23239 indirect_string_node **slot
23240 = debug_str_hash->find_slot_with_hash (s->str,
23241 htab_hash_string (s->str),
23243 gcc_assert (*slot == NULL);
23249 /* Remove from the tree DIE any dies that aren't marked. */
23252 prune_unused_types_prune (dw_die_ref die)
23256 gcc_assert (die->die_mark);
23257 prune_unused_types_update_strings (die);
23259 if (! die->die_child)
23262 c = die->die_child;
23264 dw_die_ref prev = c;
23265 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
23266 if (c == die->die_child)
23268 /* No marked children between 'prev' and the end of the list. */
23270 /* No marked children at all. */
23271 die->die_child = NULL;
23274 prev->die_sib = c->die_sib;
23275 die->die_child = prev;
23280 if (c != prev->die_sib)
23282 prune_unused_types_prune (c);
23283 } while (c != die->die_child);
23286 /* Remove dies representing declarations that we never use. */
23289 prune_unused_types (void)
23292 limbo_die_node *node;
23293 comdat_type_node *ctnode;
23295 dw_die_ref base_type;
23297 #if ENABLE_ASSERT_CHECKING
23298 /* All the marks should already be clear. */
23299 verify_marks_clear (comp_unit_die ());
23300 for (node = limbo_die_list; node; node = node->next)
23301 verify_marks_clear (node->die);
23302 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23303 verify_marks_clear (ctnode->root_die);
23304 #endif /* ENABLE_ASSERT_CHECKING */
23306 /* Mark types that are used in global variables. */
23307 premark_types_used_by_global_vars ();
23309 /* Set the mark on nodes that are actually used. */
23310 prune_unused_types_walk (comp_unit_die ());
23311 for (node = limbo_die_list; node; node = node->next)
23312 prune_unused_types_walk (node->die);
23313 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23315 prune_unused_types_walk (ctnode->root_die);
23316 prune_unused_types_mark (ctnode->type_die, 1);
23319 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
23320 are unusual in that they are pubnames that are the children of pubtypes.
23321 They should only be marked via their parent DW_TAG_enumeration_type die,
23322 not as roots in themselves. */
23323 FOR_EACH_VEC_ELT (*pubname_table, i, pub)
23324 if (pub->die->die_tag != DW_TAG_enumerator)
23325 prune_unused_types_mark (pub->die, 1);
23326 for (i = 0; base_types.iterate (i, &base_type); i++)
23327 prune_unused_types_mark (base_type, 1);
23329 if (debug_str_hash)
23330 debug_str_hash->empty ();
23331 if (skeleton_debug_str_hash)
23332 skeleton_debug_str_hash->empty ();
23333 prune_unused_types_prune (comp_unit_die ());
23334 for (node = limbo_die_list; node; node = node->next)
23335 prune_unused_types_prune (node->die);
23336 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23337 prune_unused_types_prune (ctnode->root_die);
23339 /* Leave the marks clear. */
23340 prune_unmark_dies (comp_unit_die ());
23341 for (node = limbo_die_list; node; node = node->next)
23342 prune_unmark_dies (node->die);
23343 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23344 prune_unmark_dies (ctnode->root_die);
23347 /* Set the parameter to true if there are any relative pathnames in
23350 file_table_relative_p (dwarf_file_data **slot, bool *p)
23352 struct dwarf_file_data *d = *slot;
23353 if (!IS_ABSOLUTE_PATH (d->filename))
23361 /* Helpers to manipulate hash table of comdat type units. */
23363 struct comdat_type_hasher : typed_noop_remove <comdat_type_node>
23365 typedef comdat_type_node value_type;
23366 typedef comdat_type_node compare_type;
23367 static inline hashval_t hash (const value_type *);
23368 static inline bool equal (const value_type *, const compare_type *);
23372 comdat_type_hasher::hash (const value_type *type_node)
23375 memcpy (&h, type_node->signature, sizeof (h));
23380 comdat_type_hasher::equal (const value_type *type_node_1,
23381 const compare_type *type_node_2)
23383 return (! memcmp (type_node_1->signature, type_node_2->signature,
23384 DWARF_TYPE_SIGNATURE_SIZE));
23387 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
23388 to the location it would have been added, should we know its
23389 DECL_ASSEMBLER_NAME when we added other attributes. This will
23390 probably improve compactness of debug info, removing equivalent
23391 abbrevs, and hide any differences caused by deferring the
23392 computation of the assembler name, triggered by e.g. PCH. */
23395 move_linkage_attr (dw_die_ref die)
23397 unsigned ix = vec_safe_length (die->die_attr);
23398 dw_attr_node linkage = (*die->die_attr)[ix - 1];
23400 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
23401 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
23405 dw_attr_node *prev = &(*die->die_attr)[ix - 1];
23407 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
23411 if (ix != vec_safe_length (die->die_attr) - 1)
23413 die->die_attr->pop ();
23414 die->die_attr->quick_insert (ix, linkage);
23418 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
23419 referenced from typed stack ops and count how often they are used. */
23422 mark_base_types (dw_loc_descr_ref loc)
23424 dw_die_ref base_type = NULL;
23426 for (; loc; loc = loc->dw_loc_next)
23428 switch (loc->dw_loc_opc)
23430 case DW_OP_GNU_regval_type:
23431 case DW_OP_GNU_deref_type:
23432 base_type = loc->dw_loc_oprnd2.v.val_die_ref.die;
23434 case DW_OP_GNU_convert:
23435 case DW_OP_GNU_reinterpret:
23436 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
23439 case DW_OP_GNU_const_type:
23440 base_type = loc->dw_loc_oprnd1.v.val_die_ref.die;
23442 case DW_OP_GNU_entry_value:
23443 mark_base_types (loc->dw_loc_oprnd1.v.val_loc);
23448 gcc_assert (base_type->die_parent == comp_unit_die ());
23449 if (base_type->die_mark)
23450 base_type->die_mark++;
23453 base_types.safe_push (base_type);
23454 base_type->die_mark = 1;
23459 /* Comparison function for sorting marked base types. */
23462 base_type_cmp (const void *x, const void *y)
23464 dw_die_ref dx = *(const dw_die_ref *) x;
23465 dw_die_ref dy = *(const dw_die_ref *) y;
23466 unsigned int byte_size1, byte_size2;
23467 unsigned int encoding1, encoding2;
23468 if (dx->die_mark > dy->die_mark)
23470 if (dx->die_mark < dy->die_mark)
23472 byte_size1 = get_AT_unsigned (dx, DW_AT_byte_size);
23473 byte_size2 = get_AT_unsigned (dy, DW_AT_byte_size);
23474 if (byte_size1 < byte_size2)
23476 if (byte_size1 > byte_size2)
23478 encoding1 = get_AT_unsigned (dx, DW_AT_encoding);
23479 encoding2 = get_AT_unsigned (dy, DW_AT_encoding);
23480 if (encoding1 < encoding2)
23482 if (encoding1 > encoding2)
23487 /* Move base types marked by mark_base_types as early as possible
23488 in the CU, sorted by decreasing usage count both to make the
23489 uleb128 references as small as possible and to make sure they
23490 will have die_offset already computed by calc_die_sizes when
23491 sizes of typed stack loc ops is computed. */
23494 move_marked_base_types (void)
23497 dw_die_ref base_type, die, c;
23499 if (base_types.is_empty ())
23502 /* Sort by decreasing usage count, they will be added again in that
23504 base_types.qsort (base_type_cmp);
23505 die = comp_unit_die ();
23506 c = die->die_child;
23509 dw_die_ref prev = c;
23511 while (c->die_mark)
23513 remove_child_with_prev (c, prev);
23514 /* As base types got marked, there must be at least
23515 one node other than DW_TAG_base_type. */
23516 gcc_assert (c != c->die_sib);
23520 while (c != die->die_child);
23521 gcc_assert (die->die_child);
23522 c = die->die_child;
23523 for (i = 0; base_types.iterate (i, &base_type); i++)
23525 base_type->die_mark = 0;
23526 base_type->die_sib = c->die_sib;
23527 c->die_sib = base_type;
23532 /* Helper function for resolve_addr, attempt to resolve
23533 one CONST_STRING, return true if successful. Similarly verify that
23534 SYMBOL_REFs refer to variables emitted in the current CU. */
23537 resolve_one_addr (rtx *addr)
23541 if (GET_CODE (rtl) == CONST_STRING)
23543 size_t len = strlen (XSTR (rtl, 0)) + 1;
23544 tree t = build_string (len, XSTR (rtl, 0));
23545 tree tlen = size_int (len - 1);
23547 = build_array_type (char_type_node, build_index_type (tlen));
23548 rtl = lookup_constant_def (t);
23549 if (!rtl || !MEM_P (rtl))
23551 rtl = XEXP (rtl, 0);
23552 if (GET_CODE (rtl) == SYMBOL_REF
23553 && SYMBOL_REF_DECL (rtl)
23554 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
23556 vec_safe_push (used_rtx_array, rtl);
23561 if (GET_CODE (rtl) == SYMBOL_REF
23562 && SYMBOL_REF_DECL (rtl))
23564 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl))
23566 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl))))
23569 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
23573 if (GET_CODE (rtl) == CONST)
23575 subrtx_ptr_iterator::array_type array;
23576 FOR_EACH_SUBRTX_PTR (iter, array, &XEXP (rtl, 0), ALL)
23577 if (!resolve_one_addr (*iter))
23584 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
23585 if possible, and create DW_TAG_dwarf_procedure that can be referenced
23586 from DW_OP_GNU_implicit_pointer if the string hasn't been seen yet. */
23589 string_cst_pool_decl (tree t)
23591 rtx rtl = output_constant_def (t, 1);
23592 unsigned char *array;
23593 dw_loc_descr_ref l;
23598 if (!rtl || !MEM_P (rtl))
23600 rtl = XEXP (rtl, 0);
23601 if (GET_CODE (rtl) != SYMBOL_REF
23602 || SYMBOL_REF_DECL (rtl) == NULL_TREE)
23605 decl = SYMBOL_REF_DECL (rtl);
23606 if (!lookup_decl_die (decl))
23608 len = TREE_STRING_LENGTH (t);
23609 vec_safe_push (used_rtx_array, rtl);
23610 ref = new_die (DW_TAG_dwarf_procedure, comp_unit_die (), decl);
23611 array = ggc_vec_alloc<unsigned char> (len);
23612 memcpy (array, TREE_STRING_POINTER (t), len);
23613 l = new_loc_descr (DW_OP_implicit_value, len, 0);
23614 l->dw_loc_oprnd2.val_class = dw_val_class_vec;
23615 l->dw_loc_oprnd2.v.val_vec.length = len;
23616 l->dw_loc_oprnd2.v.val_vec.elt_size = 1;
23617 l->dw_loc_oprnd2.v.val_vec.array = array;
23618 add_AT_loc (ref, DW_AT_location, l);
23619 equate_decl_number_to_die (decl, ref);
23624 /* Helper function of resolve_addr_in_expr. LOC is
23625 a DW_OP_addr followed by DW_OP_stack_value, either at the start
23626 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
23627 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
23628 with DW_OP_GNU_implicit_pointer if possible
23629 and return true, if unsuccessful, return false. */
23632 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc)
23634 rtx rtl = loc->dw_loc_oprnd1.v.val_addr;
23635 HOST_WIDE_INT offset = 0;
23636 dw_die_ref ref = NULL;
23639 if (GET_CODE (rtl) == CONST
23640 && GET_CODE (XEXP (rtl, 0)) == PLUS
23641 && CONST_INT_P (XEXP (XEXP (rtl, 0), 1)))
23643 offset = INTVAL (XEXP (XEXP (rtl, 0), 1));
23644 rtl = XEXP (XEXP (rtl, 0), 0);
23646 if (GET_CODE (rtl) == CONST_STRING)
23648 size_t len = strlen (XSTR (rtl, 0)) + 1;
23649 tree t = build_string (len, XSTR (rtl, 0));
23650 tree tlen = size_int (len - 1);
23653 = build_array_type (char_type_node, build_index_type (tlen));
23654 rtl = string_cst_pool_decl (t);
23658 if (GET_CODE (rtl) == SYMBOL_REF && SYMBOL_REF_DECL (rtl))
23660 decl = SYMBOL_REF_DECL (rtl);
23661 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
23663 ref = lookup_decl_die (decl);
23664 if (ref && (get_AT (ref, DW_AT_location)
23665 || get_AT (ref, DW_AT_const_value)))
23667 loc->dw_loc_opc = DW_OP_GNU_implicit_pointer;
23668 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23669 loc->dw_loc_oprnd1.val_entry = NULL;
23670 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
23671 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
23672 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
23673 loc->dw_loc_oprnd2.v.val_int = offset;
23681 /* Helper function for resolve_addr, handle one location
23682 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23683 the location list couldn't be resolved. */
23686 resolve_addr_in_expr (dw_loc_descr_ref loc)
23688 dw_loc_descr_ref keep = NULL;
23689 for (dw_loc_descr_ref prev = NULL; loc; prev = loc, loc = loc->dw_loc_next)
23690 switch (loc->dw_loc_opc)
23693 if (!resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
23696 || prev->dw_loc_opc == DW_OP_piece
23697 || prev->dw_loc_opc == DW_OP_bit_piece)
23698 && loc->dw_loc_next
23699 && loc->dw_loc_next->dw_loc_opc == DW_OP_stack_value
23701 && optimize_one_addr_into_implicit_ptr (loc))
23706 case DW_OP_GNU_addr_index:
23707 case DW_OP_GNU_const_index:
23708 if (loc->dw_loc_opc == DW_OP_GNU_addr_index
23709 || (loc->dw_loc_opc == DW_OP_GNU_const_index && loc->dtprel))
23711 rtx rtl = loc->dw_loc_oprnd1.val_entry->addr.rtl;
23712 if (!resolve_one_addr (&rtl))
23714 remove_addr_table_entry (loc->dw_loc_oprnd1.val_entry);
23715 loc->dw_loc_oprnd1.val_entry =
23716 add_addr_table_entry (rtl, ate_kind_rtx);
23719 case DW_OP_const4u:
23720 case DW_OP_const8u:
23722 && !resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
23725 case DW_OP_plus_uconst:
23726 if (size_of_loc_descr (loc)
23727 > size_of_int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned)
23729 && loc->dw_loc_oprnd1.v.val_unsigned > 0)
23731 dw_loc_descr_ref repl
23732 = int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned);
23733 add_loc_descr (&repl, new_loc_descr (DW_OP_plus, 0, 0));
23734 add_loc_descr (&repl, loc->dw_loc_next);
23738 case DW_OP_implicit_value:
23739 if (loc->dw_loc_oprnd2.val_class == dw_val_class_addr
23740 && !resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr))
23743 case DW_OP_GNU_implicit_pointer:
23744 case DW_OP_GNU_parameter_ref:
23745 if (loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
23748 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
23751 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23752 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
23753 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
23756 case DW_OP_GNU_const_type:
23757 case DW_OP_GNU_regval_type:
23758 case DW_OP_GNU_deref_type:
23759 case DW_OP_GNU_convert:
23760 case DW_OP_GNU_reinterpret:
23761 while (loc->dw_loc_next
23762 && loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_convert)
23764 dw_die_ref base1, base2;
23765 unsigned enc1, enc2, size1, size2;
23766 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
23767 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
23768 base1 = loc->dw_loc_oprnd2.v.val_die_ref.die;
23769 else if (loc->dw_loc_oprnd1.val_class
23770 == dw_val_class_unsigned_const)
23773 base1 = loc->dw_loc_oprnd1.v.val_die_ref.die;
23774 if (loc->dw_loc_next->dw_loc_oprnd1.val_class
23775 == dw_val_class_unsigned_const)
23777 base2 = loc->dw_loc_next->dw_loc_oprnd1.v.val_die_ref.die;
23778 gcc_assert (base1->die_tag == DW_TAG_base_type
23779 && base2->die_tag == DW_TAG_base_type);
23780 enc1 = get_AT_unsigned (base1, DW_AT_encoding);
23781 enc2 = get_AT_unsigned (base2, DW_AT_encoding);
23782 size1 = get_AT_unsigned (base1, DW_AT_byte_size);
23783 size2 = get_AT_unsigned (base2, DW_AT_byte_size);
23785 && (((enc1 == DW_ATE_unsigned || enc1 == DW_ATE_signed)
23786 && (enc2 == DW_ATE_unsigned || enc2 == DW_ATE_signed)
23790 /* Optimize away next DW_OP_GNU_convert after
23791 adjusting LOC's base type die reference. */
23792 if (loc->dw_loc_opc == DW_OP_GNU_regval_type
23793 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
23794 loc->dw_loc_oprnd2.v.val_die_ref.die = base2;
23796 loc->dw_loc_oprnd1.v.val_die_ref.die = base2;
23797 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
23800 /* Don't change integer DW_OP_GNU_convert after e.g. floating
23801 point typed stack entry. */
23802 else if (enc1 != DW_ATE_unsigned && enc1 != DW_ATE_signed)
23803 keep = loc->dw_loc_next;
23813 /* Helper function of resolve_addr. DIE had DW_AT_location of
23814 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
23815 and DW_OP_addr couldn't be resolved. resolve_addr has already
23816 removed the DW_AT_location attribute. This function attempts to
23817 add a new DW_AT_location attribute with DW_OP_GNU_implicit_pointer
23818 to it or DW_AT_const_value attribute, if possible. */
23821 optimize_location_into_implicit_ptr (dw_die_ref die, tree decl)
23823 if (TREE_CODE (decl) != VAR_DECL
23824 || lookup_decl_die (decl) != die
23825 || DECL_EXTERNAL (decl)
23826 || !TREE_STATIC (decl)
23827 || DECL_INITIAL (decl) == NULL_TREE
23828 || DECL_P (DECL_INITIAL (decl))
23829 || get_AT (die, DW_AT_const_value))
23832 tree init = DECL_INITIAL (decl);
23833 HOST_WIDE_INT offset = 0;
23834 /* For variables that have been optimized away and thus
23835 don't have a memory location, see if we can emit
23836 DW_AT_const_value instead. */
23837 if (tree_add_const_value_attribute (die, init))
23841 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
23842 and ADDR_EXPR refers to a decl that has DW_AT_location or
23843 DW_AT_const_value (but isn't addressable, otherwise
23844 resolving the original DW_OP_addr wouldn't fail), see if
23845 we can add DW_OP_GNU_implicit_pointer. */
23847 if (TREE_CODE (init) == POINTER_PLUS_EXPR
23848 && tree_fits_shwi_p (TREE_OPERAND (init, 1)))
23850 offset = tree_to_shwi (TREE_OPERAND (init, 1));
23851 init = TREE_OPERAND (init, 0);
23854 if (TREE_CODE (init) != ADDR_EXPR)
23856 if ((TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST
23857 && !TREE_ASM_WRITTEN (TREE_OPERAND (init, 0)))
23858 || (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL
23859 && !DECL_EXTERNAL (TREE_OPERAND (init, 0))
23860 && TREE_OPERAND (init, 0) != decl))
23863 dw_loc_descr_ref l;
23865 if (TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST)
23867 rtx rtl = string_cst_pool_decl (TREE_OPERAND (init, 0));
23870 decl = SYMBOL_REF_DECL (rtl);
23873 decl = TREE_OPERAND (init, 0);
23874 ref = lookup_decl_die (decl);
23876 || (!get_AT (ref, DW_AT_location)
23877 && !get_AT (ref, DW_AT_const_value)))
23879 l = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
23880 l->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23881 l->dw_loc_oprnd1.v.val_die_ref.die = ref;
23882 l->dw_loc_oprnd1.v.val_die_ref.external = 0;
23883 add_AT_loc (die, DW_AT_location, l);
23887 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23888 an address in .rodata section if the string literal is emitted there,
23889 or remove the containing location list or replace DW_AT_const_value
23890 with DW_AT_location and empty location expression, if it isn't found
23891 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23892 to something that has been emitted in the current CU. */
23895 resolve_addr (dw_die_ref die)
23899 dw_loc_list_ref *curr, *start, loc;
23902 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
23903 switch (AT_class (a))
23905 case dw_val_class_loc_list:
23906 start = curr = AT_loc_list_ptr (a);
23909 /* The same list can be referenced more than once. See if we have
23910 already recorded the result from a previous pass. */
23912 *curr = loc->dw_loc_next;
23913 else if (!loc->resolved_addr)
23915 /* As things stand, we do not expect or allow one die to
23916 reference a suffix of another die's location list chain.
23917 References must be identical or completely separate.
23918 There is therefore no need to cache the result of this
23919 pass on any list other than the first; doing so
23920 would lead to unnecessary writes. */
23923 gcc_assert (!(*curr)->replaced && !(*curr)->resolved_addr);
23924 if (!resolve_addr_in_expr ((*curr)->expr))
23926 dw_loc_list_ref next = (*curr)->dw_loc_next;
23927 dw_loc_descr_ref l = (*curr)->expr;
23929 if (next && (*curr)->ll_symbol)
23931 gcc_assert (!next->ll_symbol);
23932 next->ll_symbol = (*curr)->ll_symbol;
23934 if (dwarf_split_debug_info)
23935 remove_loc_list_addr_table_entries (l);
23940 mark_base_types ((*curr)->expr);
23941 curr = &(*curr)->dw_loc_next;
23945 loc->resolved_addr = 1;
23949 loc->dw_loc_next = *start;
23954 remove_AT (die, a->dw_attr);
23958 case dw_val_class_loc:
23960 dw_loc_descr_ref l = AT_loc (a);
23961 /* For -gdwarf-2 don't attempt to optimize
23962 DW_AT_data_member_location containing
23963 DW_OP_plus_uconst - older consumers might
23964 rely on it being that op instead of a more complex,
23965 but shorter, location description. */
23966 if ((dwarf_version > 2
23967 || a->dw_attr != DW_AT_data_member_location
23969 || l->dw_loc_opc != DW_OP_plus_uconst
23970 || l->dw_loc_next != NULL)
23971 && !resolve_addr_in_expr (l))
23973 if (dwarf_split_debug_info)
23974 remove_loc_list_addr_table_entries (l);
23976 && l->dw_loc_next == NULL
23977 && l->dw_loc_opc == DW_OP_addr
23978 && GET_CODE (l->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF
23979 && SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr)
23980 && a->dw_attr == DW_AT_location)
23982 tree decl = SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr);
23983 remove_AT (die, a->dw_attr);
23985 optimize_location_into_implicit_ptr (die, decl);
23988 remove_AT (die, a->dw_attr);
23992 mark_base_types (l);
23995 case dw_val_class_addr:
23996 if (a->dw_attr == DW_AT_const_value
23997 && !resolve_one_addr (&a->dw_attr_val.v.val_addr))
23999 if (AT_index (a) != NOT_INDEXED)
24000 remove_addr_table_entry (a->dw_attr_val.val_entry);
24001 remove_AT (die, a->dw_attr);
24004 if (die->die_tag == DW_TAG_GNU_call_site
24005 && a->dw_attr == DW_AT_abstract_origin)
24007 tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr);
24008 dw_die_ref tdie = lookup_decl_die (tdecl);
24011 && DECL_EXTERNAL (tdecl)
24012 && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE
24013 && (cdie = lookup_context_die (DECL_CONTEXT (tdecl))))
24015 /* Creating a full DIE for tdecl is overly expensive and
24016 at this point even wrong when in the LTO phase
24017 as it can end up generating new type DIEs we didn't
24018 output and thus optimize_external_refs will crash. */
24019 tdie = new_die (DW_TAG_subprogram, cdie, NULL_TREE);
24020 add_AT_flag (tdie, DW_AT_external, 1);
24021 add_AT_flag (tdie, DW_AT_declaration, 1);
24022 add_linkage_attr (tdie, tdecl);
24023 add_name_and_src_coords_attributes (tdie, tdecl);
24024 equate_decl_number_to_die (tdecl, tdie);
24028 a->dw_attr_val.val_class = dw_val_class_die_ref;
24029 a->dw_attr_val.v.val_die_ref.die = tdie;
24030 a->dw_attr_val.v.val_die_ref.external = 0;
24034 if (AT_index (a) != NOT_INDEXED)
24035 remove_addr_table_entry (a->dw_attr_val.val_entry);
24036 remove_AT (die, a->dw_attr);
24045 FOR_EACH_CHILD (die, c, resolve_addr (c));
24048 /* Helper routines for optimize_location_lists.
24049 This pass tries to share identical local lists in .debug_loc
24052 /* Iteratively hash operands of LOC opcode into HSTATE. */
24055 hash_loc_operands (dw_loc_descr_ref loc, inchash::hash &hstate)
24057 dw_val_ref val1 = &loc->dw_loc_oprnd1;
24058 dw_val_ref val2 = &loc->dw_loc_oprnd2;
24060 switch (loc->dw_loc_opc)
24062 case DW_OP_const4u:
24063 case DW_OP_const8u:
24067 case DW_OP_const1u:
24068 case DW_OP_const1s:
24069 case DW_OP_const2u:
24070 case DW_OP_const2s:
24071 case DW_OP_const4s:
24072 case DW_OP_const8s:
24076 case DW_OP_plus_uconst:
24112 case DW_OP_deref_size:
24113 case DW_OP_xderef_size:
24114 hstate.add_object (val1->v.val_int);
24121 gcc_assert (val1->val_class == dw_val_class_loc);
24122 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
24123 hstate.add_object (offset);
24126 case DW_OP_implicit_value:
24127 hstate.add_object (val1->v.val_unsigned);
24128 switch (val2->val_class)
24130 case dw_val_class_const:
24131 hstate.add_object (val2->v.val_int);
24133 case dw_val_class_vec:
24135 unsigned int elt_size = val2->v.val_vec.elt_size;
24136 unsigned int len = val2->v.val_vec.length;
24138 hstate.add_int (elt_size);
24139 hstate.add_int (len);
24140 hstate.add (val2->v.val_vec.array, len * elt_size);
24143 case dw_val_class_const_double:
24144 hstate.add_object (val2->v.val_double.low);
24145 hstate.add_object (val2->v.val_double.high);
24147 case dw_val_class_wide_int:
24148 hstate.add (val2->v.val_wide->get_val (),
24149 get_full_len (*val2->v.val_wide)
24150 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
24152 case dw_val_class_addr:
24153 inchash::add_rtx (val2->v.val_addr, hstate);
24156 gcc_unreachable ();
24160 case DW_OP_bit_piece:
24161 hstate.add_object (val1->v.val_int);
24162 hstate.add_object (val2->v.val_int);
24168 unsigned char dtprel = 0xd1;
24169 hstate.add_object (dtprel);
24171 inchash::add_rtx (val1->v.val_addr, hstate);
24173 case DW_OP_GNU_addr_index:
24174 case DW_OP_GNU_const_index:
24178 unsigned char dtprel = 0xd1;
24179 hstate.add_object (dtprel);
24181 inchash::add_rtx (val1->val_entry->addr.rtl, hstate);
24184 case DW_OP_GNU_implicit_pointer:
24185 hstate.add_int (val2->v.val_int);
24187 case DW_OP_GNU_entry_value:
24188 hstate.add_object (val1->v.val_loc);
24190 case DW_OP_GNU_regval_type:
24191 case DW_OP_GNU_deref_type:
24193 unsigned int byte_size
24194 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_byte_size);
24195 unsigned int encoding
24196 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_encoding);
24197 hstate.add_object (val1->v.val_int);
24198 hstate.add_object (byte_size);
24199 hstate.add_object (encoding);
24202 case DW_OP_GNU_convert:
24203 case DW_OP_GNU_reinterpret:
24204 if (val1->val_class == dw_val_class_unsigned_const)
24206 hstate.add_object (val1->v.val_unsigned);
24210 case DW_OP_GNU_const_type:
24212 unsigned int byte_size
24213 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_byte_size);
24214 unsigned int encoding
24215 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_encoding);
24216 hstate.add_object (byte_size);
24217 hstate.add_object (encoding);
24218 if (loc->dw_loc_opc != DW_OP_GNU_const_type)
24220 hstate.add_object (val2->val_class);
24221 switch (val2->val_class)
24223 case dw_val_class_const:
24224 hstate.add_object (val2->v.val_int);
24226 case dw_val_class_vec:
24228 unsigned int elt_size = val2->v.val_vec.elt_size;
24229 unsigned int len = val2->v.val_vec.length;
24231 hstate.add_object (elt_size);
24232 hstate.add_object (len);
24233 hstate.add (val2->v.val_vec.array, len * elt_size);
24236 case dw_val_class_const_double:
24237 hstate.add_object (val2->v.val_double.low);
24238 hstate.add_object (val2->v.val_double.high);
24240 case dw_val_class_wide_int:
24241 hstate.add (val2->v.val_wide->get_val (),
24242 get_full_len (*val2->v.val_wide)
24243 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
24246 gcc_unreachable ();
24252 /* Other codes have no operands. */
24257 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
24260 hash_locs (dw_loc_descr_ref loc, inchash::hash &hstate)
24262 dw_loc_descr_ref l;
24263 bool sizes_computed = false;
24264 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
24265 size_of_locs (loc);
24267 for (l = loc; l != NULL; l = l->dw_loc_next)
24269 enum dwarf_location_atom opc = l->dw_loc_opc;
24270 hstate.add_object (opc);
24271 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed)
24273 size_of_locs (loc);
24274 sizes_computed = true;
24276 hash_loc_operands (l, hstate);
24280 /* Compute hash of the whole location list LIST_HEAD. */
24283 hash_loc_list (dw_loc_list_ref list_head)
24285 dw_loc_list_ref curr = list_head;
24286 inchash::hash hstate;
24288 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
24290 hstate.add (curr->begin, strlen (curr->begin) + 1);
24291 hstate.add (curr->end, strlen (curr->end) + 1);
24293 hstate.add (curr->section, strlen (curr->section) + 1);
24294 hash_locs (curr->expr, hstate);
24296 list_head->hash = hstate.end ();
24299 /* Return true if X and Y opcodes have the same operands. */
24302 compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y)
24304 dw_val_ref valx1 = &x->dw_loc_oprnd1;
24305 dw_val_ref valx2 = &x->dw_loc_oprnd2;
24306 dw_val_ref valy1 = &y->dw_loc_oprnd1;
24307 dw_val_ref valy2 = &y->dw_loc_oprnd2;
24309 switch (x->dw_loc_opc)
24311 case DW_OP_const4u:
24312 case DW_OP_const8u:
24316 case DW_OP_const1u:
24317 case DW_OP_const1s:
24318 case DW_OP_const2u:
24319 case DW_OP_const2s:
24320 case DW_OP_const4s:
24321 case DW_OP_const8s:
24325 case DW_OP_plus_uconst:
24361 case DW_OP_deref_size:
24362 case DW_OP_xderef_size:
24363 return valx1->v.val_int == valy1->v.val_int;
24366 /* If splitting debug info, the use of DW_OP_GNU_addr_index
24367 can cause irrelevant differences in dw_loc_addr. */
24368 gcc_assert (valx1->val_class == dw_val_class_loc
24369 && valy1->val_class == dw_val_class_loc
24370 && (dwarf_split_debug_info
24371 || x->dw_loc_addr == y->dw_loc_addr));
24372 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr;
24373 case DW_OP_implicit_value:
24374 if (valx1->v.val_unsigned != valy1->v.val_unsigned
24375 || valx2->val_class != valy2->val_class)
24377 switch (valx2->val_class)
24379 case dw_val_class_const:
24380 return valx2->v.val_int == valy2->v.val_int;
24381 case dw_val_class_vec:
24382 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24383 && valx2->v.val_vec.length == valy2->v.val_vec.length
24384 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24385 valx2->v.val_vec.elt_size
24386 * valx2->v.val_vec.length) == 0;
24387 case dw_val_class_const_double:
24388 return valx2->v.val_double.low == valy2->v.val_double.low
24389 && valx2->v.val_double.high == valy2->v.val_double.high;
24390 case dw_val_class_wide_int:
24391 return *valx2->v.val_wide == *valy2->v.val_wide;
24392 case dw_val_class_addr:
24393 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr);
24395 gcc_unreachable ();
24398 case DW_OP_bit_piece:
24399 return valx1->v.val_int == valy1->v.val_int
24400 && valx2->v.val_int == valy2->v.val_int;
24403 return rtx_equal_p (valx1->v.val_addr, valy1->v.val_addr);
24404 case DW_OP_GNU_addr_index:
24405 case DW_OP_GNU_const_index:
24407 rtx ax1 = valx1->val_entry->addr.rtl;
24408 rtx ay1 = valy1->val_entry->addr.rtl;
24409 return rtx_equal_p (ax1, ay1);
24411 case DW_OP_GNU_implicit_pointer:
24412 return valx1->val_class == dw_val_class_die_ref
24413 && valx1->val_class == valy1->val_class
24414 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die
24415 && valx2->v.val_int == valy2->v.val_int;
24416 case DW_OP_GNU_entry_value:
24417 return compare_loc_operands (valx1->v.val_loc, valy1->v.val_loc);
24418 case DW_OP_GNU_const_type:
24419 if (valx1->v.val_die_ref.die != valy1->v.val_die_ref.die
24420 || valx2->val_class != valy2->val_class)
24422 switch (valx2->val_class)
24424 case dw_val_class_const:
24425 return valx2->v.val_int == valy2->v.val_int;
24426 case dw_val_class_vec:
24427 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24428 && valx2->v.val_vec.length == valy2->v.val_vec.length
24429 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24430 valx2->v.val_vec.elt_size
24431 * valx2->v.val_vec.length) == 0;
24432 case dw_val_class_const_double:
24433 return valx2->v.val_double.low == valy2->v.val_double.low
24434 && valx2->v.val_double.high == valy2->v.val_double.high;
24435 case dw_val_class_wide_int:
24436 return *valx2->v.val_wide == *valy2->v.val_wide;
24438 gcc_unreachable ();
24440 case DW_OP_GNU_regval_type:
24441 case DW_OP_GNU_deref_type:
24442 return valx1->v.val_int == valy1->v.val_int
24443 && valx2->v.val_die_ref.die == valy2->v.val_die_ref.die;
24444 case DW_OP_GNU_convert:
24445 case DW_OP_GNU_reinterpret:
24446 if (valx1->val_class != valy1->val_class)
24448 if (valx1->val_class == dw_val_class_unsigned_const)
24449 return valx1->v.val_unsigned == valy1->v.val_unsigned;
24450 return valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
24451 case DW_OP_GNU_parameter_ref:
24452 return valx1->val_class == dw_val_class_die_ref
24453 && valx1->val_class == valy1->val_class
24454 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
24456 /* Other codes have no operands. */
24461 /* Return true if DWARF location expressions X and Y are the same. */
24464 compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y)
24466 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next)
24467 if (x->dw_loc_opc != y->dw_loc_opc
24468 || x->dtprel != y->dtprel
24469 || !compare_loc_operands (x, y))
24471 return x == NULL && y == NULL;
24474 /* Hashtable helpers. */
24476 struct loc_list_hasher : typed_noop_remove <dw_loc_list_struct>
24478 typedef dw_loc_list_struct value_type;
24479 typedef dw_loc_list_struct compare_type;
24480 static inline hashval_t hash (const value_type *);
24481 static inline bool equal (const value_type *, const compare_type *);
24484 /* Return precomputed hash of location list X. */
24487 loc_list_hasher::hash (const value_type *x)
24492 /* Return true if location lists A and B are the same. */
24495 loc_list_hasher::equal (const value_type *a, const compare_type *b)
24499 if (a->hash != b->hash)
24501 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next)
24502 if (strcmp (a->begin, b->begin) != 0
24503 || strcmp (a->end, b->end) != 0
24504 || (a->section == NULL) != (b->section == NULL)
24505 || (a->section && strcmp (a->section, b->section) != 0)
24506 || !compare_locs (a->expr, b->expr))
24508 return a == NULL && b == NULL;
24511 typedef hash_table<loc_list_hasher> loc_list_hash_type;
24514 /* Recursively optimize location lists referenced from DIE
24515 children and share them whenever possible. */
24518 optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type *htab)
24523 dw_loc_list_struct **slot;
24525 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
24526 if (AT_class (a) == dw_val_class_loc_list)
24528 dw_loc_list_ref list = AT_loc_list (a);
24529 /* TODO: perform some optimizations here, before hashing
24530 it and storing into the hash table. */
24531 hash_loc_list (list);
24532 slot = htab->find_slot_with_hash (list, list->hash, INSERT);
24536 a->dw_attr_val.v.val_loc_list = *slot;
24539 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab));
24543 /* Recursively assign each location list a unique index into the debug_addr
24547 index_location_lists (dw_die_ref die)
24553 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
24554 if (AT_class (a) == dw_val_class_loc_list)
24556 dw_loc_list_ref list = AT_loc_list (a);
24557 dw_loc_list_ref curr;
24558 for (curr = list; curr != NULL; curr = curr->dw_loc_next)
24560 /* Don't index an entry that has already been indexed
24561 or won't be output. */
24562 if (curr->begin_entry != NULL
24563 || (strcmp (curr->begin, curr->end) == 0 && !curr->force))
24567 = add_addr_table_entry (xstrdup (curr->begin),
24572 FOR_EACH_CHILD (die, c, index_location_lists (c));
24575 /* Optimize location lists referenced from DIE
24576 children and share them whenever possible. */
24579 optimize_location_lists (dw_die_ref die)
24581 loc_list_hash_type htab (500);
24582 optimize_location_lists_1 (die, &htab);
24585 /* Output stuff that dwarf requires at the end of every file,
24586 and generate the DWARF-2 debugging info. */
24589 dwarf2out_finish (const char *filename)
24591 limbo_die_node *node, *next_node;
24592 comdat_type_node *ctnode;
24594 dw_die_ref main_comp_unit_die;
24596 /* PCH might result in DW_AT_producer string being restored from the
24597 header compilation, so always fill it with empty string initially
24598 and overwrite only here. */
24599 dw_attr_ref producer = get_AT (comp_unit_die (), DW_AT_producer);
24600 producer_string = gen_producer_string ();
24601 producer->dw_attr_val.v.val_str->refcount--;
24602 producer->dw_attr_val.v.val_str = find_AT_string (producer_string);
24604 gen_scheduled_generic_parms_dies ();
24605 gen_remaining_tmpl_value_param_die_attribute ();
24607 /* Add the name for the main input file now. We delayed this from
24608 dwarf2out_init to avoid complications with PCH.
24609 For LTO produced units use a fixed artificial name to avoid
24610 leaking tempfile names into the dwarf. */
24612 add_name_attribute (comp_unit_die (), remap_debug_filename (filename));
24614 add_name_attribute (comp_unit_die (), "<artificial>");
24615 if (!IS_ABSOLUTE_PATH (filename) || targetm.force_at_comp_dir)
24616 add_comp_dir_attribute (comp_unit_die ());
24617 else if (get_AT (comp_unit_die (), DW_AT_comp_dir) == NULL)
24620 file_table->traverse<bool *, file_table_relative_p> (&p);
24622 add_comp_dir_attribute (comp_unit_die ());
24625 if (deferred_locations_list)
24626 for (i = 0; i < deferred_locations_list->length (); i++)
24628 add_location_or_const_value_attribute (
24629 (*deferred_locations_list)[i].die,
24630 (*deferred_locations_list)[i].variable,
24635 /* Traverse the limbo die list, and add parent/child links. The only
24636 dies without parents that should be here are concrete instances of
24637 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24638 For concrete instances, we can get the parent die from the abstract
24640 for (node = limbo_die_list; node; node = next_node)
24642 dw_die_ref die = node->die;
24643 next_node = node->next;
24645 if (die->die_parent == NULL)
24647 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
24649 if (origin && origin->die_parent)
24650 add_child_die (origin->die_parent, die);
24651 else if (is_cu_die (die))
24653 else if (seen_error ())
24654 /* It's OK to be confused by errors in the input. */
24655 add_child_die (comp_unit_die (), die);
24658 /* In certain situations, the lexical block containing a
24659 nested function can be optimized away, which results
24660 in the nested function die being orphaned. Likewise
24661 with the return type of that nested function. Force
24662 this to be a child of the containing function.
24664 It may happen that even the containing function got fully
24665 inlined and optimized out. In that case we are lost and
24666 assign the empty child. This should not be big issue as
24667 the function is likely unreachable too. */
24668 gcc_assert (node->created_for);
24670 if (DECL_P (node->created_for))
24671 origin = get_context_die (DECL_CONTEXT (node->created_for));
24672 else if (TYPE_P (node->created_for))
24673 origin = scope_die_for (node->created_for, comp_unit_die ());
24675 origin = comp_unit_die ();
24677 add_child_die (origin, die);
24682 limbo_die_list = NULL;
24684 #if ENABLE_ASSERT_CHECKING
24686 dw_die_ref die = comp_unit_die (), c;
24687 FOR_EACH_CHILD (die, c, gcc_assert (! c->die_mark));
24690 resolve_addr (comp_unit_die ());
24691 move_marked_base_types ();
24693 for (node = deferred_asm_name; node; node = node->next)
24695 tree decl = node->created_for;
24696 /* When generating LTO bytecode we can not generate new assembler
24697 names at this point and all important decls got theirs via
24699 if (((!flag_generate_lto && !flag_generate_offload)
24700 || DECL_ASSEMBLER_NAME_SET_P (decl))
24701 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
24703 add_linkage_attr (node->die, decl);
24704 move_linkage_attr (node->die);
24708 deferred_asm_name = NULL;
24710 /* Walk through the list of incomplete types again, trying once more to
24711 emit full debugging info for them. */
24712 retry_incomplete_types ();
24714 if (flag_eliminate_unused_debug_types)
24715 prune_unused_types ();
24717 /* Generate separate COMDAT sections for type DIEs. */
24718 if (use_debug_types)
24720 break_out_comdat_types (comp_unit_die ());
24722 /* Each new type_unit DIE was added to the limbo die list when created.
24723 Since these have all been added to comdat_type_list, clear the
24725 limbo_die_list = NULL;
24727 /* For each new comdat type unit, copy declarations for incomplete
24728 types to make the new unit self-contained (i.e., no direct
24729 references to the main compile unit). */
24730 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24731 copy_decls_for_unworthy_types (ctnode->root_die);
24732 copy_decls_for_unworthy_types (comp_unit_die ());
24734 /* In the process of copying declarations from one unit to another,
24735 we may have left some declarations behind that are no longer
24736 referenced. Prune them. */
24737 prune_unused_types ();
24740 /* Generate separate CUs for each of the include files we've seen.
24741 They will go into limbo_die_list. */
24742 if (flag_eliminate_dwarf2_dups)
24743 break_out_includes (comp_unit_die ());
24745 /* Traverse the DIE's and add add sibling attributes to those DIE's
24746 that have children. */
24747 add_sibling_attributes (comp_unit_die ());
24748 for (node = limbo_die_list; node; node = node->next)
24749 add_sibling_attributes (node->die);
24750 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24751 add_sibling_attributes (ctnode->root_die);
24753 /* When splitting DWARF info, we put some attributes in the
24754 skeleton compile_unit DIE that remains in the .o, while
24755 most attributes go in the DWO compile_unit_die. */
24756 if (dwarf_split_debug_info)
24757 main_comp_unit_die = gen_compile_unit_die (NULL);
24759 main_comp_unit_die = comp_unit_die ();
24761 /* Output a terminator label for the .text section. */
24762 switch_to_section (text_section);
24763 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
24764 if (cold_text_section)
24766 switch_to_section (cold_text_section);
24767 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
24770 /* We can only use the low/high_pc attributes if all of the code was
24772 if (!have_multiple_function_sections
24773 || (dwarf_version < 3 && dwarf_strict))
24775 /* Don't add if the CU has no associated code. */
24776 if (text_section_used)
24777 add_AT_low_high_pc (main_comp_unit_die, text_section_label,
24778 text_end_label, true);
24784 bool range_list_added = false;
24786 if (text_section_used)
24787 add_ranges_by_labels (main_comp_unit_die, text_section_label,
24788 text_end_label, &range_list_added, true);
24789 if (cold_text_section_used)
24790 add_ranges_by_labels (main_comp_unit_die, cold_text_section_label,
24791 cold_end_label, &range_list_added, true);
24793 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
24795 if (DECL_IGNORED_P (fde->decl))
24797 if (!fde->in_std_section)
24798 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_begin,
24799 fde->dw_fde_end, &range_list_added,
24801 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
24802 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_second_begin,
24803 fde->dw_fde_second_end, &range_list_added,
24807 if (range_list_added)
24809 /* We need to give .debug_loc and .debug_ranges an appropriate
24810 "base address". Use zero so that these addresses become
24811 absolute. Historically, we've emitted the unexpected
24812 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24813 Emit both to give time for other tools to adapt. */
24814 add_AT_addr (main_comp_unit_die, DW_AT_low_pc, const0_rtx, true);
24815 if (! dwarf_strict && dwarf_version < 4)
24816 add_AT_addr (main_comp_unit_die, DW_AT_entry_pc, const0_rtx, true);
24822 if (debug_info_level >= DINFO_LEVEL_TERSE)
24823 add_AT_lineptr (main_comp_unit_die, DW_AT_stmt_list,
24824 debug_line_section_label);
24827 add_AT_macptr (comp_unit_die (),
24828 dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros,
24829 macinfo_section_label);
24831 if (dwarf_split_debug_info)
24833 /* optimize_location_lists calculates the size of the lists,
24834 so index them first, and assign indices to the entries.
24835 Although optimize_location_lists will remove entries from
24836 the table, it only does so for duplicates, and therefore
24837 only reduces ref_counts to 1. */
24838 index_location_lists (comp_unit_die ());
24840 if (addr_index_table != NULL)
24842 unsigned int index = 0;
24844 ->traverse_noresize<unsigned int *, index_addr_table_entry>
24849 if (have_location_lists)
24850 optimize_location_lists (comp_unit_die ());
24852 save_macinfo_strings ();
24854 if (dwarf_split_debug_info)
24856 unsigned int index = 0;
24858 /* Add attributes common to skeleton compile_units and
24859 type_units. Because these attributes include strings, it
24860 must be done before freezing the string table. Top-level
24861 skeleton die attrs are added when the skeleton type unit is
24862 created, so ensure it is created by this point. */
24863 add_top_level_skeleton_die_attrs (main_comp_unit_die);
24864 debug_str_hash->traverse_noresize<unsigned int *, index_string> (&index);
24867 /* Output all of the compilation units. We put the main one last so that
24868 the offsets are available to output_pubnames. */
24869 for (node = limbo_die_list; node; node = node->next)
24870 output_comp_unit (node->die, 0);
24872 hash_table<comdat_type_hasher> comdat_type_table (100);
24873 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24875 comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT);
24877 /* Don't output duplicate types. */
24878 if (*slot != HTAB_EMPTY_ENTRY)
24881 /* Add a pointer to the line table for the main compilation unit
24882 so that the debugger can make sense of DW_AT_decl_file
24884 if (debug_info_level >= DINFO_LEVEL_TERSE)
24885 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
24886 (!dwarf_split_debug_info
24887 ? debug_line_section_label
24888 : debug_skeleton_line_section_label));
24890 output_comdat_type_unit (ctnode);
24894 /* The AT_pubnames attribute needs to go in all skeleton dies, including
24895 both the main_cu and all skeleton TUs. Making this call unconditional
24896 would end up either adding a second copy of the AT_pubnames attribute, or
24897 requiring a special case in add_top_level_skeleton_die_attrs. */
24898 if (!dwarf_split_debug_info)
24899 add_AT_pubnames (comp_unit_die ());
24901 if (dwarf_split_debug_info)
24904 unsigned char checksum[16];
24905 struct md5_ctx ctx;
24907 /* Compute a checksum of the comp_unit to use as the dwo_id. */
24908 md5_init_ctx (&ctx);
24910 die_checksum (comp_unit_die (), &ctx, &mark);
24911 unmark_all_dies (comp_unit_die ());
24912 md5_finish_ctx (&ctx, checksum);
24914 /* Use the first 8 bytes of the checksum as the dwo_id,
24915 and add it to both comp-unit DIEs. */
24916 add_AT_data8 (main_comp_unit_die, DW_AT_GNU_dwo_id, checksum);
24917 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id, checksum);
24919 /* Add the base offset of the ranges table to the skeleton
24921 if (ranges_table_in_use)
24922 add_AT_lineptr (main_comp_unit_die, DW_AT_GNU_ranges_base,
24923 ranges_section_label);
24925 switch_to_section (debug_addr_section);
24926 ASM_OUTPUT_LABEL (asm_out_file, debug_addr_section_label);
24927 output_addr_table ();
24930 /* Output the main compilation unit if non-empty or if .debug_macinfo
24931 or .debug_macro will be emitted. */
24932 output_comp_unit (comp_unit_die (), have_macinfo);
24934 if (dwarf_split_debug_info && info_section_emitted)
24935 output_skeleton_debug_sections (main_comp_unit_die);
24937 /* Output the abbreviation table. */
24938 if (abbrev_die_table_in_use != 1)
24940 switch_to_section (debug_abbrev_section);
24941 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
24942 output_abbrev_section ();
24945 /* Output location list section if necessary. */
24946 if (have_location_lists)
24948 /* Output the location lists info. */
24949 switch_to_section (debug_loc_section);
24950 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
24951 output_location_lists (comp_unit_die ());
24954 output_pubtables ();
24956 /* Output the address range information if a CU (.debug_info section)
24957 was emitted. We output an empty table even if we had no functions
24958 to put in it. This because the consumer has no way to tell the
24959 difference between an empty table that we omitted and failure to
24960 generate a table that would have contained data. */
24961 if (info_section_emitted)
24963 unsigned long aranges_length = size_of_aranges ();
24965 switch_to_section (debug_aranges_section);
24966 output_aranges (aranges_length);
24969 /* Output ranges section if necessary. */
24970 if (ranges_table_in_use)
24972 switch_to_section (debug_ranges_section);
24973 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
24977 /* Have to end the macro section. */
24980 switch_to_section (debug_macinfo_section);
24981 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
24983 dw2_asm_output_data (1, 0, "End compilation unit");
24986 /* Output the source line correspondence table. We must do this
24987 even if there is no line information. Otherwise, on an empty
24988 translation unit, we will generate a present, but empty,
24989 .debug_info section. IRIX 6.5 `nm' will then complain when
24990 examining the file. This is done late so that any filenames
24991 used by the debug_info section are marked as 'used'. */
24992 switch_to_section (debug_line_section);
24993 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
24994 if (! DWARF2_ASM_LINE_DEBUG_INFO)
24995 output_line_info (false);
24997 if (dwarf_split_debug_info && info_section_emitted)
24999 switch_to_section (debug_skeleton_line_section);
25000 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_line_section_label);
25001 output_line_info (true);
25004 /* If we emitted any indirect strings, output the string table too. */
25005 if (debug_str_hash || skeleton_debug_str_hash)
25006 output_indirect_strings ();
25009 /* Reset all state within dwarf2out.c so that we can rerun the compiler
25010 within the same process. For use by toplev::finalize. */
25013 dwarf2out_c_finalize (void)
25015 last_var_location_insn = NULL;
25016 cached_next_real_insn = NULL;
25017 used_rtx_array = NULL;
25018 incomplete_types = NULL;
25019 decl_scope_table = NULL;
25020 debug_info_section = NULL;
25021 debug_skeleton_info_section = NULL;
25022 debug_abbrev_section = NULL;
25023 debug_skeleton_abbrev_section = NULL;
25024 debug_aranges_section = NULL;
25025 debug_addr_section = NULL;
25026 debug_macinfo_section = NULL;
25027 debug_line_section = NULL;
25028 debug_skeleton_line_section = NULL;
25029 debug_loc_section = NULL;
25030 debug_pubnames_section = NULL;
25031 debug_pubtypes_section = NULL;
25032 debug_str_section = NULL;
25033 debug_str_dwo_section = NULL;
25034 debug_str_offsets_section = NULL;
25035 debug_ranges_section = NULL;
25036 debug_frame_section = NULL;
25038 debug_str_hash = NULL;
25039 skeleton_debug_str_hash = NULL;
25040 dw2_string_counter = 0;
25041 have_multiple_function_sections = false;
25042 text_section_used = false;
25043 cold_text_section_used = false;
25044 cold_text_section = NULL;
25045 current_unit_personality = NULL;
25047 deferred_locations_list = NULL;
25049 next_die_offset = 0;
25050 single_comp_unit_die = NULL;
25051 comdat_type_list = NULL;
25052 limbo_die_list = NULL;
25053 deferred_asm_name = NULL;
25055 decl_die_table = NULL;
25056 common_block_die_table = NULL;
25057 decl_loc_table = NULL;
25058 call_arg_locations = NULL;
25059 call_arg_loc_last = NULL;
25060 call_site_count = -1;
25061 tail_call_site_count = -1;
25062 //block_map = NULL;
25063 cached_dw_loc_list_table = NULL;
25064 abbrev_die_table = NULL;
25065 abbrev_die_table_allocated = 0;
25066 abbrev_die_table_in_use = 0;
25067 line_info_label_num = 0;
25068 cur_line_info_table = NULL;
25069 text_section_line_info = NULL;
25070 cold_text_section_line_info = NULL;
25071 separate_line_info = NULL;
25072 info_section_emitted = false;
25073 pubname_table = NULL;
25074 pubtype_table = NULL;
25075 macinfo_table = NULL;
25076 ranges_table = NULL;
25077 ranges_table_allocated = 0;
25078 ranges_table_in_use = 0;
25079 ranges_by_label = 0;
25080 ranges_by_label_allocated = 0;
25081 ranges_by_label_in_use = 0;
25082 have_location_lists = false;
25085 last_emitted_file = NULL;
25087 file_table_last_lookup = NULL;
25088 tmpl_value_parm_die_table = NULL;
25089 generic_type_instances = NULL;
25090 frame_pointer_fb_offset = 0;
25091 frame_pointer_fb_offset_valid = false;
25092 base_types.release ();
25093 XDELETEVEC (producer_string);
25094 producer_string = NULL;
25097 #include "gt-dwarf2out.h"