1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5 Contributed by Gary Funck (gary@intrepid.com).
6 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
7 Extensively modified by Jason Merrill (jason@cygnus.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
25 /* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
31 /* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
37 /* DWARF2 Abbreviation Glossary:
39 CFA = Canonical Frame Address
40 a fixed address on the stack which identifies a call frame.
41 We define it to be the value of SP just before the call insn.
42 The CFA register and offset, which may change during the course
43 of the function, are used to calculate its value at runtime.
45 CFI = Call Frame Instruction
46 an instruction for the DWARF2 abstract machine
48 CIE = Common Information Entry
49 information describing information common to one or more FDEs
51 DIE = Debugging Information Entry
53 FDE = Frame Description Entry
54 information describing the stack call frame, in particular,
55 how to restore registers
57 DW_CFA_... = DWARF2 CFA call frame instruction
58 DW_TAG_... = DWARF2 DIE tag */
62 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
84 #include "diagnostic.h"
85 #include "tree-pretty-print.h"
88 #include "langhooks.h"
93 #include "tree-pass.h"
94 #include "tree-flow.h"
95 #include "cfglayout.h"
97 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
98 static rtx last_var_location_insn;
100 #ifdef VMS_DEBUGGING_INFO
101 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
103 /* Define this macro to be a nonzero value if the directory specifications
104 which are output in the debug info should end with a separator. */
105 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
106 /* Define this macro to evaluate to a nonzero value if GCC should refrain
107 from generating indirect strings in DWARF2 debug information, for instance
108 if your target is stuck with an old version of GDB that is unable to
109 process them properly or uses VMS Debug. */
110 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
112 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
113 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
116 /* ??? Poison these here until it can be done generically. They've been
117 totally replaced in this file; make sure it stays that way. */
118 #undef DWARF2_UNWIND_INFO
119 #undef DWARF2_FRAME_INFO
120 #if (GCC_VERSION >= 3000)
121 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
124 #ifndef INCOMING_RETURN_ADDR_RTX
125 #define INCOMING_RETURN_ADDR_RTX (gcc_unreachable (), NULL_RTX)
128 /* Map register numbers held in the call frame info that gcc has
129 collected using DWARF_FRAME_REGNUM to those that should be output in
130 .debug_frame and .eh_frame. */
131 #ifndef DWARF2_FRAME_REG_OUT
132 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
135 /* Save the result of dwarf2out_do_frame across PCH. */
136 static GTY(()) bool saved_do_cfi_asm = 0;
138 /* Decide whether we want to emit frame unwind information for the current
142 dwarf2out_do_frame (void)
144 /* We want to emit correct CFA location expressions or lists, so we
145 have to return true if we're going to output debug info, even if
146 we're not going to output frame or unwind info. */
147 if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
150 if (saved_do_cfi_asm)
153 if (targetm.debug_unwind_info () == UI_DWARF2)
156 if ((flag_unwind_tables || flag_exceptions)
157 && targetm.except_unwind_info (&global_options) == UI_DWARF2)
163 /* Decide whether to emit frame unwind via assembler directives. */
166 dwarf2out_do_cfi_asm (void)
170 #ifdef MIPS_DEBUGGING_INFO
173 if (saved_do_cfi_asm)
175 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
177 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
180 /* Make sure the personality encoding is one the assembler can support.
181 In particular, aligned addresses can't be handled. */
182 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
183 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
185 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
186 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
189 /* If we can't get the assembler to emit only .debug_frame, and we don't need
190 dwarf2 unwind info for exceptions, then emit .debug_frame by hand. */
191 if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE
192 && !flag_unwind_tables && !flag_exceptions
193 && targetm.except_unwind_info (&global_options) != UI_DWARF2)
196 saved_do_cfi_asm = true;
200 /* The size of the target's pointer type. */
202 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
205 /* Array of RTXes referenced by the debugging information, which therefore
206 must be kept around forever. */
207 static GTY(()) VEC(rtx,gc) *used_rtx_array;
209 /* A pointer to the base of a list of incomplete types which might be
210 completed at some later time. incomplete_types_list needs to be a
211 VEC(tree,gc) because we want to tell the garbage collector about
213 static GTY(()) VEC(tree,gc) *incomplete_types;
215 /* A pointer to the base of a table of references to declaration
216 scopes. This table is a display which tracks the nesting
217 of declaration scopes at the current scope and containing
218 scopes. This table is used to find the proper place to
219 define type declaration DIE's. */
220 static GTY(()) VEC(tree,gc) *decl_scope_table;
222 /* Pointers to various DWARF2 sections. */
223 static GTY(()) section *debug_info_section;
224 static GTY(()) section *debug_abbrev_section;
225 static GTY(()) section *debug_aranges_section;
226 static GTY(()) section *debug_macinfo_section;
227 static GTY(()) section *debug_line_section;
228 static GTY(()) section *debug_loc_section;
229 static GTY(()) section *debug_pubnames_section;
230 static GTY(()) section *debug_pubtypes_section;
231 static GTY(()) section *debug_str_section;
232 static GTY(()) section *debug_ranges_section;
233 static GTY(()) section *debug_frame_section;
235 /* Personality decl of current unit. Used only when assembler does not support
237 static GTY(()) rtx current_unit_personality;
239 /* How to start an assembler comment. */
240 #ifndef ASM_COMMENT_START
241 #define ASM_COMMENT_START ";#"
244 typedef struct dw_cfi_struct *dw_cfi_ref;
245 typedef struct dw_fde_struct *dw_fde_ref;
246 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
248 /* Call frames are described using a sequence of Call Frame
249 Information instructions. The register number, offset
250 and address fields are provided as possible operands;
251 their use is selected by the opcode field. */
253 enum dw_cfi_oprnd_type {
255 dw_cfi_oprnd_reg_num,
261 typedef union GTY(()) dw_cfi_oprnd_struct {
262 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
263 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
264 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
265 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
269 typedef struct GTY(()) dw_cfi_struct {
270 enum dwarf_call_frame_info dw_cfi_opc;
271 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
273 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
278 DEF_VEC_P (dw_cfi_ref);
279 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
280 DEF_VEC_ALLOC_P (dw_cfi_ref, gc);
282 typedef VEC(dw_cfi_ref, gc) *cfi_vec;
284 /* This is how we define the location of the CFA. We use to handle it
285 as REG + OFFSET all the time, but now it can be more complex.
286 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
287 Instead of passing around REG and OFFSET, we pass a copy
288 of this structure. */
289 typedef struct cfa_loc {
290 HOST_WIDE_INT offset;
291 HOST_WIDE_INT base_offset;
293 BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
294 BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
297 /* All call frame descriptions (FDE's) in the GCC generated DWARF
298 refer to a single Common Information Entry (CIE), defined at
299 the beginning of the .debug_frame section. This use of a single
300 CIE obviates the need to keep track of multiple CIE's
301 in the DWARF generation routines below. */
303 typedef struct GTY(()) dw_fde_struct {
305 const char *dw_fde_begin;
306 const char *dw_fde_current_label;
307 const char *dw_fde_end;
308 const char *dw_fde_vms_end_prologue;
309 const char *dw_fde_vms_begin_epilogue;
310 const char *dw_fde_second_begin;
311 const char *dw_fde_second_end;
313 int dw_fde_switch_cfi_index; /* Last CFI before switching sections. */
314 HOST_WIDE_INT stack_realignment;
315 unsigned funcdef_number;
316 /* Dynamic realign argument pointer register. */
317 unsigned int drap_reg;
318 /* Virtual dynamic realign argument pointer register. */
319 unsigned int vdrap_reg;
320 /* These 3 flags are copied from rtl_data in function.h. */
321 unsigned all_throwers_are_sibcalls : 1;
322 unsigned uses_eh_lsda : 1;
323 unsigned nothrow : 1;
324 /* Whether we did stack realign in this call frame. */
325 unsigned stack_realign : 1;
326 /* Whether dynamic realign argument pointer register has been saved. */
327 unsigned drap_reg_saved: 1;
328 /* True iff dw_fde_begin label is in text_section or cold_text_section. */
329 unsigned in_std_section : 1;
330 /* True iff dw_fde_second_begin label is in text_section or
331 cold_text_section. */
332 unsigned second_in_std_section : 1;
336 /* Maximum size (in bytes) of an artificially generated label. */
337 #define MAX_ARTIFICIAL_LABEL_BYTES 30
339 /* The size of addresses as they appear in the Dwarf 2 data.
340 Some architectures use word addresses to refer to code locations,
341 but Dwarf 2 info always uses byte addresses. On such machines,
342 Dwarf 2 addresses need to be larger than the architecture's
344 #ifndef DWARF2_ADDR_SIZE
345 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
348 /* The size in bytes of a DWARF field indicating an offset or length
349 relative to a debug info section, specified to be 4 bytes in the
350 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
353 #ifndef DWARF_OFFSET_SIZE
354 #define DWARF_OFFSET_SIZE 4
357 /* The size in bytes of a DWARF 4 type signature. */
359 #ifndef DWARF_TYPE_SIGNATURE_SIZE
360 #define DWARF_TYPE_SIGNATURE_SIZE 8
363 /* According to the (draft) DWARF 3 specification, the initial length
364 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
365 bytes are 0xffffffff, followed by the length stored in the next 8
368 However, the SGI/MIPS ABI uses an initial length which is equal to
369 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
371 #ifndef DWARF_INITIAL_LENGTH_SIZE
372 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
375 /* Round SIZE up to the nearest BOUNDARY. */
376 #define DWARF_ROUND(SIZE,BOUNDARY) \
377 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
379 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
380 #ifndef DWARF_CIE_DATA_ALIGNMENT
381 #ifdef STACK_GROWS_DOWNWARD
382 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
384 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
388 /* CIE identifier. */
389 #if HOST_BITS_PER_WIDE_INT >= 64
390 #define DWARF_CIE_ID \
391 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
393 #define DWARF_CIE_ID DW_CIE_ID
396 /* A pointer to the base of a table that contains frame description
397 information for each routine. */
398 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
400 /* Number of elements currently allocated for fde_table. */
401 static GTY(()) unsigned fde_table_allocated;
403 /* Number of elements in fde_table currently in use. */
404 static GTY(()) unsigned fde_table_in_use;
406 /* Size (in elements) of increments by which we may expand the
408 #define FDE_TABLE_INCREMENT 256
410 /* Get the current fde_table entry we should use. */
412 static inline dw_fde_ref
415 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
418 /* A vector of call frame insns for the CIE. */
419 static GTY(()) cfi_vec cie_cfi_vec;
421 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
422 attribute that accelerates the lookup of the FDE associated
423 with the subprogram. This variable holds the table index of the FDE
424 associated with the current function (body) definition. */
425 static unsigned current_funcdef_fde;
427 struct GTY(()) indirect_string_node {
429 unsigned int refcount;
430 enum dwarf_form form;
434 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
436 static GTY(()) int dw2_string_counter;
437 static GTY(()) unsigned long dwarf2out_cfi_label_num;
439 /* True if the compilation unit places functions in more than one section. */
440 static GTY(()) bool have_multiple_function_sections = false;
442 /* Whether the default text and cold text sections have been used at all. */
444 static GTY(()) bool text_section_used = false;
445 static GTY(()) bool cold_text_section_used = false;
447 /* The default cold text section. */
448 static GTY(()) section *cold_text_section;
450 /* Forward declarations for functions defined in this file. */
452 static char *stripattributes (const char *);
453 static const char *dwarf_cfi_name (unsigned);
454 static dw_cfi_ref new_cfi (void);
455 static void add_cfi (cfi_vec *, dw_cfi_ref);
456 static void add_fde_cfi (const char *, dw_cfi_ref);
457 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
458 static void lookup_cfa (dw_cfa_location *);
459 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
460 static void initial_return_save (rtx);
461 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
463 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
464 static void output_cfi_directive (dw_cfi_ref);
465 static void output_call_frame_info (int);
466 static void dwarf2out_note_section_used (void);
467 static bool clobbers_queued_reg_save (const_rtx);
468 static void dwarf2out_frame_debug_expr (rtx, const char *);
470 /* Support for complex CFA locations. */
471 static void output_cfa_loc (dw_cfi_ref, int);
472 static void output_cfa_loc_raw (dw_cfi_ref);
473 static void get_cfa_from_loc_descr (dw_cfa_location *,
474 struct dw_loc_descr_struct *);
475 static struct dw_loc_descr_struct *build_cfa_loc
476 (dw_cfa_location *, HOST_WIDE_INT);
477 static struct dw_loc_descr_struct *build_cfa_aligned_loc
478 (HOST_WIDE_INT, HOST_WIDE_INT);
479 static void def_cfa_1 (const char *, dw_cfa_location *);
480 static struct dw_loc_descr_struct *mem_loc_descriptor
481 (rtx, enum machine_mode mode, enum machine_mode mem_mode,
482 enum var_init_status);
484 /* How to start an assembler comment. */
485 #ifndef ASM_COMMENT_START
486 #define ASM_COMMENT_START ";#"
489 /* Data and reference forms for relocatable data. */
490 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
491 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
493 #ifndef DEBUG_FRAME_SECTION
494 #define DEBUG_FRAME_SECTION ".debug_frame"
497 #ifndef FUNC_BEGIN_LABEL
498 #define FUNC_BEGIN_LABEL "LFB"
501 #ifndef FUNC_END_LABEL
502 #define FUNC_END_LABEL "LFE"
505 #ifndef PROLOGUE_END_LABEL
506 #define PROLOGUE_END_LABEL "LPE"
509 #ifndef EPILOGUE_BEGIN_LABEL
510 #define EPILOGUE_BEGIN_LABEL "LEB"
513 #ifndef FRAME_BEGIN_LABEL
514 #define FRAME_BEGIN_LABEL "Lframe"
516 #define CIE_AFTER_SIZE_LABEL "LSCIE"
517 #define CIE_END_LABEL "LECIE"
518 #define FDE_LABEL "LSFDE"
519 #define FDE_AFTER_SIZE_LABEL "LASFDE"
520 #define FDE_END_LABEL "LEFDE"
521 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
522 #define LINE_NUMBER_END_LABEL "LELT"
523 #define LN_PROLOG_AS_LABEL "LASLTP"
524 #define LN_PROLOG_END_LABEL "LELTP"
525 #define DIE_LABEL_PREFIX "DW"
527 /* The DWARF 2 CFA column which tracks the return address. Normally this
528 is the column for PC, or the first column after all of the hard
530 #ifndef DWARF_FRAME_RETURN_COLUMN
532 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
534 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
538 /* The mapping from gcc register number to DWARF 2 CFA column number. By
539 default, we just provide columns for all registers. */
540 #ifndef DWARF_FRAME_REGNUM
541 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
544 /* Match the base name of a file to the base name of a compilation unit. */
547 matches_main_base (const char *path)
549 /* Cache the last query. */
550 static const char *last_path = NULL;
551 static int last_match = 0;
552 if (path != last_path)
555 int length = base_of_path (path, &base);
557 last_match = (length == main_input_baselength
558 && memcmp (base, main_input_basename, length) == 0);
563 #ifdef DEBUG_DEBUG_STRUCT
566 dump_struct_debug (tree type, enum debug_info_usage usage,
567 enum debug_struct_file criterion, int generic,
568 int matches, int result)
570 /* Find the type name. */
571 tree type_decl = TYPE_STUB_DECL (type);
573 const char *name = 0;
574 if (TREE_CODE (t) == TYPE_DECL)
577 name = IDENTIFIER_POINTER (t);
579 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
581 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
582 matches ? "bas" : "hdr",
583 generic ? "gen" : "ord",
584 usage == DINFO_USAGE_DFN ? ";" :
585 usage == DINFO_USAGE_DIR_USE ? "." : "*",
587 (void*) type_decl, name);
590 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
591 dump_struct_debug (type, usage, criterion, generic, matches, result)
595 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
601 should_emit_struct_debug (tree type, enum debug_info_usage usage)
603 enum debug_struct_file criterion;
605 bool generic = lang_hooks.types.generic_p (type);
608 criterion = debug_struct_generic[usage];
610 criterion = debug_struct_ordinary[usage];
612 if (criterion == DINFO_STRUCT_FILE_NONE)
613 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
614 if (criterion == DINFO_STRUCT_FILE_ANY)
615 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
617 type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
619 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
620 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
622 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
623 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
624 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
627 /* Hook used by __throw. */
630 expand_builtin_dwarf_sp_column (void)
632 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
633 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
636 /* Return a pointer to a copy of the section string name S with all
637 attributes stripped off, and an asterisk prepended (for assemble_name). */
640 stripattributes (const char *s)
642 char *stripped = XNEWVEC (char, strlen (s) + 2);
647 while (*s && *s != ',')
654 /* MEM is a memory reference for the register size table, each element of
655 which has mode MODE. Initialize column C as a return address column. */
658 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
660 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
661 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
662 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
665 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
667 static inline HOST_WIDE_INT
668 div_data_align (HOST_WIDE_INT off)
670 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
671 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
675 /* Return true if we need a signed version of a given opcode
676 (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended). */
679 need_data_align_sf_opcode (HOST_WIDE_INT off)
681 return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
684 /* Generate code to initialize the register size table. */
687 expand_builtin_init_dwarf_reg_sizes (tree address)
690 enum machine_mode mode = TYPE_MODE (char_type_node);
691 rtx addr = expand_normal (address);
692 rtx mem = gen_rtx_MEM (BLKmode, addr);
693 bool wrote_return_column = false;
695 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
697 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
699 if (rnum < DWARF_FRAME_REGISTERS)
701 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
702 enum machine_mode save_mode = reg_raw_mode[i];
705 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
706 save_mode = choose_hard_reg_mode (i, 1, true);
707 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
709 if (save_mode == VOIDmode)
711 wrote_return_column = true;
713 size = GET_MODE_SIZE (save_mode);
717 emit_move_insn (adjust_address (mem, mode, offset),
718 gen_int_mode (size, mode));
722 if (!wrote_return_column)
723 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
725 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
726 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
729 targetm.init_dwarf_reg_sizes_extra (address);
732 /* Convert a DWARF call frame info. operation to its string name */
735 dwarf_cfi_name (unsigned int cfi_opc)
739 case DW_CFA_advance_loc:
740 return "DW_CFA_advance_loc";
742 return "DW_CFA_offset";
744 return "DW_CFA_restore";
748 return "DW_CFA_set_loc";
749 case DW_CFA_advance_loc1:
750 return "DW_CFA_advance_loc1";
751 case DW_CFA_advance_loc2:
752 return "DW_CFA_advance_loc2";
753 case DW_CFA_advance_loc4:
754 return "DW_CFA_advance_loc4";
755 case DW_CFA_offset_extended:
756 return "DW_CFA_offset_extended";
757 case DW_CFA_restore_extended:
758 return "DW_CFA_restore_extended";
759 case DW_CFA_undefined:
760 return "DW_CFA_undefined";
761 case DW_CFA_same_value:
762 return "DW_CFA_same_value";
763 case DW_CFA_register:
764 return "DW_CFA_register";
765 case DW_CFA_remember_state:
766 return "DW_CFA_remember_state";
767 case DW_CFA_restore_state:
768 return "DW_CFA_restore_state";
770 return "DW_CFA_def_cfa";
771 case DW_CFA_def_cfa_register:
772 return "DW_CFA_def_cfa_register";
773 case DW_CFA_def_cfa_offset:
774 return "DW_CFA_def_cfa_offset";
777 case DW_CFA_def_cfa_expression:
778 return "DW_CFA_def_cfa_expression";
779 case DW_CFA_expression:
780 return "DW_CFA_expression";
781 case DW_CFA_offset_extended_sf:
782 return "DW_CFA_offset_extended_sf";
783 case DW_CFA_def_cfa_sf:
784 return "DW_CFA_def_cfa_sf";
785 case DW_CFA_def_cfa_offset_sf:
786 return "DW_CFA_def_cfa_offset_sf";
788 /* SGI/MIPS specific */
789 case DW_CFA_MIPS_advance_loc8:
790 return "DW_CFA_MIPS_advance_loc8";
793 case DW_CFA_GNU_window_save:
794 return "DW_CFA_GNU_window_save";
795 case DW_CFA_GNU_args_size:
796 return "DW_CFA_GNU_args_size";
797 case DW_CFA_GNU_negative_offset_extended:
798 return "DW_CFA_GNU_negative_offset_extended";
801 return "DW_CFA_<unknown>";
805 /* Return a pointer to a newly allocated Call Frame Instruction. */
807 static inline dw_cfi_ref
810 dw_cfi_ref cfi = ggc_alloc_dw_cfi_node ();
812 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
813 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
818 /* Add a Call Frame Instruction to list of instructions. */
821 add_cfi (cfi_vec *vec, dw_cfi_ref cfi)
823 dw_fde_ref fde = current_fde ();
825 /* When DRAP is used, CFA is defined with an expression. Redefine
826 CFA may lead to a different CFA value. */
827 /* ??? Of course, this heuristic fails when we're annotating epilogues,
828 because of course we'll always want to redefine the CFA back to the
829 stack pointer on the way out. Where should we move this check? */
830 if (0 && fde && fde->drap_reg != INVALID_REGNUM)
831 switch (cfi->dw_cfi_opc)
833 case DW_CFA_def_cfa_register:
834 case DW_CFA_def_cfa_offset:
835 case DW_CFA_def_cfa_offset_sf:
837 case DW_CFA_def_cfa_sf:
844 VEC_safe_push (dw_cfi_ref, gc, *vec, cfi);
847 /* Generate a new label for the CFI info to refer to. FORCE is true
848 if a label needs to be output even when using .cfi_* directives. */
851 dwarf2out_cfi_label (bool force)
853 static char label[20];
855 if (!force && dwarf2out_do_cfi_asm ())
857 /* In this case, we will be emitting the asm directive instead of
858 the label, so just return a placeholder to keep the rest of the
860 strcpy (label, "<do not output>");
864 int num = dwarf2out_cfi_label_num++;
865 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", num);
866 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LCFI", num);
872 /* True if remember_state should be emitted before following CFI directive. */
873 static bool emit_cfa_remember;
875 /* True if any CFI directives were emitted at the current insn. */
876 static bool any_cfis_emitted;
878 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
879 or to the CIE if LABEL is NULL. */
882 add_fde_cfi (const char *label, dw_cfi_ref cfi)
886 if (cie_cfi_vec == NULL)
887 cie_cfi_vec = VEC_alloc (dw_cfi_ref, gc, 20);
891 if (emit_cfa_remember)
893 dw_cfi_ref cfi_remember;
895 /* Emit the state save. */
896 emit_cfa_remember = false;
897 cfi_remember = new_cfi ();
898 cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
899 add_fde_cfi (label, cfi_remember);
902 if (dwarf2out_do_cfi_asm ())
906 dw_fde_ref fde = current_fde ();
908 gcc_assert (fde != NULL);
910 /* We still have to add the cfi to the list so that lookup_cfa
911 works later on. When -g2 and above we even need to force
912 emitting of CFI labels and add to list a DW_CFA_set_loc for
913 convert_cfa_to_fb_loc_list purposes. If we're generating
914 DWARF3 output we use DW_OP_call_frame_cfa and so don't use
915 convert_cfa_to_fb_loc_list. */
916 if (dwarf_version == 2
917 && debug_info_level > DINFO_LEVEL_TERSE
918 && (write_symbols == DWARF2_DEBUG
919 || write_symbols == VMS_AND_DWARF2_DEBUG))
921 switch (cfi->dw_cfi_opc)
923 case DW_CFA_def_cfa_offset:
924 case DW_CFA_def_cfa_offset_sf:
925 case DW_CFA_def_cfa_register:
927 case DW_CFA_def_cfa_sf:
928 case DW_CFA_def_cfa_expression:
929 case DW_CFA_restore_state:
930 if (*label == 0 || strcmp (label, "<do not output>") == 0)
931 label = dwarf2out_cfi_label (true);
933 if (fde->dw_fde_current_label == NULL
934 || strcmp (label, fde->dw_fde_current_label) != 0)
938 label = xstrdup (label);
940 /* Set the location counter to the new label. */
942 /* It doesn't metter whether DW_CFA_set_loc
943 or DW_CFA_advance_loc4 is added here, those aren't
944 emitted into assembly, only looked up by
945 convert_cfa_to_fb_loc_list. */
946 xcfi->dw_cfi_opc = DW_CFA_set_loc;
947 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
948 add_cfi (&fde->dw_fde_cfi, xcfi);
949 fde->dw_fde_current_label = label;
957 output_cfi_directive (cfi);
959 vec = &fde->dw_fde_cfi;
960 any_cfis_emitted = true;
962 /* ??? If this is a CFI for the CIE, we don't emit. This
963 assumes that the standard CIE contents that the assembler
964 uses matches the standard CIE contents that the compiler
965 uses. This is probably a bad assumption. I'm not quite
966 sure how to address this for now. */
970 dw_fde_ref fde = current_fde ();
972 gcc_assert (fde != NULL);
975 label = dwarf2out_cfi_label (false);
977 if (fde->dw_fde_current_label == NULL
978 || strcmp (label, fde->dw_fde_current_label) != 0)
982 label = xstrdup (label);
984 /* Set the location counter to the new label. */
986 /* If we have a current label, advance from there, otherwise
987 set the location directly using set_loc. */
988 xcfi->dw_cfi_opc = fde->dw_fde_current_label
989 ? DW_CFA_advance_loc4
991 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
992 add_cfi (&fde->dw_fde_cfi, xcfi);
994 fde->dw_fde_current_label = label;
997 vec = &fde->dw_fde_cfi;
998 any_cfis_emitted = true;
1004 /* Subroutine of lookup_cfa. */
1007 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
1009 switch (cfi->dw_cfi_opc)
1011 case DW_CFA_def_cfa_offset:
1012 case DW_CFA_def_cfa_offset_sf:
1013 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
1015 case DW_CFA_def_cfa_register:
1016 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
1018 case DW_CFA_def_cfa:
1019 case DW_CFA_def_cfa_sf:
1020 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
1021 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
1023 case DW_CFA_def_cfa_expression:
1024 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
1027 case DW_CFA_remember_state:
1028 gcc_assert (!remember->in_use);
1030 remember->in_use = 1;
1032 case DW_CFA_restore_state:
1033 gcc_assert (remember->in_use);
1035 remember->in_use = 0;
1043 /* Find the previous value for the CFA. */
1046 lookup_cfa (dw_cfa_location *loc)
1051 dw_cfa_location remember;
1053 memset (loc, 0, sizeof (*loc));
1054 loc->reg = INVALID_REGNUM;
1057 FOR_EACH_VEC_ELT (dw_cfi_ref, cie_cfi_vec, ix, cfi)
1058 lookup_cfa_1 (cfi, loc, &remember);
1060 fde = current_fde ();
1062 FOR_EACH_VEC_ELT (dw_cfi_ref, fde->dw_fde_cfi, ix, cfi)
1063 lookup_cfa_1 (cfi, loc, &remember);
1066 /* The current rule for calculating the DWARF2 canonical frame address. */
1067 static dw_cfa_location cfa;
1069 /* The register used for saving registers to the stack, and its offset
1071 static dw_cfa_location cfa_store;
1073 /* The current save location around an epilogue. */
1074 static dw_cfa_location cfa_remember;
1076 /* The running total of the size of arguments pushed onto the stack. */
1077 static HOST_WIDE_INT args_size;
1079 /* The last args_size we actually output. */
1080 static HOST_WIDE_INT old_args_size;
1082 /* Entry point to update the canonical frame address (CFA).
1083 LABEL is passed to add_fde_cfi. The value of CFA is now to be
1084 calculated from REG+OFFSET. */
1087 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1089 dw_cfa_location loc;
1091 loc.base_offset = 0;
1093 loc.offset = offset;
1094 def_cfa_1 (label, &loc);
1097 /* Determine if two dw_cfa_location structures define the same data. */
1100 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
1102 return (loc1->reg == loc2->reg
1103 && loc1->offset == loc2->offset
1104 && loc1->indirect == loc2->indirect
1105 && (loc1->indirect == 0
1106 || loc1->base_offset == loc2->base_offset));
1109 /* This routine does the actual work. The CFA is now calculated from
1110 the dw_cfa_location structure. */
1113 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1116 dw_cfa_location old_cfa, loc;
1121 if (cfa_store.reg == loc.reg && loc.indirect == 0)
1122 cfa_store.offset = loc.offset;
1124 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1125 lookup_cfa (&old_cfa);
1127 /* If nothing changed, no need to issue any call frame instructions. */
1128 if (cfa_equal_p (&loc, &old_cfa))
1133 if (loc.reg == old_cfa.reg && !loc.indirect && !old_cfa.indirect)
1135 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1136 the CFA register did not change but the offset did. The data
1137 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1138 in the assembler via the .cfi_def_cfa_offset directive. */
1140 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1142 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1143 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1146 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
1147 else if (loc.offset == old_cfa.offset
1148 && old_cfa.reg != INVALID_REGNUM
1150 && !old_cfa.indirect)
1152 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1153 indicating the CFA register has changed to <register> but the
1154 offset has not changed. */
1155 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1156 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1160 else if (loc.indirect == 0)
1162 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1163 indicating the CFA register has changed to <register> with
1164 the specified offset. The data factoring for DW_CFA_def_cfa_sf
1165 happens in output_cfi, or in the assembler via the .cfi_def_cfa
1168 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1170 cfi->dw_cfi_opc = DW_CFA_def_cfa;
1171 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1172 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1176 /* Construct a DW_CFA_def_cfa_expression instruction to
1177 calculate the CFA using a full location expression since no
1178 register-offset pair is available. */
1179 struct dw_loc_descr_struct *loc_list;
1181 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1182 loc_list = build_cfa_loc (&loc, 0);
1183 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1186 add_fde_cfi (label, cfi);
1189 /* Add the CFI for saving a register. REG is the CFA column number.
1190 LABEL is passed to add_fde_cfi.
1191 If SREG is -1, the register is saved at OFFSET from the CFA;
1192 otherwise it is saved in SREG. */
1195 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1197 dw_cfi_ref cfi = new_cfi ();
1198 dw_fde_ref fde = current_fde ();
1200 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1202 /* When stack is aligned, store REG using DW_CFA_expression with
1205 && fde->stack_realign
1206 && sreg == INVALID_REGNUM)
1208 cfi->dw_cfi_opc = DW_CFA_expression;
1209 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1210 cfi->dw_cfi_oprnd2.dw_cfi_loc
1211 = build_cfa_aligned_loc (offset, fde->stack_realignment);
1213 else if (sreg == INVALID_REGNUM)
1215 if (need_data_align_sf_opcode (offset))
1216 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1217 else if (reg & ~0x3f)
1218 cfi->dw_cfi_opc = DW_CFA_offset_extended;
1220 cfi->dw_cfi_opc = DW_CFA_offset;
1221 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1223 else if (sreg == reg)
1224 cfi->dw_cfi_opc = DW_CFA_same_value;
1227 cfi->dw_cfi_opc = DW_CFA_register;
1228 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1231 add_fde_cfi (label, cfi);
1234 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1235 This CFI tells the unwinder that it needs to restore the window registers
1236 from the previous frame's window save area.
1238 ??? Perhaps we should note in the CIE where windows are saved (instead of
1239 assuming 0(cfa)) and what registers are in the window. */
1242 dwarf2out_window_save (const char *label)
1244 dw_cfi_ref cfi = new_cfi ();
1246 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1247 add_fde_cfi (label, cfi);
1250 /* Entry point for saving a register to the stack. REG is the GCC register
1251 number. LABEL and OFFSET are passed to reg_save. */
1254 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1256 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1259 /* Entry point for saving the return address in the stack.
1260 LABEL and OFFSET are passed to reg_save. */
1263 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1265 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1268 /* Entry point for saving the return address in a register.
1269 LABEL and SREG are passed to reg_save. */
1272 dwarf2out_return_reg (const char *label, unsigned int sreg)
1274 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1277 /* Record the initial position of the return address. RTL is
1278 INCOMING_RETURN_ADDR_RTX. */
1281 initial_return_save (rtx rtl)
1283 unsigned int reg = INVALID_REGNUM;
1284 HOST_WIDE_INT offset = 0;
1286 switch (GET_CODE (rtl))
1289 /* RA is in a register. */
1290 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1294 /* RA is on the stack. */
1295 rtl = XEXP (rtl, 0);
1296 switch (GET_CODE (rtl))
1299 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1304 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1305 offset = INTVAL (XEXP (rtl, 1));
1309 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1310 offset = -INTVAL (XEXP (rtl, 1));
1320 /* The return address is at some offset from any value we can
1321 actually load. For instance, on the SPARC it is in %i7+8. Just
1322 ignore the offset for now; it doesn't matter for unwinding frames. */
1323 gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1324 initial_return_save (XEXP (rtl, 0));
1331 if (reg != DWARF_FRAME_RETURN_COLUMN)
1332 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1335 /* Given a SET, calculate the amount of stack adjustment it
1338 static HOST_WIDE_INT
1339 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1340 HOST_WIDE_INT cur_offset)
1342 const_rtx src = SET_SRC (pattern);
1343 const_rtx dest = SET_DEST (pattern);
1344 HOST_WIDE_INT offset = 0;
1347 if (dest == stack_pointer_rtx)
1349 code = GET_CODE (src);
1351 /* Assume (set (reg sp) (reg whatever)) sets args_size
1353 if (code == REG && src != stack_pointer_rtx)
1355 offset = -cur_args_size;
1356 #ifndef STACK_GROWS_DOWNWARD
1359 return offset - cur_offset;
1362 if (! (code == PLUS || code == MINUS)
1363 || XEXP (src, 0) != stack_pointer_rtx
1364 || !CONST_INT_P (XEXP (src, 1)))
1367 /* (set (reg sp) (plus (reg sp) (const_int))) */
1368 offset = INTVAL (XEXP (src, 1));
1374 if (MEM_P (src) && !MEM_P (dest))
1378 /* (set (mem (pre_dec (reg sp))) (foo)) */
1379 src = XEXP (dest, 0);
1380 code = GET_CODE (src);
1386 if (XEXP (src, 0) == stack_pointer_rtx)
1388 rtx val = XEXP (XEXP (src, 1), 1);
1389 /* We handle only adjustments by constant amount. */
1390 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1391 && CONST_INT_P (val));
1392 offset = -INTVAL (val);
1399 if (XEXP (src, 0) == stack_pointer_rtx)
1401 offset = GET_MODE_SIZE (GET_MODE (dest));
1408 if (XEXP (src, 0) == stack_pointer_rtx)
1410 offset = -GET_MODE_SIZE (GET_MODE (dest));
1425 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1426 indexed by INSN_UID. */
1428 static HOST_WIDE_INT *barrier_args_size;
1430 /* Helper function for compute_barrier_args_size. Handle one insn. */
1432 static HOST_WIDE_INT
1433 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1434 VEC (rtx, heap) **next)
1436 HOST_WIDE_INT offset = 0;
1439 if (! RTX_FRAME_RELATED_P (insn))
1441 if (prologue_epilogue_contains (insn))
1443 else if (GET_CODE (PATTERN (insn)) == SET)
1444 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1445 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1446 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1448 /* There may be stack adjustments inside compound insns. Search
1450 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1451 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1452 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1453 cur_args_size, offset);
1458 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1462 expr = XEXP (expr, 0);
1463 if (GET_CODE (expr) == PARALLEL
1464 || GET_CODE (expr) == SEQUENCE)
1465 for (i = 1; i < XVECLEN (expr, 0); i++)
1467 rtx elem = XVECEXP (expr, 0, i);
1469 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1470 offset += stack_adjust_offset (elem, cur_args_size, offset);
1475 #ifndef STACK_GROWS_DOWNWARD
1479 cur_args_size += offset;
1480 if (cur_args_size < 0)
1485 rtx dest = JUMP_LABEL (insn);
1489 if (barrier_args_size [INSN_UID (dest)] < 0)
1491 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1492 VEC_safe_push (rtx, heap, *next, dest);
1497 return cur_args_size;
1500 /* Walk the whole function and compute args_size on BARRIERs. */
1503 compute_barrier_args_size (void)
1505 int max_uid = get_max_uid (), i;
1507 VEC (rtx, heap) *worklist, *next, *tmp;
1509 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1510 for (i = 0; i < max_uid; i++)
1511 barrier_args_size[i] = -1;
1513 worklist = VEC_alloc (rtx, heap, 20);
1514 next = VEC_alloc (rtx, heap, 20);
1515 insn = get_insns ();
1516 barrier_args_size[INSN_UID (insn)] = 0;
1517 VEC_quick_push (rtx, worklist, insn);
1520 while (!VEC_empty (rtx, worklist))
1522 rtx prev, body, first_insn;
1523 HOST_WIDE_INT cur_args_size;
1525 first_insn = insn = VEC_pop (rtx, worklist);
1526 cur_args_size = barrier_args_size[INSN_UID (insn)];
1527 prev = prev_nonnote_insn (insn);
1528 if (prev && BARRIER_P (prev))
1529 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1531 for (; insn; insn = NEXT_INSN (insn))
1533 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1535 if (BARRIER_P (insn))
1540 if (insn == first_insn)
1542 else if (barrier_args_size[INSN_UID (insn)] < 0)
1544 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1549 /* The insns starting with this label have been
1550 already scanned or are in the worklist. */
1555 body = PATTERN (insn);
1556 if (GET_CODE (body) == SEQUENCE)
1558 HOST_WIDE_INT dest_args_size = cur_args_size;
1559 for (i = 1; i < XVECLEN (body, 0); i++)
1560 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1561 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1563 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1564 dest_args_size, &next);
1567 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1568 cur_args_size, &next);
1570 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1571 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1572 dest_args_size, &next);
1575 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1576 cur_args_size, &next);
1580 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1584 if (VEC_empty (rtx, next))
1587 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1591 VEC_truncate (rtx, next, 0);
1594 VEC_free (rtx, heap, worklist);
1595 VEC_free (rtx, heap, next);
1598 /* Add a CFI to update the running total of the size of arguments
1599 pushed onto the stack. */
1602 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1606 if (size == old_args_size)
1609 old_args_size = size;
1612 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1613 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1614 add_fde_cfi (label, cfi);
1617 /* Record a stack adjustment of OFFSET bytes. */
1620 dwarf2out_stack_adjust (HOST_WIDE_INT offset, const char *label)
1622 if (cfa.reg == STACK_POINTER_REGNUM)
1623 cfa.offset += offset;
1625 if (cfa_store.reg == STACK_POINTER_REGNUM)
1626 cfa_store.offset += offset;
1628 if (ACCUMULATE_OUTGOING_ARGS)
1631 #ifndef STACK_GROWS_DOWNWARD
1635 args_size += offset;
1639 def_cfa_1 (label, &cfa);
1640 if (flag_asynchronous_unwind_tables)
1641 dwarf2out_args_size (label, args_size);
1644 /* Check INSN to see if it looks like a push or a stack adjustment, and
1645 make a note of it if it does. EH uses this information to find out
1646 how much extra space it needs to pop off the stack. */
1649 dwarf2out_notice_stack_adjust (rtx insn, bool after_p)
1651 HOST_WIDE_INT offset;
1655 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1656 with this function. Proper support would require all frame-related
1657 insns to be marked, and to be able to handle saving state around
1658 epilogues textually in the middle of the function. */
1659 if (prologue_epilogue_contains (insn))
1662 /* If INSN is an instruction from target of an annulled branch, the
1663 effects are for the target only and so current argument size
1664 shouldn't change at all. */
1666 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1667 && INSN_FROM_TARGET_P (insn))
1670 /* If only calls can throw, and we have a frame pointer,
1671 save up adjustments until we see the CALL_INSN. */
1672 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1674 if (CALL_P (insn) && !after_p)
1676 /* Extract the size of the args from the CALL rtx itself. */
1677 insn = PATTERN (insn);
1678 if (GET_CODE (insn) == PARALLEL)
1679 insn = XVECEXP (insn, 0, 0);
1680 if (GET_CODE (insn) == SET)
1681 insn = SET_SRC (insn);
1682 gcc_assert (GET_CODE (insn) == CALL);
1683 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1688 if (CALL_P (insn) && !after_p)
1690 if (!flag_asynchronous_unwind_tables)
1691 dwarf2out_args_size ("", args_size);
1694 else if (BARRIER_P (insn))
1696 /* Don't call compute_barrier_args_size () if the only
1697 BARRIER is at the end of function. */
1698 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1699 compute_barrier_args_size ();
1700 if (barrier_args_size == NULL)
1704 offset = barrier_args_size[INSN_UID (insn)];
1709 offset -= args_size;
1710 #ifndef STACK_GROWS_DOWNWARD
1714 else if (GET_CODE (PATTERN (insn)) == SET)
1715 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1716 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1717 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1719 /* There may be stack adjustments inside compound insns. Search
1721 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1722 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1723 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1732 label = dwarf2out_cfi_label (false);
1733 dwarf2out_stack_adjust (offset, label);
1736 /* We delay emitting a register save until either (a) we reach the end
1737 of the prologue or (b) the register is clobbered. This clusters
1738 register saves so that there are fewer pc advances. */
1740 struct GTY(()) queued_reg_save {
1741 struct queued_reg_save *next;
1743 HOST_WIDE_INT cfa_offset;
1747 static GTY(()) struct queued_reg_save *queued_reg_saves;
1749 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1750 struct GTY(()) reg_saved_in_data {
1755 /* A list of registers saved in other registers.
1756 The list intentionally has a small maximum capacity of 4; if your
1757 port needs more than that, you might consider implementing a
1758 more efficient data structure. */
1759 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1760 static GTY(()) size_t num_regs_saved_in_regs;
1762 static const char *last_reg_save_label;
1764 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1765 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1768 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1770 struct queued_reg_save *q;
1772 /* Duplicates waste space, but it's also necessary to remove them
1773 for correctness, since the queue gets output in reverse
1775 for (q = queued_reg_saves; q != NULL; q = q->next)
1776 if (REGNO (q->reg) == REGNO (reg))
1781 q = ggc_alloc_queued_reg_save ();
1782 q->next = queued_reg_saves;
1783 queued_reg_saves = q;
1787 q->cfa_offset = offset;
1788 q->saved_reg = sreg;
1790 last_reg_save_label = label;
1793 /* Output all the entries in QUEUED_REG_SAVES. */
1796 dwarf2out_flush_queued_reg_saves (void)
1798 struct queued_reg_save *q;
1800 for (q = queued_reg_saves; q; q = q->next)
1803 unsigned int reg, sreg;
1805 for (i = 0; i < num_regs_saved_in_regs; i++)
1806 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1808 if (q->saved_reg && i == num_regs_saved_in_regs)
1810 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1811 num_regs_saved_in_regs++;
1813 if (i != num_regs_saved_in_regs)
1815 regs_saved_in_regs[i].orig_reg = q->reg;
1816 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1819 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1821 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1823 sreg = INVALID_REGNUM;
1824 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1827 queued_reg_saves = NULL;
1828 last_reg_save_label = NULL;
1831 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1832 location for? Or, does it clobber a register which we've previously
1833 said that some other register is saved in, and for which we now
1834 have a new location for? */
1837 clobbers_queued_reg_save (const_rtx insn)
1839 struct queued_reg_save *q;
1841 for (q = queued_reg_saves; q; q = q->next)
1844 if (modified_in_p (q->reg, insn))
1846 for (i = 0; i < num_regs_saved_in_regs; i++)
1847 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1848 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1855 /* Entry point for saving the first register into the second. */
1858 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1861 unsigned int regno, sregno;
1863 for (i = 0; i < num_regs_saved_in_regs; i++)
1864 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1866 if (i == num_regs_saved_in_regs)
1868 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1869 num_regs_saved_in_regs++;
1871 regs_saved_in_regs[i].orig_reg = reg;
1872 regs_saved_in_regs[i].saved_in_reg = sreg;
1874 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1875 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1876 reg_save (label, regno, sregno, 0);
1879 /* What register, if any, is currently saved in REG? */
1882 reg_saved_in (rtx reg)
1884 unsigned int regn = REGNO (reg);
1886 struct queued_reg_save *q;
1888 for (q = queued_reg_saves; q; q = q->next)
1889 if (q->saved_reg && regn == REGNO (q->saved_reg))
1892 for (i = 0; i < num_regs_saved_in_regs; i++)
1893 if (regs_saved_in_regs[i].saved_in_reg
1894 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1895 return regs_saved_in_regs[i].orig_reg;
1901 /* A temporary register holding an integral value used in adjusting SP
1902 or setting up the store_reg. The "offset" field holds the integer
1903 value, not an offset. */
1904 static dw_cfa_location cfa_temp;
1906 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1909 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1911 memset (&cfa, 0, sizeof (cfa));
1913 switch (GET_CODE (pat))
1916 cfa.reg = REGNO (XEXP (pat, 0));
1917 cfa.offset = INTVAL (XEXP (pat, 1));
1921 cfa.reg = REGNO (pat);
1926 pat = XEXP (pat, 0);
1927 if (GET_CODE (pat) == PLUS)
1929 cfa.base_offset = INTVAL (XEXP (pat, 1));
1930 pat = XEXP (pat, 0);
1932 cfa.reg = REGNO (pat);
1936 /* Recurse and define an expression. */
1940 def_cfa_1 (label, &cfa);
1943 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1946 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1950 gcc_assert (GET_CODE (pat) == SET);
1951 dest = XEXP (pat, 0);
1952 src = XEXP (pat, 1);
1954 switch (GET_CODE (src))
1957 gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1958 cfa.offset -= INTVAL (XEXP (src, 1));
1968 cfa.reg = REGNO (dest);
1969 gcc_assert (cfa.indirect == 0);
1971 def_cfa_1 (label, &cfa);
1974 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1977 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1979 HOST_WIDE_INT offset;
1980 rtx src, addr, span;
1982 src = XEXP (set, 1);
1983 addr = XEXP (set, 0);
1984 gcc_assert (MEM_P (addr));
1985 addr = XEXP (addr, 0);
1987 /* As documented, only consider extremely simple addresses. */
1988 switch (GET_CODE (addr))
1991 gcc_assert (REGNO (addr) == cfa.reg);
1992 offset = -cfa.offset;
1995 gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1996 offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
2002 span = targetm.dwarf_register_span (src);
2004 /* ??? We'd like to use queue_reg_save, but we need to come up with
2005 a different flushing heuristic for epilogues. */
2007 reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
2010 /* We have a PARALLEL describing where the contents of SRC live.
2011 Queue register saves for each piece of the PARALLEL. */
2014 HOST_WIDE_INT span_offset = offset;
2016 gcc_assert (GET_CODE (span) == PARALLEL);
2018 limit = XVECLEN (span, 0);
2019 for (par_index = 0; par_index < limit; par_index++)
2021 rtx elem = XVECEXP (span, 0, par_index);
2023 reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
2024 INVALID_REGNUM, span_offset);
2025 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2030 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
2033 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
2036 unsigned sregno, dregno;
2038 src = XEXP (set, 1);
2039 dest = XEXP (set, 0);
2042 sregno = DWARF_FRAME_RETURN_COLUMN;
2044 sregno = DWARF_FRAME_REGNUM (REGNO (src));
2046 dregno = DWARF_FRAME_REGNUM (REGNO (dest));
2048 /* ??? We'd like to use queue_reg_save, but we need to come up with
2049 a different flushing heuristic for epilogues. */
2050 reg_save (label, sregno, dregno, 0);
2053 /* Helper function to get mode of MEM's address. */
2055 static inline enum machine_mode
2056 get_address_mode (rtx mem)
2058 enum machine_mode mode = GET_MODE (XEXP (mem, 0));
2059 if (mode != VOIDmode)
2061 return targetm.addr_space.address_mode (MEM_ADDR_SPACE (mem));
2064 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_EXPRESSION note. */
2067 dwarf2out_frame_debug_cfa_expression (rtx set, const char *label)
2069 rtx src, dest, span;
2070 dw_cfi_ref cfi = new_cfi ();
2072 dest = SET_DEST (set);
2073 src = SET_SRC (set);
2075 gcc_assert (REG_P (src));
2076 gcc_assert (MEM_P (dest));
2078 span = targetm.dwarf_register_span (src);
2081 cfi->dw_cfi_opc = DW_CFA_expression;
2082 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = DWARF_FRAME_REGNUM (REGNO (src));
2083 cfi->dw_cfi_oprnd2.dw_cfi_loc
2084 = mem_loc_descriptor (XEXP (dest, 0), get_address_mode (dest),
2085 GET_MODE (dest), VAR_INIT_STATUS_INITIALIZED);
2087 /* ??? We'd like to use queue_reg_save, were the interface different,
2088 and, as above, we could manage flushing for epilogues. */
2089 add_fde_cfi (label, cfi);
2092 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
2095 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
2097 dw_cfi_ref cfi = new_cfi ();
2098 unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
2100 cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
2101 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
2103 add_fde_cfi (label, cfi);
2106 /* Record call frame debugging information for an expression EXPR,
2107 which either sets SP or FP (adjusting how we calculate the frame
2108 address) or saves a register to the stack or another register.
2109 LABEL indicates the address of EXPR.
2111 This function encodes a state machine mapping rtxes to actions on
2112 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
2113 users need not read the source code.
2115 The High-Level Picture
2117 Changes in the register we use to calculate the CFA: Currently we
2118 assume that if you copy the CFA register into another register, we
2119 should take the other one as the new CFA register; this seems to
2120 work pretty well. If it's wrong for some target, it's simple
2121 enough not to set RTX_FRAME_RELATED_P on the insn in question.
2123 Changes in the register we use for saving registers to the stack:
2124 This is usually SP, but not always. Again, we deduce that if you
2125 copy SP into another register (and SP is not the CFA register),
2126 then the new register is the one we will be using for register
2127 saves. This also seems to work.
2129 Register saves: There's not much guesswork about this one; if
2130 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
2131 register save, and the register used to calculate the destination
2132 had better be the one we think we're using for this purpose.
2133 It's also assumed that a copy from a call-saved register to another
2134 register is saving that register if RTX_FRAME_RELATED_P is set on
2135 that instruction. If the copy is from a call-saved register to
2136 the *same* register, that means that the register is now the same
2137 value as in the caller.
2139 Except: If the register being saved is the CFA register, and the
2140 offset is nonzero, we are saving the CFA, so we assume we have to
2141 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
2142 the intent is to save the value of SP from the previous frame.
2144 In addition, if a register has previously been saved to a different
2147 Invariants / Summaries of Rules
2149 cfa current rule for calculating the CFA. It usually
2150 consists of a register and an offset.
2151 cfa_store register used by prologue code to save things to the stack
2152 cfa_store.offset is the offset from the value of
2153 cfa_store.reg to the actual CFA
2154 cfa_temp register holding an integral value. cfa_temp.offset
2155 stores the value, which will be used to adjust the
2156 stack pointer. cfa_temp is also used like cfa_store,
2157 to track stores to the stack via fp or a temp reg.
2159 Rules 1- 4: Setting a register's value to cfa.reg or an expression
2160 with cfa.reg as the first operand changes the cfa.reg and its
2161 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
2164 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
2165 expression yielding a constant. This sets cfa_temp.reg
2166 and cfa_temp.offset.
2168 Rule 5: Create a new register cfa_store used to save items to the
2171 Rules 10-14: Save a register to the stack. Define offset as the
2172 difference of the original location and cfa_store's
2173 location (or cfa_temp's location if cfa_temp is used).
2175 Rules 16-20: If AND operation happens on sp in prologue, we assume
2176 stack is realigned. We will use a group of DW_OP_XXX
2177 expressions to represent the location of the stored
2178 register instead of CFA+offset.
2182 "{a,b}" indicates a choice of a xor b.
2183 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2186 (set <reg1> <reg2>:cfa.reg)
2187 effects: cfa.reg = <reg1>
2188 cfa.offset unchanged
2189 cfa_temp.reg = <reg1>
2190 cfa_temp.offset = cfa.offset
2193 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2194 {<const_int>,<reg>:cfa_temp.reg}))
2195 effects: cfa.reg = sp if fp used
2196 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2197 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2198 if cfa_store.reg==sp
2201 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2202 effects: cfa.reg = fp
2203 cfa_offset += +/- <const_int>
2206 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2207 constraints: <reg1> != fp
2209 effects: cfa.reg = <reg1>
2210 cfa_temp.reg = <reg1>
2211 cfa_temp.offset = cfa.offset
2214 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2215 constraints: <reg1> != fp
2217 effects: cfa_store.reg = <reg1>
2218 cfa_store.offset = cfa.offset - cfa_temp.offset
2221 (set <reg> <const_int>)
2222 effects: cfa_temp.reg = <reg>
2223 cfa_temp.offset = <const_int>
2226 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2227 effects: cfa_temp.reg = <reg1>
2228 cfa_temp.offset |= <const_int>
2231 (set <reg> (high <exp>))
2235 (set <reg> (lo_sum <exp> <const_int>))
2236 effects: cfa_temp.reg = <reg>
2237 cfa_temp.offset = <const_int>
2240 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2241 effects: cfa_store.offset -= <const_int>
2242 cfa.offset = cfa_store.offset if cfa.reg == sp
2244 cfa.base_offset = -cfa_store.offset
2247 (set (mem ({pre_inc,pre_dec,post_dec} sp:cfa_store.reg)) <reg>)
2248 effects: cfa_store.offset += -/+ mode_size(mem)
2249 cfa.offset = cfa_store.offset if cfa.reg == sp
2251 cfa.base_offset = -cfa_store.offset
2254 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2257 effects: cfa.reg = <reg1>
2258 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2261 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2262 effects: cfa.reg = <reg1>
2263 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2266 (set (mem (post_inc <reg1>:cfa_temp <const_int>)) <reg2>)
2267 effects: cfa.reg = <reg1>
2268 cfa.base_offset = -cfa_temp.offset
2269 cfa_temp.offset -= mode_size(mem)
2272 (set <reg> {unspec, unspec_volatile})
2273 effects: target-dependent
2276 (set sp (and: sp <const_int>))
2277 constraints: cfa_store.reg == sp
2278 effects: current_fde.stack_realign = 1
2279 cfa_store.offset = 0
2280 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2283 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2284 effects: cfa_store.offset += -/+ mode_size(mem)
2287 (set (mem ({pre_inc, pre_dec} sp)) fp)
2288 constraints: fde->stack_realign == 1
2289 effects: cfa_store.offset = 0
2290 cfa.reg != HARD_FRAME_POINTER_REGNUM
2293 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2294 constraints: fde->stack_realign == 1
2296 && cfa.indirect == 0
2297 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2298 effects: Use DW_CFA_def_cfa_expression to define cfa
2299 cfa.reg == fde->drap_reg */
2302 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2304 rtx src, dest, span;
2305 HOST_WIDE_INT offset;
2308 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2309 the PARALLEL independently. The first element is always processed if
2310 it is a SET. This is for backward compatibility. Other elements
2311 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2312 flag is set in them. */
2313 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2316 int limit = XVECLEN (expr, 0);
2319 /* PARALLELs have strict read-modify-write semantics, so we
2320 ought to evaluate every rvalue before changing any lvalue.
2321 It's cumbersome to do that in general, but there's an
2322 easy approximation that is enough for all current users:
2323 handle register saves before register assignments. */
2324 if (GET_CODE (expr) == PARALLEL)
2325 for (par_index = 0; par_index < limit; par_index++)
2327 elem = XVECEXP (expr, 0, par_index);
2328 if (GET_CODE (elem) == SET
2329 && MEM_P (SET_DEST (elem))
2330 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2331 dwarf2out_frame_debug_expr (elem, label);
2334 for (par_index = 0; par_index < limit; par_index++)
2336 elem = XVECEXP (expr, 0, par_index);
2337 if (GET_CODE (elem) == SET
2338 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2339 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2340 dwarf2out_frame_debug_expr (elem, label);
2341 else if (GET_CODE (elem) == SET
2343 && !RTX_FRAME_RELATED_P (elem))
2345 /* Stack adjustment combining might combine some post-prologue
2346 stack adjustment into a prologue stack adjustment. */
2347 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2350 dwarf2out_stack_adjust (offset, label);
2356 gcc_assert (GET_CODE (expr) == SET);
2358 src = SET_SRC (expr);
2359 dest = SET_DEST (expr);
2363 rtx rsi = reg_saved_in (src);
2368 fde = current_fde ();
2370 switch (GET_CODE (dest))
2373 switch (GET_CODE (src))
2375 /* Setting FP from SP. */
2377 if (cfa.reg == (unsigned) REGNO (src))
2380 /* Update the CFA rule wrt SP or FP. Make sure src is
2381 relative to the current CFA register.
2383 We used to require that dest be either SP or FP, but the
2384 ARM copies SP to a temporary register, and from there to
2385 FP. So we just rely on the backends to only set
2386 RTX_FRAME_RELATED_P on appropriate insns. */
2387 cfa.reg = REGNO (dest);
2388 cfa_temp.reg = cfa.reg;
2389 cfa_temp.offset = cfa.offset;
2393 /* Saving a register in a register. */
2394 gcc_assert (!fixed_regs [REGNO (dest)]
2395 /* For the SPARC and its register window. */
2396 || (DWARF_FRAME_REGNUM (REGNO (src))
2397 == DWARF_FRAME_RETURN_COLUMN));
2399 /* After stack is aligned, we can only save SP in FP
2400 if drap register is used. In this case, we have
2401 to restore stack pointer with the CFA value and we
2402 don't generate this DWARF information. */
2404 && fde->stack_realign
2405 && REGNO (src) == STACK_POINTER_REGNUM)
2406 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2407 && fde->drap_reg != INVALID_REGNUM
2408 && cfa.reg != REGNO (src));
2410 queue_reg_save (label, src, dest, 0);
2417 if (dest == stack_pointer_rtx)
2421 switch (GET_CODE (XEXP (src, 1)))
2424 offset = INTVAL (XEXP (src, 1));
2427 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2429 offset = cfa_temp.offset;
2435 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2437 /* Restoring SP from FP in the epilogue. */
2438 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2439 cfa.reg = STACK_POINTER_REGNUM;
2441 else if (GET_CODE (src) == LO_SUM)
2442 /* Assume we've set the source reg of the LO_SUM from sp. */
2445 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2447 if (GET_CODE (src) != MINUS)
2449 if (cfa.reg == STACK_POINTER_REGNUM)
2450 cfa.offset += offset;
2451 if (cfa_store.reg == STACK_POINTER_REGNUM)
2452 cfa_store.offset += offset;
2454 else if (dest == hard_frame_pointer_rtx)
2457 /* Either setting the FP from an offset of the SP,
2458 or adjusting the FP */
2459 gcc_assert (frame_pointer_needed);
2461 gcc_assert (REG_P (XEXP (src, 0))
2462 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2463 && CONST_INT_P (XEXP (src, 1)));
2464 offset = INTVAL (XEXP (src, 1));
2465 if (GET_CODE (src) != MINUS)
2467 cfa.offset += offset;
2468 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2472 gcc_assert (GET_CODE (src) != MINUS);
2475 if (REG_P (XEXP (src, 0))
2476 && REGNO (XEXP (src, 0)) == cfa.reg
2477 && CONST_INT_P (XEXP (src, 1)))
2479 /* Setting a temporary CFA register that will be copied
2480 into the FP later on. */
2481 offset = - INTVAL (XEXP (src, 1));
2482 cfa.offset += offset;
2483 cfa.reg = REGNO (dest);
2484 /* Or used to save regs to the stack. */
2485 cfa_temp.reg = cfa.reg;
2486 cfa_temp.offset = cfa.offset;
2490 else if (REG_P (XEXP (src, 0))
2491 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2492 && XEXP (src, 1) == stack_pointer_rtx)
2494 /* Setting a scratch register that we will use instead
2495 of SP for saving registers to the stack. */
2496 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2497 cfa_store.reg = REGNO (dest);
2498 cfa_store.offset = cfa.offset - cfa_temp.offset;
2502 else if (GET_CODE (src) == LO_SUM
2503 && CONST_INT_P (XEXP (src, 1)))
2505 cfa_temp.reg = REGNO (dest);
2506 cfa_temp.offset = INTVAL (XEXP (src, 1));
2515 cfa_temp.reg = REGNO (dest);
2516 cfa_temp.offset = INTVAL (src);
2521 gcc_assert (REG_P (XEXP (src, 0))
2522 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2523 && CONST_INT_P (XEXP (src, 1)));
2525 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2526 cfa_temp.reg = REGNO (dest);
2527 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2530 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2531 which will fill in all of the bits. */
2538 case UNSPEC_VOLATILE:
2539 gcc_assert (targetm.dwarf_handle_frame_unspec);
2540 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2545 /* If this AND operation happens on stack pointer in prologue,
2546 we assume the stack is realigned and we extract the
2548 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2550 /* We interpret reg_save differently with stack_realign set.
2551 Thus we must flush whatever we have queued first. */
2552 dwarf2out_flush_queued_reg_saves ();
2554 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2555 fde->stack_realign = 1;
2556 fde->stack_realignment = INTVAL (XEXP (src, 1));
2557 cfa_store.offset = 0;
2559 if (cfa.reg != STACK_POINTER_REGNUM
2560 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2561 fde->drap_reg = cfa.reg;
2569 def_cfa_1 (label, &cfa);
2574 /* Saving a register to the stack. Make sure dest is relative to the
2576 switch (GET_CODE (XEXP (dest, 0)))
2581 /* We can't handle variable size modifications. */
2582 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2584 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2586 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2587 && cfa_store.reg == STACK_POINTER_REGNUM);
2589 cfa_store.offset += offset;
2590 if (cfa.reg == STACK_POINTER_REGNUM)
2591 cfa.offset = cfa_store.offset;
2593 offset = -cfa_store.offset;
2600 offset = GET_MODE_SIZE (GET_MODE (dest));
2601 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2604 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2605 == STACK_POINTER_REGNUM)
2606 && cfa_store.reg == STACK_POINTER_REGNUM);
2608 cfa_store.offset += offset;
2610 /* Rule 18: If stack is aligned, we will use FP as a
2611 reference to represent the address of the stored
2614 && fde->stack_realign
2615 && src == hard_frame_pointer_rtx)
2617 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2618 cfa_store.offset = 0;
2621 if (cfa.reg == STACK_POINTER_REGNUM)
2622 cfa.offset = cfa_store.offset;
2624 if (GET_CODE (XEXP (dest, 0)) == POST_DEC)
2625 offset += -cfa_store.offset;
2627 offset = -cfa_store.offset;
2631 /* With an offset. */
2638 gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2639 && REG_P (XEXP (XEXP (dest, 0), 0)));
2640 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2641 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2644 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2646 if (cfa.reg == (unsigned) regno)
2647 offset -= cfa.offset;
2648 else if (cfa_store.reg == (unsigned) regno)
2649 offset -= cfa_store.offset;
2652 gcc_assert (cfa_temp.reg == (unsigned) regno);
2653 offset -= cfa_temp.offset;
2659 /* Without an offset. */
2662 int regno = REGNO (XEXP (dest, 0));
2664 if (cfa.reg == (unsigned) regno)
2665 offset = -cfa.offset;
2666 else if (cfa_store.reg == (unsigned) regno)
2667 offset = -cfa_store.offset;
2670 gcc_assert (cfa_temp.reg == (unsigned) regno);
2671 offset = -cfa_temp.offset;
2678 gcc_assert (cfa_temp.reg
2679 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2680 offset = -cfa_temp.offset;
2681 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2689 /* If the source operand of this MEM operation is not a
2690 register, basically the source is return address. Here
2691 we only care how much stack grew and we don't save it. */
2695 if (REGNO (src) != STACK_POINTER_REGNUM
2696 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2697 && (unsigned) REGNO (src) == cfa.reg)
2699 /* We're storing the current CFA reg into the stack. */
2701 if (cfa.offset == 0)
2704 /* If stack is aligned, putting CFA reg into stack means
2705 we can no longer use reg + offset to represent CFA.
2706 Here we use DW_CFA_def_cfa_expression instead. The
2707 result of this expression equals to the original CFA
2710 && fde->stack_realign
2711 && cfa.indirect == 0
2712 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2714 dw_cfa_location cfa_exp;
2716 gcc_assert (fde->drap_reg == cfa.reg);
2718 cfa_exp.indirect = 1;
2719 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2720 cfa_exp.base_offset = offset;
2723 fde->drap_reg_saved = 1;
2725 def_cfa_1 (label, &cfa_exp);
2729 /* If the source register is exactly the CFA, assume
2730 we're saving SP like any other register; this happens
2732 def_cfa_1 (label, &cfa);
2733 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2738 /* Otherwise, we'll need to look in the stack to
2739 calculate the CFA. */
2740 rtx x = XEXP (dest, 0);
2744 gcc_assert (REG_P (x));
2746 cfa.reg = REGNO (x);
2747 cfa.base_offset = offset;
2749 def_cfa_1 (label, &cfa);
2754 def_cfa_1 (label, &cfa);
2756 span = targetm.dwarf_register_span (src);
2759 queue_reg_save (label, src, NULL_RTX, offset);
2762 /* We have a PARALLEL describing where the contents of SRC
2763 live. Queue register saves for each piece of the
2767 HOST_WIDE_INT span_offset = offset;
2769 gcc_assert (GET_CODE (span) == PARALLEL);
2771 limit = XVECLEN (span, 0);
2772 for (par_index = 0; par_index < limit; par_index++)
2774 rtx elem = XVECEXP (span, 0, par_index);
2776 queue_reg_save (label, elem, NULL_RTX, span_offset);
2777 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2788 /* Record call frame debugging information for INSN, which either
2789 sets SP or FP (adjusting how we calculate the frame address) or saves a
2790 register to the stack. If INSN is NULL_RTX, initialize our state.
2792 If AFTER_P is false, we're being called before the insn is emitted,
2793 otherwise after. Call instructions get invoked twice. */
2796 dwarf2out_frame_debug (rtx insn, bool after_p)
2800 bool handled_one = false;
2802 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2803 dwarf2out_flush_queued_reg_saves ();
2805 if (!RTX_FRAME_RELATED_P (insn))
2807 /* ??? This should be done unconditionally since stack adjustments
2808 matter if the stack pointer is not the CFA register anymore but
2809 is still used to save registers. */
2810 if (!ACCUMULATE_OUTGOING_ARGS)
2811 dwarf2out_notice_stack_adjust (insn, after_p);
2815 label = dwarf2out_cfi_label (false);
2816 any_cfis_emitted = false;
2818 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2819 switch (REG_NOTE_KIND (note))
2821 case REG_FRAME_RELATED_EXPR:
2822 insn = XEXP (note, 0);
2825 case REG_CFA_DEF_CFA:
2826 dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2830 case REG_CFA_ADJUST_CFA:
2835 if (GET_CODE (n) == PARALLEL)
2836 n = XVECEXP (n, 0, 0);
2838 dwarf2out_frame_debug_adjust_cfa (n, label);
2842 case REG_CFA_OFFSET:
2845 n = single_set (insn);
2846 dwarf2out_frame_debug_cfa_offset (n, label);
2850 case REG_CFA_REGISTER:
2855 if (GET_CODE (n) == PARALLEL)
2856 n = XVECEXP (n, 0, 0);
2858 dwarf2out_frame_debug_cfa_register (n, label);
2862 case REG_CFA_EXPRESSION:
2865 n = single_set (insn);
2866 dwarf2out_frame_debug_cfa_expression (n, label);
2870 case REG_CFA_RESTORE:
2875 if (GET_CODE (n) == PARALLEL)
2876 n = XVECEXP (n, 0, 0);
2879 dwarf2out_frame_debug_cfa_restore (n, label);
2883 case REG_CFA_SET_VDRAP:
2887 dw_fde_ref fde = current_fde ();
2890 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2892 fde->vdrap_reg = REGNO (n);
2903 if (any_cfis_emitted)
2904 dwarf2out_flush_queued_reg_saves ();
2908 insn = PATTERN (insn);
2910 dwarf2out_frame_debug_expr (insn, label);
2912 /* Check again. A parallel can save and update the same register.
2913 We could probably check just once, here, but this is safer than
2914 removing the check above. */
2915 if (any_cfis_emitted || clobbers_queued_reg_save (insn))
2916 dwarf2out_flush_queued_reg_saves ();
2919 /* Called once at the start of final to initialize some data for the
2920 current function. */
2922 dwarf2out_frame_debug_init (void)
2926 /* Flush any queued register saves. */
2927 dwarf2out_flush_queued_reg_saves ();
2929 /* Set up state for generating call frame debug info. */
2932 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2934 cfa.reg = STACK_POINTER_REGNUM;
2937 cfa_temp.offset = 0;
2939 for (i = 0; i < num_regs_saved_in_regs; i++)
2941 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2942 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2944 num_regs_saved_in_regs = 0;
2946 if (barrier_args_size)
2948 XDELETEVEC (barrier_args_size);
2949 barrier_args_size = NULL;
2953 /* Determine if we need to save and restore CFI information around this
2954 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2955 we do need to save/restore, then emit the save now, and insert a
2956 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2959 dwarf2out_cfi_begin_epilogue (rtx insn)
2961 bool saw_frp = false;
2964 /* Scan forward to the return insn, noticing if there are possible
2965 frame related insns. */
2966 for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2971 /* Look for both regular and sibcalls to end the block. */
2972 if (returnjump_p (i))
2974 if (CALL_P (i) && SIBLING_CALL_P (i))
2977 if (GET_CODE (PATTERN (i)) == SEQUENCE)
2980 rtx seq = PATTERN (i);
2982 if (returnjump_p (XVECEXP (seq, 0, 0)))
2984 if (CALL_P (XVECEXP (seq, 0, 0))
2985 && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2988 for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2989 if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2993 if (RTX_FRAME_RELATED_P (i))
2997 /* If the port doesn't emit epilogue unwind info, we don't need a
2998 save/restore pair. */
3002 /* Otherwise, search forward to see if the return insn was the last
3003 basic block of the function. If so, we don't need save/restore. */
3004 gcc_assert (i != NULL);
3005 i = next_real_insn (i);
3009 /* Insert the restore before that next real insn in the stream, and before
3010 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
3011 properly nested. This should be after any label or alignment. This
3012 will be pushed into the CFI stream by the function below. */
3015 rtx p = PREV_INSN (i);
3018 if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
3022 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
3024 emit_cfa_remember = true;
3026 /* And emulate the state save. */
3027 gcc_assert (!cfa_remember.in_use);
3029 cfa_remember.in_use = 1;
3032 /* A "subroutine" of dwarf2out_cfi_begin_epilogue. Emit the restore
3036 dwarf2out_frame_debug_restore_state (void)
3038 dw_cfi_ref cfi = new_cfi ();
3039 const char *label = dwarf2out_cfi_label (false);
3041 cfi->dw_cfi_opc = DW_CFA_restore_state;
3042 add_fde_cfi (label, cfi);
3044 gcc_assert (cfa_remember.in_use);
3046 cfa_remember.in_use = 0;
3049 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
3050 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
3051 (enum dwarf_call_frame_info cfi);
3053 static enum dw_cfi_oprnd_type
3054 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
3059 case DW_CFA_GNU_window_save:
3060 case DW_CFA_remember_state:
3061 case DW_CFA_restore_state:
3062 return dw_cfi_oprnd_unused;
3064 case DW_CFA_set_loc:
3065 case DW_CFA_advance_loc1:
3066 case DW_CFA_advance_loc2:
3067 case DW_CFA_advance_loc4:
3068 case DW_CFA_MIPS_advance_loc8:
3069 return dw_cfi_oprnd_addr;
3072 case DW_CFA_offset_extended:
3073 case DW_CFA_def_cfa:
3074 case DW_CFA_offset_extended_sf:
3075 case DW_CFA_def_cfa_sf:
3076 case DW_CFA_restore:
3077 case DW_CFA_restore_extended:
3078 case DW_CFA_undefined:
3079 case DW_CFA_same_value:
3080 case DW_CFA_def_cfa_register:
3081 case DW_CFA_register:
3082 case DW_CFA_expression:
3083 return dw_cfi_oprnd_reg_num;
3085 case DW_CFA_def_cfa_offset:
3086 case DW_CFA_GNU_args_size:
3087 case DW_CFA_def_cfa_offset_sf:
3088 return dw_cfi_oprnd_offset;
3090 case DW_CFA_def_cfa_expression:
3091 return dw_cfi_oprnd_loc;
3098 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
3099 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
3100 (enum dwarf_call_frame_info cfi);
3102 static enum dw_cfi_oprnd_type
3103 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
3107 case DW_CFA_def_cfa:
3108 case DW_CFA_def_cfa_sf:
3110 case DW_CFA_offset_extended_sf:
3111 case DW_CFA_offset_extended:
3112 return dw_cfi_oprnd_offset;
3114 case DW_CFA_register:
3115 return dw_cfi_oprnd_reg_num;
3117 case DW_CFA_expression:
3118 return dw_cfi_oprnd_loc;
3121 return dw_cfi_oprnd_unused;
3125 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
3126 switch to the data section instead, and write out a synthetic start label
3127 for collect2 the first time around. */
3130 switch_to_eh_frame_section (bool back)
3134 #ifdef EH_FRAME_SECTION_NAME
3135 if (eh_frame_section == 0)
3139 if (EH_TABLES_CAN_BE_READ_ONLY)
3145 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
3147 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
3149 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
3151 flags = ((! flag_pic
3152 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
3153 && (fde_encoding & 0x70) != DW_EH_PE_aligned
3154 && (per_encoding & 0x70) != DW_EH_PE_absptr
3155 && (per_encoding & 0x70) != DW_EH_PE_aligned
3156 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
3157 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
3158 ? 0 : SECTION_WRITE);
3161 flags = SECTION_WRITE;
3162 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
3164 #endif /* EH_FRAME_SECTION_NAME */
3166 if (eh_frame_section)
3167 switch_to_section (eh_frame_section);
3170 /* We have no special eh_frame section. Put the information in
3171 the data section and emit special labels to guide collect2. */
3172 switch_to_section (data_section);
3176 label = get_file_function_name ("F");
3177 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3178 targetm.asm_out.globalize_label (asm_out_file,
3179 IDENTIFIER_POINTER (label));
3180 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
3185 /* Switch [BACK] to the eh or debug frame table section, depending on
3189 switch_to_frame_table_section (int for_eh, bool back)
3192 switch_to_eh_frame_section (back);
3195 if (!debug_frame_section)
3196 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3197 SECTION_DEBUG, NULL);
3198 switch_to_section (debug_frame_section);
3202 /* Output a Call Frame Information opcode and its operand(s). */
3205 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3210 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3211 dw2_asm_output_data (1, (cfi->dw_cfi_opc
3212 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3213 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3214 ((unsigned HOST_WIDE_INT)
3215 cfi->dw_cfi_oprnd1.dw_cfi_offset));
3216 else if (cfi->dw_cfi_opc == DW_CFA_offset)
3218 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3219 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3220 "DW_CFA_offset, column %#lx", r);
3221 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3222 dw2_asm_output_data_uleb128 (off, NULL);
3224 else if (cfi->dw_cfi_opc == DW_CFA_restore)
3226 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3227 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3228 "DW_CFA_restore, column %#lx", r);
3232 dw2_asm_output_data (1, cfi->dw_cfi_opc,
3233 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3235 switch (cfi->dw_cfi_opc)
3237 case DW_CFA_set_loc:
3239 dw2_asm_output_encoded_addr_rtx (
3240 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3241 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3244 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3245 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3246 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3249 case DW_CFA_advance_loc1:
3250 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3251 fde->dw_fde_current_label, NULL);
3252 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3255 case DW_CFA_advance_loc2:
3256 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3257 fde->dw_fde_current_label, NULL);
3258 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3261 case DW_CFA_advance_loc4:
3262 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3263 fde->dw_fde_current_label, NULL);
3264 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3267 case DW_CFA_MIPS_advance_loc8:
3268 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3269 fde->dw_fde_current_label, NULL);
3270 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3273 case DW_CFA_offset_extended:
3274 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3275 dw2_asm_output_data_uleb128 (r, NULL);
3276 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3277 dw2_asm_output_data_uleb128 (off, NULL);
3280 case DW_CFA_def_cfa:
3281 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3282 dw2_asm_output_data_uleb128 (r, NULL);
3283 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3286 case DW_CFA_offset_extended_sf:
3287 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3288 dw2_asm_output_data_uleb128 (r, NULL);
3289 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3290 dw2_asm_output_data_sleb128 (off, NULL);
3293 case DW_CFA_def_cfa_sf:
3294 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3295 dw2_asm_output_data_uleb128 (r, NULL);
3296 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3297 dw2_asm_output_data_sleb128 (off, NULL);
3300 case DW_CFA_restore_extended:
3301 case DW_CFA_undefined:
3302 case DW_CFA_same_value:
3303 case DW_CFA_def_cfa_register:
3304 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3305 dw2_asm_output_data_uleb128 (r, NULL);
3308 case DW_CFA_register:
3309 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3310 dw2_asm_output_data_uleb128 (r, NULL);
3311 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3312 dw2_asm_output_data_uleb128 (r, NULL);
3315 case DW_CFA_def_cfa_offset:
3316 case DW_CFA_GNU_args_size:
3317 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3320 case DW_CFA_def_cfa_offset_sf:
3321 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3322 dw2_asm_output_data_sleb128 (off, NULL);
3325 case DW_CFA_GNU_window_save:
3328 case DW_CFA_def_cfa_expression:
3329 case DW_CFA_expression:
3330 output_cfa_loc (cfi, for_eh);
3333 case DW_CFA_GNU_negative_offset_extended:
3334 /* Obsoleted by DW_CFA_offset_extended_sf. */
3343 /* Similar, but do it via assembler directives instead. */
3346 output_cfi_directive (dw_cfi_ref cfi)
3348 unsigned long r, r2;
3350 switch (cfi->dw_cfi_opc)
3352 case DW_CFA_advance_loc:
3353 case DW_CFA_advance_loc1:
3354 case DW_CFA_advance_loc2:
3355 case DW_CFA_advance_loc4:
3356 case DW_CFA_MIPS_advance_loc8:
3357 case DW_CFA_set_loc:
3358 /* Should only be created by add_fde_cfi in a code path not
3359 followed when emitting via directives. The assembler is
3360 going to take care of this for us. */
3364 case DW_CFA_offset_extended:
3365 case DW_CFA_offset_extended_sf:
3366 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3367 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3368 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3371 case DW_CFA_restore:
3372 case DW_CFA_restore_extended:
3373 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3374 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3377 case DW_CFA_undefined:
3378 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3379 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3382 case DW_CFA_same_value:
3383 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3384 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3387 case DW_CFA_def_cfa:
3388 case DW_CFA_def_cfa_sf:
3389 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3390 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3391 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3394 case DW_CFA_def_cfa_register:
3395 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3396 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3399 case DW_CFA_register:
3400 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3401 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3402 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3405 case DW_CFA_def_cfa_offset:
3406 case DW_CFA_def_cfa_offset_sf:
3407 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3408 HOST_WIDE_INT_PRINT_DEC"\n",
3409 cfi->dw_cfi_oprnd1.dw_cfi_offset);
3412 case DW_CFA_remember_state:
3413 fprintf (asm_out_file, "\t.cfi_remember_state\n");
3415 case DW_CFA_restore_state:
3416 fprintf (asm_out_file, "\t.cfi_restore_state\n");
3419 case DW_CFA_GNU_args_size:
3420 fprintf (asm_out_file, "\t.cfi_escape %#x,", DW_CFA_GNU_args_size);
3421 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3423 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3424 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3425 fputc ('\n', asm_out_file);
3428 case DW_CFA_GNU_window_save:
3429 fprintf (asm_out_file, "\t.cfi_window_save\n");
3432 case DW_CFA_def_cfa_expression:
3433 case DW_CFA_expression:
3434 fprintf (asm_out_file, "\t.cfi_escape %#x,", cfi->dw_cfi_opc);
3435 output_cfa_loc_raw (cfi);
3436 fputc ('\n', asm_out_file);
3444 /* Output CFIs from VEC, up to index UPTO, to bring current FDE to the
3445 same state as after executing CFIs in CFI chain. DO_CFI_ASM is
3446 true if .cfi_* directives shall be emitted, false otherwise. If it
3447 is false, FDE and FOR_EH are the other arguments to pass to
3451 output_cfis (cfi_vec vec, int upto, bool do_cfi_asm,
3452 dw_fde_ref fde, bool for_eh)
3455 struct dw_cfi_struct cfi_buf;
3457 dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3458 VEC(dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3459 unsigned int len, idx;
3461 for (ix = 0; ix < upto + 1; ix++)
3463 dw_cfi_ref cfi = ix < upto ? VEC_index (dw_cfi_ref, vec, ix) : NULL;
3464 switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3466 case DW_CFA_advance_loc:
3467 case DW_CFA_advance_loc1:
3468 case DW_CFA_advance_loc2:
3469 case DW_CFA_advance_loc4:
3470 case DW_CFA_MIPS_advance_loc8:
3471 case DW_CFA_set_loc:
3472 /* All advances should be ignored. */
3474 case DW_CFA_remember_state:
3476 dw_cfi_ref args_size = cfi_args_size;
3478 /* Skip everything between .cfi_remember_state and
3479 .cfi_restore_state. */
3484 for (; ix < upto; ix++)
3486 cfi2 = VEC_index (dw_cfi_ref, vec, ix);
3487 if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3489 else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3492 gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3495 cfi_args_size = args_size;
3498 case DW_CFA_GNU_args_size:
3499 cfi_args_size = cfi;
3501 case DW_CFA_GNU_window_save:
3504 case DW_CFA_offset_extended:
3505 case DW_CFA_offset_extended_sf:
3506 case DW_CFA_restore:
3507 case DW_CFA_restore_extended:
3508 case DW_CFA_undefined:
3509 case DW_CFA_same_value:
3510 case DW_CFA_register:
3511 case DW_CFA_val_offset:
3512 case DW_CFA_val_offset_sf:
3513 case DW_CFA_expression:
3514 case DW_CFA_val_expression:
3515 case DW_CFA_GNU_negative_offset_extended:
3516 if (VEC_length (dw_cfi_ref, regs)
3517 <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3518 VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3519 cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3520 VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num,
3523 case DW_CFA_def_cfa:
3524 case DW_CFA_def_cfa_sf:
3525 case DW_CFA_def_cfa_expression:
3527 cfi_cfa_offset = cfi;
3529 case DW_CFA_def_cfa_register:
3532 case DW_CFA_def_cfa_offset:
3533 case DW_CFA_def_cfa_offset_sf:
3534 cfi_cfa_offset = cfi;
3537 gcc_assert (cfi == NULL);
3539 len = VEC_length (dw_cfi_ref, regs);
3540 for (idx = 0; idx < len; idx++)
3542 cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3544 && cfi2->dw_cfi_opc != DW_CFA_restore
3545 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3548 output_cfi_directive (cfi2);
3550 output_cfi (cfi2, fde, for_eh);
3553 if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3555 gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3557 switch (cfi_cfa_offset->dw_cfi_opc)
3559 case DW_CFA_def_cfa_offset:
3560 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3561 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3563 case DW_CFA_def_cfa_offset_sf:
3564 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3565 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3567 case DW_CFA_def_cfa:
3568 case DW_CFA_def_cfa_sf:
3569 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3570 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3577 else if (cfi_cfa_offset)
3578 cfi_cfa = cfi_cfa_offset;
3582 output_cfi_directive (cfi_cfa);
3584 output_cfi (cfi_cfa, fde, for_eh);
3587 cfi_cfa_offset = NULL;
3589 && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3592 output_cfi_directive (cfi_args_size);
3594 output_cfi (cfi_args_size, fde, for_eh);
3596 cfi_args_size = NULL;
3599 VEC_free (dw_cfi_ref, heap, regs);
3602 else if (do_cfi_asm)
3603 output_cfi_directive (cfi);
3605 output_cfi (cfi, fde, for_eh);
3613 /* Like output_cfis, but emit all CFIs in the vector. */
3615 output_all_cfis (cfi_vec vec, bool do_cfi_asm,
3616 dw_fde_ref fde, bool for_eh)
3618 output_cfis (vec, VEC_length (dw_cfi_ref, vec), do_cfi_asm, fde, for_eh);
3621 /* Output one FDE. */
3624 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3625 char *section_start_label, int fde_encoding, char *augmentation,
3626 bool any_lsda_needed, int lsda_encoding)
3629 const char *begin, *end;
3630 static unsigned int j;
3631 char l1[20], l2[20];
3634 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
3636 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3638 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3639 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3640 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3641 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3642 " indicating 64-bit DWARF extension");
3643 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3645 ASM_OUTPUT_LABEL (asm_out_file, l1);
3648 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3650 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3651 debug_frame_section, "FDE CIE offset");
3653 begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
3654 end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
3658 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
3659 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3660 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
3661 "FDE initial location");
3662 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3663 end, begin, "FDE address range");
3667 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
3668 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
3671 if (augmentation[0])
3673 if (any_lsda_needed)
3675 int size = size_of_encoded_value (lsda_encoding);
3677 if (lsda_encoding == DW_EH_PE_aligned)
3679 int offset = ( 4 /* Length */
3680 + 4 /* CIE offset */
3681 + 2 * size_of_encoded_value (fde_encoding)
3682 + 1 /* Augmentation size */ );
3683 int pad = -offset & (PTR_SIZE - 1);
3686 gcc_assert (size_of_uleb128 (size) == 1);
3689 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3691 if (fde->uses_eh_lsda)
3693 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
3694 fde->funcdef_number);
3695 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
3696 gen_rtx_SYMBOL_REF (Pmode, l1),
3698 "Language Specific Data Area");
3702 if (lsda_encoding == DW_EH_PE_aligned)
3703 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3704 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
3705 "Language Specific Data Area (none)");
3709 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3712 /* Loop through the Call Frame Instructions associated with
3714 fde->dw_fde_current_label = begin;
3715 if (fde->dw_fde_second_begin == NULL)
3716 FOR_EACH_VEC_ELT (dw_cfi_ref, fde->dw_fde_cfi, ix, cfi)
3717 output_cfi (cfi, fde, for_eh);
3720 if (fde->dw_fde_switch_cfi_index > 0)
3721 FOR_EACH_VEC_ELT (dw_cfi_ref, fde->dw_fde_cfi, ix, cfi)
3723 if (ix == fde->dw_fde_switch_cfi_index)
3725 output_cfi (cfi, fde, for_eh);
3731 int until = VEC_length (dw_cfi_ref, fde->dw_fde_cfi);
3733 if (fde->dw_fde_switch_cfi_index > 0)
3735 from = fde->dw_fde_switch_cfi_index;
3736 output_cfis (fde->dw_fde_cfi, from, false, fde, for_eh);
3738 for (i = from; i < until; i++)
3739 output_cfi (VEC_index (dw_cfi_ref, fde->dw_fde_cfi, i),
3743 /* If we are to emit a ref/link from function bodies to their frame tables,
3744 do it now. This is typically performed to make sure that tables
3745 associated with functions are dragged with them and not discarded in
3746 garbage collecting links. We need to do this on a per function basis to
3747 cope with -ffunction-sections. */
3749 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3750 /* Switch to the function section, emit the ref to the tables, and
3751 switch *back* into the table section. */
3752 switch_to_section (function_section (fde->decl));
3753 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
3754 switch_to_frame_table_section (for_eh, true);
3757 /* Pad the FDE out to an address sized boundary. */
3758 ASM_OUTPUT_ALIGN (asm_out_file,
3759 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3760 ASM_OUTPUT_LABEL (asm_out_file, l2);
3765 /* Return true if frame description entry FDE is needed for EH. */
3768 fde_needed_for_eh_p (dw_fde_ref fde)
3770 if (flag_asynchronous_unwind_tables)
3773 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
3776 if (fde->uses_eh_lsda)
3779 /* If exceptions are enabled, we have collected nothrow info. */
3780 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
3786 /* Output the call frame information used to record information
3787 that relates to calculating the frame pointer, and records the
3788 location of saved registers. */
3791 output_call_frame_info (int for_eh)
3796 char l1[20], l2[20], section_start_label[20];
3797 bool any_lsda_needed = false;
3798 char augmentation[6];
3799 int augmentation_size;
3800 int fde_encoding = DW_EH_PE_absptr;
3801 int per_encoding = DW_EH_PE_absptr;
3802 int lsda_encoding = DW_EH_PE_absptr;
3804 rtx personality = NULL;
3807 /* Don't emit a CIE if there won't be any FDEs. */
3808 if (fde_table_in_use == 0)
3811 /* Nothing to do if the assembler's doing it all. */
3812 if (dwarf2out_do_cfi_asm ())
3815 /* If we don't have any functions we'll want to unwind out of, don't emit
3816 any EH unwind information. If we make FDEs linkonce, we may have to
3817 emit an empty label for an FDE that wouldn't otherwise be emitted. We
3818 want to avoid having an FDE kept around when the function it refers to
3819 is discarded. Example where this matters: a primary function template
3820 in C++ requires EH information, an explicit specialization doesn't. */
3823 bool any_eh_needed = false;
3825 for (i = 0; i < fde_table_in_use; i++)
3826 if (fde_table[i].uses_eh_lsda)
3827 any_eh_needed = any_lsda_needed = true;
3828 else if (fde_needed_for_eh_p (&fde_table[i]))
3829 any_eh_needed = true;
3830 else if (TARGET_USES_WEAK_UNWIND_INFO)
3831 targetm.asm_out.emit_unwind_label (asm_out_file, fde_table[i].decl,
3838 /* We're going to be generating comments, so turn on app. */
3842 /* Switch to the proper frame section, first time. */
3843 switch_to_frame_table_section (for_eh, false);
3845 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3846 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3848 /* Output the CIE. */
3849 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3850 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3851 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3852 dw2_asm_output_data (4, 0xffffffff,
3853 "Initial length escape value indicating 64-bit DWARF extension");
3854 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3855 "Length of Common Information Entry");
3856 ASM_OUTPUT_LABEL (asm_out_file, l1);
3858 /* Now that the CIE pointer is PC-relative for EH,
3859 use 0 to identify the CIE. */
3860 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3861 (for_eh ? 0 : DWARF_CIE_ID),
3862 "CIE Identifier Tag");
3864 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3865 use CIE version 1, unless that would produce incorrect results
3866 due to overflowing the return register column. */
3867 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3869 if (return_reg >= 256 || dwarf_version > 2)
3871 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
3873 augmentation[0] = 0;
3874 augmentation_size = 0;
3876 personality = current_unit_personality;
3882 z Indicates that a uleb128 is present to size the
3883 augmentation section.
3884 L Indicates the encoding (and thus presence) of
3885 an LSDA pointer in the FDE augmentation.
3886 R Indicates a non-default pointer encoding for
3888 P Indicates the presence of an encoding + language
3889 personality routine in the CIE augmentation. */
3891 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3892 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3893 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3895 p = augmentation + 1;
3899 augmentation_size += 1 + size_of_encoded_value (per_encoding);
3900 assemble_external_libcall (personality);
3902 if (any_lsda_needed)
3905 augmentation_size += 1;
3907 if (fde_encoding != DW_EH_PE_absptr)
3910 augmentation_size += 1;
3912 if (p > augmentation + 1)
3914 augmentation[0] = 'z';
3918 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3919 if (personality && per_encoding == DW_EH_PE_aligned)
3921 int offset = ( 4 /* Length */
3923 + 1 /* CIE version */
3924 + strlen (augmentation) + 1 /* Augmentation */
3925 + size_of_uleb128 (1) /* Code alignment */
3926 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3928 + 1 /* Augmentation size */
3929 + 1 /* Personality encoding */ );
3930 int pad = -offset & (PTR_SIZE - 1);
3932 augmentation_size += pad;
3934 /* Augmentations should be small, so there's scarce need to
3935 iterate for a solution. Die if we exceed one uleb128 byte. */
3936 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3940 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3941 if (dw_cie_version >= 4)
3943 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
3944 dw2_asm_output_data (1, 0, "CIE Segment Size");
3946 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3947 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3948 "CIE Data Alignment Factor");
3950 if (dw_cie_version == 1)
3951 dw2_asm_output_data (1, return_reg, "CIE RA Column");
3953 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3955 if (augmentation[0])
3957 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3960 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3961 eh_data_format_name (per_encoding));
3962 dw2_asm_output_encoded_addr_rtx (per_encoding,
3967 if (any_lsda_needed)
3968 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3969 eh_data_format_name (lsda_encoding));
3971 if (fde_encoding != DW_EH_PE_absptr)
3972 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3973 eh_data_format_name (fde_encoding));
3976 FOR_EACH_VEC_ELT (dw_cfi_ref, cie_cfi_vec, i, cfi)
3977 output_cfi (cfi, NULL, for_eh);
3979 /* Pad the CIE out to an address sized boundary. */
3980 ASM_OUTPUT_ALIGN (asm_out_file,
3981 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3982 ASM_OUTPUT_LABEL (asm_out_file, l2);
3984 /* Loop through all of the FDE's. */
3985 for (i = 0; i < fde_table_in_use; i++)
3988 fde = &fde_table[i];
3990 /* Don't emit EH unwind info for leaf functions that don't need it. */
3991 if (for_eh && !fde_needed_for_eh_p (fde))
3994 for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
3995 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
3996 augmentation, any_lsda_needed, lsda_encoding);
3999 if (for_eh && targetm.terminate_dw2_eh_frame_info)
4000 dw2_asm_output_data (4, 0, "End of Table");
4001 #ifdef MIPS_DEBUGGING_INFO
4002 /* Work around Irix 6 assembler bug whereby labels at the end of a section
4003 get a value of 0. Putting .align 0 after the label fixes it. */
4004 ASM_OUTPUT_ALIGN (asm_out_file, 0);
4007 /* Turn off app to make assembly quicker. */
4012 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
4015 dwarf2out_do_cfi_startproc (bool second)
4019 rtx personality = get_personality_function (current_function_decl);
4021 fprintf (asm_out_file, "\t.cfi_startproc\n");
4025 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
4028 /* ??? The GAS support isn't entirely consistent. We have to
4029 handle indirect support ourselves, but PC-relative is done
4030 in the assembler. Further, the assembler can't handle any
4031 of the weirder relocation types. */
4032 if (enc & DW_EH_PE_indirect)
4033 ref = dw2_force_const_mem (ref, true);
4035 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
4036 output_addr_const (asm_out_file, ref);
4037 fputc ('\n', asm_out_file);
4040 if (crtl->uses_eh_lsda)
4044 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
4045 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
4046 current_function_funcdef_no);
4047 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
4048 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
4050 if (enc & DW_EH_PE_indirect)
4051 ref = dw2_force_const_mem (ref, true);
4053 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
4054 output_addr_const (asm_out_file, ref);
4055 fputc ('\n', asm_out_file);
4059 /* Output a marker (i.e. a label) for the beginning of a function, before
4063 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
4064 const char *file ATTRIBUTE_UNUSED)
4066 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4072 current_function_func_begin_label = NULL;
4074 do_frame = dwarf2out_do_frame ();
4076 /* ??? current_function_func_begin_label is also used by except.c for
4077 call-site information. We must emit this label if it might be used. */
4079 && (!flag_exceptions
4080 || targetm.except_unwind_info (&global_options) != UI_TARGET))
4083 fnsec = function_section (current_function_decl);
4084 switch_to_section (fnsec);
4085 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
4086 current_function_funcdef_no);
4087 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
4088 current_function_funcdef_no);
4089 dup_label = xstrdup (label);
4090 current_function_func_begin_label = dup_label;
4092 /* We can elide the fde allocation if we're not emitting debug info. */
4096 /* Expand the fde table if necessary. */
4097 if (fde_table_in_use == fde_table_allocated)
4099 fde_table_allocated += FDE_TABLE_INCREMENT;
4100 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
4101 memset (fde_table + fde_table_in_use, 0,
4102 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
4105 /* Record the FDE associated with this function. */
4106 current_funcdef_fde = fde_table_in_use;
4108 /* Add the new FDE at the end of the fde_table. */
4109 fde = &fde_table[fde_table_in_use++];
4110 fde->decl = current_function_decl;
4111 fde->dw_fde_begin = dup_label;
4112 fde->dw_fde_end = NULL;
4113 fde->dw_fde_current_label = dup_label;
4114 fde->dw_fde_second_begin = NULL;
4115 fde->dw_fde_second_end = NULL;
4116 fde->dw_fde_vms_end_prologue = NULL;
4117 fde->dw_fde_vms_begin_epilogue = NULL;
4118 fde->dw_fde_cfi = VEC_alloc (dw_cfi_ref, gc, 20);
4119 fde->dw_fde_switch_cfi_index = 0;
4120 fde->funcdef_number = current_function_funcdef_no;
4121 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
4122 fde->uses_eh_lsda = crtl->uses_eh_lsda;
4123 fde->nothrow = crtl->nothrow;
4124 fde->drap_reg = INVALID_REGNUM;
4125 fde->vdrap_reg = INVALID_REGNUM;
4126 fde->in_std_section = (fnsec == text_section
4127 || (cold_text_section && fnsec == cold_text_section));
4128 fde->second_in_std_section = 0;
4130 args_size = old_args_size = 0;
4132 /* We only want to output line number information for the genuine dwarf2
4133 prologue case, not the eh frame case. */
4134 #ifdef DWARF2_DEBUGGING_INFO
4136 dwarf2out_source_line (line, file, 0, true);
4139 if (dwarf2out_do_cfi_asm ())
4140 dwarf2out_do_cfi_startproc (false);
4143 rtx personality = get_personality_function (current_function_decl);
4144 if (!current_unit_personality)
4145 current_unit_personality = personality;
4147 /* We cannot keep a current personality per function as without CFI
4148 asm, at the point where we emit the CFI data, there is no current
4149 function anymore. */
4150 if (personality && current_unit_personality != personality)
4151 sorry ("multiple EH personalities are supported only with assemblers "
4152 "supporting .cfi_personality directive");
4156 /* Output a marker (i.e. a label) for the end of the generated code
4157 for a function prologue. This gets called *after* the prologue code has
4161 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
4162 const char *file ATTRIBUTE_UNUSED)
4165 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4167 /* Output a label to mark the endpoint of the code generated for this
4169 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
4170 current_function_funcdef_no);
4171 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
4172 current_function_funcdef_no);
4173 fde = &fde_table[fde_table_in_use - 1];
4174 fde->dw_fde_vms_end_prologue = xstrdup (label);
4177 /* Output a marker (i.e. a label) for the beginning of the generated code
4178 for a function epilogue. This gets called *before* the prologue code has
4182 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4183 const char *file ATTRIBUTE_UNUSED)
4186 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4188 fde = &fde_table[fde_table_in_use - 1];
4189 if (fde->dw_fde_vms_begin_epilogue)
4192 /* Output a label to mark the endpoint of the code generated for this
4194 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
4195 current_function_funcdef_no);
4196 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
4197 current_function_funcdef_no);
4198 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
4201 /* Output a marker (i.e. a label) for the absolute end of the generated code
4202 for a function definition. This gets called *after* the epilogue code has
4206 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4207 const char *file ATTRIBUTE_UNUSED)
4210 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4212 last_var_location_insn = NULL_RTX;
4214 if (dwarf2out_do_cfi_asm ())
4215 fprintf (asm_out_file, "\t.cfi_endproc\n");
4217 /* Output a label to mark the endpoint of the code generated for this
4219 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
4220 current_function_funcdef_no);
4221 ASM_OUTPUT_LABEL (asm_out_file, label);
4222 fde = current_fde ();
4223 gcc_assert (fde != NULL);
4224 if (fde->dw_fde_second_begin == NULL)
4225 fde->dw_fde_end = xstrdup (label);
4229 dwarf2out_frame_init (void)
4231 /* Allocate the initial hunk of the fde_table. */
4232 fde_table = ggc_alloc_cleared_vec_dw_fde_node (FDE_TABLE_INCREMENT);
4233 fde_table_allocated = FDE_TABLE_INCREMENT;
4234 fde_table_in_use = 0;
4236 /* Generate the CFA instructions common to all FDE's. Do it now for the
4237 sake of lookup_cfa. */
4239 /* On entry, the Canonical Frame Address is at SP. */
4240 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
4242 if (targetm.debug_unwind_info () == UI_DWARF2
4243 || targetm.except_unwind_info (&global_options) == UI_DWARF2)
4244 initial_return_save (INCOMING_RETURN_ADDR_RTX);
4248 dwarf2out_frame_finish (void)
4250 /* Output call frame information. */
4251 if (targetm.debug_unwind_info () == UI_DWARF2)
4252 output_call_frame_info (0);
4254 /* Output another copy for the unwinder. */
4255 if ((flag_unwind_tables || flag_exceptions)
4256 && targetm.except_unwind_info (&global_options) == UI_DWARF2)
4257 output_call_frame_info (1);
4260 /* Note that the current function section is being used for code. */
4263 dwarf2out_note_section_used (void)
4265 section *sec = current_function_section ();
4266 if (sec == text_section)
4267 text_section_used = true;
4268 else if (sec == cold_text_section)
4269 cold_text_section_used = true;
4272 static void var_location_switch_text_section (void);
4273 static void set_cur_line_info_table (section *);
4276 dwarf2out_switch_text_section (void)
4279 dw_fde_ref fde = current_fde ();
4281 gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
4283 if (!in_cold_section_p)
4285 fde->dw_fde_end = crtl->subsections.cold_section_end_label;
4286 fde->dw_fde_second_begin = crtl->subsections.hot_section_label;
4287 fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
4291 fde->dw_fde_end = crtl->subsections.hot_section_end_label;
4292 fde->dw_fde_second_begin = crtl->subsections.cold_section_label;
4293 fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
4295 have_multiple_function_sections = true;
4297 /* Reset the current label on switching text sections, so that we
4298 don't attempt to advance_loc4 between labels in different sections. */
4299 fde->dw_fde_current_label = NULL;
4301 /* There is no need to mark used sections when not debugging. */
4302 if (cold_text_section != NULL)
4303 dwarf2out_note_section_used ();
4305 if (dwarf2out_do_cfi_asm ())
4306 fprintf (asm_out_file, "\t.cfi_endproc\n");
4308 /* Now do the real section switch. */
4309 sect = current_function_section ();
4310 switch_to_section (sect);
4312 fde->second_in_std_section
4313 = (sect == text_section
4314 || (cold_text_section && sect == cold_text_section));
4316 if (dwarf2out_do_cfi_asm ())
4318 dwarf2out_do_cfi_startproc (true);
4319 /* As this is a different FDE, insert all current CFI instructions
4321 output_all_cfis (fde->dw_fde_cfi, true, fde, true);
4323 fde->dw_fde_switch_cfi_index = VEC_length (dw_cfi_ref, fde->dw_fde_cfi);
4324 var_location_switch_text_section ();
4326 set_cur_line_info_table (sect);
4329 /* And now, the subset of the debugging information support code necessary
4330 for emitting location expressions. */
4332 /* Data about a single source file. */
4333 struct GTY(()) dwarf_file_data {
4334 const char * filename;
4338 typedef struct dw_val_struct *dw_val_ref;
4339 typedef struct die_struct *dw_die_ref;
4340 typedef const struct die_struct *const_dw_die_ref;
4341 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
4342 typedef struct dw_loc_list_struct *dw_loc_list_ref;
4344 typedef struct GTY(()) deferred_locations_struct
4348 } deferred_locations;
4350 DEF_VEC_O(deferred_locations);
4351 DEF_VEC_ALLOC_O(deferred_locations,gc);
4353 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
4355 DEF_VEC_P(dw_die_ref);
4356 DEF_VEC_ALLOC_P(dw_die_ref,heap);
4358 /* Each DIE may have a series of attribute/value pairs. Values
4359 can take on several forms. The forms that are used in this
4360 implementation are listed below. */
4365 dw_val_class_offset,
4367 dw_val_class_loc_list,
4368 dw_val_class_range_list,
4370 dw_val_class_unsigned_const,
4371 dw_val_class_const_double,
4374 dw_val_class_die_ref,
4375 dw_val_class_fde_ref,
4376 dw_val_class_lbl_id,
4377 dw_val_class_lineptr,
4379 dw_val_class_macptr,
4382 dw_val_class_decl_ref,
4383 dw_val_class_vms_delta
4386 /* Describe a floating point constant value, or a vector constant value. */
4388 typedef struct GTY(()) dw_vec_struct {
4389 unsigned char * GTY((length ("%h.length"))) array;
4395 /* The dw_val_node describes an attribute's value, as it is
4396 represented internally. */
4398 typedef struct GTY(()) dw_val_struct {
4399 enum dw_val_class val_class;
4400 union dw_val_struct_union
4402 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
4403 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
4404 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
4405 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
4406 HOST_WIDE_INT GTY ((default)) val_int;
4407 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
4408 double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
4409 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
4410 struct dw_val_die_union
4414 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
4415 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
4416 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
4417 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
4418 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
4419 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
4420 unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
4421 tree GTY ((tag ("dw_val_class_decl_ref"))) val_decl_ref;
4422 struct dw_val_vms_delta_union
4426 } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
4428 GTY ((desc ("%1.val_class"))) v;
4432 /* Locations in memory are described using a sequence of stack machine
4435 typedef struct GTY(()) dw_loc_descr_struct {
4436 dw_loc_descr_ref dw_loc_next;
4437 ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
4438 /* Used to distinguish DW_OP_addr with a direct symbol relocation
4439 from DW_OP_addr with a dtp-relative symbol relocation. */
4440 unsigned int dtprel : 1;
4442 dw_val_node dw_loc_oprnd1;
4443 dw_val_node dw_loc_oprnd2;
4447 /* Location lists are ranges + location descriptions for that range,
4448 so you can track variables that are in different places over
4449 their entire life. */
4450 typedef struct GTY(()) dw_loc_list_struct {
4451 dw_loc_list_ref dw_loc_next;
4452 const char *begin; /* Label for begin address of range */
4453 const char *end; /* Label for end address of range */
4454 char *ll_symbol; /* Label for beginning of location list.
4455 Only on head of list */
4456 const char *section; /* Section this loclist is relative to */
4457 dw_loc_descr_ref expr;
4459 /* True if all addresses in this and subsequent lists are known to be
4462 /* True if this list has been replaced by dw_loc_next. */
4467 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4469 /* Convert a DWARF stack opcode into its string name. */
4472 dwarf_stack_op_name (unsigned int op)
4477 return "DW_OP_addr";
4479 return "DW_OP_deref";
4481 return "DW_OP_const1u";
4483 return "DW_OP_const1s";
4485 return "DW_OP_const2u";
4487 return "DW_OP_const2s";
4489 return "DW_OP_const4u";
4491 return "DW_OP_const4s";
4493 return "DW_OP_const8u";
4495 return "DW_OP_const8s";
4497 return "DW_OP_constu";
4499 return "DW_OP_consts";
4503 return "DW_OP_drop";
4505 return "DW_OP_over";
4507 return "DW_OP_pick";
4509 return "DW_OP_swap";
4513 return "DW_OP_xderef";
4521 return "DW_OP_minus";
4533 return "DW_OP_plus";
4534 case DW_OP_plus_uconst:
4535 return "DW_OP_plus_uconst";
4541 return "DW_OP_shra";
4559 return "DW_OP_skip";
4561 return "DW_OP_lit0";
4563 return "DW_OP_lit1";
4565 return "DW_OP_lit2";
4567 return "DW_OP_lit3";
4569 return "DW_OP_lit4";
4571 return "DW_OP_lit5";
4573 return "DW_OP_lit6";
4575 return "DW_OP_lit7";
4577 return "DW_OP_lit8";
4579 return "DW_OP_lit9";
4581 return "DW_OP_lit10";
4583 return "DW_OP_lit11";
4585 return "DW_OP_lit12";
4587 return "DW_OP_lit13";
4589 return "DW_OP_lit14";
4591 return "DW_OP_lit15";
4593 return "DW_OP_lit16";
4595 return "DW_OP_lit17";
4597 return "DW_OP_lit18";
4599 return "DW_OP_lit19";
4601 return "DW_OP_lit20";
4603 return "DW_OP_lit21";
4605 return "DW_OP_lit22";
4607 return "DW_OP_lit23";
4609 return "DW_OP_lit24";
4611 return "DW_OP_lit25";
4613 return "DW_OP_lit26";
4615 return "DW_OP_lit27";
4617 return "DW_OP_lit28";
4619 return "DW_OP_lit29";
4621 return "DW_OP_lit30";
4623 return "DW_OP_lit31";
4625 return "DW_OP_reg0";
4627 return "DW_OP_reg1";
4629 return "DW_OP_reg2";
4631 return "DW_OP_reg3";
4633 return "DW_OP_reg4";
4635 return "DW_OP_reg5";
4637 return "DW_OP_reg6";
4639 return "DW_OP_reg7";
4641 return "DW_OP_reg8";
4643 return "DW_OP_reg9";
4645 return "DW_OP_reg10";
4647 return "DW_OP_reg11";
4649 return "DW_OP_reg12";
4651 return "DW_OP_reg13";
4653 return "DW_OP_reg14";
4655 return "DW_OP_reg15";
4657 return "DW_OP_reg16";
4659 return "DW_OP_reg17";
4661 return "DW_OP_reg18";
4663 return "DW_OP_reg19";
4665 return "DW_OP_reg20";
4667 return "DW_OP_reg21";
4669 return "DW_OP_reg22";
4671 return "DW_OP_reg23";
4673 return "DW_OP_reg24";
4675 return "DW_OP_reg25";
4677 return "DW_OP_reg26";
4679 return "DW_OP_reg27";
4681 return "DW_OP_reg28";
4683 return "DW_OP_reg29";
4685 return "DW_OP_reg30";
4687 return "DW_OP_reg31";
4689 return "DW_OP_breg0";
4691 return "DW_OP_breg1";
4693 return "DW_OP_breg2";
4695 return "DW_OP_breg3";
4697 return "DW_OP_breg4";
4699 return "DW_OP_breg5";
4701 return "DW_OP_breg6";
4703 return "DW_OP_breg7";
4705 return "DW_OP_breg8";
4707 return "DW_OP_breg9";
4709 return "DW_OP_breg10";
4711 return "DW_OP_breg11";
4713 return "DW_OP_breg12";
4715 return "DW_OP_breg13";
4717 return "DW_OP_breg14";
4719 return "DW_OP_breg15";
4721 return "DW_OP_breg16";
4723 return "DW_OP_breg17";
4725 return "DW_OP_breg18";
4727 return "DW_OP_breg19";
4729 return "DW_OP_breg20";
4731 return "DW_OP_breg21";
4733 return "DW_OP_breg22";
4735 return "DW_OP_breg23";
4737 return "DW_OP_breg24";
4739 return "DW_OP_breg25";
4741 return "DW_OP_breg26";
4743 return "DW_OP_breg27";
4745 return "DW_OP_breg28";
4747 return "DW_OP_breg29";
4749 return "DW_OP_breg30";
4751 return "DW_OP_breg31";
4753 return "DW_OP_regx";
4755 return "DW_OP_fbreg";
4757 return "DW_OP_bregx";
4759 return "DW_OP_piece";
4760 case DW_OP_deref_size:
4761 return "DW_OP_deref_size";
4762 case DW_OP_xderef_size:
4763 return "DW_OP_xderef_size";
4767 case DW_OP_push_object_address:
4768 return "DW_OP_push_object_address";
4770 return "DW_OP_call2";
4772 return "DW_OP_call4";
4773 case DW_OP_call_ref:
4774 return "DW_OP_call_ref";
4775 case DW_OP_implicit_value:
4776 return "DW_OP_implicit_value";
4777 case DW_OP_stack_value:
4778 return "DW_OP_stack_value";
4779 case DW_OP_form_tls_address:
4780 return "DW_OP_form_tls_address";
4781 case DW_OP_call_frame_cfa:
4782 return "DW_OP_call_frame_cfa";
4783 case DW_OP_bit_piece:
4784 return "DW_OP_bit_piece";
4786 case DW_OP_GNU_push_tls_address:
4787 return "DW_OP_GNU_push_tls_address";
4788 case DW_OP_GNU_uninit:
4789 return "DW_OP_GNU_uninit";
4790 case DW_OP_GNU_encoded_addr:
4791 return "DW_OP_GNU_encoded_addr";
4792 case DW_OP_GNU_implicit_pointer:
4793 return "DW_OP_GNU_implicit_pointer";
4794 case DW_OP_GNU_entry_value:
4795 return "DW_OP_GNU_entry_value";
4796 case DW_OP_GNU_const_type:
4797 return "DW_OP_GNU_const_type";
4798 case DW_OP_GNU_regval_type:
4799 return "DW_OP_GNU_regval_type";
4800 case DW_OP_GNU_deref_type:
4801 return "DW_OP_GNU_deref_type";
4802 case DW_OP_GNU_convert:
4803 return "DW_OP_GNU_convert";
4804 case DW_OP_GNU_reinterpret:
4805 return "DW_OP_GNU_reinterpret";
4808 return "OP_<unknown>";
4812 /* Return a pointer to a newly allocated location description. Location
4813 descriptions are simple expression terms that can be strung
4814 together to form more complicated location (address) descriptions. */
4816 static inline dw_loc_descr_ref
4817 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
4818 unsigned HOST_WIDE_INT oprnd2)
4820 dw_loc_descr_ref descr = ggc_alloc_cleared_dw_loc_descr_node ();
4822 descr->dw_loc_opc = op;
4823 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4824 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4825 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4826 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4831 /* Return a pointer to a newly allocated location description for
4834 static inline dw_loc_descr_ref
4835 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
4838 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
4841 return new_loc_descr (DW_OP_bregx, reg, offset);
4844 /* Add a location description term to a location description expression. */
4847 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
4849 dw_loc_descr_ref *d;
4851 /* Find the end of the chain. */
4852 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4858 /* Add a constant OFFSET to a location expression. */
4861 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
4863 dw_loc_descr_ref loc;
4866 gcc_assert (*list_head != NULL);
4871 /* Find the end of the chain. */
4872 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
4876 if (loc->dw_loc_opc == DW_OP_fbreg
4877 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
4878 p = &loc->dw_loc_oprnd1.v.val_int;
4879 else if (loc->dw_loc_opc == DW_OP_bregx)
4880 p = &loc->dw_loc_oprnd2.v.val_int;
4882 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4883 offset. Don't optimize if an signed integer overflow would happen. */
4885 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
4886 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
4889 else if (offset > 0)
4890 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4894 loc->dw_loc_next = int_loc_descriptor (-offset);
4895 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
4899 /* Add a constant OFFSET to a location list. */
4902 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
4905 for (d = list_head; d != NULL; d = d->dw_loc_next)
4906 loc_descr_plus_const (&d->expr, offset);
4909 #define DWARF_REF_SIZE \
4910 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
4912 static unsigned long size_of_locs (dw_loc_descr_ref);
4913 static unsigned long int get_base_type_offset (dw_die_ref);
4915 /* Return the size of a location descriptor. */
4917 static unsigned long
4918 size_of_loc_descr (dw_loc_descr_ref loc)
4920 unsigned long size = 1;
4922 switch (loc->dw_loc_opc)
4925 size += DWARF2_ADDR_SIZE;
4944 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4947 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4952 case DW_OP_plus_uconst:
4953 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4991 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4994 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4997 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
5000 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
5001 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
5004 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
5006 case DW_OP_bit_piece:
5007 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
5008 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
5010 case DW_OP_deref_size:
5011 case DW_OP_xderef_size:
5020 case DW_OP_call_ref:
5021 size += DWARF_REF_SIZE;
5023 case DW_OP_implicit_value:
5024 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
5025 + loc->dw_loc_oprnd1.v.val_unsigned;
5027 case DW_OP_GNU_implicit_pointer:
5028 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
5030 case DW_OP_GNU_entry_value:
5032 unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
5033 size += size_of_uleb128 (op_size) + op_size;
5036 case DW_OP_GNU_const_type:
5039 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
5040 size += size_of_uleb128 (o) + 1;
5041 switch (loc->dw_loc_oprnd2.val_class)
5043 case dw_val_class_vec:
5044 size += loc->dw_loc_oprnd2.v.val_vec.length
5045 * loc->dw_loc_oprnd2.v.val_vec.elt_size;
5047 case dw_val_class_const:
5048 size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
5050 case dw_val_class_const_double:
5051 size += 2 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
5058 case DW_OP_GNU_regval_type:
5061 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
5062 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
5063 + size_of_uleb128 (o);
5066 case DW_OP_GNU_deref_type:
5069 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
5070 size += 1 + size_of_uleb128 (o);
5073 case DW_OP_GNU_convert:
5074 case DW_OP_GNU_reinterpret:
5077 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
5078 size += size_of_uleb128 (o);
5087 /* Return the size of a series of location descriptors. */
5089 static unsigned long
5090 size_of_locs (dw_loc_descr_ref loc)
5095 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
5096 field, to avoid writing to a PCH file. */
5097 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
5099 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
5101 size += size_of_loc_descr (l);
5106 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
5108 l->dw_loc_addr = size;
5109 size += size_of_loc_descr (l);
5115 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
5116 static void get_ref_die_offset_label (char *, dw_die_ref);
5117 static void output_loc_sequence (dw_loc_descr_ref, int);
5119 /* Output location description stack opcode's operands (if any).
5120 The for_eh_or_skip parameter controls whether register numbers are
5121 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
5122 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
5123 info). This should be suppressed for the cases that have not been converted
5124 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
5127 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
5129 dw_val_ref val1 = &loc->dw_loc_oprnd1;
5130 dw_val_ref val2 = &loc->dw_loc_oprnd2;
5132 switch (loc->dw_loc_opc)
5134 #ifdef DWARF2_DEBUGGING_INFO
5137 dw2_asm_output_data (2, val1->v.val_int, NULL);
5142 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
5143 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
5145 fputc ('\n', asm_out_file);
5150 dw2_asm_output_data (4, val1->v.val_int, NULL);
5155 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
5156 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
5158 fputc ('\n', asm_out_file);
5163 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5164 dw2_asm_output_data (8, val1->v.val_int, NULL);
5171 gcc_assert (val1->val_class == dw_val_class_loc);
5172 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5174 dw2_asm_output_data (2, offset, NULL);
5177 case DW_OP_implicit_value:
5178 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5179 switch (val2->val_class)
5181 case dw_val_class_const:
5182 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
5184 case dw_val_class_vec:
5186 unsigned int elt_size = val2->v.val_vec.elt_size;
5187 unsigned int len = val2->v.val_vec.length;
5191 if (elt_size > sizeof (HOST_WIDE_INT))
5196 for (i = 0, p = val2->v.val_vec.array;
5199 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
5200 "fp or vector constant word %u", i);
5203 case dw_val_class_const_double:
5205 unsigned HOST_WIDE_INT first, second;
5207 if (WORDS_BIG_ENDIAN)
5209 first = val2->v.val_double.high;
5210 second = val2->v.val_double.low;
5214 first = val2->v.val_double.low;
5215 second = val2->v.val_double.high;
5217 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
5219 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
5223 case dw_val_class_addr:
5224 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
5225 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
5240 case DW_OP_implicit_value:
5241 /* We currently don't make any attempt to make sure these are
5242 aligned properly like we do for the main unwind info, so
5243 don't support emitting things larger than a byte if we're
5244 only doing unwinding. */
5249 dw2_asm_output_data (1, val1->v.val_int, NULL);
5252 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5255 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5258 dw2_asm_output_data (1, val1->v.val_int, NULL);
5260 case DW_OP_plus_uconst:
5261 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5295 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5299 unsigned r = val1->v.val_unsigned;
5300 if (for_eh_or_skip >= 0)
5301 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
5302 gcc_assert (size_of_uleb128 (r)
5303 == size_of_uleb128 (val1->v.val_unsigned));
5304 dw2_asm_output_data_uleb128 (r, NULL);
5308 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5312 unsigned r = val1->v.val_unsigned;
5313 if (for_eh_or_skip >= 0)
5314 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
5315 gcc_assert (size_of_uleb128 (r)
5316 == size_of_uleb128 (val1->v.val_unsigned));
5317 dw2_asm_output_data_uleb128 (r, NULL);
5318 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
5322 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5324 case DW_OP_bit_piece:
5325 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5326 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
5328 case DW_OP_deref_size:
5329 case DW_OP_xderef_size:
5330 dw2_asm_output_data (1, val1->v.val_int, NULL);
5336 if (targetm.asm_out.output_dwarf_dtprel)
5338 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
5341 fputc ('\n', asm_out_file);
5348 #ifdef DWARF2_DEBUGGING_INFO
5349 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
5356 case DW_OP_GNU_implicit_pointer:
5358 char label[MAX_ARTIFICIAL_LABEL_BYTES
5359 + HOST_BITS_PER_WIDE_INT / 2 + 2];
5360 gcc_assert (val1->val_class == dw_val_class_die_ref);
5361 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
5362 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
5363 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
5367 case DW_OP_GNU_entry_value:
5368 dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
5369 output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
5372 case DW_OP_GNU_const_type:
5374 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
5376 dw2_asm_output_data_uleb128 (o, NULL);
5377 switch (val2->val_class)
5379 case dw_val_class_const:
5380 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
5381 dw2_asm_output_data (1, l, NULL);
5382 dw2_asm_output_data (l, val2->v.val_int, NULL);
5384 case dw_val_class_vec:
5386 unsigned int elt_size = val2->v.val_vec.elt_size;
5387 unsigned int len = val2->v.val_vec.length;
5392 dw2_asm_output_data (1, l, NULL);
5393 if (elt_size > sizeof (HOST_WIDE_INT))
5398 for (i = 0, p = val2->v.val_vec.array;
5401 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
5402 "fp or vector constant word %u", i);
5405 case dw_val_class_const_double:
5407 unsigned HOST_WIDE_INT first, second;
5408 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
5410 dw2_asm_output_data (1, 2 * l, NULL);
5411 if (WORDS_BIG_ENDIAN)
5413 first = val2->v.val_double.high;
5414 second = val2->v.val_double.low;
5418 first = val2->v.val_double.low;
5419 second = val2->v.val_double.high;
5421 dw2_asm_output_data (l, first, NULL);
5422 dw2_asm_output_data (l, second, NULL);
5430 case DW_OP_GNU_regval_type:
5432 unsigned r = val1->v.val_unsigned;
5433 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
5435 if (for_eh_or_skip >= 0)
5437 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
5438 gcc_assert (size_of_uleb128 (r)
5439 == size_of_uleb128 (val1->v.val_unsigned));
5441 dw2_asm_output_data_uleb128 (r, NULL);
5442 dw2_asm_output_data_uleb128 (o, NULL);
5445 case DW_OP_GNU_deref_type:
5447 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
5449 dw2_asm_output_data (1, val1->v.val_int, NULL);
5450 dw2_asm_output_data_uleb128 (o, NULL);
5453 case DW_OP_GNU_convert:
5454 case DW_OP_GNU_reinterpret:
5456 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
5458 dw2_asm_output_data_uleb128 (o, NULL);
5463 /* Other codes have no operands. */
5468 /* Output a sequence of location operations.
5469 The for_eh_or_skip parameter controls whether register numbers are
5470 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
5471 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
5472 info). This should be suppressed for the cases that have not been converted
5473 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
5476 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
5478 for (; loc != NULL; loc = loc->dw_loc_next)
5480 enum dwarf_location_atom opc = loc->dw_loc_opc;
5481 /* Output the opcode. */
5482 if (for_eh_or_skip >= 0
5483 && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
5485 unsigned r = (opc - DW_OP_breg0);
5486 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
5487 gcc_assert (r <= 31);
5488 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
5490 else if (for_eh_or_skip >= 0
5491 && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
5493 unsigned r = (opc - DW_OP_reg0);
5494 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
5495 gcc_assert (r <= 31);
5496 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
5499 dw2_asm_output_data (1, opc,
5500 "%s", dwarf_stack_op_name (opc));
5502 /* Output the operand(s) (if any). */
5503 output_loc_operands (loc, for_eh_or_skip);
5507 /* Output location description stack opcode's operands (if any).
5508 The output is single bytes on a line, suitable for .cfi_escape. */
5511 output_loc_operands_raw (dw_loc_descr_ref loc)
5513 dw_val_ref val1 = &loc->dw_loc_oprnd1;
5514 dw_val_ref val2 = &loc->dw_loc_oprnd2;
5516 switch (loc->dw_loc_opc)
5519 case DW_OP_implicit_value:
5520 /* We cannot output addresses in .cfi_escape, only bytes. */
5526 case DW_OP_deref_size:
5527 case DW_OP_xderef_size:
5528 fputc (',', asm_out_file);
5529 dw2_asm_output_data_raw (1, val1->v.val_int);
5534 fputc (',', asm_out_file);
5535 dw2_asm_output_data_raw (2, val1->v.val_int);
5540 fputc (',', asm_out_file);
5541 dw2_asm_output_data_raw (4, val1->v.val_int);
5546 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5547 fputc (',', asm_out_file);
5548 dw2_asm_output_data_raw (8, val1->v.val_int);
5556 gcc_assert (val1->val_class == dw_val_class_loc);
5557 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5559 fputc (',', asm_out_file);
5560 dw2_asm_output_data_raw (2, offset);
5566 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
5567 gcc_assert (size_of_uleb128 (r)
5568 == size_of_uleb128 (val1->v.val_unsigned));
5569 fputc (',', asm_out_file);
5570 dw2_asm_output_data_uleb128_raw (r);
5575 case DW_OP_plus_uconst:
5577 fputc (',', asm_out_file);
5578 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5581 case DW_OP_bit_piece:
5582 fputc (',', asm_out_file);
5583 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5584 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
5621 fputc (',', asm_out_file);
5622 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
5627 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
5628 gcc_assert (size_of_uleb128 (r)
5629 == size_of_uleb128 (val1->v.val_unsigned));
5630 fputc (',', asm_out_file);
5631 dw2_asm_output_data_uleb128_raw (r);
5632 fputc (',', asm_out_file);
5633 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
5637 case DW_OP_GNU_implicit_pointer:
5638 case DW_OP_GNU_entry_value:
5639 case DW_OP_GNU_const_type:
5640 case DW_OP_GNU_regval_type:
5641 case DW_OP_GNU_deref_type:
5642 case DW_OP_GNU_convert:
5643 case DW_OP_GNU_reinterpret:
5648 /* Other codes have no operands. */
5654 output_loc_sequence_raw (dw_loc_descr_ref loc)
5658 enum dwarf_location_atom opc = loc->dw_loc_opc;
5659 /* Output the opcode. */
5660 if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
5662 unsigned r = (opc - DW_OP_breg0);
5663 r = DWARF2_FRAME_REG_OUT (r, 1);
5664 gcc_assert (r <= 31);
5665 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
5667 else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
5669 unsigned r = (opc - DW_OP_reg0);
5670 r = DWARF2_FRAME_REG_OUT (r, 1);
5671 gcc_assert (r <= 31);
5672 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
5674 /* Output the opcode. */
5675 fprintf (asm_out_file, "%#x", opc);
5676 output_loc_operands_raw (loc);
5678 if (!loc->dw_loc_next)
5680 loc = loc->dw_loc_next;
5682 fputc (',', asm_out_file);
5686 /* This routine will generate the correct assembly data for a location
5687 description based on a cfi entry with a complex address. */
5690 output_cfa_loc (dw_cfi_ref cfi, int for_eh)
5692 dw_loc_descr_ref loc;
5695 if (cfi->dw_cfi_opc == DW_CFA_expression)
5698 DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
5699 dw2_asm_output_data (1, r, NULL);
5700 loc = cfi->dw_cfi_oprnd2.dw_cfi_loc;
5703 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5705 /* Output the size of the block. */
5706 size = size_of_locs (loc);
5707 dw2_asm_output_data_uleb128 (size, NULL);
5709 /* Now output the operations themselves. */
5710 output_loc_sequence (loc, for_eh);
5713 /* Similar, but used for .cfi_escape. */
5716 output_cfa_loc_raw (dw_cfi_ref cfi)
5718 dw_loc_descr_ref loc;
5721 if (cfi->dw_cfi_opc == DW_CFA_expression)
5724 DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
5725 fprintf (asm_out_file, "%#x,", r);
5726 loc = cfi->dw_cfi_oprnd2.dw_cfi_loc;
5729 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5731 /* Output the size of the block. */
5732 size = size_of_locs (loc);
5733 dw2_asm_output_data_uleb128_raw (size);
5734 fputc (',', asm_out_file);
5736 /* Now output the operations themselves. */
5737 output_loc_sequence_raw (loc);
5740 /* This function builds a dwarf location descriptor sequence from a
5741 dw_cfa_location, adding the given OFFSET to the result of the
5744 static struct dw_loc_descr_struct *
5745 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
5747 struct dw_loc_descr_struct *head, *tmp;
5749 offset += cfa->offset;
5753 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
5754 head->dw_loc_oprnd1.val_class = dw_val_class_const;
5755 tmp = new_loc_descr (DW_OP_deref, 0, 0);
5756 add_loc_descr (&head, tmp);
5759 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
5760 add_loc_descr (&head, tmp);
5764 head = new_reg_loc_descr (cfa->reg, offset);
5769 /* This function builds a dwarf location descriptor sequence for
5770 the address at OFFSET from the CFA when stack is aligned to
5773 static struct dw_loc_descr_struct *
5774 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
5776 struct dw_loc_descr_struct *head;
5777 unsigned int dwarf_fp
5778 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
5780 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
5781 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
5783 head = new_reg_loc_descr (dwarf_fp, 0);
5784 add_loc_descr (&head, int_loc_descriptor (alignment));
5785 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
5786 loc_descr_plus_const (&head, offset);
5789 head = new_reg_loc_descr (dwarf_fp, offset);
5793 /* This function fills in aa dw_cfa_location structure from a dwarf location
5794 descriptor sequence. */
5797 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
5799 struct dw_loc_descr_struct *ptr;
5801 cfa->base_offset = 0;
5805 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
5807 enum dwarf_location_atom op = ptr->dw_loc_opc;
5843 cfa->reg = op - DW_OP_reg0;
5846 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5880 cfa->reg = op - DW_OP_breg0;
5881 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
5884 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5885 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
5890 case DW_OP_plus_uconst:
5891 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
5894 internal_error ("DW_LOC_OP %s not implemented",
5895 dwarf_stack_op_name (ptr->dw_loc_opc));
5900 /* And now, the support for symbolic debugging information. */
5902 /* .debug_str support. */
5903 static int output_indirect_string (void **, void *);
5905 static void dwarf2out_init (const char *);
5906 static void dwarf2out_finish (const char *);
5907 static void dwarf2out_assembly_start (void);
5908 static void dwarf2out_define (unsigned int, const char *);
5909 static void dwarf2out_undef (unsigned int, const char *);
5910 static void dwarf2out_start_source_file (unsigned, const char *);
5911 static void dwarf2out_end_source_file (unsigned);
5912 static void dwarf2out_function_decl (tree);
5913 static void dwarf2out_begin_block (unsigned, unsigned);
5914 static void dwarf2out_end_block (unsigned, unsigned);
5915 static bool dwarf2out_ignore_block (const_tree);
5916 static void dwarf2out_global_decl (tree);
5917 static void dwarf2out_type_decl (tree, int);
5918 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
5919 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
5921 static void dwarf2out_abstract_function (tree);
5922 static void dwarf2out_var_location (rtx);
5923 static void dwarf2out_begin_function (tree);
5924 static void dwarf2out_set_name (tree, tree);
5926 /* The debug hooks structure. */
5928 const struct gcc_debug_hooks dwarf2_debug_hooks =
5932 dwarf2out_assembly_start,
5935 dwarf2out_start_source_file,
5936 dwarf2out_end_source_file,
5937 dwarf2out_begin_block,
5938 dwarf2out_end_block,
5939 dwarf2out_ignore_block,
5940 dwarf2out_source_line,
5941 dwarf2out_begin_prologue,
5942 #if VMS_DEBUGGING_INFO
5943 dwarf2out_vms_end_prologue,
5944 dwarf2out_vms_begin_epilogue,
5946 debug_nothing_int_charstar,
5947 debug_nothing_int_charstar,
5949 dwarf2out_end_epilogue,
5950 dwarf2out_begin_function,
5951 debug_nothing_int, /* end_function */
5952 dwarf2out_function_decl, /* function_decl */
5953 dwarf2out_global_decl,
5954 dwarf2out_type_decl, /* type_decl */
5955 dwarf2out_imported_module_or_decl,
5956 debug_nothing_tree, /* deferred_inline_function */
5957 /* The DWARF 2 backend tries to reduce debugging bloat by not
5958 emitting the abstract description of inline functions until
5959 something tries to reference them. */
5960 dwarf2out_abstract_function, /* outlining_inline_function */
5961 debug_nothing_rtx, /* label */
5962 debug_nothing_int, /* handle_pch */
5963 dwarf2out_var_location,
5964 dwarf2out_switch_text_section,
5966 1, /* start_end_main_source_file */
5967 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */
5970 /* NOTE: In the comments in this file, many references are made to
5971 "Debugging Information Entries". This term is abbreviated as `DIE'
5972 throughout the remainder of this file. */
5974 /* An internal representation of the DWARF output is built, and then
5975 walked to generate the DWARF debugging info. The walk of the internal
5976 representation is done after the entire program has been compiled.
5977 The types below are used to describe the internal representation. */
5979 /* Whether to put type DIEs into their own section .debug_types instead
5980 of making them part of the .debug_info section. Only supported for
5981 Dwarf V4 or higher and the user didn't disable them through
5982 -fno-debug-types-section. It is more efficient to put them in a
5983 separate comdat sections since the linker will then be able to
5984 remove duplicates. But not all tools support .debug_types sections
5987 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
5989 /* Various DIE's use offsets relative to the beginning of the
5990 .debug_info section to refer to each other. */
5992 typedef long int dw_offset;
5994 /* Define typedefs here to avoid circular dependencies. */
5996 typedef struct dw_attr_struct *dw_attr_ref;
5997 typedef struct dw_line_info_struct *dw_line_info_ref;
5998 typedef struct pubname_struct *pubname_ref;
5999 typedef struct dw_ranges_struct *dw_ranges_ref;
6000 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
6001 typedef struct comdat_type_struct *comdat_type_node_ref;
6003 /* The entries in the line_info table more-or-less mirror the opcodes
6004 that are used in the real dwarf line table. Arrays of these entries
6005 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
6008 enum dw_line_info_opcode {
6009 /* Emit DW_LNE_set_address; the operand is the label index. */
6012 /* Emit a row to the matrix with the given line. This may be done
6013 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
6017 /* Emit a DW_LNS_set_file. */
6020 /* Emit a DW_LNS_set_column. */
6023 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
6026 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
6027 LI_set_prologue_end,
6028 LI_set_epilogue_begin,
6030 /* Emit a DW_LNE_set_discriminator. */
6031 LI_set_discriminator
6034 typedef struct GTY(()) dw_line_info_struct {
6035 enum dw_line_info_opcode opcode;
6037 } dw_line_info_entry;
6039 DEF_VEC_O(dw_line_info_entry);
6040 DEF_VEC_ALLOC_O(dw_line_info_entry, gc);
6042 typedef struct GTY(()) dw_line_info_table_struct {
6043 /* The label that marks the end of this section. */
6044 const char *end_label;
6046 /* The values for the last row of the matrix, as collected in the table.
6047 These are used to minimize the changes to the next row. */
6048 unsigned int file_num;
6049 unsigned int line_num;
6050 unsigned int column_num;
6055 VEC(dw_line_info_entry, gc) *entries;
6056 } dw_line_info_table;
6058 typedef dw_line_info_table *dw_line_info_table_p;
6060 DEF_VEC_P(dw_line_info_table_p);
6061 DEF_VEC_ALLOC_P(dw_line_info_table_p, gc);
6063 /* Each DIE attribute has a field specifying the attribute kind,
6064 a link to the next attribute in the chain, and an attribute value.
6065 Attributes are typically linked below the DIE they modify. */
6067 typedef struct GTY(()) dw_attr_struct {
6068 enum dwarf_attribute dw_attr;
6069 dw_val_node dw_attr_val;
6073 DEF_VEC_O(dw_attr_node);
6074 DEF_VEC_ALLOC_O(dw_attr_node,gc);
6076 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
6077 The children of each node form a circular list linked by
6078 die_sib. die_child points to the node *before* the "first" child node. */
6080 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
6081 union die_symbol_or_type_node
6083 char * GTY ((tag ("0"))) die_symbol;
6084 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
6086 GTY ((desc ("use_debug_types"))) die_id;
6087 VEC(dw_attr_node,gc) * die_attr;
6088 dw_die_ref die_parent;
6089 dw_die_ref die_child;
6091 dw_die_ref die_definition; /* ref from a specification to its definition */
6092 dw_offset die_offset;
6093 unsigned long die_abbrev;
6095 /* Die is used and must not be pruned as unused. */
6096 int die_perennial_p;
6097 unsigned int decl_id;
6098 enum dwarf_tag die_tag;
6102 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
6103 #define FOR_EACH_CHILD(die, c, expr) do { \
6104 c = die->die_child; \
6108 } while (c != die->die_child); \
6111 /* The pubname structure */
6113 typedef struct GTY(()) pubname_struct {
6119 DEF_VEC_O(pubname_entry);
6120 DEF_VEC_ALLOC_O(pubname_entry, gc);
6122 struct GTY(()) dw_ranges_struct {
6123 /* If this is positive, it's a block number, otherwise it's a
6124 bitwise-negated index into dw_ranges_by_label. */
6128 /* A structure to hold a macinfo entry. */
6130 typedef struct GTY(()) macinfo_struct {
6131 unsigned HOST_WIDE_INT code;
6132 unsigned HOST_WIDE_INT lineno;
6137 DEF_VEC_O(macinfo_entry);
6138 DEF_VEC_ALLOC_O(macinfo_entry, gc);
6140 struct GTY(()) dw_ranges_by_label_struct {
6145 /* The comdat type node structure. */
6146 typedef struct GTY(()) comdat_type_struct
6148 dw_die_ref root_die;
6149 dw_die_ref type_die;
6150 char signature[DWARF_TYPE_SIGNATURE_SIZE];
6151 struct comdat_type_struct *next;
6155 /* The limbo die list structure. */
6156 typedef struct GTY(()) limbo_die_struct {
6159 struct limbo_die_struct *next;
6163 typedef struct skeleton_chain_struct
6167 struct skeleton_chain_struct *parent;
6169 skeleton_chain_node;
6171 /* How to start an assembler comment. */
6172 #ifndef ASM_COMMENT_START
6173 #define ASM_COMMENT_START ";#"
6176 /* Define a macro which returns nonzero for a TYPE_DECL which was
6177 implicitly generated for a tagged type.
6179 Note that unlike the gcc front end (which generates a NULL named
6180 TYPE_DECL node for each complete tagged type, each array type, and
6181 each function type node created) the g++ front end generates a
6182 _named_ TYPE_DECL node for each tagged type node created.
6183 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
6184 generate a DW_TAG_typedef DIE for them. */
6186 #define TYPE_DECL_IS_STUB(decl) \
6187 (DECL_NAME (decl) == NULL_TREE \
6188 || (DECL_ARTIFICIAL (decl) \
6189 && is_tagged_type (TREE_TYPE (decl)) \
6190 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
6191 /* This is necessary for stub decls that \
6192 appear in nested inline functions. */ \
6193 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
6194 && (decl_ultimate_origin (decl) \
6195 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
6197 /* Information concerning the compilation unit's programming
6198 language, and compiler version. */
6200 /* Fixed size portion of the DWARF compilation unit header. */
6201 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
6202 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
6204 /* Fixed size portion of the DWARF comdat type unit header. */
6205 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
6206 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
6207 + DWARF_OFFSET_SIZE)
6209 /* Fixed size portion of public names info. */
6210 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
6212 /* Fixed size portion of the address range info. */
6213 #define DWARF_ARANGES_HEADER_SIZE \
6214 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
6215 DWARF2_ADDR_SIZE * 2) \
6216 - DWARF_INITIAL_LENGTH_SIZE)
6218 /* Size of padding portion in the address range info. It must be
6219 aligned to twice the pointer size. */
6220 #define DWARF_ARANGES_PAD_SIZE \
6221 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
6222 DWARF2_ADDR_SIZE * 2) \
6223 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
6225 /* Use assembler line directives if available. */
6226 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
6227 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
6228 #define DWARF2_ASM_LINE_DEBUG_INFO 1
6230 #define DWARF2_ASM_LINE_DEBUG_INFO 0
6234 /* Minimum line offset in a special line info. opcode.
6235 This value was chosen to give a reasonable range of values. */
6236 #define DWARF_LINE_BASE -10
6238 /* First special line opcode - leave room for the standard opcodes. */
6239 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
6241 /* Range of line offsets in a special line info. opcode. */
6242 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
6244 /* Flag that indicates the initial value of the is_stmt_start flag.
6245 In the present implementation, we do not mark any lines as
6246 the beginning of a source statement, because that information
6247 is not made available by the GCC front-end. */
6248 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
6250 /* Maximum number of operations per instruction bundle. */
6251 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
6252 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
6255 /* This location is used by calc_die_sizes() to keep track
6256 the offset of each DIE within the .debug_info section. */
6257 static unsigned long next_die_offset;
6259 /* Record the root of the DIE's built for the current compilation unit. */
6260 static GTY(()) dw_die_ref single_comp_unit_die;
6262 /* A list of type DIEs that have been separated into comdat sections. */
6263 static GTY(()) comdat_type_node *comdat_type_list;
6265 /* A list of DIEs with a NULL parent waiting to be relocated. */
6266 static GTY(()) limbo_die_node *limbo_die_list;
6268 /* A list of DIEs for which we may have to generate
6269 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
6270 static GTY(()) limbo_die_node *deferred_asm_name;
6272 /* Filenames referenced by this compilation unit. */
6273 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
6275 /* A hash table of references to DIE's that describe declarations.
6276 The key is a DECL_UID() which is a unique number identifying each decl. */
6277 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
6279 /* A hash table of references to DIE's that describe COMMON blocks.
6280 The key is DECL_UID() ^ die_parent. */
6281 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
6283 typedef struct GTY(()) die_arg_entry_struct {
6288 DEF_VEC_O(die_arg_entry);
6289 DEF_VEC_ALLOC_O(die_arg_entry,gc);
6291 /* Node of the variable location list. */
6292 struct GTY ((chain_next ("%h.next"))) var_loc_node {
6293 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
6294 EXPR_LIST chain. For small bitsizes, bitsize is encoded
6295 in mode of the EXPR_LIST node and first EXPR_LIST operand
6296 is either NOTE_INSN_VAR_LOCATION for a piece with a known
6297 location or NULL for padding. For larger bitsizes,
6298 mode is 0 and first operand is a CONCAT with bitsize
6299 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
6300 NULL as second operand. */
6302 const char * GTY (()) label;
6303 struct var_loc_node * GTY (()) next;
6306 /* Variable location list. */
6307 struct GTY (()) var_loc_list_def {
6308 struct var_loc_node * GTY (()) first;
6310 /* Pointer to the last but one or last element of the
6311 chained list. If the list is empty, both first and
6312 last are NULL, if the list contains just one node
6313 or the last node certainly is not redundant, it points
6314 to the last node, otherwise points to the last but one.
6315 Do not mark it for GC because it is marked through the chain. */
6316 struct var_loc_node * GTY ((skip ("%h"))) last;
6318 /* Pointer to the last element before section switch,
6319 if NULL, either sections weren't switched or first
6320 is after section switch. */
6321 struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
6323 /* DECL_UID of the variable decl. */
6324 unsigned int decl_id;
6326 typedef struct var_loc_list_def var_loc_list;
6328 /* Call argument location list. */
6329 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
6330 rtx GTY (()) call_arg_loc_note;
6331 const char * GTY (()) label;
6332 tree GTY (()) block;
6334 rtx GTY (()) symbol_ref;
6335 struct call_arg_loc_node * GTY (()) next;
6339 /* Table of decl location linked lists. */
6340 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
6342 /* Head and tail of call_arg_loc chain. */
6343 static GTY (()) struct call_arg_loc_node *call_arg_locations;
6344 static struct call_arg_loc_node *call_arg_loc_last;
6346 /* Number of call sites in the current function. */
6347 static int call_site_count = -1;
6348 /* Number of tail call sites in the current function. */
6349 static int tail_call_site_count = -1;
6351 /* Vector mapping block numbers to DW_TAG_{lexical_block,inlined_subroutine}
6353 static VEC (dw_die_ref, heap) *block_map;
6355 /* A cached location list. */
6356 struct GTY (()) cached_dw_loc_list_def {
6357 /* The DECL_UID of the decl that this entry describes. */
6358 unsigned int decl_id;
6360 /* The cached location list. */
6361 dw_loc_list_ref loc_list;
6363 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
6365 /* Table of cached location lists. */
6366 static GTY ((param_is (cached_dw_loc_list))) htab_t cached_dw_loc_list_table;
6368 /* A pointer to the base of a list of references to DIE's that
6369 are uniquely identified by their tag, presence/absence of
6370 children DIE's, and list of attribute/value pairs. */
6371 static GTY((length ("abbrev_die_table_allocated")))
6372 dw_die_ref *abbrev_die_table;
6374 /* Number of elements currently allocated for abbrev_die_table. */
6375 static GTY(()) unsigned abbrev_die_table_allocated;
6377 /* Number of elements in type_die_table currently in use. */
6378 static GTY(()) unsigned abbrev_die_table_in_use;
6380 /* Size (in elements) of increments by which we may expand the
6381 abbrev_die_table. */
6382 #define ABBREV_DIE_TABLE_INCREMENT 256
6384 /* A global counter for generating labels for line number data. */
6385 static unsigned int line_info_label_num;
6387 /* The current table to which we should emit line number information
6388 for the current function. This will be set up at the beginning of
6389 assembly for the function. */
6390 static dw_line_info_table *cur_line_info_table;
6392 /* The two default tables of line number info. */
6393 static GTY(()) dw_line_info_table *text_section_line_info;
6394 static GTY(()) dw_line_info_table *cold_text_section_line_info;
6396 /* The set of all non-default tables of line number info. */
6397 static GTY(()) VEC (dw_line_info_table_p, gc) *separate_line_info;
6399 /* A flag to tell pubnames/types export if there is an info section to
6401 static bool info_section_emitted;
6403 /* A pointer to the base of a table that contains a list of publicly
6404 accessible names. */
6405 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
6407 /* A pointer to the base of a table that contains a list of publicly
6408 accessible types. */
6409 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
6411 /* A pointer to the base of a table that contains a list of macro
6412 defines/undefines (and file start/end markers). */
6413 static GTY (()) VEC (macinfo_entry, gc) * macinfo_table;
6415 /* Array of dies for which we should generate .debug_ranges info. */
6416 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
6418 /* Number of elements currently allocated for ranges_table. */
6419 static GTY(()) unsigned ranges_table_allocated;
6421 /* Number of elements in ranges_table currently in use. */
6422 static GTY(()) unsigned ranges_table_in_use;
6424 /* Array of pairs of labels referenced in ranges_table. */
6425 static GTY ((length ("ranges_by_label_allocated")))
6426 dw_ranges_by_label_ref ranges_by_label;
6428 /* Number of elements currently allocated for ranges_by_label. */
6429 static GTY(()) unsigned ranges_by_label_allocated;
6431 /* Number of elements in ranges_by_label currently in use. */
6432 static GTY(()) unsigned ranges_by_label_in_use;
6434 /* Size (in elements) of increments by which we may expand the
6436 #define RANGES_TABLE_INCREMENT 64
6438 /* Whether we have location lists that need outputting */
6439 static GTY(()) bool have_location_lists;
6441 /* Unique label counter. */
6442 static GTY(()) unsigned int loclabel_num;
6444 /* Unique label counter for point-of-call tables. */
6445 static GTY(()) unsigned int poc_label_num;
6447 /* Record whether the function being analyzed contains inlined functions. */
6448 static int current_function_has_inlines;
6450 /* The last file entry emitted by maybe_emit_file(). */
6451 static GTY(()) struct dwarf_file_data * last_emitted_file;
6453 /* Number of internal labels generated by gen_internal_sym(). */
6454 static GTY(()) int label_num;
6456 /* Cached result of previous call to lookup_filename. */
6457 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
6459 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
6461 /* Instances of generic types for which we need to generate debug
6462 info that describe their generic parameters and arguments. That
6463 generation needs to happen once all types are properly laid out so
6464 we do it at the end of compilation. */
6465 static GTY(()) VEC(tree,gc) *generic_type_instances;
6467 /* Offset from the "steady-state frame pointer" to the frame base,
6468 within the current function. */
6469 static HOST_WIDE_INT frame_pointer_fb_offset;
6471 static VEC (dw_die_ref, heap) *base_types;
6473 /* Forward declarations for functions defined in this file. */
6475 static int is_pseudo_reg (const_rtx);
6476 static tree type_main_variant (tree);
6477 static int is_tagged_type (const_tree);
6478 static const char *dwarf_tag_name (unsigned);
6479 static const char *dwarf_attr_name (unsigned);
6480 static const char *dwarf_form_name (unsigned);
6481 static tree decl_ultimate_origin (const_tree);
6482 static tree decl_class_context (tree);
6483 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
6484 static inline enum dw_val_class AT_class (dw_attr_ref);
6485 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
6486 static inline unsigned AT_flag (dw_attr_ref);
6487 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
6488 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
6489 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
6490 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
6491 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
6492 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
6493 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
6494 unsigned int, unsigned char *);
6495 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
6496 static hashval_t debug_str_do_hash (const void *);
6497 static int debug_str_eq (const void *, const void *);
6498 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
6499 static inline const char *AT_string (dw_attr_ref);
6500 static enum dwarf_form AT_string_form (dw_attr_ref);
6501 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
6502 static void add_AT_specification (dw_die_ref, dw_die_ref);
6503 static inline dw_die_ref AT_ref (dw_attr_ref);
6504 static inline int AT_ref_external (dw_attr_ref);
6505 static inline void set_AT_ref_external (dw_attr_ref, int);
6506 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
6507 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
6508 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
6509 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
6511 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
6512 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
6513 static inline rtx AT_addr (dw_attr_ref);
6514 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
6515 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
6516 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
6517 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
6518 unsigned HOST_WIDE_INT);
6519 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
6521 static inline const char *AT_lbl (dw_attr_ref);
6522 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
6523 static const char *get_AT_low_pc (dw_die_ref);
6524 static const char *get_AT_hi_pc (dw_die_ref);
6525 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
6526 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
6527 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
6528 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
6529 static bool is_cxx (void);
6530 static bool is_fortran (void);
6531 static bool is_ada (void);
6532 static void remove_AT (dw_die_ref, enum dwarf_attribute);
6533 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
6534 static void add_child_die (dw_die_ref, dw_die_ref);
6535 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
6536 static dw_die_ref lookup_type_die (tree);
6537 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
6538 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
6539 static void equate_type_number_to_die (tree, dw_die_ref);
6540 static hashval_t decl_die_table_hash (const void *);
6541 static int decl_die_table_eq (const void *, const void *);
6542 static dw_die_ref lookup_decl_die (tree);
6543 static hashval_t common_block_die_table_hash (const void *);
6544 static int common_block_die_table_eq (const void *, const void *);
6545 static hashval_t decl_loc_table_hash (const void *);
6546 static int decl_loc_table_eq (const void *, const void *);
6547 static var_loc_list *lookup_decl_loc (const_tree);
6548 static void equate_decl_number_to_die (tree, dw_die_ref);
6549 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
6550 static void print_spaces (FILE *);
6551 static void print_die (dw_die_ref, FILE *);
6552 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
6553 static dw_die_ref pop_compile_unit (dw_die_ref);
6554 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
6555 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
6556 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
6557 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
6558 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
6559 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
6560 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
6561 struct md5_ctx *, int *);
6562 struct checksum_attributes;
6563 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
6564 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
6565 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
6566 static void generate_type_signature (dw_die_ref, comdat_type_node *);
6567 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
6568 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
6569 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
6570 static int same_die_p (dw_die_ref, dw_die_ref, int *);
6571 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
6572 static void compute_section_prefix (dw_die_ref);
6573 static int is_type_die (dw_die_ref);
6574 static int is_comdat_die (dw_die_ref);
6575 static int is_symbol_die (dw_die_ref);
6576 static void assign_symbol_names (dw_die_ref);
6577 static void break_out_includes (dw_die_ref);
6578 static int is_declaration_die (dw_die_ref);
6579 static int should_move_die_to_comdat (dw_die_ref);
6580 static dw_die_ref clone_as_declaration (dw_die_ref);
6581 static dw_die_ref clone_die (dw_die_ref);
6582 static dw_die_ref clone_tree (dw_die_ref);
6583 static void copy_declaration_context (dw_die_ref, dw_die_ref);
6584 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
6585 static void generate_skeleton_bottom_up (skeleton_chain_node *);
6586 static dw_die_ref generate_skeleton (dw_die_ref);
6587 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
6589 static void break_out_comdat_types (dw_die_ref);
6590 static dw_die_ref copy_ancestor_tree (dw_die_ref, dw_die_ref, htab_t);
6591 static void copy_decls_walk (dw_die_ref, dw_die_ref, htab_t);
6592 static void copy_decls_for_unworthy_types (dw_die_ref);
6594 static hashval_t htab_cu_hash (const void *);
6595 static int htab_cu_eq (const void *, const void *);
6596 static void htab_cu_del (void *);
6597 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
6598 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
6599 static void add_sibling_attributes (dw_die_ref);
6600 static void build_abbrev_table (dw_die_ref);
6601 static void output_location_lists (dw_die_ref);
6602 static int constant_size (unsigned HOST_WIDE_INT);
6603 static unsigned long size_of_die (dw_die_ref);
6604 static void calc_die_sizes (dw_die_ref);
6605 static void calc_base_type_die_sizes (void);
6606 static void mark_dies (dw_die_ref);
6607 static void unmark_dies (dw_die_ref);
6608 static void unmark_all_dies (dw_die_ref);
6609 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
6610 static unsigned long size_of_aranges (void);
6611 static enum dwarf_form value_format (dw_attr_ref);
6612 static void output_value_format (dw_attr_ref);
6613 static void output_abbrev_section (void);
6614 static void output_die_symbol (dw_die_ref);
6615 static void output_die (dw_die_ref);
6616 static void output_compilation_unit_header (void);
6617 static void output_comp_unit (dw_die_ref, int);
6618 static void output_comdat_type_unit (comdat_type_node *);
6619 static const char *dwarf2_name (tree, int);
6620 static void add_pubname (tree, dw_die_ref);
6621 static void add_pubname_string (const char *, dw_die_ref);
6622 static void add_pubtype (tree, dw_die_ref);
6623 static void output_pubnames (VEC (pubname_entry,gc) *);
6624 static void output_aranges (unsigned long);
6625 static unsigned int add_ranges_num (int);
6626 static unsigned int add_ranges (const_tree);
6627 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
6629 static void output_ranges (void);
6630 static dw_line_info_table *new_line_info_table (void);
6631 static void output_line_info (void);
6632 static void output_file_names (void);
6633 static dw_die_ref base_type_die (tree);
6634 static int is_base_type (tree);
6635 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
6636 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
6637 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
6638 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
6639 static int type_is_enum (const_tree);
6640 static unsigned int dbx_reg_number (const_rtx);
6641 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
6642 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
6643 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
6644 enum var_init_status);
6645 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
6646 enum var_init_status);
6647 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
6648 enum var_init_status);
6649 static int is_based_loc (const_rtx);
6650 static int resolve_one_addr (rtx *, void *);
6651 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
6652 enum var_init_status);
6653 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
6654 enum var_init_status);
6655 static dw_loc_list_ref loc_list_from_tree (tree, int);
6656 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
6657 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
6658 static tree field_type (const_tree);
6659 static unsigned int simple_type_align_in_bits (const_tree);
6660 static unsigned int simple_decl_align_in_bits (const_tree);
6661 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
6662 static HOST_WIDE_INT field_byte_offset (const_tree);
6663 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
6665 static void add_data_member_location_attribute (dw_die_ref, tree);
6666 static bool add_const_value_attribute (dw_die_ref, rtx);
6667 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
6668 static void insert_double (double_int, unsigned char *);
6669 static void insert_float (const_rtx, unsigned char *);
6670 static rtx rtl_for_decl_location (tree);
6671 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool,
6672 enum dwarf_attribute);
6673 static bool tree_add_const_value_attribute (dw_die_ref, tree);
6674 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
6675 static void add_name_attribute (dw_die_ref, const char *);
6676 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
6677 static void add_comp_dir_attribute (dw_die_ref);
6678 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
6679 static void add_subscript_info (dw_die_ref, tree, bool);
6680 static void add_byte_size_attribute (dw_die_ref, tree);
6681 static void add_bit_offset_attribute (dw_die_ref, tree);
6682 static void add_bit_size_attribute (dw_die_ref, tree);
6683 static void add_prototyped_attribute (dw_die_ref, tree);
6684 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
6685 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
6686 static void add_src_coords_attributes (dw_die_ref, tree);
6687 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
6688 static void push_decl_scope (tree);
6689 static void pop_decl_scope (void);
6690 static dw_die_ref scope_die_for (tree, dw_die_ref);
6691 static inline int local_scope_p (dw_die_ref);
6692 static inline int class_scope_p (dw_die_ref);
6693 static inline int class_or_namespace_scope_p (dw_die_ref);
6694 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
6695 static void add_calling_convention_attribute (dw_die_ref, tree);
6696 static const char *type_tag (const_tree);
6697 static tree member_declared_type (const_tree);
6699 static const char *decl_start_label (tree);
6701 static void gen_array_type_die (tree, dw_die_ref);
6702 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
6704 static void gen_entry_point_die (tree, dw_die_ref);
6706 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
6707 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
6708 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
6709 static void gen_unspecified_parameters_die (tree, dw_die_ref);
6710 static void gen_formal_types_die (tree, dw_die_ref);
6711 static void gen_subprogram_die (tree, dw_die_ref);
6712 static void gen_variable_die (tree, tree, dw_die_ref);
6713 static void gen_const_die (tree, dw_die_ref);
6714 static void gen_label_die (tree, dw_die_ref);
6715 static void gen_lexical_block_die (tree, dw_die_ref, int);
6716 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
6717 static void gen_field_die (tree, dw_die_ref);
6718 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
6719 static dw_die_ref gen_compile_unit_die (const char *);
6720 static void gen_inheritance_die (tree, tree, dw_die_ref);
6721 static void gen_member_die (tree, dw_die_ref);
6722 static void gen_struct_or_union_type_die (tree, dw_die_ref,
6723 enum debug_info_usage);
6724 static void gen_subroutine_type_die (tree, dw_die_ref);
6725 static void gen_typedef_die (tree, dw_die_ref);
6726 static void gen_type_die (tree, dw_die_ref);
6727 static void gen_block_die (tree, dw_die_ref, int);
6728 static void decls_for_scope (tree, dw_die_ref, int);
6729 static inline int is_redundant_typedef (const_tree);
6730 static bool is_naming_typedef_decl (const_tree);
6731 static inline dw_die_ref get_context_die (tree);
6732 static void gen_namespace_die (tree, dw_die_ref);
6733 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
6734 static dw_die_ref force_decl_die (tree);
6735 static dw_die_ref force_type_die (tree);
6736 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
6737 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
6738 static struct dwarf_file_data * lookup_filename (const char *);
6739 static void retry_incomplete_types (void);
6740 static void gen_type_die_for_member (tree, tree, dw_die_ref);
6741 static void gen_generic_params_dies (tree);
6742 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
6743 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
6744 static void splice_child_die (dw_die_ref, dw_die_ref);
6745 static int file_info_cmp (const void *, const void *);
6746 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
6747 const char *, const char *);
6748 static void output_loc_list (dw_loc_list_ref);
6749 static char *gen_internal_sym (const char *);
6751 static void prune_unmark_dies (dw_die_ref);
6752 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
6753 static void prune_unused_types_mark (dw_die_ref, int);
6754 static void prune_unused_types_walk (dw_die_ref);
6755 static void prune_unused_types_walk_attribs (dw_die_ref);
6756 static void prune_unused_types_prune (dw_die_ref);
6757 static void prune_unused_types (void);
6758 static int maybe_emit_file (struct dwarf_file_data *fd);
6759 static inline const char *AT_vms_delta1 (dw_attr_ref);
6760 static inline const char *AT_vms_delta2 (dw_attr_ref);
6761 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
6762 const char *, const char *);
6763 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
6764 static void gen_remaining_tmpl_value_param_die_attribute (void);
6765 static bool generic_type_p (tree);
6766 static void schedule_generic_params_dies_gen (tree t);
6767 static void gen_scheduled_generic_parms_dies (void);
6769 /* Section names used to hold DWARF debugging information. */
6770 #ifndef DEBUG_INFO_SECTION
6771 #define DEBUG_INFO_SECTION ".debug_info"
6773 #ifndef DEBUG_ABBREV_SECTION
6774 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
6776 #ifndef DEBUG_ARANGES_SECTION
6777 #define DEBUG_ARANGES_SECTION ".debug_aranges"
6779 #ifndef DEBUG_MACINFO_SECTION
6780 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
6782 #ifndef DEBUG_LINE_SECTION
6783 #define DEBUG_LINE_SECTION ".debug_line"
6785 #ifndef DEBUG_LOC_SECTION
6786 #define DEBUG_LOC_SECTION ".debug_loc"
6788 #ifndef DEBUG_PUBNAMES_SECTION
6789 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
6791 #ifndef DEBUG_PUBTYPES_SECTION
6792 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
6794 #ifndef DEBUG_STR_SECTION
6795 #define DEBUG_STR_SECTION ".debug_str"
6797 #ifndef DEBUG_RANGES_SECTION
6798 #define DEBUG_RANGES_SECTION ".debug_ranges"
6801 /* Standard ELF section names for compiled code and data. */
6802 #ifndef TEXT_SECTION_NAME
6803 #define TEXT_SECTION_NAME ".text"
6806 /* Section flags for .debug_str section. */
6807 #define DEBUG_STR_SECTION_FLAGS \
6808 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
6809 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
6812 /* Labels we insert at beginning sections we can reference instead of
6813 the section names themselves. */
6815 #ifndef TEXT_SECTION_LABEL
6816 #define TEXT_SECTION_LABEL "Ltext"
6818 #ifndef COLD_TEXT_SECTION_LABEL
6819 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
6821 #ifndef DEBUG_LINE_SECTION_LABEL
6822 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
6824 #ifndef DEBUG_INFO_SECTION_LABEL
6825 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
6827 #ifndef DEBUG_ABBREV_SECTION_LABEL
6828 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
6830 #ifndef DEBUG_LOC_SECTION_LABEL
6831 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
6833 #ifndef DEBUG_RANGES_SECTION_LABEL
6834 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
6836 #ifndef DEBUG_MACINFO_SECTION_LABEL
6837 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
6841 /* Definitions of defaults for formats and names of various special
6842 (artificial) labels which may be generated within this file (when the -g
6843 options is used and DWARF2_DEBUGGING_INFO is in effect.
6844 If necessary, these may be overridden from within the tm.h file, but
6845 typically, overriding these defaults is unnecessary. */
6847 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6848 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6849 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6850 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6851 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6852 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6853 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6854 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6855 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6856 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
6858 #ifndef TEXT_END_LABEL
6859 #define TEXT_END_LABEL "Letext"
6861 #ifndef COLD_END_LABEL
6862 #define COLD_END_LABEL "Letext_cold"
6864 #ifndef BLOCK_BEGIN_LABEL
6865 #define BLOCK_BEGIN_LABEL "LBB"
6867 #ifndef BLOCK_END_LABEL
6868 #define BLOCK_END_LABEL "LBE"
6870 #ifndef LINE_CODE_LABEL
6871 #define LINE_CODE_LABEL "LM"
6875 /* Return the root of the DIE's built for the current compilation unit. */
6877 comp_unit_die (void)
6879 if (!single_comp_unit_die)
6880 single_comp_unit_die = gen_compile_unit_die (NULL);
6881 return single_comp_unit_die;
6884 /* We allow a language front-end to designate a function that is to be
6885 called to "demangle" any name before it is put into a DIE. */
6887 static const char *(*demangle_name_func) (const char *);
6890 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
6892 demangle_name_func = func;
6895 /* Test if rtl node points to a pseudo register. */
6898 is_pseudo_reg (const_rtx rtl)
6900 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
6901 || (GET_CODE (rtl) == SUBREG
6902 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
6905 /* Return a reference to a type, with its const and volatile qualifiers
6909 type_main_variant (tree type)
6911 type = TYPE_MAIN_VARIANT (type);
6913 /* ??? There really should be only one main variant among any group of
6914 variants of a given type (and all of the MAIN_VARIANT values for all
6915 members of the group should point to that one type) but sometimes the C
6916 front-end messes this up for array types, so we work around that bug
6918 if (TREE_CODE (type) == ARRAY_TYPE)
6919 while (type != TYPE_MAIN_VARIANT (type))
6920 type = TYPE_MAIN_VARIANT (type);
6925 /* Return nonzero if the given type node represents a tagged type. */
6928 is_tagged_type (const_tree type)
6930 enum tree_code code = TREE_CODE (type);
6932 return (code == RECORD_TYPE || code == UNION_TYPE
6933 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
6936 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
6939 get_ref_die_offset_label (char *label, dw_die_ref ref)
6941 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
6944 /* Return die_offset of a DIE reference to a base type. */
6946 static unsigned long int
6947 get_base_type_offset (dw_die_ref ref)
6949 if (ref->die_offset)
6950 return ref->die_offset;
6951 if (comp_unit_die ()->die_abbrev)
6953 calc_base_type_die_sizes ();
6954 gcc_assert (ref->die_offset);
6956 return ref->die_offset;
6959 /* Convert a DIE tag into its string name. */
6962 dwarf_tag_name (unsigned int tag)
6966 case DW_TAG_padding:
6967 return "DW_TAG_padding";
6968 case DW_TAG_array_type:
6969 return "DW_TAG_array_type";
6970 case DW_TAG_class_type:
6971 return "DW_TAG_class_type";
6972 case DW_TAG_entry_point:
6973 return "DW_TAG_entry_point";
6974 case DW_TAG_enumeration_type:
6975 return "DW_TAG_enumeration_type";
6976 case DW_TAG_formal_parameter:
6977 return "DW_TAG_formal_parameter";
6978 case DW_TAG_imported_declaration:
6979 return "DW_TAG_imported_declaration";
6981 return "DW_TAG_label";
6982 case DW_TAG_lexical_block:
6983 return "DW_TAG_lexical_block";
6985 return "DW_TAG_member";
6986 case DW_TAG_pointer_type:
6987 return "DW_TAG_pointer_type";
6988 case DW_TAG_reference_type:
6989 return "DW_TAG_reference_type";
6990 case DW_TAG_compile_unit:
6991 return "DW_TAG_compile_unit";
6992 case DW_TAG_string_type:
6993 return "DW_TAG_string_type";
6994 case DW_TAG_structure_type:
6995 return "DW_TAG_structure_type";
6996 case DW_TAG_subroutine_type:
6997 return "DW_TAG_subroutine_type";
6998 case DW_TAG_typedef:
6999 return "DW_TAG_typedef";
7000 case DW_TAG_union_type:
7001 return "DW_TAG_union_type";
7002 case DW_TAG_unspecified_parameters:
7003 return "DW_TAG_unspecified_parameters";
7004 case DW_TAG_variant:
7005 return "DW_TAG_variant";
7006 case DW_TAG_common_block:
7007 return "DW_TAG_common_block";
7008 case DW_TAG_common_inclusion:
7009 return "DW_TAG_common_inclusion";
7010 case DW_TAG_inheritance:
7011 return "DW_TAG_inheritance";
7012 case DW_TAG_inlined_subroutine:
7013 return "DW_TAG_inlined_subroutine";
7015 return "DW_TAG_module";
7016 case DW_TAG_ptr_to_member_type:
7017 return "DW_TAG_ptr_to_member_type";
7018 case DW_TAG_set_type:
7019 return "DW_TAG_set_type";
7020 case DW_TAG_subrange_type:
7021 return "DW_TAG_subrange_type";
7022 case DW_TAG_with_stmt:
7023 return "DW_TAG_with_stmt";
7024 case DW_TAG_access_declaration:
7025 return "DW_TAG_access_declaration";
7026 case DW_TAG_base_type:
7027 return "DW_TAG_base_type";
7028 case DW_TAG_catch_block:
7029 return "DW_TAG_catch_block";
7030 case DW_TAG_const_type:
7031 return "DW_TAG_const_type";
7032 case DW_TAG_constant:
7033 return "DW_TAG_constant";
7034 case DW_TAG_enumerator:
7035 return "DW_TAG_enumerator";
7036 case DW_TAG_file_type:
7037 return "DW_TAG_file_type";
7039 return "DW_TAG_friend";
7040 case DW_TAG_namelist:
7041 return "DW_TAG_namelist";
7042 case DW_TAG_namelist_item:
7043 return "DW_TAG_namelist_item";
7044 case DW_TAG_packed_type:
7045 return "DW_TAG_packed_type";
7046 case DW_TAG_subprogram:
7047 return "DW_TAG_subprogram";
7048 case DW_TAG_template_type_param:
7049 return "DW_TAG_template_type_param";
7050 case DW_TAG_template_value_param:
7051 return "DW_TAG_template_value_param";
7052 case DW_TAG_thrown_type:
7053 return "DW_TAG_thrown_type";
7054 case DW_TAG_try_block:
7055 return "DW_TAG_try_block";
7056 case DW_TAG_variant_part:
7057 return "DW_TAG_variant_part";
7058 case DW_TAG_variable:
7059 return "DW_TAG_variable";
7060 case DW_TAG_volatile_type:
7061 return "DW_TAG_volatile_type";
7062 case DW_TAG_dwarf_procedure:
7063 return "DW_TAG_dwarf_procedure";
7064 case DW_TAG_restrict_type:
7065 return "DW_TAG_restrict_type";
7066 case DW_TAG_interface_type:
7067 return "DW_TAG_interface_type";
7068 case DW_TAG_namespace:
7069 return "DW_TAG_namespace";
7070 case DW_TAG_imported_module:
7071 return "DW_TAG_imported_module";
7072 case DW_TAG_unspecified_type:
7073 return "DW_TAG_unspecified_type";
7074 case DW_TAG_partial_unit:
7075 return "DW_TAG_partial_unit";
7076 case DW_TAG_imported_unit:
7077 return "DW_TAG_imported_unit";
7078 case DW_TAG_condition:
7079 return "DW_TAG_condition";
7080 case DW_TAG_shared_type:
7081 return "DW_TAG_shared_type";
7082 case DW_TAG_type_unit:
7083 return "DW_TAG_type_unit";
7084 case DW_TAG_rvalue_reference_type:
7085 return "DW_TAG_rvalue_reference_type";
7086 case DW_TAG_template_alias:
7087 return "DW_TAG_template_alias";
7088 case DW_TAG_GNU_template_parameter_pack:
7089 return "DW_TAG_GNU_template_parameter_pack";
7090 case DW_TAG_GNU_formal_parameter_pack:
7091 return "DW_TAG_GNU_formal_parameter_pack";
7092 case DW_TAG_MIPS_loop:
7093 return "DW_TAG_MIPS_loop";
7094 case DW_TAG_format_label:
7095 return "DW_TAG_format_label";
7096 case DW_TAG_function_template:
7097 return "DW_TAG_function_template";
7098 case DW_TAG_class_template:
7099 return "DW_TAG_class_template";
7100 case DW_TAG_GNU_BINCL:
7101 return "DW_TAG_GNU_BINCL";
7102 case DW_TAG_GNU_EINCL:
7103 return "DW_TAG_GNU_EINCL";
7104 case DW_TAG_GNU_template_template_param:
7105 return "DW_TAG_GNU_template_template_param";
7106 case DW_TAG_GNU_call_site:
7107 return "DW_TAG_GNU_call_site";
7108 case DW_TAG_GNU_call_site_parameter:
7109 return "DW_TAG_GNU_call_site_parameter";
7111 return "DW_TAG_<unknown>";
7115 /* Convert a DWARF attribute code into its string name. */
7118 dwarf_attr_name (unsigned int attr)
7123 return "DW_AT_sibling";
7124 case DW_AT_location:
7125 return "DW_AT_location";
7127 return "DW_AT_name";
7128 case DW_AT_ordering:
7129 return "DW_AT_ordering";
7130 case DW_AT_subscr_data:
7131 return "DW_AT_subscr_data";
7132 case DW_AT_byte_size:
7133 return "DW_AT_byte_size";
7134 case DW_AT_bit_offset:
7135 return "DW_AT_bit_offset";
7136 case DW_AT_bit_size:
7137 return "DW_AT_bit_size";
7138 case DW_AT_element_list:
7139 return "DW_AT_element_list";
7140 case DW_AT_stmt_list:
7141 return "DW_AT_stmt_list";
7143 return "DW_AT_low_pc";
7145 return "DW_AT_high_pc";
7146 case DW_AT_language:
7147 return "DW_AT_language";
7149 return "DW_AT_member";
7151 return "DW_AT_discr";
7152 case DW_AT_discr_value:
7153 return "DW_AT_discr_value";
7154 case DW_AT_visibility:
7155 return "DW_AT_visibility";
7157 return "DW_AT_import";
7158 case DW_AT_string_length:
7159 return "DW_AT_string_length";
7160 case DW_AT_common_reference:
7161 return "DW_AT_common_reference";
7162 case DW_AT_comp_dir:
7163 return "DW_AT_comp_dir";
7164 case DW_AT_const_value:
7165 return "DW_AT_const_value";
7166 case DW_AT_containing_type:
7167 return "DW_AT_containing_type";
7168 case DW_AT_default_value:
7169 return "DW_AT_default_value";
7171 return "DW_AT_inline";
7172 case DW_AT_is_optional:
7173 return "DW_AT_is_optional";
7174 case DW_AT_lower_bound:
7175 return "DW_AT_lower_bound";
7176 case DW_AT_producer:
7177 return "DW_AT_producer";
7178 case DW_AT_prototyped:
7179 return "DW_AT_prototyped";
7180 case DW_AT_return_addr:
7181 return "DW_AT_return_addr";
7182 case DW_AT_start_scope:
7183 return "DW_AT_start_scope";
7184 case DW_AT_bit_stride:
7185 return "DW_AT_bit_stride";
7186 case DW_AT_upper_bound:
7187 return "DW_AT_upper_bound";
7188 case DW_AT_abstract_origin:
7189 return "DW_AT_abstract_origin";
7190 case DW_AT_accessibility:
7191 return "DW_AT_accessibility";
7192 case DW_AT_address_class:
7193 return "DW_AT_address_class";
7194 case DW_AT_artificial:
7195 return "DW_AT_artificial";
7196 case DW_AT_base_types:
7197 return "DW_AT_base_types";
7198 case DW_AT_calling_convention:
7199 return "DW_AT_calling_convention";
7201 return "DW_AT_count";
7202 case DW_AT_data_member_location:
7203 return "DW_AT_data_member_location";
7204 case DW_AT_decl_column:
7205 return "DW_AT_decl_column";
7206 case DW_AT_decl_file:
7207 return "DW_AT_decl_file";
7208 case DW_AT_decl_line:
7209 return "DW_AT_decl_line";
7210 case DW_AT_declaration:
7211 return "DW_AT_declaration";
7212 case DW_AT_discr_list:
7213 return "DW_AT_discr_list";
7214 case DW_AT_encoding:
7215 return "DW_AT_encoding";
7216 case DW_AT_external:
7217 return "DW_AT_external";
7218 case DW_AT_explicit:
7219 return "DW_AT_explicit";
7220 case DW_AT_frame_base:
7221 return "DW_AT_frame_base";
7223 return "DW_AT_friend";
7224 case DW_AT_identifier_case:
7225 return "DW_AT_identifier_case";
7226 case DW_AT_macro_info:
7227 return "DW_AT_macro_info";
7228 case DW_AT_namelist_items:
7229 return "DW_AT_namelist_items";
7230 case DW_AT_priority:
7231 return "DW_AT_priority";
7233 return "DW_AT_segment";
7234 case DW_AT_specification:
7235 return "DW_AT_specification";
7236 case DW_AT_static_link:
7237 return "DW_AT_static_link";
7239 return "DW_AT_type";
7240 case DW_AT_use_location:
7241 return "DW_AT_use_location";
7242 case DW_AT_variable_parameter:
7243 return "DW_AT_variable_parameter";
7244 case DW_AT_virtuality:
7245 return "DW_AT_virtuality";
7246 case DW_AT_vtable_elem_location:
7247 return "DW_AT_vtable_elem_location";
7249 case DW_AT_allocated:
7250 return "DW_AT_allocated";
7251 case DW_AT_associated:
7252 return "DW_AT_associated";
7253 case DW_AT_data_location:
7254 return "DW_AT_data_location";
7255 case DW_AT_byte_stride:
7256 return "DW_AT_byte_stride";
7257 case DW_AT_entry_pc:
7258 return "DW_AT_entry_pc";
7259 case DW_AT_use_UTF8:
7260 return "DW_AT_use_UTF8";
7261 case DW_AT_extension:
7262 return "DW_AT_extension";
7264 return "DW_AT_ranges";
7265 case DW_AT_trampoline:
7266 return "DW_AT_trampoline";
7267 case DW_AT_call_column:
7268 return "DW_AT_call_column";
7269 case DW_AT_call_file:
7270 return "DW_AT_call_file";
7271 case DW_AT_call_line:
7272 return "DW_AT_call_line";
7273 case DW_AT_object_pointer:
7274 return "DW_AT_object_pointer";
7276 case DW_AT_signature:
7277 return "DW_AT_signature";
7278 case DW_AT_main_subprogram:
7279 return "DW_AT_main_subprogram";
7280 case DW_AT_data_bit_offset:
7281 return "DW_AT_data_bit_offset";
7282 case DW_AT_const_expr:
7283 return "DW_AT_const_expr";
7284 case DW_AT_enum_class:
7285 return "DW_AT_enum_class";
7286 case DW_AT_linkage_name:
7287 return "DW_AT_linkage_name";
7289 case DW_AT_MIPS_fde:
7290 return "DW_AT_MIPS_fde";
7291 case DW_AT_MIPS_loop_begin:
7292 return "DW_AT_MIPS_loop_begin";
7293 case DW_AT_MIPS_tail_loop_begin:
7294 return "DW_AT_MIPS_tail_loop_begin";
7295 case DW_AT_MIPS_epilog_begin:
7296 return "DW_AT_MIPS_epilog_begin";
7297 #if VMS_DEBUGGING_INFO
7298 case DW_AT_HP_prologue:
7299 return "DW_AT_HP_prologue";
7301 case DW_AT_MIPS_loop_unroll_factor:
7302 return "DW_AT_MIPS_loop_unroll_factor";
7304 case DW_AT_MIPS_software_pipeline_depth:
7305 return "DW_AT_MIPS_software_pipeline_depth";
7306 case DW_AT_MIPS_linkage_name:
7307 return "DW_AT_MIPS_linkage_name";
7308 #if VMS_DEBUGGING_INFO
7309 case DW_AT_HP_epilogue:
7310 return "DW_AT_HP_epilogue";
7312 case DW_AT_MIPS_stride:
7313 return "DW_AT_MIPS_stride";
7315 case DW_AT_MIPS_abstract_name:
7316 return "DW_AT_MIPS_abstract_name";
7317 case DW_AT_MIPS_clone_origin:
7318 return "DW_AT_MIPS_clone_origin";
7319 case DW_AT_MIPS_has_inlines:
7320 return "DW_AT_MIPS_has_inlines";
7322 case DW_AT_sf_names:
7323 return "DW_AT_sf_names";
7324 case DW_AT_src_info:
7325 return "DW_AT_src_info";
7326 case DW_AT_mac_info:
7327 return "DW_AT_mac_info";
7328 case DW_AT_src_coords:
7329 return "DW_AT_src_coords";
7330 case DW_AT_body_begin:
7331 return "DW_AT_body_begin";
7332 case DW_AT_body_end:
7333 return "DW_AT_body_end";
7335 case DW_AT_GNU_vector:
7336 return "DW_AT_GNU_vector";
7337 case DW_AT_GNU_guarded_by:
7338 return "DW_AT_GNU_guarded_by";
7339 case DW_AT_GNU_pt_guarded_by:
7340 return "DW_AT_GNU_pt_guarded_by";
7341 case DW_AT_GNU_guarded:
7342 return "DW_AT_GNU_guarded";
7343 case DW_AT_GNU_pt_guarded:
7344 return "DW_AT_GNU_pt_guarded";
7345 case DW_AT_GNU_locks_excluded:
7346 return "DW_AT_GNU_locks_excluded";
7347 case DW_AT_GNU_exclusive_locks_required:
7348 return "DW_AT_GNU_exclusive_locks_required";
7349 case DW_AT_GNU_shared_locks_required:
7350 return "DW_AT_GNU_shared_locks_required";
7351 case DW_AT_GNU_odr_signature:
7352 return "DW_AT_GNU_odr_signature";
7353 case DW_AT_GNU_template_name:
7354 return "DW_AT_GNU_template_name";
7355 case DW_AT_GNU_call_site_value:
7356 return "DW_AT_GNU_call_site_value";
7357 case DW_AT_GNU_call_site_data_value:
7358 return "DW_AT_GNU_call_site_data_value";
7359 case DW_AT_GNU_call_site_target:
7360 return "DW_AT_GNU_call_site_target";
7361 case DW_AT_GNU_call_site_target_clobbered:
7362 return "DW_AT_GNU_call_site_target_clobbered";
7363 case DW_AT_GNU_tail_call:
7364 return "DW_AT_GNU_tail_call";
7365 case DW_AT_GNU_all_tail_call_sites:
7366 return "DW_AT_GNU_all_tail_call_sites";
7367 case DW_AT_GNU_all_call_sites:
7368 return "DW_AT_GNU_all_call_sites";
7369 case DW_AT_GNU_all_source_call_sites:
7370 return "DW_AT_GNU_all_source_call_sites";
7372 case DW_AT_GNAT_descriptive_type:
7373 return "DW_AT_GNAT_descriptive_type";
7375 case DW_AT_VMS_rtnbeg_pd_address:
7376 return "DW_AT_VMS_rtnbeg_pd_address";
7379 return "DW_AT_<unknown>";
7383 /* Convert a DWARF value form code into its string name. */
7386 dwarf_form_name (unsigned int form)
7391 return "DW_FORM_addr";
7392 case DW_FORM_block2:
7393 return "DW_FORM_block2";
7394 case DW_FORM_block4:
7395 return "DW_FORM_block4";
7397 return "DW_FORM_data2";
7399 return "DW_FORM_data4";
7401 return "DW_FORM_data8";
7402 case DW_FORM_string:
7403 return "DW_FORM_string";
7405 return "DW_FORM_block";
7406 case DW_FORM_block1:
7407 return "DW_FORM_block1";
7409 return "DW_FORM_data1";
7411 return "DW_FORM_flag";
7413 return "DW_FORM_sdata";
7415 return "DW_FORM_strp";
7417 return "DW_FORM_udata";
7418 case DW_FORM_ref_addr:
7419 return "DW_FORM_ref_addr";
7421 return "DW_FORM_ref1";
7423 return "DW_FORM_ref2";
7425 return "DW_FORM_ref4";
7427 return "DW_FORM_ref8";
7428 case DW_FORM_ref_udata:
7429 return "DW_FORM_ref_udata";
7430 case DW_FORM_indirect:
7431 return "DW_FORM_indirect";
7432 case DW_FORM_sec_offset:
7433 return "DW_FORM_sec_offset";
7434 case DW_FORM_exprloc:
7435 return "DW_FORM_exprloc";
7436 case DW_FORM_flag_present:
7437 return "DW_FORM_flag_present";
7438 case DW_FORM_ref_sig8:
7439 return "DW_FORM_ref_sig8";
7441 return "DW_FORM_<unknown>";
7445 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
7446 instance of an inlined instance of a decl which is local to an inline
7447 function, so we have to trace all of the way back through the origin chain
7448 to find out what sort of node actually served as the original seed for the
7452 decl_ultimate_origin (const_tree decl)
7454 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
7457 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
7458 nodes in the function to point to themselves; ignore that if
7459 we're trying to output the abstract instance of this function. */
7460 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
7463 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
7464 most distant ancestor, this should never happen. */
7465 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
7467 return DECL_ABSTRACT_ORIGIN (decl);
7470 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
7471 of a virtual function may refer to a base class, so we check the 'this'
7475 decl_class_context (tree decl)
7477 tree context = NULL_TREE;
7479 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
7480 context = DECL_CONTEXT (decl);
7482 context = TYPE_MAIN_VARIANT
7483 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
7485 if (context && !TYPE_P (context))
7486 context = NULL_TREE;
7491 /* Add an attribute/value pair to a DIE. */
7494 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
7496 /* Maybe this should be an assert? */
7500 if (die->die_attr == NULL)
7501 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
7502 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
7505 static inline enum dw_val_class
7506 AT_class (dw_attr_ref a)
7508 return a->dw_attr_val.val_class;
7511 /* Add a flag value attribute to a DIE. */
7514 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
7518 attr.dw_attr = attr_kind;
7519 attr.dw_attr_val.val_class = dw_val_class_flag;
7520 attr.dw_attr_val.v.val_flag = flag;
7521 add_dwarf_attr (die, &attr);
7524 static inline unsigned
7525 AT_flag (dw_attr_ref a)
7527 gcc_assert (a && AT_class (a) == dw_val_class_flag);
7528 return a->dw_attr_val.v.val_flag;
7531 /* Add a signed integer attribute value to a DIE. */
7534 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
7538 attr.dw_attr = attr_kind;
7539 attr.dw_attr_val.val_class = dw_val_class_const;
7540 attr.dw_attr_val.v.val_int = int_val;
7541 add_dwarf_attr (die, &attr);
7544 static inline HOST_WIDE_INT
7545 AT_int (dw_attr_ref a)
7547 gcc_assert (a && AT_class (a) == dw_val_class_const);
7548 return a->dw_attr_val.v.val_int;
7551 /* Add an unsigned integer attribute value to a DIE. */
7554 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
7555 unsigned HOST_WIDE_INT unsigned_val)
7559 attr.dw_attr = attr_kind;
7560 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
7561 attr.dw_attr_val.v.val_unsigned = unsigned_val;
7562 add_dwarf_attr (die, &attr);
7565 static inline unsigned HOST_WIDE_INT
7566 AT_unsigned (dw_attr_ref a)
7568 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
7569 return a->dw_attr_val.v.val_unsigned;
7572 /* Add an unsigned double integer attribute value to a DIE. */
7575 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
7576 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
7580 attr.dw_attr = attr_kind;
7581 attr.dw_attr_val.val_class = dw_val_class_const_double;
7582 attr.dw_attr_val.v.val_double.high = high;
7583 attr.dw_attr_val.v.val_double.low = low;
7584 add_dwarf_attr (die, &attr);
7587 /* Add a floating point attribute value to a DIE and return it. */
7590 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
7591 unsigned int length, unsigned int elt_size, unsigned char *array)
7595 attr.dw_attr = attr_kind;
7596 attr.dw_attr_val.val_class = dw_val_class_vec;
7597 attr.dw_attr_val.v.val_vec.length = length;
7598 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
7599 attr.dw_attr_val.v.val_vec.array = array;
7600 add_dwarf_attr (die, &attr);
7603 /* Add an 8-byte data attribute value to a DIE. */
7606 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
7607 unsigned char data8[8])
7611 attr.dw_attr = attr_kind;
7612 attr.dw_attr_val.val_class = dw_val_class_data8;
7613 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
7614 add_dwarf_attr (die, &attr);
7617 /* Hash and equality functions for debug_str_hash. */
7620 debug_str_do_hash (const void *x)
7622 return htab_hash_string (((const struct indirect_string_node *)x)->str);
7626 debug_str_eq (const void *x1, const void *x2)
7628 return strcmp ((((const struct indirect_string_node *)x1)->str),
7629 (const char *)x2) == 0;
7632 /* Add STR to the indirect string hash table. */
7634 static struct indirect_string_node *
7635 find_AT_string (const char *str)
7637 struct indirect_string_node *node;
7640 if (! debug_str_hash)
7641 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
7642 debug_str_eq, NULL);
7644 slot = htab_find_slot_with_hash (debug_str_hash, str,
7645 htab_hash_string (str), INSERT);
7648 node = ggc_alloc_cleared_indirect_string_node ();
7649 node->str = ggc_strdup (str);
7653 node = (struct indirect_string_node *) *slot;
7659 /* Add a string attribute value to a DIE. */
7662 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
7665 struct indirect_string_node *node;
7667 node = find_AT_string (str);
7669 attr.dw_attr = attr_kind;
7670 attr.dw_attr_val.val_class = dw_val_class_str;
7671 attr.dw_attr_val.v.val_str = node;
7672 add_dwarf_attr (die, &attr);
7675 static inline const char *
7676 AT_string (dw_attr_ref a)
7678 gcc_assert (a && AT_class (a) == dw_val_class_str);
7679 return a->dw_attr_val.v.val_str->str;
7682 /* Find out whether a string should be output inline in DIE
7683 or out-of-line in .debug_str section. */
7685 static enum dwarf_form
7686 AT_string_form (dw_attr_ref a)
7688 struct indirect_string_node *node;
7692 gcc_assert (a && AT_class (a) == dw_val_class_str);
7694 node = a->dw_attr_val.v.val_str;
7698 len = strlen (node->str) + 1;
7700 /* If the string is shorter or equal to the size of the reference, it is
7701 always better to put it inline. */
7702 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
7703 return node->form = DW_FORM_string;
7705 /* If we cannot expect the linker to merge strings in .debug_str
7706 section, only put it into .debug_str if it is worth even in this
7708 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
7709 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
7710 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
7711 return node->form = DW_FORM_string;
7713 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
7714 ++dw2_string_counter;
7715 node->label = xstrdup (label);
7717 return node->form = DW_FORM_strp;
7720 /* Add a DIE reference attribute value to a DIE. */
7723 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
7727 #ifdef ENABLE_CHECKING
7728 gcc_assert (targ_die != NULL);
7730 /* With LTO we can end up trying to reference something we didn't create
7731 a DIE for. Avoid crashing later on a NULL referenced DIE. */
7732 if (targ_die == NULL)
7736 attr.dw_attr = attr_kind;
7737 attr.dw_attr_val.val_class = dw_val_class_die_ref;
7738 attr.dw_attr_val.v.val_die_ref.die = targ_die;
7739 attr.dw_attr_val.v.val_die_ref.external = 0;
7740 add_dwarf_attr (die, &attr);
7743 /* Add an AT_specification attribute to a DIE, and also make the back
7744 pointer from the specification to the definition. */
7747 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
7749 add_AT_die_ref (die, DW_AT_specification, targ_die);
7750 gcc_assert (!targ_die->die_definition);
7751 targ_die->die_definition = die;
7754 static inline dw_die_ref
7755 AT_ref (dw_attr_ref a)
7757 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7758 return a->dw_attr_val.v.val_die_ref.die;
7762 AT_ref_external (dw_attr_ref a)
7764 if (a && AT_class (a) == dw_val_class_die_ref)
7765 return a->dw_attr_val.v.val_die_ref.external;
7771 set_AT_ref_external (dw_attr_ref a, int i)
7773 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7774 a->dw_attr_val.v.val_die_ref.external = i;
7777 /* Add an FDE reference attribute value to a DIE. */
7780 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
7784 attr.dw_attr = attr_kind;
7785 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
7786 attr.dw_attr_val.v.val_fde_index = targ_fde;
7787 add_dwarf_attr (die, &attr);
7790 /* Add a location description attribute value to a DIE. */
7793 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
7797 attr.dw_attr = attr_kind;
7798 attr.dw_attr_val.val_class = dw_val_class_loc;
7799 attr.dw_attr_val.v.val_loc = loc;
7800 add_dwarf_attr (die, &attr);
7803 static inline dw_loc_descr_ref
7804 AT_loc (dw_attr_ref a)
7806 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7807 return a->dw_attr_val.v.val_loc;
7811 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
7815 attr.dw_attr = attr_kind;
7816 attr.dw_attr_val.val_class = dw_val_class_loc_list;
7817 attr.dw_attr_val.v.val_loc_list = loc_list;
7818 add_dwarf_attr (die, &attr);
7819 have_location_lists = true;
7822 static inline dw_loc_list_ref
7823 AT_loc_list (dw_attr_ref a)
7825 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7826 return a->dw_attr_val.v.val_loc_list;
7829 static inline dw_loc_list_ref *
7830 AT_loc_list_ptr (dw_attr_ref a)
7832 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7833 return &a->dw_attr_val.v.val_loc_list;
7836 /* Add an address constant attribute value to a DIE. */
7839 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
7843 attr.dw_attr = attr_kind;
7844 attr.dw_attr_val.val_class = dw_val_class_addr;
7845 attr.dw_attr_val.v.val_addr = addr;
7846 add_dwarf_attr (die, &attr);
7849 /* Get the RTX from to an address DIE attribute. */
7852 AT_addr (dw_attr_ref a)
7854 gcc_assert (a && AT_class (a) == dw_val_class_addr);
7855 return a->dw_attr_val.v.val_addr;
7858 /* Add a file attribute value to a DIE. */
7861 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
7862 struct dwarf_file_data *fd)
7866 attr.dw_attr = attr_kind;
7867 attr.dw_attr_val.val_class = dw_val_class_file;
7868 attr.dw_attr_val.v.val_file = fd;
7869 add_dwarf_attr (die, &attr);
7872 /* Get the dwarf_file_data from a file DIE attribute. */
7874 static inline struct dwarf_file_data *
7875 AT_file (dw_attr_ref a)
7877 gcc_assert (a && AT_class (a) == dw_val_class_file);
7878 return a->dw_attr_val.v.val_file;
7881 /* Add a vms delta attribute value to a DIE. */
7884 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
7885 const char *lbl1, const char *lbl2)
7889 attr.dw_attr = attr_kind;
7890 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
7891 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
7892 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
7893 add_dwarf_attr (die, &attr);
7896 /* Add a label identifier attribute value to a DIE. */
7899 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
7903 attr.dw_attr = attr_kind;
7904 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
7905 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
7906 add_dwarf_attr (die, &attr);
7909 /* Add a section offset attribute value to a DIE, an offset into the
7910 debug_line section. */
7913 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7918 attr.dw_attr = attr_kind;
7919 attr.dw_attr_val.val_class = dw_val_class_lineptr;
7920 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7921 add_dwarf_attr (die, &attr);
7924 /* Add a section offset attribute value to a DIE, an offset into the
7925 debug_macinfo section. */
7928 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7933 attr.dw_attr = attr_kind;
7934 attr.dw_attr_val.val_class = dw_val_class_macptr;
7935 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7936 add_dwarf_attr (die, &attr);
7939 /* Add an offset attribute value to a DIE. */
7942 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
7943 unsigned HOST_WIDE_INT offset)
7947 attr.dw_attr = attr_kind;
7948 attr.dw_attr_val.val_class = dw_val_class_offset;
7949 attr.dw_attr_val.v.val_offset = offset;
7950 add_dwarf_attr (die, &attr);
7953 /* Add an range_list attribute value to a DIE. */
7956 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
7957 long unsigned int offset)
7961 attr.dw_attr = attr_kind;
7962 attr.dw_attr_val.val_class = dw_val_class_range_list;
7963 attr.dw_attr_val.v.val_offset = offset;
7964 add_dwarf_attr (die, &attr);
7967 /* Return the start label of a delta attribute. */
7969 static inline const char *
7970 AT_vms_delta1 (dw_attr_ref a)
7972 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
7973 return a->dw_attr_val.v.val_vms_delta.lbl1;
7976 /* Return the end label of a delta attribute. */
7978 static inline const char *
7979 AT_vms_delta2 (dw_attr_ref a)
7981 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
7982 return a->dw_attr_val.v.val_vms_delta.lbl2;
7985 static inline const char *
7986 AT_lbl (dw_attr_ref a)
7988 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
7989 || AT_class (a) == dw_val_class_lineptr
7990 || AT_class (a) == dw_val_class_macptr));
7991 return a->dw_attr_val.v.val_lbl_id;
7994 /* Get the attribute of type attr_kind. */
7997 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
8001 dw_die_ref spec = NULL;
8006 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
8007 if (a->dw_attr == attr_kind)
8009 else if (a->dw_attr == DW_AT_specification
8010 || a->dw_attr == DW_AT_abstract_origin)
8014 return get_AT (spec, attr_kind);
8019 /* Return the "low pc" attribute value, typically associated with a subprogram
8020 DIE. Return null if the "low pc" attribute is either not present, or if it
8021 cannot be represented as an assembler label identifier. */
8023 static inline const char *
8024 get_AT_low_pc (dw_die_ref die)
8026 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
8028 return a ? AT_lbl (a) : NULL;
8031 /* Return the "high pc" attribute value, typically associated with a subprogram
8032 DIE. Return null if the "high pc" attribute is either not present, or if it
8033 cannot be represented as an assembler label identifier. */
8035 static inline const char *
8036 get_AT_hi_pc (dw_die_ref die)
8038 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
8040 return a ? AT_lbl (a) : NULL;
8043 /* Return the value of the string attribute designated by ATTR_KIND, or
8044 NULL if it is not present. */
8046 static inline const char *
8047 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
8049 dw_attr_ref a = get_AT (die, attr_kind);
8051 return a ? AT_string (a) : NULL;
8054 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
8055 if it is not present. */
8058 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
8060 dw_attr_ref a = get_AT (die, attr_kind);
8062 return a ? AT_flag (a) : 0;
8065 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
8066 if it is not present. */
8068 static inline unsigned
8069 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
8071 dw_attr_ref a = get_AT (die, attr_kind);
8073 return a ? AT_unsigned (a) : 0;
8076 static inline dw_die_ref
8077 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
8079 dw_attr_ref a = get_AT (die, attr_kind);
8081 return a ? AT_ref (a) : NULL;
8084 static inline struct dwarf_file_data *
8085 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
8087 dw_attr_ref a = get_AT (die, attr_kind);
8089 return a ? AT_file (a) : NULL;
8092 /* Return TRUE if the language is C++. */
8097 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
8099 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
8102 /* Return TRUE if the language is Fortran. */
8107 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
8109 return (lang == DW_LANG_Fortran77
8110 || lang == DW_LANG_Fortran90
8111 || lang == DW_LANG_Fortran95);
8114 /* Return TRUE if the language is Ada. */
8119 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
8121 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
8124 /* Remove the specified attribute if present. */
8127 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
8135 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
8136 if (a->dw_attr == attr_kind)
8138 if (AT_class (a) == dw_val_class_str)
8139 if (a->dw_attr_val.v.val_str->refcount)
8140 a->dw_attr_val.v.val_str->refcount--;
8142 /* VEC_ordered_remove should help reduce the number of abbrevs
8144 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
8149 /* Remove CHILD from its parent. PREV must have the property that
8150 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
8153 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
8155 gcc_assert (child->die_parent == prev->die_parent);
8156 gcc_assert (prev->die_sib == child);
8159 gcc_assert (child->die_parent->die_child == child);
8163 prev->die_sib = child->die_sib;
8164 if (child->die_parent->die_child == child)
8165 child->die_parent->die_child = prev;
8168 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
8169 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
8172 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
8174 dw_die_ref parent = old_child->die_parent;
8176 gcc_assert (parent == prev->die_parent);
8177 gcc_assert (prev->die_sib == old_child);
8179 new_child->die_parent = parent;
8180 if (prev == old_child)
8182 gcc_assert (parent->die_child == old_child);
8183 new_child->die_sib = new_child;
8187 prev->die_sib = new_child;
8188 new_child->die_sib = old_child->die_sib;
8190 if (old_child->die_parent->die_child == old_child)
8191 old_child->die_parent->die_child = new_child;
8194 /* Move all children from OLD_PARENT to NEW_PARENT. */
8197 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
8200 new_parent->die_child = old_parent->die_child;
8201 old_parent->die_child = NULL;
8202 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
8205 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
8209 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
8215 dw_die_ref prev = c;
8217 while (c->die_tag == tag)
8219 remove_child_with_prev (c, prev);
8220 /* Might have removed every child. */
8221 if (c == c->die_sib)
8225 } while (c != die->die_child);
8228 /* Add a CHILD_DIE as the last child of DIE. */
8231 add_child_die (dw_die_ref die, dw_die_ref child_die)
8233 /* FIXME this should probably be an assert. */
8234 if (! die || ! child_die)
8236 gcc_assert (die != child_die);
8238 child_die->die_parent = die;
8241 child_die->die_sib = die->die_child->die_sib;
8242 die->die_child->die_sib = child_die;
8245 child_die->die_sib = child_die;
8246 die->die_child = child_die;
8249 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
8250 is the specification, to the end of PARENT's list of children.
8251 This is done by removing and re-adding it. */
8254 splice_child_die (dw_die_ref parent, dw_die_ref child)
8258 /* We want the declaration DIE from inside the class, not the
8259 specification DIE at toplevel. */
8260 if (child->die_parent != parent)
8262 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
8268 gcc_assert (child->die_parent == parent
8269 || (child->die_parent
8270 == get_AT_ref (parent, DW_AT_specification)));
8272 for (p = child->die_parent->die_child; ; p = p->die_sib)
8273 if (p->die_sib == child)
8275 remove_child_with_prev (child, p);
8279 add_child_die (parent, child);
8282 /* Return a pointer to a newly created DIE node. */
8284 static inline dw_die_ref
8285 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
8287 dw_die_ref die = ggc_alloc_cleared_die_node ();
8289 die->die_tag = tag_value;
8291 if (parent_die != NULL)
8292 add_child_die (parent_die, die);
8295 limbo_die_node *limbo_node;
8297 limbo_node = ggc_alloc_cleared_limbo_die_node ();
8298 limbo_node->die = die;
8299 limbo_node->created_for = t;
8300 limbo_node->next = limbo_die_list;
8301 limbo_die_list = limbo_node;
8307 /* Return the DIE associated with the given type specifier. */
8309 static inline dw_die_ref
8310 lookup_type_die (tree type)
8312 return TYPE_SYMTAB_DIE (type);
8315 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
8316 anonymous type named by the typedef TYPE_DIE, return the DIE of the
8317 anonymous type instead the one of the naming typedef. */
8319 static inline dw_die_ref
8320 strip_naming_typedef (tree type, dw_die_ref type_die)
8323 && TREE_CODE (type) == RECORD_TYPE
8325 && type_die->die_tag == DW_TAG_typedef
8326 && is_naming_typedef_decl (TYPE_NAME (type)))
8327 type_die = get_AT_ref (type_die, DW_AT_type);
8331 /* Like lookup_type_die, but if type is an anonymous type named by a
8332 typedef[1], return the DIE of the anonymous type instead the one of
8333 the naming typedef. This is because in gen_typedef_die, we did
8334 equate the anonymous struct named by the typedef with the DIE of
8335 the naming typedef. So by default, lookup_type_die on an anonymous
8336 struct yields the DIE of the naming typedef.
8338 [1]: Read the comment of is_naming_typedef_decl to learn about what
8339 a naming typedef is. */
8341 static inline dw_die_ref
8342 lookup_type_die_strip_naming_typedef (tree type)
8344 dw_die_ref die = lookup_type_die (type);
8345 return strip_naming_typedef (type, die);
8348 /* Equate a DIE to a given type specifier. */
8351 equate_type_number_to_die (tree type, dw_die_ref type_die)
8353 TYPE_SYMTAB_DIE (type) = type_die;
8356 /* Returns a hash value for X (which really is a die_struct). */
8359 decl_die_table_hash (const void *x)
8361 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
8364 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
8367 decl_die_table_eq (const void *x, const void *y)
8369 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
8372 /* Return the DIE associated with a given declaration. */
8374 static inline dw_die_ref
8375 lookup_decl_die (tree decl)
8377 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
8380 /* Returns a hash value for X (which really is a var_loc_list). */
8383 decl_loc_table_hash (const void *x)
8385 return (hashval_t) ((const var_loc_list *) x)->decl_id;
8388 /* Return nonzero if decl_id of var_loc_list X is the same as
8392 decl_loc_table_eq (const void *x, const void *y)
8394 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
8397 /* Return the var_loc list associated with a given declaration. */
8399 static inline var_loc_list *
8400 lookup_decl_loc (const_tree decl)
8402 if (!decl_loc_table)
8404 return (var_loc_list *)
8405 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
8408 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
8411 cached_dw_loc_list_table_hash (const void *x)
8413 return (hashval_t) ((const cached_dw_loc_list *) x)->decl_id;
8416 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
8420 cached_dw_loc_list_table_eq (const void *x, const void *y)
8422 return (((const cached_dw_loc_list *) x)->decl_id
8423 == DECL_UID ((const_tree) y));
8426 /* Equate a DIE to a particular declaration. */
8429 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
8431 unsigned int decl_id = DECL_UID (decl);
8434 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
8436 decl_die->decl_id = decl_id;
8439 /* Return how many bits covers PIECE EXPR_LIST. */
8442 decl_piece_bitsize (rtx piece)
8444 int ret = (int) GET_MODE (piece);
8447 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
8448 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
8449 return INTVAL (XEXP (XEXP (piece, 0), 0));
8452 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
8455 decl_piece_varloc_ptr (rtx piece)
8457 if ((int) GET_MODE (piece))
8458 return &XEXP (piece, 0);
8460 return &XEXP (XEXP (piece, 0), 1);
8463 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
8464 Next is the chain of following piece nodes. */
8467 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
8469 if (bitsize <= (int) MAX_MACHINE_MODE)
8470 return alloc_EXPR_LIST (bitsize, loc_note, next);
8472 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
8477 /* Return rtx that should be stored into loc field for
8478 LOC_NOTE and BITPOS/BITSIZE. */
8481 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
8482 HOST_WIDE_INT bitsize)
8486 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
8488 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
8493 /* This function either modifies location piece list *DEST in
8494 place (if SRC and INNER is NULL), or copies location piece list
8495 *SRC to *DEST while modifying it. Location BITPOS is modified
8496 to contain LOC_NOTE, any pieces overlapping it are removed resp.
8497 not copied and if needed some padding around it is added.
8498 When modifying in place, DEST should point to EXPR_LIST where
8499 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
8500 to the start of the whole list and INNER points to the EXPR_LIST
8501 where earlier pieces cover PIECE_BITPOS bits. */
8504 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
8505 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
8506 HOST_WIDE_INT bitsize, rtx loc_note)
8509 bool copy = inner != NULL;
8513 /* First copy all nodes preceeding the current bitpos. */
8514 while (src != inner)
8516 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
8517 decl_piece_bitsize (*src), NULL_RTX);
8518 dest = &XEXP (*dest, 1);
8519 src = &XEXP (*src, 1);
8522 /* Add padding if needed. */
8523 if (bitpos != piece_bitpos)
8525 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
8526 copy ? NULL_RTX : *dest);
8527 dest = &XEXP (*dest, 1);
8529 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
8532 /* A piece with correct bitpos and bitsize already exist,
8533 just update the location for it and return. */
8534 *decl_piece_varloc_ptr (*dest) = loc_note;
8537 /* Add the piece that changed. */
8538 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
8539 dest = &XEXP (*dest, 1);
8540 /* Skip over pieces that overlap it. */
8541 diff = bitpos - piece_bitpos + bitsize;
8544 while (diff > 0 && *src)
8547 diff -= decl_piece_bitsize (piece);
8549 src = &XEXP (piece, 1);
8552 *src = XEXP (piece, 1);
8553 free_EXPR_LIST_node (piece);
8556 /* Add padding if needed. */
8557 if (diff < 0 && *src)
8561 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
8562 dest = &XEXP (*dest, 1);
8566 /* Finally copy all nodes following it. */
8569 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
8570 decl_piece_bitsize (*src), NULL_RTX);
8571 dest = &XEXP (*dest, 1);
8572 src = &XEXP (*src, 1);
8576 /* Add a variable location node to the linked list for DECL. */
8578 static struct var_loc_node *
8579 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label)
8581 unsigned int decl_id;
8584 struct var_loc_node *loc = NULL;
8585 HOST_WIDE_INT bitsize = -1, bitpos = -1;
8587 if (DECL_DEBUG_EXPR_IS_FROM (decl))
8589 tree realdecl = DECL_DEBUG_EXPR (decl);
8590 if (realdecl && handled_component_p (realdecl))
8592 HOST_WIDE_INT maxsize;
8595 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize);
8596 if (!DECL_P (innerdecl)
8597 || DECL_IGNORED_P (innerdecl)
8598 || TREE_STATIC (innerdecl)
8600 || bitpos + bitsize > 256
8601 || bitsize != maxsize)
8607 decl_id = DECL_UID (decl);
8608 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
8611 temp = ggc_alloc_cleared_var_loc_list ();
8612 temp->decl_id = decl_id;
8616 temp = (var_loc_list *) *slot;
8620 struct var_loc_node *last = temp->last, *unused = NULL;
8621 rtx *piece_loc = NULL, last_loc_note;
8622 int piece_bitpos = 0;
8626 gcc_assert (last->next == NULL);
8628 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
8630 piece_loc = &last->loc;
8633 int cur_bitsize = decl_piece_bitsize (*piece_loc);
8634 if (piece_bitpos + cur_bitsize > bitpos)
8636 piece_bitpos += cur_bitsize;
8637 piece_loc = &XEXP (*piece_loc, 1);
8641 /* TEMP->LAST here is either pointer to the last but one or
8642 last element in the chained list, LAST is pointer to the
8644 if (label && strcmp (last->label, label) == 0)
8646 /* For SRA optimized variables if there weren't any real
8647 insns since last note, just modify the last node. */
8648 if (piece_loc != NULL)
8650 adjust_piece_list (piece_loc, NULL, NULL,
8651 bitpos, piece_bitpos, bitsize, loc_note);
8654 /* If the last note doesn't cover any instructions, remove it. */
8655 if (temp->last != last)
8657 temp->last->next = NULL;
8660 gcc_assert (strcmp (last->label, label) != 0);
8664 gcc_assert (temp->first == temp->last);
8665 memset (temp->last, '\0', sizeof (*temp->last));
8666 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
8670 if (bitsize == -1 && NOTE_P (last->loc))
8671 last_loc_note = last->loc;
8672 else if (piece_loc != NULL
8673 && *piece_loc != NULL_RTX
8674 && piece_bitpos == bitpos
8675 && decl_piece_bitsize (*piece_loc) == bitsize)
8676 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
8678 last_loc_note = NULL_RTX;
8679 /* If the current location is the same as the end of the list,
8680 and either both or neither of the locations is uninitialized,
8681 we have nothing to do. */
8682 if (last_loc_note == NULL_RTX
8683 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
8684 NOTE_VAR_LOCATION_LOC (loc_note)))
8685 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
8686 != NOTE_VAR_LOCATION_STATUS (loc_note))
8687 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
8688 == VAR_INIT_STATUS_UNINITIALIZED)
8689 || (NOTE_VAR_LOCATION_STATUS (loc_note)
8690 == VAR_INIT_STATUS_UNINITIALIZED))))
8692 /* Add LOC to the end of list and update LAST. If the last
8693 element of the list has been removed above, reuse its
8694 memory for the new node, otherwise allocate a new one. */
8698 memset (loc, '\0', sizeof (*loc));
8701 loc = ggc_alloc_cleared_var_loc_node ();
8702 if (bitsize == -1 || piece_loc == NULL)
8703 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
8705 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
8706 bitpos, piece_bitpos, bitsize, loc_note);
8708 /* Ensure TEMP->LAST will point either to the new last but one
8709 element of the chain, or to the last element in it. */
8710 if (last != temp->last)
8718 loc = ggc_alloc_cleared_var_loc_node ();
8721 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
8726 /* Keep track of the number of spaces used to indent the
8727 output of the debugging routines that print the structure of
8728 the DIE internal representation. */
8729 static int print_indent;
8731 /* Indent the line the number of spaces given by print_indent. */
8734 print_spaces (FILE *outfile)
8736 fprintf (outfile, "%*s", print_indent, "");
8739 /* Print a type signature in hex. */
8742 print_signature (FILE *outfile, char *sig)
8746 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8747 fprintf (outfile, "%02x", sig[i] & 0xff);
8750 /* Print the information associated with a given DIE, and its children.
8751 This routine is a debugging aid only. */
8754 print_die (dw_die_ref die, FILE *outfile)
8760 print_spaces (outfile);
8761 fprintf (outfile, "DIE %4ld: %s (%p)\n",
8762 die->die_offset, dwarf_tag_name (die->die_tag),
8764 print_spaces (outfile);
8765 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
8766 fprintf (outfile, " offset: %ld", die->die_offset);
8767 fprintf (outfile, " mark: %d\n", die->die_mark);
8769 if (use_debug_types && die->die_id.die_type_node)
8771 print_spaces (outfile);
8772 fprintf (outfile, " signature: ");
8773 print_signature (outfile, die->die_id.die_type_node->signature);
8774 fprintf (outfile, "\n");
8777 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
8779 print_spaces (outfile);
8780 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
8782 switch (AT_class (a))
8784 case dw_val_class_addr:
8785 fprintf (outfile, "address");
8787 case dw_val_class_offset:
8788 fprintf (outfile, "offset");
8790 case dw_val_class_loc:
8791 fprintf (outfile, "location descriptor");
8793 case dw_val_class_loc_list:
8794 fprintf (outfile, "location list -> label:%s",
8795 AT_loc_list (a)->ll_symbol);
8797 case dw_val_class_range_list:
8798 fprintf (outfile, "range list");
8800 case dw_val_class_const:
8801 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
8803 case dw_val_class_unsigned_const:
8804 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
8806 case dw_val_class_const_double:
8807 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
8808 HOST_WIDE_INT_PRINT_UNSIGNED")",
8809 a->dw_attr_val.v.val_double.high,
8810 a->dw_attr_val.v.val_double.low);
8812 case dw_val_class_vec:
8813 fprintf (outfile, "floating-point or vector constant");
8815 case dw_val_class_flag:
8816 fprintf (outfile, "%u", AT_flag (a));
8818 case dw_val_class_die_ref:
8819 if (AT_ref (a) != NULL)
8821 if (use_debug_types && AT_ref (a)->die_id.die_type_node)
8823 fprintf (outfile, "die -> signature: ");
8824 print_signature (outfile,
8825 AT_ref (a)->die_id.die_type_node->signature);
8827 else if (! use_debug_types && AT_ref (a)->die_id.die_symbol)
8828 fprintf (outfile, "die -> label: %s",
8829 AT_ref (a)->die_id.die_symbol);
8831 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
8832 fprintf (outfile, " (%p)", (void *) AT_ref (a));
8835 fprintf (outfile, "die -> <null>");
8837 case dw_val_class_vms_delta:
8838 fprintf (outfile, "delta: @slotcount(%s-%s)",
8839 AT_vms_delta2 (a), AT_vms_delta1 (a));
8841 case dw_val_class_lbl_id:
8842 case dw_val_class_lineptr:
8843 case dw_val_class_macptr:
8844 fprintf (outfile, "label: %s", AT_lbl (a));
8846 case dw_val_class_str:
8847 if (AT_string (a) != NULL)
8848 fprintf (outfile, "\"%s\"", AT_string (a));
8850 fprintf (outfile, "<null>");
8852 case dw_val_class_file:
8853 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
8854 AT_file (a)->emitted_number);
8856 case dw_val_class_data8:
8860 for (i = 0; i < 8; i++)
8861 fprintf (outfile, "%02x", a->dw_attr_val.v.val_data8[i]);
8868 fprintf (outfile, "\n");
8871 if (die->die_child != NULL)
8874 FOR_EACH_CHILD (die, c, print_die (c, outfile));
8877 if (print_indent == 0)
8878 fprintf (outfile, "\n");
8881 /* Print the information collected for a given DIE. */
8884 debug_dwarf_die (dw_die_ref die)
8886 print_die (die, stderr);
8889 /* Print all DWARF information collected for the compilation unit.
8890 This routine is a debugging aid only. */
8896 print_die (comp_unit_die (), stderr);
8899 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
8900 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
8901 DIE that marks the start of the DIEs for this include file. */
8904 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
8906 const char *filename = get_AT_string (bincl_die, DW_AT_name);
8907 dw_die_ref new_unit = gen_compile_unit_die (filename);
8909 new_unit->die_sib = old_unit;
8913 /* Close an include-file CU and reopen the enclosing one. */
8916 pop_compile_unit (dw_die_ref old_unit)
8918 dw_die_ref new_unit = old_unit->die_sib;
8920 old_unit->die_sib = NULL;
8924 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8925 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
8927 /* Calculate the checksum of a location expression. */
8930 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
8934 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
8936 CHECKSUM (loc->dw_loc_oprnd1);
8937 CHECKSUM (loc->dw_loc_oprnd2);
8940 /* Calculate the checksum of an attribute. */
8943 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
8945 dw_loc_descr_ref loc;
8948 CHECKSUM (at->dw_attr);
8950 /* We don't care that this was compiled with a different compiler
8951 snapshot; if the output is the same, that's what matters. */
8952 if (at->dw_attr == DW_AT_producer)
8955 switch (AT_class (at))
8957 case dw_val_class_const:
8958 CHECKSUM (at->dw_attr_val.v.val_int);
8960 case dw_val_class_unsigned_const:
8961 CHECKSUM (at->dw_attr_val.v.val_unsigned);
8963 case dw_val_class_const_double:
8964 CHECKSUM (at->dw_attr_val.v.val_double);
8966 case dw_val_class_vec:
8967 CHECKSUM (at->dw_attr_val.v.val_vec);
8969 case dw_val_class_flag:
8970 CHECKSUM (at->dw_attr_val.v.val_flag);
8972 case dw_val_class_str:
8973 CHECKSUM_STRING (AT_string (at));
8976 case dw_val_class_addr:
8978 gcc_assert (GET_CODE (r) == SYMBOL_REF);
8979 CHECKSUM_STRING (XSTR (r, 0));
8982 case dw_val_class_offset:
8983 CHECKSUM (at->dw_attr_val.v.val_offset);
8986 case dw_val_class_loc:
8987 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
8988 loc_checksum (loc, ctx);
8991 case dw_val_class_die_ref:
8992 die_checksum (AT_ref (at), ctx, mark);
8995 case dw_val_class_fde_ref:
8996 case dw_val_class_vms_delta:
8997 case dw_val_class_lbl_id:
8998 case dw_val_class_lineptr:
8999 case dw_val_class_macptr:
9002 case dw_val_class_file:
9003 CHECKSUM_STRING (AT_file (at)->filename);
9006 case dw_val_class_data8:
9007 CHECKSUM (at->dw_attr_val.v.val_data8);
9015 /* Calculate the checksum of a DIE. */
9018 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
9024 /* To avoid infinite recursion. */
9027 CHECKSUM (die->die_mark);
9030 die->die_mark = ++(*mark);
9032 CHECKSUM (die->die_tag);
9034 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
9035 attr_checksum (a, ctx, mark);
9037 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
9041 #undef CHECKSUM_STRING
9043 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
9044 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
9045 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
9046 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
9047 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
9048 #define CHECKSUM_ATTR(FOO) \
9049 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
9051 /* Calculate the checksum of a number in signed LEB128 format. */
9054 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
9061 byte = (value & 0x7f);
9063 more = !((value == 0 && (byte & 0x40) == 0)
9064 || (value == -1 && (byte & 0x40) != 0));
9073 /* Calculate the checksum of a number in unsigned LEB128 format. */
9076 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
9080 unsigned char byte = (value & 0x7f);
9083 /* More bytes to follow. */
9091 /* Checksum the context of the DIE. This adds the names of any
9092 surrounding namespaces or structures to the checksum. */
9095 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
9099 int tag = die->die_tag;
9101 if (tag != DW_TAG_namespace
9102 && tag != DW_TAG_structure_type
9103 && tag != DW_TAG_class_type)
9106 name = get_AT_string (die, DW_AT_name);
9108 spec = get_AT_ref (die, DW_AT_specification);
9112 if (die->die_parent != NULL)
9113 checksum_die_context (die->die_parent, ctx);
9115 CHECKSUM_ULEB128 ('C');
9116 CHECKSUM_ULEB128 (tag);
9118 CHECKSUM_STRING (name);
9121 /* Calculate the checksum of a location expression. */
9124 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
9126 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
9127 were emitted as a DW_FORM_sdata instead of a location expression. */
9128 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
9130 CHECKSUM_ULEB128 (DW_FORM_sdata);
9131 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
9135 /* Otherwise, just checksum the raw location expression. */
9138 CHECKSUM_ULEB128 (loc->dw_loc_opc);
9139 CHECKSUM (loc->dw_loc_oprnd1);
9140 CHECKSUM (loc->dw_loc_oprnd2);
9141 loc = loc->dw_loc_next;
9145 /* Calculate the checksum of an attribute. */
9148 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
9149 struct md5_ctx *ctx, int *mark)
9151 dw_loc_descr_ref loc;
9154 if (AT_class (at) == dw_val_class_die_ref)
9156 dw_die_ref target_die = AT_ref (at);
9158 /* For pointer and reference types, we checksum only the (qualified)
9159 name of the target type (if there is a name). For friend entries,
9160 we checksum only the (qualified) name of the target type or function.
9161 This allows the checksum to remain the same whether the target type
9162 is complete or not. */
9163 if ((at->dw_attr == DW_AT_type
9164 && (tag == DW_TAG_pointer_type
9165 || tag == DW_TAG_reference_type
9166 || tag == DW_TAG_rvalue_reference_type
9167 || tag == DW_TAG_ptr_to_member_type))
9168 || (at->dw_attr == DW_AT_friend
9169 && tag == DW_TAG_friend))
9171 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
9173 if (name_attr != NULL)
9175 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
9179 CHECKSUM_ULEB128 ('N');
9180 CHECKSUM_ULEB128 (at->dw_attr);
9181 if (decl->die_parent != NULL)
9182 checksum_die_context (decl->die_parent, ctx);
9183 CHECKSUM_ULEB128 ('E');
9184 CHECKSUM_STRING (AT_string (name_attr));
9189 /* For all other references to another DIE, we check to see if the
9190 target DIE has already been visited. If it has, we emit a
9191 backward reference; if not, we descend recursively. */
9192 if (target_die->die_mark > 0)
9194 CHECKSUM_ULEB128 ('R');
9195 CHECKSUM_ULEB128 (at->dw_attr);
9196 CHECKSUM_ULEB128 (target_die->die_mark);
9200 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
9204 target_die->die_mark = ++(*mark);
9205 CHECKSUM_ULEB128 ('T');
9206 CHECKSUM_ULEB128 (at->dw_attr);
9207 if (decl->die_parent != NULL)
9208 checksum_die_context (decl->die_parent, ctx);
9209 die_checksum_ordered (target_die, ctx, mark);
9214 CHECKSUM_ULEB128 ('A');
9215 CHECKSUM_ULEB128 (at->dw_attr);
9217 switch (AT_class (at))
9219 case dw_val_class_const:
9220 CHECKSUM_ULEB128 (DW_FORM_sdata);
9221 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
9224 case dw_val_class_unsigned_const:
9225 CHECKSUM_ULEB128 (DW_FORM_sdata);
9226 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
9229 case dw_val_class_const_double:
9230 CHECKSUM_ULEB128 (DW_FORM_block);
9231 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
9232 CHECKSUM (at->dw_attr_val.v.val_double);
9235 case dw_val_class_vec:
9236 CHECKSUM_ULEB128 (DW_FORM_block);
9237 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_vec));
9238 CHECKSUM (at->dw_attr_val.v.val_vec);
9241 case dw_val_class_flag:
9242 CHECKSUM_ULEB128 (DW_FORM_flag);
9243 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
9246 case dw_val_class_str:
9247 CHECKSUM_ULEB128 (DW_FORM_string);
9248 CHECKSUM_STRING (AT_string (at));
9251 case dw_val_class_addr:
9253 gcc_assert (GET_CODE (r) == SYMBOL_REF);
9254 CHECKSUM_ULEB128 (DW_FORM_string);
9255 CHECKSUM_STRING (XSTR (r, 0));
9258 case dw_val_class_offset:
9259 CHECKSUM_ULEB128 (DW_FORM_sdata);
9260 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
9263 case dw_val_class_loc:
9264 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
9265 loc_checksum_ordered (loc, ctx);
9268 case dw_val_class_fde_ref:
9269 case dw_val_class_lbl_id:
9270 case dw_val_class_lineptr:
9271 case dw_val_class_macptr:
9274 case dw_val_class_file:
9275 CHECKSUM_ULEB128 (DW_FORM_string);
9276 CHECKSUM_STRING (AT_file (at)->filename);
9279 case dw_val_class_data8:
9280 CHECKSUM (at->dw_attr_val.v.val_data8);
9288 struct checksum_attributes
9290 dw_attr_ref at_name;
9291 dw_attr_ref at_type;
9292 dw_attr_ref at_friend;
9293 dw_attr_ref at_accessibility;
9294 dw_attr_ref at_address_class;
9295 dw_attr_ref at_allocated;
9296 dw_attr_ref at_artificial;
9297 dw_attr_ref at_associated;
9298 dw_attr_ref at_binary_scale;
9299 dw_attr_ref at_bit_offset;
9300 dw_attr_ref at_bit_size;
9301 dw_attr_ref at_bit_stride;
9302 dw_attr_ref at_byte_size;
9303 dw_attr_ref at_byte_stride;
9304 dw_attr_ref at_const_value;
9305 dw_attr_ref at_containing_type;
9306 dw_attr_ref at_count;
9307 dw_attr_ref at_data_location;
9308 dw_attr_ref at_data_member_location;
9309 dw_attr_ref at_decimal_scale;
9310 dw_attr_ref at_decimal_sign;
9311 dw_attr_ref at_default_value;
9312 dw_attr_ref at_digit_count;
9313 dw_attr_ref at_discr;
9314 dw_attr_ref at_discr_list;
9315 dw_attr_ref at_discr_value;
9316 dw_attr_ref at_encoding;
9317 dw_attr_ref at_endianity;
9318 dw_attr_ref at_explicit;
9319 dw_attr_ref at_is_optional;
9320 dw_attr_ref at_location;
9321 dw_attr_ref at_lower_bound;
9322 dw_attr_ref at_mutable;
9323 dw_attr_ref at_ordering;
9324 dw_attr_ref at_picture_string;
9325 dw_attr_ref at_prototyped;
9326 dw_attr_ref at_small;
9327 dw_attr_ref at_segment;
9328 dw_attr_ref at_string_length;
9329 dw_attr_ref at_threads_scaled;
9330 dw_attr_ref at_upper_bound;
9331 dw_attr_ref at_use_location;
9332 dw_attr_ref at_use_UTF8;
9333 dw_attr_ref at_variable_parameter;
9334 dw_attr_ref at_virtuality;
9335 dw_attr_ref at_visibility;
9336 dw_attr_ref at_vtable_elem_location;
9339 /* Collect the attributes that we will want to use for the checksum. */
9342 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
9347 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
9358 attrs->at_friend = a;
9360 case DW_AT_accessibility:
9361 attrs->at_accessibility = a;
9363 case DW_AT_address_class:
9364 attrs->at_address_class = a;
9366 case DW_AT_allocated:
9367 attrs->at_allocated = a;
9369 case DW_AT_artificial:
9370 attrs->at_artificial = a;
9372 case DW_AT_associated:
9373 attrs->at_associated = a;
9375 case DW_AT_binary_scale:
9376 attrs->at_binary_scale = a;
9378 case DW_AT_bit_offset:
9379 attrs->at_bit_offset = a;
9381 case DW_AT_bit_size:
9382 attrs->at_bit_size = a;
9384 case DW_AT_bit_stride:
9385 attrs->at_bit_stride = a;
9387 case DW_AT_byte_size:
9388 attrs->at_byte_size = a;
9390 case DW_AT_byte_stride:
9391 attrs->at_byte_stride = a;
9393 case DW_AT_const_value:
9394 attrs->at_const_value = a;
9396 case DW_AT_containing_type:
9397 attrs->at_containing_type = a;
9400 attrs->at_count = a;
9402 case DW_AT_data_location:
9403 attrs->at_data_location = a;
9405 case DW_AT_data_member_location:
9406 attrs->at_data_member_location = a;
9408 case DW_AT_decimal_scale:
9409 attrs->at_decimal_scale = a;
9411 case DW_AT_decimal_sign:
9412 attrs->at_decimal_sign = a;
9414 case DW_AT_default_value:
9415 attrs->at_default_value = a;
9417 case DW_AT_digit_count:
9418 attrs->at_digit_count = a;
9421 attrs->at_discr = a;
9423 case DW_AT_discr_list:
9424 attrs->at_discr_list = a;
9426 case DW_AT_discr_value:
9427 attrs->at_discr_value = a;
9429 case DW_AT_encoding:
9430 attrs->at_encoding = a;
9432 case DW_AT_endianity:
9433 attrs->at_endianity = a;
9435 case DW_AT_explicit:
9436 attrs->at_explicit = a;
9438 case DW_AT_is_optional:
9439 attrs->at_is_optional = a;
9441 case DW_AT_location:
9442 attrs->at_location = a;
9444 case DW_AT_lower_bound:
9445 attrs->at_lower_bound = a;
9448 attrs->at_mutable = a;
9450 case DW_AT_ordering:
9451 attrs->at_ordering = a;
9453 case DW_AT_picture_string:
9454 attrs->at_picture_string = a;
9456 case DW_AT_prototyped:
9457 attrs->at_prototyped = a;
9460 attrs->at_small = a;
9463 attrs->at_segment = a;
9465 case DW_AT_string_length:
9466 attrs->at_string_length = a;
9468 case DW_AT_threads_scaled:
9469 attrs->at_threads_scaled = a;
9471 case DW_AT_upper_bound:
9472 attrs->at_upper_bound = a;
9474 case DW_AT_use_location:
9475 attrs->at_use_location = a;
9477 case DW_AT_use_UTF8:
9478 attrs->at_use_UTF8 = a;
9480 case DW_AT_variable_parameter:
9481 attrs->at_variable_parameter = a;
9483 case DW_AT_virtuality:
9484 attrs->at_virtuality = a;
9486 case DW_AT_visibility:
9487 attrs->at_visibility = a;
9489 case DW_AT_vtable_elem_location:
9490 attrs->at_vtable_elem_location = a;
9498 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
9501 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
9505 struct checksum_attributes attrs;
9507 CHECKSUM_ULEB128 ('D');
9508 CHECKSUM_ULEB128 (die->die_tag);
9510 memset (&attrs, 0, sizeof (attrs));
9512 decl = get_AT_ref (die, DW_AT_specification);
9514 collect_checksum_attributes (&attrs, decl);
9515 collect_checksum_attributes (&attrs, die);
9517 CHECKSUM_ATTR (attrs.at_name);
9518 CHECKSUM_ATTR (attrs.at_accessibility);
9519 CHECKSUM_ATTR (attrs.at_address_class);
9520 CHECKSUM_ATTR (attrs.at_allocated);
9521 CHECKSUM_ATTR (attrs.at_artificial);
9522 CHECKSUM_ATTR (attrs.at_associated);
9523 CHECKSUM_ATTR (attrs.at_binary_scale);
9524 CHECKSUM_ATTR (attrs.at_bit_offset);
9525 CHECKSUM_ATTR (attrs.at_bit_size);
9526 CHECKSUM_ATTR (attrs.at_bit_stride);
9527 CHECKSUM_ATTR (attrs.at_byte_size);
9528 CHECKSUM_ATTR (attrs.at_byte_stride);
9529 CHECKSUM_ATTR (attrs.at_const_value);
9530 CHECKSUM_ATTR (attrs.at_containing_type);
9531 CHECKSUM_ATTR (attrs.at_count);
9532 CHECKSUM_ATTR (attrs.at_data_location);
9533 CHECKSUM_ATTR (attrs.at_data_member_location);
9534 CHECKSUM_ATTR (attrs.at_decimal_scale);
9535 CHECKSUM_ATTR (attrs.at_decimal_sign);
9536 CHECKSUM_ATTR (attrs.at_default_value);
9537 CHECKSUM_ATTR (attrs.at_digit_count);
9538 CHECKSUM_ATTR (attrs.at_discr);
9539 CHECKSUM_ATTR (attrs.at_discr_list);
9540 CHECKSUM_ATTR (attrs.at_discr_value);
9541 CHECKSUM_ATTR (attrs.at_encoding);
9542 CHECKSUM_ATTR (attrs.at_endianity);
9543 CHECKSUM_ATTR (attrs.at_explicit);
9544 CHECKSUM_ATTR (attrs.at_is_optional);
9545 CHECKSUM_ATTR (attrs.at_location);
9546 CHECKSUM_ATTR (attrs.at_lower_bound);
9547 CHECKSUM_ATTR (attrs.at_mutable);
9548 CHECKSUM_ATTR (attrs.at_ordering);
9549 CHECKSUM_ATTR (attrs.at_picture_string);
9550 CHECKSUM_ATTR (attrs.at_prototyped);
9551 CHECKSUM_ATTR (attrs.at_small);
9552 CHECKSUM_ATTR (attrs.at_segment);
9553 CHECKSUM_ATTR (attrs.at_string_length);
9554 CHECKSUM_ATTR (attrs.at_threads_scaled);
9555 CHECKSUM_ATTR (attrs.at_upper_bound);
9556 CHECKSUM_ATTR (attrs.at_use_location);
9557 CHECKSUM_ATTR (attrs.at_use_UTF8);
9558 CHECKSUM_ATTR (attrs.at_variable_parameter);
9559 CHECKSUM_ATTR (attrs.at_virtuality);
9560 CHECKSUM_ATTR (attrs.at_visibility);
9561 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
9562 CHECKSUM_ATTR (attrs.at_type);
9563 CHECKSUM_ATTR (attrs.at_friend);
9565 /* Checksum the child DIEs, except for nested types and member functions. */
9568 dw_attr_ref name_attr;
9571 name_attr = get_AT (c, DW_AT_name);
9572 if ((is_type_die (c) || c->die_tag == DW_TAG_subprogram)
9573 && name_attr != NULL)
9575 CHECKSUM_ULEB128 ('S');
9576 CHECKSUM_ULEB128 (c->die_tag);
9577 CHECKSUM_STRING (AT_string (name_attr));
9581 /* Mark this DIE so it gets processed when unmarking. */
9582 if (c->die_mark == 0)
9584 die_checksum_ordered (c, ctx, mark);
9586 } while (c != die->die_child);
9588 CHECKSUM_ULEB128 (0);
9592 #undef CHECKSUM_STRING
9593 #undef CHECKSUM_ATTR
9594 #undef CHECKSUM_LEB128
9595 #undef CHECKSUM_ULEB128
9597 /* Generate the type signature for DIE. This is computed by generating an
9598 MD5 checksum over the DIE's tag, its relevant attributes, and its
9599 children. Attributes that are references to other DIEs are processed
9600 by recursion, using the MARK field to prevent infinite recursion.
9601 If the DIE is nested inside a namespace or another type, we also
9602 need to include that context in the signature. The lower 64 bits
9603 of the resulting MD5 checksum comprise the signature. */
9606 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
9610 unsigned char checksum[16];
9614 name = get_AT_string (die, DW_AT_name);
9615 decl = get_AT_ref (die, DW_AT_specification);
9617 /* First, compute a signature for just the type name (and its surrounding
9618 context, if any. This is stored in the type unit DIE for link-time
9619 ODR (one-definition rule) checking. */
9621 if (is_cxx() && name != NULL)
9623 md5_init_ctx (&ctx);
9625 /* Checksum the names of surrounding namespaces and structures. */
9626 if (decl != NULL && decl->die_parent != NULL)
9627 checksum_die_context (decl->die_parent, &ctx);
9629 md5_process_bytes (&die->die_tag, sizeof (die->die_tag), &ctx);
9630 md5_process_bytes (name, strlen (name) + 1, &ctx);
9631 md5_finish_ctx (&ctx, checksum);
9633 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
9636 /* Next, compute the complete type signature. */
9638 md5_init_ctx (&ctx);
9640 die->die_mark = mark;
9642 /* Checksum the names of surrounding namespaces and structures. */
9643 if (decl != NULL && decl->die_parent != NULL)
9644 checksum_die_context (decl->die_parent, &ctx);
9646 /* Checksum the DIE and its children. */
9647 die_checksum_ordered (die, &ctx, &mark);
9648 unmark_all_dies (die);
9649 md5_finish_ctx (&ctx, checksum);
9651 /* Store the signature in the type node and link the type DIE and the
9652 type node together. */
9653 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
9654 DWARF_TYPE_SIGNATURE_SIZE);
9655 die->die_id.die_type_node = type_node;
9656 type_node->type_die = die;
9658 /* If the DIE is a specification, link its declaration to the type node
9661 decl->die_id.die_type_node = type_node;
9664 /* Do the location expressions look same? */
9666 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
9668 return loc1->dw_loc_opc == loc2->dw_loc_opc
9669 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
9670 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
9673 /* Do the values look the same? */
9675 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
9677 dw_loc_descr_ref loc1, loc2;
9680 if (v1->val_class != v2->val_class)
9683 switch (v1->val_class)
9685 case dw_val_class_const:
9686 return v1->v.val_int == v2->v.val_int;
9687 case dw_val_class_unsigned_const:
9688 return v1->v.val_unsigned == v2->v.val_unsigned;
9689 case dw_val_class_const_double:
9690 return v1->v.val_double.high == v2->v.val_double.high
9691 && v1->v.val_double.low == v2->v.val_double.low;
9692 case dw_val_class_vec:
9693 if (v1->v.val_vec.length != v2->v.val_vec.length
9694 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
9696 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
9697 v1->v.val_vec.length * v1->v.val_vec.elt_size))
9700 case dw_val_class_flag:
9701 return v1->v.val_flag == v2->v.val_flag;
9702 case dw_val_class_str:
9703 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
9705 case dw_val_class_addr:
9706 r1 = v1->v.val_addr;
9707 r2 = v2->v.val_addr;
9708 if (GET_CODE (r1) != GET_CODE (r2))
9710 return !rtx_equal_p (r1, r2);
9712 case dw_val_class_offset:
9713 return v1->v.val_offset == v2->v.val_offset;
9715 case dw_val_class_loc:
9716 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
9718 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
9719 if (!same_loc_p (loc1, loc2, mark))
9721 return !loc1 && !loc2;
9723 case dw_val_class_die_ref:
9724 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
9726 case dw_val_class_fde_ref:
9727 case dw_val_class_vms_delta:
9728 case dw_val_class_lbl_id:
9729 case dw_val_class_lineptr:
9730 case dw_val_class_macptr:
9733 case dw_val_class_file:
9734 return v1->v.val_file == v2->v.val_file;
9736 case dw_val_class_data8:
9737 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
9744 /* Do the attributes look the same? */
9747 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
9749 if (at1->dw_attr != at2->dw_attr)
9752 /* We don't care that this was compiled with a different compiler
9753 snapshot; if the output is the same, that's what matters. */
9754 if (at1->dw_attr == DW_AT_producer)
9757 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
9760 /* Do the dies look the same? */
9763 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
9769 /* To avoid infinite recursion. */
9771 return die1->die_mark == die2->die_mark;
9772 die1->die_mark = die2->die_mark = ++(*mark);
9774 if (die1->die_tag != die2->die_tag)
9777 if (VEC_length (dw_attr_node, die1->die_attr)
9778 != VEC_length (dw_attr_node, die2->die_attr))
9781 FOR_EACH_VEC_ELT (dw_attr_node, die1->die_attr, ix, a1)
9782 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
9785 c1 = die1->die_child;
9786 c2 = die2->die_child;
9795 if (!same_die_p (c1, c2, mark))
9799 if (c1 == die1->die_child)
9801 if (c2 == die2->die_child)
9811 /* Do the dies look the same? Wrapper around same_die_p. */
9814 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
9817 int ret = same_die_p (die1, die2, &mark);
9819 unmark_all_dies (die1);
9820 unmark_all_dies (die2);
9825 /* The prefix to attach to symbols on DIEs in the current comdat debug
9827 static char *comdat_symbol_id;
9829 /* The index of the current symbol within the current comdat CU. */
9830 static unsigned int comdat_symbol_number;
9832 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
9833 children, and set comdat_symbol_id accordingly. */
9836 compute_section_prefix (dw_die_ref unit_die)
9838 const char *die_name = get_AT_string (unit_die, DW_AT_name);
9839 const char *base = die_name ? lbasename (die_name) : "anonymous";
9840 char *name = XALLOCAVEC (char, strlen (base) + 64);
9843 unsigned char checksum[16];
9846 /* Compute the checksum of the DIE, then append part of it as hex digits to
9847 the name filename of the unit. */
9849 md5_init_ctx (&ctx);
9851 die_checksum (unit_die, &ctx, &mark);
9852 unmark_all_dies (unit_die);
9853 md5_finish_ctx (&ctx, checksum);
9855 sprintf (name, "%s.", base);
9856 clean_symbol_name (name);
9858 p = name + strlen (name);
9859 for (i = 0; i < 4; i++)
9861 sprintf (p, "%.2x", checksum[i]);
9865 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
9866 comdat_symbol_number = 0;
9869 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
9872 is_type_die (dw_die_ref die)
9874 switch (die->die_tag)
9876 case DW_TAG_array_type:
9877 case DW_TAG_class_type:
9878 case DW_TAG_interface_type:
9879 case DW_TAG_enumeration_type:
9880 case DW_TAG_pointer_type:
9881 case DW_TAG_reference_type:
9882 case DW_TAG_rvalue_reference_type:
9883 case DW_TAG_string_type:
9884 case DW_TAG_structure_type:
9885 case DW_TAG_subroutine_type:
9886 case DW_TAG_union_type:
9887 case DW_TAG_ptr_to_member_type:
9888 case DW_TAG_set_type:
9889 case DW_TAG_subrange_type:
9890 case DW_TAG_base_type:
9891 case DW_TAG_const_type:
9892 case DW_TAG_file_type:
9893 case DW_TAG_packed_type:
9894 case DW_TAG_volatile_type:
9895 case DW_TAG_typedef:
9902 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
9903 Basically, we want to choose the bits that are likely to be shared between
9904 compilations (types) and leave out the bits that are specific to individual
9905 compilations (functions). */
9908 is_comdat_die (dw_die_ref c)
9910 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
9911 we do for stabs. The advantage is a greater likelihood of sharing between
9912 objects that don't include headers in the same order (and therefore would
9913 put the base types in a different comdat). jason 8/28/00 */
9915 if (c->die_tag == DW_TAG_base_type)
9918 if (c->die_tag == DW_TAG_pointer_type
9919 || c->die_tag == DW_TAG_reference_type
9920 || c->die_tag == DW_TAG_rvalue_reference_type
9921 || c->die_tag == DW_TAG_const_type
9922 || c->die_tag == DW_TAG_volatile_type)
9924 dw_die_ref t = get_AT_ref (c, DW_AT_type);
9926 return t ? is_comdat_die (t) : 0;
9929 return is_type_die (c);
9932 /* Returns 1 iff C is the sort of DIE that might be referred to from another
9933 compilation unit. */
9936 is_symbol_die (dw_die_ref c)
9938 return (is_type_die (c)
9939 || is_declaration_die (c)
9940 || c->die_tag == DW_TAG_namespace
9941 || c->die_tag == DW_TAG_module);
9944 /* Returns true iff C is a compile-unit DIE. */
9947 is_cu_die (dw_die_ref c)
9949 return c && c->die_tag == DW_TAG_compile_unit;
9953 gen_internal_sym (const char *prefix)
9957 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
9958 return xstrdup (buf);
9961 /* Assign symbols to all worthy DIEs under DIE. */
9964 assign_symbol_names (dw_die_ref die)
9968 if (is_symbol_die (die))
9970 if (comdat_symbol_id)
9972 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
9974 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
9975 comdat_symbol_id, comdat_symbol_number++);
9976 die->die_id.die_symbol = xstrdup (p);
9979 die->die_id.die_symbol = gen_internal_sym ("LDIE");
9982 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
9985 struct cu_hash_table_entry
9988 unsigned min_comdat_num, max_comdat_num;
9989 struct cu_hash_table_entry *next;
9992 /* Routines to manipulate hash table of CUs. */
9994 htab_cu_hash (const void *of)
9996 const struct cu_hash_table_entry *const entry =
9997 (const struct cu_hash_table_entry *) of;
9999 return htab_hash_string (entry->cu->die_id.die_symbol);
10003 htab_cu_eq (const void *of1, const void *of2)
10005 const struct cu_hash_table_entry *const entry1 =
10006 (const struct cu_hash_table_entry *) of1;
10007 const struct die_struct *const entry2 = (const struct die_struct *) of2;
10009 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
10013 htab_cu_del (void *what)
10015 struct cu_hash_table_entry *next,
10016 *entry = (struct cu_hash_table_entry *) what;
10020 next = entry->next;
10026 /* Check whether we have already seen this CU and set up SYM_NUM
10029 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
10031 struct cu_hash_table_entry dummy;
10032 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
10034 dummy.max_comdat_num = 0;
10036 slot = (struct cu_hash_table_entry **)
10037 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
10041 for (; entry; last = entry, entry = entry->next)
10043 if (same_die_p_wrap (cu, entry->cu))
10049 *sym_num = entry->min_comdat_num;
10053 entry = XCNEW (struct cu_hash_table_entry);
10055 entry->min_comdat_num = *sym_num = last->max_comdat_num;
10056 entry->next = *slot;
10062 /* Record SYM_NUM to record of CU in HTABLE. */
10064 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
10066 struct cu_hash_table_entry **slot, *entry;
10068 slot = (struct cu_hash_table_entry **)
10069 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
10073 entry->max_comdat_num = sym_num;
10076 /* Traverse the DIE (which is always comp_unit_die), and set up
10077 additional compilation units for each of the include files we see
10078 bracketed by BINCL/EINCL. */
10081 break_out_includes (dw_die_ref die)
10084 dw_die_ref unit = NULL;
10085 limbo_die_node *node, **pnode;
10086 htab_t cu_hash_table;
10088 c = die->die_child;
10090 dw_die_ref prev = c;
10092 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
10093 || (unit && is_comdat_die (c)))
10095 dw_die_ref next = c->die_sib;
10097 /* This DIE is for a secondary CU; remove it from the main one. */
10098 remove_child_with_prev (c, prev);
10100 if (c->die_tag == DW_TAG_GNU_BINCL)
10101 unit = push_new_compile_unit (unit, c);
10102 else if (c->die_tag == DW_TAG_GNU_EINCL)
10103 unit = pop_compile_unit (unit);
10105 add_child_die (unit, c);
10107 if (c == die->die_child)
10110 } while (c != die->die_child);
10113 /* We can only use this in debugging, since the frontend doesn't check
10114 to make sure that we leave every include file we enter. */
10115 gcc_assert (!unit);
10118 assign_symbol_names (die);
10119 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
10120 for (node = limbo_die_list, pnode = &limbo_die_list;
10126 compute_section_prefix (node->die);
10127 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
10128 &comdat_symbol_number);
10129 assign_symbol_names (node->die);
10131 *pnode = node->next;
10134 pnode = &node->next;
10135 record_comdat_symbol_number (node->die, cu_hash_table,
10136 comdat_symbol_number);
10139 htab_delete (cu_hash_table);
10142 /* Return non-zero if this DIE is a declaration. */
10145 is_declaration_die (dw_die_ref die)
10150 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10151 if (a->dw_attr == DW_AT_declaration)
10157 /* Return non-zero if this DIE is nested inside a subprogram. */
10160 is_nested_in_subprogram (dw_die_ref die)
10162 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
10166 return local_scope_p (decl);
10169 /* Return non-zero if this is a type DIE that should be moved to a
10170 COMDAT .debug_types section. */
10173 should_move_die_to_comdat (dw_die_ref die)
10175 switch (die->die_tag)
10177 case DW_TAG_class_type:
10178 case DW_TAG_structure_type:
10179 case DW_TAG_enumeration_type:
10180 case DW_TAG_union_type:
10181 /* Don't move declarations, inlined instances, or types nested in a
10183 if (is_declaration_die (die)
10184 || get_AT (die, DW_AT_abstract_origin)
10185 || is_nested_in_subprogram (die))
10188 case DW_TAG_array_type:
10189 case DW_TAG_interface_type:
10190 case DW_TAG_pointer_type:
10191 case DW_TAG_reference_type:
10192 case DW_TAG_rvalue_reference_type:
10193 case DW_TAG_string_type:
10194 case DW_TAG_subroutine_type:
10195 case DW_TAG_ptr_to_member_type:
10196 case DW_TAG_set_type:
10197 case DW_TAG_subrange_type:
10198 case DW_TAG_base_type:
10199 case DW_TAG_const_type:
10200 case DW_TAG_file_type:
10201 case DW_TAG_packed_type:
10202 case DW_TAG_volatile_type:
10203 case DW_TAG_typedef:
10209 /* Make a clone of DIE. */
10212 clone_die (dw_die_ref die)
10218 clone = ggc_alloc_cleared_die_node ();
10219 clone->die_tag = die->die_tag;
10221 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10222 add_dwarf_attr (clone, a);
10227 /* Make a clone of the tree rooted at DIE. */
10230 clone_tree (dw_die_ref die)
10233 dw_die_ref clone = clone_die (die);
10235 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree(c)));
10240 /* Make a clone of DIE as a declaration. */
10243 clone_as_declaration (dw_die_ref die)
10250 /* If the DIE is already a declaration, just clone it. */
10251 if (is_declaration_die (die))
10252 return clone_die (die);
10254 /* If the DIE is a specification, just clone its declaration DIE. */
10255 decl = get_AT_ref (die, DW_AT_specification);
10257 return clone_die (decl);
10259 clone = ggc_alloc_cleared_die_node ();
10260 clone->die_tag = die->die_tag;
10262 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10264 /* We don't want to copy over all attributes.
10265 For example we don't want DW_AT_byte_size because otherwise we will no
10266 longer have a declaration and GDB will treat it as a definition. */
10268 switch (a->dw_attr)
10270 case DW_AT_artificial:
10271 case DW_AT_containing_type:
10272 case DW_AT_external:
10275 case DW_AT_virtuality:
10276 case DW_AT_linkage_name:
10277 case DW_AT_MIPS_linkage_name:
10278 add_dwarf_attr (clone, a);
10280 case DW_AT_byte_size:
10286 if (die->die_id.die_type_node)
10287 add_AT_die_ref (clone, DW_AT_signature, die);
10289 add_AT_flag (clone, DW_AT_declaration, 1);
10293 /* Copy the declaration context to the new compile unit DIE. This includes
10294 any surrounding namespace or type declarations. If the DIE has an
10295 AT_specification attribute, it also includes attributes and children
10296 attached to the specification. */
10299 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
10302 dw_die_ref new_decl;
10304 decl = get_AT_ref (die, DW_AT_specification);
10313 /* Copy the type node pointer from the new DIE to the original
10314 declaration DIE so we can forward references later. */
10315 decl->die_id.die_type_node = die->die_id.die_type_node;
10317 remove_AT (die, DW_AT_specification);
10319 FOR_EACH_VEC_ELT (dw_attr_node, decl->die_attr, ix, a)
10321 if (a->dw_attr != DW_AT_name
10322 && a->dw_attr != DW_AT_declaration
10323 && a->dw_attr != DW_AT_external)
10324 add_dwarf_attr (die, a);
10327 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree(c)));
10330 if (decl->die_parent != NULL
10331 && decl->die_parent->die_tag != DW_TAG_compile_unit
10332 && decl->die_parent->die_tag != DW_TAG_type_unit)
10334 new_decl = copy_ancestor_tree (unit, decl, NULL);
10335 if (new_decl != NULL)
10337 remove_AT (new_decl, DW_AT_signature);
10338 add_AT_specification (die, new_decl);
10343 /* Generate the skeleton ancestor tree for the given NODE, then clone
10344 the DIE and add the clone into the tree. */
10347 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
10349 if (node->new_die != NULL)
10352 node->new_die = clone_as_declaration (node->old_die);
10354 if (node->parent != NULL)
10356 generate_skeleton_ancestor_tree (node->parent);
10357 add_child_die (node->parent->new_die, node->new_die);
10361 /* Generate a skeleton tree of DIEs containing any declarations that are
10362 found in the original tree. We traverse the tree looking for declaration
10363 DIEs, and construct the skeleton from the bottom up whenever we find one. */
10366 generate_skeleton_bottom_up (skeleton_chain_node *parent)
10368 skeleton_chain_node node;
10371 dw_die_ref prev = NULL;
10372 dw_die_ref next = NULL;
10374 node.parent = parent;
10376 first = c = parent->old_die->die_child;
10380 if (prev == NULL || prev->die_sib == c)
10383 next = (c == first ? NULL : c->die_sib);
10385 node.new_die = NULL;
10386 if (is_declaration_die (c))
10388 /* Clone the existing DIE, move the original to the skeleton
10389 tree (which is in the main CU), and put the clone, with
10390 all the original's children, where the original came from. */
10391 dw_die_ref clone = clone_die (c);
10392 move_all_children (c, clone);
10394 replace_child (c, clone, prev);
10395 generate_skeleton_ancestor_tree (parent);
10396 add_child_die (parent->new_die, c);
10400 generate_skeleton_bottom_up (&node);
10401 } while (next != NULL);
10404 /* Wrapper function for generate_skeleton_bottom_up. */
10407 generate_skeleton (dw_die_ref die)
10409 skeleton_chain_node node;
10411 node.old_die = die;
10412 node.new_die = NULL;
10413 node.parent = NULL;
10415 /* If this type definition is nested inside another type,
10416 always leave at least a declaration in its place. */
10417 if (die->die_parent != NULL && is_type_die (die->die_parent))
10418 node.new_die = clone_as_declaration (die);
10420 generate_skeleton_bottom_up (&node);
10421 return node.new_die;
10424 /* Remove the DIE from its parent, possibly replacing it with a cloned
10425 declaration. The original DIE will be moved to a new compile unit
10426 so that existing references to it follow it to the new location. If
10427 any of the original DIE's descendants is a declaration, we need to
10428 replace the original DIE with a skeleton tree and move the
10429 declarations back into the skeleton tree. */
10432 remove_child_or_replace_with_skeleton (dw_die_ref child, dw_die_ref prev)
10434 dw_die_ref skeleton;
10436 skeleton = generate_skeleton (child);
10437 if (skeleton == NULL)
10438 remove_child_with_prev (child, prev);
10441 skeleton->die_id.die_type_node = child->die_id.die_type_node;
10442 replace_child (child, skeleton, prev);
10448 /* Traverse the DIE and set up additional .debug_types sections for each
10449 type worthy of being placed in a COMDAT section. */
10452 break_out_comdat_types (dw_die_ref die)
10456 dw_die_ref prev = NULL;
10457 dw_die_ref next = NULL;
10458 dw_die_ref unit = NULL;
10460 first = c = die->die_child;
10464 if (prev == NULL || prev->die_sib == c)
10467 next = (c == first ? NULL : c->die_sib);
10468 if (should_move_die_to_comdat (c))
10470 dw_die_ref replacement;
10471 comdat_type_node_ref type_node;
10473 /* Create a new type unit DIE as the root for the new tree, and
10474 add it to the list of comdat types. */
10475 unit = new_die (DW_TAG_type_unit, NULL, NULL);
10476 add_AT_unsigned (unit, DW_AT_language,
10477 get_AT_unsigned (comp_unit_die (), DW_AT_language));
10478 type_node = ggc_alloc_cleared_comdat_type_node ();
10479 type_node->root_die = unit;
10480 type_node->next = comdat_type_list;
10481 comdat_type_list = type_node;
10483 /* Generate the type signature. */
10484 generate_type_signature (c, type_node);
10486 /* Copy the declaration context, attributes, and children of the
10487 declaration into the new compile unit DIE. */
10488 copy_declaration_context (unit, c);
10490 /* Remove this DIE from the main CU. */
10491 replacement = remove_child_or_replace_with_skeleton (c, prev);
10493 /* Break out nested types into their own type units. */
10494 break_out_comdat_types (c);
10496 /* Add the DIE to the new compunit. */
10497 add_child_die (unit, c);
10499 if (replacement != NULL)
10502 else if (c->die_tag == DW_TAG_namespace
10503 || c->die_tag == DW_TAG_class_type
10504 || c->die_tag == DW_TAG_structure_type
10505 || c->die_tag == DW_TAG_union_type)
10507 /* Look for nested types that can be broken out. */
10508 break_out_comdat_types (c);
10510 } while (next != NULL);
10513 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
10515 struct decl_table_entry
10521 /* Routines to manipulate hash table of copied declarations. */
10524 htab_decl_hash (const void *of)
10526 const struct decl_table_entry *const entry =
10527 (const struct decl_table_entry *) of;
10529 return htab_hash_pointer (entry->orig);
10533 htab_decl_eq (const void *of1, const void *of2)
10535 const struct decl_table_entry *const entry1 =
10536 (const struct decl_table_entry *) of1;
10537 const struct die_struct *const entry2 = (const struct die_struct *) of2;
10539 return entry1->orig == entry2;
10543 htab_decl_del (void *what)
10545 struct decl_table_entry *entry = (struct decl_table_entry *) what;
10550 /* Copy DIE and its ancestors, up to, but not including, the compile unit
10551 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
10552 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
10553 to check if the ancestor has already been copied into UNIT. */
10556 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
10558 dw_die_ref parent = die->die_parent;
10559 dw_die_ref new_parent = unit;
10561 void **slot = NULL;
10562 struct decl_table_entry *entry = NULL;
10566 /* Check if the entry has already been copied to UNIT. */
10567 slot = htab_find_slot_with_hash (decl_table, die,
10568 htab_hash_pointer (die), INSERT);
10569 if (*slot != HTAB_EMPTY_ENTRY)
10571 entry = (struct decl_table_entry *) *slot;
10572 return entry->copy;
10575 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
10576 entry = XCNEW (struct decl_table_entry);
10578 entry->copy = NULL;
10582 if (parent != NULL)
10584 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
10587 if (parent->die_tag != DW_TAG_compile_unit
10588 && parent->die_tag != DW_TAG_type_unit)
10589 new_parent = copy_ancestor_tree (unit, parent, decl_table);
10592 copy = clone_as_declaration (die);
10593 add_child_die (new_parent, copy);
10595 if (decl_table != NULL)
10597 /* Record the pointer to the copy. */
10598 entry->copy = copy;
10604 /* Walk the DIE and its children, looking for references to incomplete
10605 or trivial types that are unmarked (i.e., that are not in the current
10609 copy_decls_walk (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
10615 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10617 if (AT_class (a) == dw_val_class_die_ref)
10619 dw_die_ref targ = AT_ref (a);
10620 comdat_type_node_ref type_node = targ->die_id.die_type_node;
10622 struct decl_table_entry *entry;
10624 if (targ->die_mark != 0 || type_node != NULL)
10627 slot = htab_find_slot_with_hash (decl_table, targ,
10628 htab_hash_pointer (targ), INSERT);
10630 if (*slot != HTAB_EMPTY_ENTRY)
10632 /* TARG has already been copied, so we just need to
10633 modify the reference to point to the copy. */
10634 entry = (struct decl_table_entry *) *slot;
10635 a->dw_attr_val.v.val_die_ref.die = entry->copy;
10639 dw_die_ref parent = unit;
10640 dw_die_ref copy = clone_tree (targ);
10642 /* Make sure the cloned tree is marked as part of the
10646 /* Record in DECL_TABLE that TARG has been copied.
10647 Need to do this now, before the recursive call,
10648 because DECL_TABLE may be expanded and SLOT
10649 would no longer be a valid pointer. */
10650 entry = XCNEW (struct decl_table_entry);
10651 entry->orig = targ;
10652 entry->copy = copy;
10655 /* If TARG has surrounding context, copy its ancestor tree
10656 into the new type unit. */
10657 if (targ->die_parent != NULL
10658 && targ->die_parent->die_tag != DW_TAG_compile_unit
10659 && targ->die_parent->die_tag != DW_TAG_type_unit)
10660 parent = copy_ancestor_tree (unit, targ->die_parent,
10663 add_child_die (parent, copy);
10664 a->dw_attr_val.v.val_die_ref.die = copy;
10666 /* Make sure the newly-copied DIE is walked. If it was
10667 installed in a previously-added context, it won't
10668 get visited otherwise. */
10669 if (parent != unit)
10671 /* Find the highest point of the newly-added tree,
10672 mark each node along the way, and walk from there. */
10673 parent->die_mark = 1;
10674 while (parent->die_parent
10675 && parent->die_parent->die_mark == 0)
10677 parent = parent->die_parent;
10678 parent->die_mark = 1;
10680 copy_decls_walk (unit, parent, decl_table);
10686 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
10689 /* Copy declarations for "unworthy" types into the new comdat section.
10690 Incomplete types, modified types, and certain other types aren't broken
10691 out into comdat sections of their own, so they don't have a signature,
10692 and we need to copy the declaration into the same section so that we
10693 don't have an external reference. */
10696 copy_decls_for_unworthy_types (dw_die_ref unit)
10701 decl_table = htab_create (10, htab_decl_hash, htab_decl_eq, htab_decl_del);
10702 copy_decls_walk (unit, unit, decl_table);
10703 htab_delete (decl_table);
10704 unmark_dies (unit);
10707 /* Traverse the DIE and add a sibling attribute if it may have the
10708 effect of speeding up access to siblings. To save some space,
10709 avoid generating sibling attributes for DIE's without children. */
10712 add_sibling_attributes (dw_die_ref die)
10716 if (! die->die_child)
10719 if (die->die_parent && die != die->die_parent->die_child)
10720 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
10722 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
10725 /* Output all location lists for the DIE and its children. */
10728 output_location_lists (dw_die_ref die)
10734 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10735 if (AT_class (a) == dw_val_class_loc_list)
10736 output_loc_list (AT_loc_list (a));
10738 FOR_EACH_CHILD (die, c, output_location_lists (c));
10741 /* The format of each DIE (and its attribute value pairs) is encoded in an
10742 abbreviation table. This routine builds the abbreviation table and assigns
10743 a unique abbreviation id for each abbreviation entry. The children of each
10744 die are visited recursively. */
10747 build_abbrev_table (dw_die_ref die)
10749 unsigned long abbrev_id;
10750 unsigned int n_alloc;
10755 /* Scan the DIE references, and mark as external any that refer to
10756 DIEs from other CUs (i.e. those which are not marked). */
10757 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10758 if (AT_class (a) == dw_val_class_die_ref
10759 && AT_ref (a)->die_mark == 0)
10761 gcc_assert (use_debug_types || AT_ref (a)->die_id.die_symbol);
10762 set_AT_ref_external (a, 1);
10765 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
10767 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
10768 dw_attr_ref die_a, abbrev_a;
10772 if (abbrev->die_tag != die->die_tag)
10774 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
10777 if (VEC_length (dw_attr_node, abbrev->die_attr)
10778 != VEC_length (dw_attr_node, die->die_attr))
10781 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, die_a)
10783 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
10784 if ((abbrev_a->dw_attr != die_a->dw_attr)
10785 || (value_format (abbrev_a) != value_format (die_a)))
10795 if (abbrev_id >= abbrev_die_table_in_use)
10797 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
10799 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
10800 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
10803 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
10804 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
10805 abbrev_die_table_allocated = n_alloc;
10808 ++abbrev_die_table_in_use;
10809 abbrev_die_table[abbrev_id] = die;
10812 die->die_abbrev = abbrev_id;
10813 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
10816 /* Return the power-of-two number of bytes necessary to represent VALUE. */
10819 constant_size (unsigned HOST_WIDE_INT value)
10826 log = floor_log2 (value);
10829 log = 1 << (floor_log2 (log) + 1);
10834 /* Return the size of a DIE as it is represented in the
10835 .debug_info section. */
10837 static unsigned long
10838 size_of_die (dw_die_ref die)
10840 unsigned long size = 0;
10844 size += size_of_uleb128 (die->die_abbrev);
10845 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10847 switch (AT_class (a))
10849 case dw_val_class_addr:
10850 size += DWARF2_ADDR_SIZE;
10852 case dw_val_class_offset:
10853 size += DWARF_OFFSET_SIZE;
10855 case dw_val_class_loc:
10857 unsigned long lsize = size_of_locs (AT_loc (a));
10859 /* Block length. */
10860 if (dwarf_version >= 4)
10861 size += size_of_uleb128 (lsize);
10863 size += constant_size (lsize);
10867 case dw_val_class_loc_list:
10868 size += DWARF_OFFSET_SIZE;
10870 case dw_val_class_range_list:
10871 size += DWARF_OFFSET_SIZE;
10873 case dw_val_class_const:
10874 size += size_of_sleb128 (AT_int (a));
10876 case dw_val_class_unsigned_const:
10877 size += constant_size (AT_unsigned (a));
10879 case dw_val_class_const_double:
10880 size += 2 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
10881 if (HOST_BITS_PER_WIDE_INT >= 64)
10882 size++; /* block */
10884 case dw_val_class_vec:
10885 size += constant_size (a->dw_attr_val.v.val_vec.length
10886 * a->dw_attr_val.v.val_vec.elt_size)
10887 + a->dw_attr_val.v.val_vec.length
10888 * a->dw_attr_val.v.val_vec.elt_size; /* block */
10890 case dw_val_class_flag:
10891 if (dwarf_version >= 4)
10892 /* Currently all add_AT_flag calls pass in 1 as last argument,
10893 so DW_FORM_flag_present can be used. If that ever changes,
10894 we'll need to use DW_FORM_flag and have some optimization
10895 in build_abbrev_table that will change those to
10896 DW_FORM_flag_present if it is set to 1 in all DIEs using
10897 the same abbrev entry. */
10898 gcc_assert (a->dw_attr_val.v.val_flag == 1);
10902 case dw_val_class_die_ref:
10903 if (AT_ref_external (a))
10905 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
10906 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
10907 is sized by target address length, whereas in DWARF3
10908 it's always sized as an offset. */
10909 if (use_debug_types)
10910 size += DWARF_TYPE_SIGNATURE_SIZE;
10911 else if (dwarf_version == 2)
10912 size += DWARF2_ADDR_SIZE;
10914 size += DWARF_OFFSET_SIZE;
10917 size += DWARF_OFFSET_SIZE;
10919 case dw_val_class_fde_ref:
10920 size += DWARF_OFFSET_SIZE;
10922 case dw_val_class_lbl_id:
10923 size += DWARF2_ADDR_SIZE;
10925 case dw_val_class_lineptr:
10926 case dw_val_class_macptr:
10927 size += DWARF_OFFSET_SIZE;
10929 case dw_val_class_str:
10930 if (AT_string_form (a) == DW_FORM_strp)
10931 size += DWARF_OFFSET_SIZE;
10933 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
10935 case dw_val_class_file:
10936 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
10938 case dw_val_class_data8:
10941 case dw_val_class_vms_delta:
10942 size += DWARF_OFFSET_SIZE;
10945 gcc_unreachable ();
10952 /* Size the debugging information associated with a given DIE. Visits the
10953 DIE's children recursively. Updates the global variable next_die_offset, on
10954 each time through. Uses the current value of next_die_offset to update the
10955 die_offset field in each DIE. */
10958 calc_die_sizes (dw_die_ref die)
10962 gcc_assert (die->die_offset == 0
10963 || (unsigned long int) die->die_offset == next_die_offset);
10964 die->die_offset = next_die_offset;
10965 next_die_offset += size_of_die (die);
10967 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
10969 if (die->die_child != NULL)
10970 /* Count the null byte used to terminate sibling lists. */
10971 next_die_offset += 1;
10974 /* Size just the base type children at the start of the CU.
10975 This is needed because build_abbrev needs to size locs
10976 and sizing of type based stack ops needs to know die_offset
10977 values for the base types. */
10980 calc_base_type_die_sizes (void)
10982 unsigned long die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10984 dw_die_ref base_type;
10985 #if ENABLE_ASSERT_CHECKING
10986 dw_die_ref prev = comp_unit_die ()->die_child;
10989 die_offset += size_of_die (comp_unit_die ());
10990 for (i = 0; VEC_iterate (dw_die_ref, base_types, i, base_type); i++)
10992 #if ENABLE_ASSERT_CHECKING
10993 gcc_assert (base_type->die_offset == 0
10994 && prev->die_sib == base_type
10995 && base_type->die_child == NULL
10996 && base_type->die_abbrev);
10999 base_type->die_offset = die_offset;
11000 die_offset += size_of_die (base_type);
11004 /* Set the marks for a die and its children. We do this so
11005 that we know whether or not a reference needs to use FORM_ref_addr; only
11006 DIEs in the same CU will be marked. We used to clear out the offset
11007 and use that as the flag, but ran into ordering problems. */
11010 mark_dies (dw_die_ref die)
11014 gcc_assert (!die->die_mark);
11017 FOR_EACH_CHILD (die, c, mark_dies (c));
11020 /* Clear the marks for a die and its children. */
11023 unmark_dies (dw_die_ref die)
11027 if (! use_debug_types)
11028 gcc_assert (die->die_mark);
11031 FOR_EACH_CHILD (die, c, unmark_dies (c));
11034 /* Clear the marks for a die, its children and referred dies. */
11037 unmark_all_dies (dw_die_ref die)
11043 if (!die->die_mark)
11047 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
11049 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
11050 if (AT_class (a) == dw_val_class_die_ref)
11051 unmark_all_dies (AT_ref (a));
11054 /* Return the size of the .debug_pubnames or .debug_pubtypes table
11055 generated for the compilation unit. */
11057 static unsigned long
11058 size_of_pubnames (VEC (pubname_entry, gc) * names)
11060 unsigned long size;
11064 size = DWARF_PUBNAMES_HEADER_SIZE;
11065 FOR_EACH_VEC_ELT (pubname_entry, names, i, p)
11066 if (names != pubtype_table
11067 || p->die->die_offset != 0
11068 || !flag_eliminate_unused_debug_types)
11069 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
11071 size += DWARF_OFFSET_SIZE;
11075 /* Return the size of the information in the .debug_aranges section. */
11077 static unsigned long
11078 size_of_aranges (void)
11080 unsigned long size;
11082 size = DWARF_ARANGES_HEADER_SIZE;
11084 /* Count the address/length pair for this compilation unit. */
11085 if (text_section_used)
11086 size += 2 * DWARF2_ADDR_SIZE;
11087 if (cold_text_section_used)
11088 size += 2 * DWARF2_ADDR_SIZE;
11089 if (have_multiple_function_sections)
11091 unsigned fde_idx = 0;
11093 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
11095 dw_fde_ref fde = &fde_table[fde_idx];
11097 if (!fde->in_std_section)
11098 size += 2 * DWARF2_ADDR_SIZE;
11099 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
11100 size += 2 * DWARF2_ADDR_SIZE;
11104 /* Count the two zero words used to terminated the address range table. */
11105 size += 2 * DWARF2_ADDR_SIZE;
11109 /* Select the encoding of an attribute value. */
11111 static enum dwarf_form
11112 value_format (dw_attr_ref a)
11114 switch (a->dw_attr_val.val_class)
11116 case dw_val_class_addr:
11117 /* Only very few attributes allow DW_FORM_addr. */
11118 switch (a->dw_attr)
11121 case DW_AT_high_pc:
11122 case DW_AT_entry_pc:
11123 case DW_AT_trampoline:
11124 return DW_FORM_addr;
11128 switch (DWARF2_ADDR_SIZE)
11131 return DW_FORM_data1;
11133 return DW_FORM_data2;
11135 return DW_FORM_data4;
11137 return DW_FORM_data8;
11139 gcc_unreachable ();
11141 case dw_val_class_range_list:
11142 case dw_val_class_loc_list:
11143 if (dwarf_version >= 4)
11144 return DW_FORM_sec_offset;
11146 case dw_val_class_vms_delta:
11147 case dw_val_class_offset:
11148 switch (DWARF_OFFSET_SIZE)
11151 return DW_FORM_data4;
11153 return DW_FORM_data8;
11155 gcc_unreachable ();
11157 case dw_val_class_loc:
11158 if (dwarf_version >= 4)
11159 return DW_FORM_exprloc;
11160 switch (constant_size (size_of_locs (AT_loc (a))))
11163 return DW_FORM_block1;
11165 return DW_FORM_block2;
11167 gcc_unreachable ();
11169 case dw_val_class_const:
11170 return DW_FORM_sdata;
11171 case dw_val_class_unsigned_const:
11172 switch (constant_size (AT_unsigned (a)))
11175 return DW_FORM_data1;
11177 return DW_FORM_data2;
11179 return DW_FORM_data4;
11181 return DW_FORM_data8;
11183 gcc_unreachable ();
11185 case dw_val_class_const_double:
11186 switch (HOST_BITS_PER_WIDE_INT)
11189 return DW_FORM_data2;
11191 return DW_FORM_data4;
11193 return DW_FORM_data8;
11196 return DW_FORM_block1;
11198 case dw_val_class_vec:
11199 switch (constant_size (a->dw_attr_val.v.val_vec.length
11200 * a->dw_attr_val.v.val_vec.elt_size))
11203 return DW_FORM_block1;
11205 return DW_FORM_block2;
11207 return DW_FORM_block4;
11209 gcc_unreachable ();
11211 case dw_val_class_flag:
11212 if (dwarf_version >= 4)
11214 /* Currently all add_AT_flag calls pass in 1 as last argument,
11215 so DW_FORM_flag_present can be used. If that ever changes,
11216 we'll need to use DW_FORM_flag and have some optimization
11217 in build_abbrev_table that will change those to
11218 DW_FORM_flag_present if it is set to 1 in all DIEs using
11219 the same abbrev entry. */
11220 gcc_assert (a->dw_attr_val.v.val_flag == 1);
11221 return DW_FORM_flag_present;
11223 return DW_FORM_flag;
11224 case dw_val_class_die_ref:
11225 if (AT_ref_external (a))
11226 return use_debug_types ? DW_FORM_ref_sig8 : DW_FORM_ref_addr;
11228 return DW_FORM_ref;
11229 case dw_val_class_fde_ref:
11230 return DW_FORM_data;
11231 case dw_val_class_lbl_id:
11232 return DW_FORM_addr;
11233 case dw_val_class_lineptr:
11234 case dw_val_class_macptr:
11235 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
11236 case dw_val_class_str:
11237 return AT_string_form (a);
11238 case dw_val_class_file:
11239 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
11242 return DW_FORM_data1;
11244 return DW_FORM_data2;
11246 return DW_FORM_data4;
11248 gcc_unreachable ();
11251 case dw_val_class_data8:
11252 return DW_FORM_data8;
11255 gcc_unreachable ();
11259 /* Output the encoding of an attribute value. */
11262 output_value_format (dw_attr_ref a)
11264 enum dwarf_form form = value_format (a);
11266 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
11269 /* Output the .debug_abbrev section which defines the DIE abbreviation
11273 output_abbrev_section (void)
11275 unsigned long abbrev_id;
11277 if (abbrev_die_table_in_use == 1)
11280 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
11282 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
11284 dw_attr_ref a_attr;
11286 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
11287 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
11288 dwarf_tag_name (abbrev->die_tag));
11290 if (abbrev->die_child != NULL)
11291 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
11293 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
11295 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
11298 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
11299 dwarf_attr_name (a_attr->dw_attr));
11300 output_value_format (a_attr);
11303 dw2_asm_output_data (1, 0, NULL);
11304 dw2_asm_output_data (1, 0, NULL);
11307 /* Terminate the table. */
11308 dw2_asm_output_data (1, 0, NULL);
11311 /* Output a symbol we can use to refer to this DIE from another CU. */
11314 output_die_symbol (dw_die_ref die)
11316 char *sym = die->die_id.die_symbol;
11321 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
11322 /* We make these global, not weak; if the target doesn't support
11323 .linkonce, it doesn't support combining the sections, so debugging
11325 targetm.asm_out.globalize_label (asm_out_file, sym);
11327 ASM_OUTPUT_LABEL (asm_out_file, sym);
11330 /* Return a new location list, given the begin and end range, and the
11333 static inline dw_loc_list_ref
11334 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
11335 const char *section)
11337 dw_loc_list_ref retlist = ggc_alloc_cleared_dw_loc_list_node ();
11339 retlist->begin = begin;
11340 retlist->end = end;
11341 retlist->expr = expr;
11342 retlist->section = section;
11347 /* Generate a new internal symbol for this location list node, if it
11348 hasn't got one yet. */
11351 gen_llsym (dw_loc_list_ref list)
11353 gcc_assert (!list->ll_symbol);
11354 list->ll_symbol = gen_internal_sym ("LLST");
11357 /* Output the location list given to us. */
11360 output_loc_list (dw_loc_list_ref list_head)
11362 dw_loc_list_ref curr = list_head;
11364 if (list_head->emitted)
11366 list_head->emitted = true;
11368 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
11370 /* Walk the location list, and output each range + expression. */
11371 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
11373 unsigned long size;
11374 /* Don't output an entry that starts and ends at the same address. */
11375 if (strcmp (curr->begin, curr->end) == 0)
11377 if (!have_multiple_function_sections)
11379 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
11380 "Location list begin address (%s)",
11381 list_head->ll_symbol);
11382 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
11383 "Location list end address (%s)",
11384 list_head->ll_symbol);
11388 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
11389 "Location list begin address (%s)",
11390 list_head->ll_symbol);
11391 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
11392 "Location list end address (%s)",
11393 list_head->ll_symbol);
11395 size = size_of_locs (curr->expr);
11397 /* Output the block length for this list of location operations. */
11398 gcc_assert (size <= 0xffff);
11399 dw2_asm_output_data (2, size, "%s", "Location expression size");
11401 output_loc_sequence (curr->expr, -1);
11404 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
11405 "Location list terminator begin (%s)",
11406 list_head->ll_symbol);
11407 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
11408 "Location list terminator end (%s)",
11409 list_head->ll_symbol);
11412 /* Output a type signature. */
11415 output_signature (const char *sig, const char *name)
11419 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11420 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
11423 /* Output the DIE and its attributes. Called recursively to generate
11424 the definitions of each child DIE. */
11427 output_die (dw_die_ref die)
11431 unsigned long size;
11434 /* If someone in another CU might refer to us, set up a symbol for
11435 them to point to. */
11436 if (! use_debug_types && die->die_id.die_symbol)
11437 output_die_symbol (die);
11439 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
11440 (unsigned long)die->die_offset,
11441 dwarf_tag_name (die->die_tag));
11443 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
11445 const char *name = dwarf_attr_name (a->dw_attr);
11447 switch (AT_class (a))
11449 case dw_val_class_addr:
11450 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
11453 case dw_val_class_offset:
11454 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
11458 case dw_val_class_range_list:
11460 char *p = strchr (ranges_section_label, '\0');
11462 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
11463 a->dw_attr_val.v.val_offset);
11464 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
11465 debug_ranges_section, "%s", name);
11470 case dw_val_class_loc:
11471 size = size_of_locs (AT_loc (a));
11473 /* Output the block length for this list of location operations. */
11474 if (dwarf_version >= 4)
11475 dw2_asm_output_data_uleb128 (size, "%s", name);
11477 dw2_asm_output_data (constant_size (size), size, "%s", name);
11479 output_loc_sequence (AT_loc (a), -1);
11482 case dw_val_class_const:
11483 /* ??? It would be slightly more efficient to use a scheme like is
11484 used for unsigned constants below, but gdb 4.x does not sign
11485 extend. Gdb 5.x does sign extend. */
11486 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
11489 case dw_val_class_unsigned_const:
11490 dw2_asm_output_data (constant_size (AT_unsigned (a)),
11491 AT_unsigned (a), "%s", name);
11494 case dw_val_class_const_double:
11496 unsigned HOST_WIDE_INT first, second;
11498 if (HOST_BITS_PER_WIDE_INT >= 64)
11499 dw2_asm_output_data (1,
11500 2 * HOST_BITS_PER_WIDE_INT
11501 / HOST_BITS_PER_CHAR,
11504 if (WORDS_BIG_ENDIAN)
11506 first = a->dw_attr_val.v.val_double.high;
11507 second = a->dw_attr_val.v.val_double.low;
11511 first = a->dw_attr_val.v.val_double.low;
11512 second = a->dw_attr_val.v.val_double.high;
11515 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
11517 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
11522 case dw_val_class_vec:
11524 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
11525 unsigned int len = a->dw_attr_val.v.val_vec.length;
11529 dw2_asm_output_data (constant_size (len * elt_size),
11530 len * elt_size, "%s", name);
11531 if (elt_size > sizeof (HOST_WIDE_INT))
11536 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
11538 i++, p += elt_size)
11539 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
11540 "fp or vector constant word %u", i);
11544 case dw_val_class_flag:
11545 if (dwarf_version >= 4)
11547 /* Currently all add_AT_flag calls pass in 1 as last argument,
11548 so DW_FORM_flag_present can be used. If that ever changes,
11549 we'll need to use DW_FORM_flag and have some optimization
11550 in build_abbrev_table that will change those to
11551 DW_FORM_flag_present if it is set to 1 in all DIEs using
11552 the same abbrev entry. */
11553 gcc_assert (AT_flag (a) == 1);
11554 if (flag_debug_asm)
11555 fprintf (asm_out_file, "\t\t\t%s %s\n",
11556 ASM_COMMENT_START, name);
11559 dw2_asm_output_data (1, AT_flag (a), "%s", name);
11562 case dw_val_class_loc_list:
11564 char *sym = AT_loc_list (a)->ll_symbol;
11567 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
11572 case dw_val_class_die_ref:
11573 if (AT_ref_external (a))
11575 if (use_debug_types)
11577 comdat_type_node_ref type_node =
11578 AT_ref (a)->die_id.die_type_node;
11580 gcc_assert (type_node);
11581 output_signature (type_node->signature, name);
11585 char *sym = AT_ref (a)->die_id.die_symbol;
11589 /* In DWARF2, DW_FORM_ref_addr is sized by target address
11590 length, whereas in DWARF3 it's always sized as an
11592 if (dwarf_version == 2)
11593 size = DWARF2_ADDR_SIZE;
11595 size = DWARF_OFFSET_SIZE;
11596 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
11602 gcc_assert (AT_ref (a)->die_offset);
11603 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
11608 case dw_val_class_fde_ref:
11612 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
11613 a->dw_attr_val.v.val_fde_index * 2);
11614 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
11619 case dw_val_class_vms_delta:
11620 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
11621 AT_vms_delta2 (a), AT_vms_delta1 (a),
11625 case dw_val_class_lbl_id:
11626 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
11629 case dw_val_class_lineptr:
11630 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
11631 debug_line_section, "%s", name);
11634 case dw_val_class_macptr:
11635 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
11636 debug_macinfo_section, "%s", name);
11639 case dw_val_class_str:
11640 if (AT_string_form (a) == DW_FORM_strp)
11641 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
11642 a->dw_attr_val.v.val_str->label,
11644 "%s: \"%s\"", name, AT_string (a));
11646 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
11649 case dw_val_class_file:
11651 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
11653 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
11654 a->dw_attr_val.v.val_file->filename);
11658 case dw_val_class_data8:
11662 for (i = 0; i < 8; i++)
11663 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
11664 i == 0 ? "%s" : NULL, name);
11669 gcc_unreachable ();
11673 FOR_EACH_CHILD (die, c, output_die (c));
11675 /* Add null byte to terminate sibling list. */
11676 if (die->die_child != NULL)
11677 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
11678 (unsigned long) die->die_offset);
11681 /* Output the compilation unit that appears at the beginning of the
11682 .debug_info section, and precedes the DIE descriptions. */
11685 output_compilation_unit_header (void)
11687 int ver = dwarf_version;
11689 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11690 dw2_asm_output_data (4, 0xffffffff,
11691 "Initial length escape value indicating 64-bit DWARF extension");
11692 dw2_asm_output_data (DWARF_OFFSET_SIZE,
11693 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
11694 "Length of Compilation Unit Info");
11695 dw2_asm_output_data (2, ver, "DWARF version number");
11696 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
11697 debug_abbrev_section,
11698 "Offset Into Abbrev. Section");
11699 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11702 /* Output the compilation unit DIE and its children. */
11705 output_comp_unit (dw_die_ref die, int output_if_empty)
11707 const char *secname;
11708 char *oldsym, *tmp;
11710 /* Unless we are outputting main CU, we may throw away empty ones. */
11711 if (!output_if_empty && die->die_child == NULL)
11714 /* Even if there are no children of this DIE, we must output the information
11715 about the compilation unit. Otherwise, on an empty translation unit, we
11716 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11717 will then complain when examining the file. First mark all the DIEs in
11718 this CU so we know which get local refs. */
11721 build_abbrev_table (die);
11723 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11724 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
11725 calc_die_sizes (die);
11727 oldsym = die->die_id.die_symbol;
11730 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
11732 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
11734 die->die_id.die_symbol = NULL;
11735 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11739 switch_to_section (debug_info_section);
11740 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
11741 info_section_emitted = true;
11744 /* Output debugging information. */
11745 output_compilation_unit_header ();
11748 /* Leave the marks on the main CU, so we can check them in
11749 output_pubnames. */
11753 die->die_id.die_symbol = oldsym;
11757 /* Output a comdat type unit DIE and its children. */
11760 output_comdat_type_unit (comdat_type_node *node)
11762 const char *secname;
11765 #if defined (OBJECT_FORMAT_ELF)
11769 /* First mark all the DIEs in this CU so we know which get local refs. */
11770 mark_dies (node->root_die);
11772 build_abbrev_table (node->root_die);
11774 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11775 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
11776 calc_die_sizes (node->root_die);
11778 #if defined (OBJECT_FORMAT_ELF)
11779 secname = ".debug_types";
11780 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11781 sprintf (tmp, "wt.");
11782 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11783 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
11784 comdat_key = get_identifier (tmp);
11785 targetm.asm_out.named_section (secname,
11786 SECTION_DEBUG | SECTION_LINKONCE,
11789 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11790 sprintf (tmp, ".gnu.linkonce.wt.");
11791 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11792 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
11794 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11797 /* Output debugging information. */
11798 output_compilation_unit_header ();
11799 output_signature (node->signature, "Type Signature");
11800 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
11801 "Offset to Type DIE");
11802 output_die (node->root_die);
11804 unmark_dies (node->root_die);
11807 /* Return the DWARF2/3 pubname associated with a decl. */
11809 static const char *
11810 dwarf2_name (tree decl, int scope)
11812 if (DECL_NAMELESS (decl))
11814 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
11817 /* Add a new entry to .debug_pubnames if appropriate. */
11820 add_pubname_string (const char *str, dw_die_ref die)
11822 if (targetm.want_debug_pub_sections)
11827 e.name = xstrdup (str);
11828 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
11833 add_pubname (tree decl, dw_die_ref die)
11835 if (targetm.want_debug_pub_sections && TREE_PUBLIC (decl))
11837 const char *name = dwarf2_name (decl, 1);
11839 add_pubname_string (name, die);
11843 /* Add a new entry to .debug_pubtypes if appropriate. */
11846 add_pubtype (tree decl, dw_die_ref die)
11850 if (!targetm.want_debug_pub_sections)
11854 if ((TREE_PUBLIC (decl)
11855 || is_cu_die (die->die_parent))
11856 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
11861 if (TYPE_NAME (decl))
11863 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
11864 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
11865 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
11866 && DECL_NAME (TYPE_NAME (decl)))
11867 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
11869 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
11874 e.name = dwarf2_name (decl, 1);
11876 e.name = xstrdup (e.name);
11879 /* If we don't have a name for the type, there's no point in adding
11880 it to the table. */
11881 if (e.name && e.name[0] != '\0')
11882 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
11886 /* Output the public names table used to speed up access to externally
11887 visible names; or the public types table used to find type definitions. */
11890 output_pubnames (VEC (pubname_entry, gc) * names)
11893 unsigned long pubnames_length = size_of_pubnames (names);
11896 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11897 dw2_asm_output_data (4, 0xffffffff,
11898 "Initial length escape value indicating 64-bit DWARF extension");
11899 if (names == pubname_table)
11900 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
11901 "Length of Public Names Info");
11903 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
11904 "Length of Public Type Names Info");
11905 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
11906 dw2_asm_output_data (2, 2, "DWARF Version");
11907 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11908 debug_info_section,
11909 "Offset of Compilation Unit Info");
11910 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
11911 "Compilation Unit Length");
11913 FOR_EACH_VEC_ELT (pubname_entry, names, i, pub)
11915 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11916 if (names == pubname_table)
11917 gcc_assert (pub->die->die_mark);
11919 if (names != pubtype_table
11920 || pub->die->die_offset != 0
11921 || !flag_eliminate_unused_debug_types)
11923 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
11926 dw2_asm_output_nstring (pub->name, -1, "external name");
11930 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
11933 /* Output the information that goes into the .debug_aranges table.
11934 Namely, define the beginning and ending address range of the
11935 text section generated for this compilation unit. */
11938 output_aranges (unsigned long aranges_length)
11942 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11943 dw2_asm_output_data (4, 0xffffffff,
11944 "Initial length escape value indicating 64-bit DWARF extension");
11945 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
11946 "Length of Address Ranges Info");
11947 /* Version number for aranges is still 2, even in DWARF3. */
11948 dw2_asm_output_data (2, 2, "DWARF Version");
11949 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11950 debug_info_section,
11951 "Offset of Compilation Unit Info");
11952 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
11953 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11955 /* We need to align to twice the pointer size here. */
11956 if (DWARF_ARANGES_PAD_SIZE)
11958 /* Pad using a 2 byte words so that padding is correct for any
11960 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11961 2 * DWARF2_ADDR_SIZE);
11962 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
11963 dw2_asm_output_data (2, 0, NULL);
11966 /* It is necessary not to output these entries if the sections were
11967 not used; if the sections were not used, the length will be 0 and
11968 the address may end up as 0 if the section is discarded by ld
11969 --gc-sections, leaving an invalid (0, 0) entry that can be
11970 confused with the terminator. */
11971 if (text_section_used)
11973 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
11974 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
11975 text_section_label, "Length");
11977 if (cold_text_section_used)
11979 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
11981 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
11982 cold_text_section_label, "Length");
11985 if (have_multiple_function_sections)
11987 unsigned fde_idx = 0;
11989 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
11991 dw_fde_ref fde = &fde_table[fde_idx];
11993 if (!fde->in_std_section)
11995 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
11997 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end,
11998 fde->dw_fde_begin, "Length");
12000 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
12002 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_second_begin,
12004 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_second_end,
12005 fde->dw_fde_second_begin, "Length");
12010 /* Output the terminator words. */
12011 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
12012 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
12015 /* Add a new entry to .debug_ranges. Return the offset at which it
12018 static unsigned int
12019 add_ranges_num (int num)
12021 unsigned int in_use = ranges_table_in_use;
12023 if (in_use == ranges_table_allocated)
12025 ranges_table_allocated += RANGES_TABLE_INCREMENT;
12026 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
12027 ranges_table_allocated);
12028 memset (ranges_table + ranges_table_in_use, 0,
12029 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
12032 ranges_table[in_use].num = num;
12033 ranges_table_in_use = in_use + 1;
12035 return in_use * 2 * DWARF2_ADDR_SIZE;
12038 /* Add a new entry to .debug_ranges corresponding to a block, or a
12039 range terminator if BLOCK is NULL. */
12041 static unsigned int
12042 add_ranges (const_tree block)
12044 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
12047 /* Add a new entry to .debug_ranges corresponding to a pair of
12051 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
12054 unsigned int in_use = ranges_by_label_in_use;
12055 unsigned int offset;
12057 if (in_use == ranges_by_label_allocated)
12059 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
12060 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
12062 ranges_by_label_allocated);
12063 memset (ranges_by_label + ranges_by_label_in_use, 0,
12064 RANGES_TABLE_INCREMENT
12065 * sizeof (struct dw_ranges_by_label_struct));
12068 ranges_by_label[in_use].begin = begin;
12069 ranges_by_label[in_use].end = end;
12070 ranges_by_label_in_use = in_use + 1;
12072 offset = add_ranges_num (-(int)in_use - 1);
12075 add_AT_range_list (die, DW_AT_ranges, offset);
12081 output_ranges (void)
12084 static const char *const start_fmt = "Offset %#x";
12085 const char *fmt = start_fmt;
12087 for (i = 0; i < ranges_table_in_use; i++)
12089 int block_num = ranges_table[i].num;
12093 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
12094 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
12096 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
12097 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
12099 /* If all code is in the text section, then the compilation
12100 unit base address defaults to DW_AT_low_pc, which is the
12101 base of the text section. */
12102 if (!have_multiple_function_sections)
12104 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
12105 text_section_label,
12106 fmt, i * 2 * DWARF2_ADDR_SIZE);
12107 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
12108 text_section_label, NULL);
12111 /* Otherwise, the compilation unit base address is zero,
12112 which allows us to use absolute addresses, and not worry
12113 about whether the target supports cross-section
12117 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
12118 fmt, i * 2 * DWARF2_ADDR_SIZE);
12119 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
12125 /* Negative block_num stands for an index into ranges_by_label. */
12126 else if (block_num < 0)
12128 int lab_idx = - block_num - 1;
12130 if (!have_multiple_function_sections)
12132 gcc_unreachable ();
12134 /* If we ever use add_ranges_by_labels () for a single
12135 function section, all we have to do is to take out
12136 the #if 0 above. */
12137 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
12138 ranges_by_label[lab_idx].begin,
12139 text_section_label,
12140 fmt, i * 2 * DWARF2_ADDR_SIZE);
12141 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
12142 ranges_by_label[lab_idx].end,
12143 text_section_label, NULL);
12148 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
12149 ranges_by_label[lab_idx].begin,
12150 fmt, i * 2 * DWARF2_ADDR_SIZE);
12151 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
12152 ranges_by_label[lab_idx].end,
12158 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
12159 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
12165 /* Data structure containing information about input files. */
12168 const char *path; /* Complete file name. */
12169 const char *fname; /* File name part. */
12170 int length; /* Length of entire string. */
12171 struct dwarf_file_data * file_idx; /* Index in input file table. */
12172 int dir_idx; /* Index in directory table. */
12175 /* Data structure containing information about directories with source
12179 const char *path; /* Path including directory name. */
12180 int length; /* Path length. */
12181 int prefix; /* Index of directory entry which is a prefix. */
12182 int count; /* Number of files in this directory. */
12183 int dir_idx; /* Index of directory used as base. */
12186 /* Callback function for file_info comparison. We sort by looking at
12187 the directories in the path. */
12190 file_info_cmp (const void *p1, const void *p2)
12192 const struct file_info *const s1 = (const struct file_info *) p1;
12193 const struct file_info *const s2 = (const struct file_info *) p2;
12194 const unsigned char *cp1;
12195 const unsigned char *cp2;
12197 /* Take care of file names without directories. We need to make sure that
12198 we return consistent values to qsort since some will get confused if
12199 we return the same value when identical operands are passed in opposite
12200 orders. So if neither has a directory, return 0 and otherwise return
12201 1 or -1 depending on which one has the directory. */
12202 if ((s1->path == s1->fname || s2->path == s2->fname))
12203 return (s2->path == s2->fname) - (s1->path == s1->fname);
12205 cp1 = (const unsigned char *) s1->path;
12206 cp2 = (const unsigned char *) s2->path;
12212 /* Reached the end of the first path? If so, handle like above. */
12213 if ((cp1 == (const unsigned char *) s1->fname)
12214 || (cp2 == (const unsigned char *) s2->fname))
12215 return ((cp2 == (const unsigned char *) s2->fname)
12216 - (cp1 == (const unsigned char *) s1->fname));
12218 /* Character of current path component the same? */
12219 else if (*cp1 != *cp2)
12220 return *cp1 - *cp2;
12224 struct file_name_acquire_data
12226 struct file_info *files;
12231 /* Traversal function for the hash table. */
12234 file_name_acquire (void ** slot, void *data)
12236 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
12237 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
12238 struct file_info *fi;
12241 gcc_assert (fnad->max_files >= d->emitted_number);
12243 if (! d->emitted_number)
12246 gcc_assert (fnad->max_files != fnad->used_files);
12248 fi = fnad->files + fnad->used_files++;
12250 /* Skip all leading "./". */
12252 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
12255 /* Create a new array entry. */
12257 fi->length = strlen (f);
12260 /* Search for the file name part. */
12261 f = strrchr (f, DIR_SEPARATOR);
12262 #if defined (DIR_SEPARATOR_2)
12264 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
12268 if (f == NULL || f < g)
12274 fi->fname = f == NULL ? fi->path : f + 1;
12278 /* Output the directory table and the file name table. We try to minimize
12279 the total amount of memory needed. A heuristic is used to avoid large
12280 slowdowns with many input files. */
12283 output_file_names (void)
12285 struct file_name_acquire_data fnad;
12287 struct file_info *files;
12288 struct dir_info *dirs;
12296 if (!last_emitted_file)
12298 dw2_asm_output_data (1, 0, "End directory table");
12299 dw2_asm_output_data (1, 0, "End file name table");
12303 numfiles = last_emitted_file->emitted_number;
12305 /* Allocate the various arrays we need. */
12306 files = XALLOCAVEC (struct file_info, numfiles);
12307 dirs = XALLOCAVEC (struct dir_info, numfiles);
12309 fnad.files = files;
12310 fnad.used_files = 0;
12311 fnad.max_files = numfiles;
12312 htab_traverse (file_table, file_name_acquire, &fnad);
12313 gcc_assert (fnad.used_files == fnad.max_files);
12315 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
12317 /* Find all the different directories used. */
12318 dirs[0].path = files[0].path;
12319 dirs[0].length = files[0].fname - files[0].path;
12320 dirs[0].prefix = -1;
12322 dirs[0].dir_idx = 0;
12323 files[0].dir_idx = 0;
12326 for (i = 1; i < numfiles; i++)
12327 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
12328 && memcmp (dirs[ndirs - 1].path, files[i].path,
12329 dirs[ndirs - 1].length) == 0)
12331 /* Same directory as last entry. */
12332 files[i].dir_idx = ndirs - 1;
12333 ++dirs[ndirs - 1].count;
12339 /* This is a new directory. */
12340 dirs[ndirs].path = files[i].path;
12341 dirs[ndirs].length = files[i].fname - files[i].path;
12342 dirs[ndirs].count = 1;
12343 dirs[ndirs].dir_idx = ndirs;
12344 files[i].dir_idx = ndirs;
12346 /* Search for a prefix. */
12347 dirs[ndirs].prefix = -1;
12348 for (j = 0; j < ndirs; j++)
12349 if (dirs[j].length < dirs[ndirs].length
12350 && dirs[j].length > 1
12351 && (dirs[ndirs].prefix == -1
12352 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
12353 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
12354 dirs[ndirs].prefix = j;
12359 /* Now to the actual work. We have to find a subset of the directories which
12360 allow expressing the file name using references to the directory table
12361 with the least amount of characters. We do not do an exhaustive search
12362 where we would have to check out every combination of every single
12363 possible prefix. Instead we use a heuristic which provides nearly optimal
12364 results in most cases and never is much off. */
12365 saved = XALLOCAVEC (int, ndirs);
12366 savehere = XALLOCAVEC (int, ndirs);
12368 memset (saved, '\0', ndirs * sizeof (saved[0]));
12369 for (i = 0; i < ndirs; i++)
12374 /* We can always save some space for the current directory. But this
12375 does not mean it will be enough to justify adding the directory. */
12376 savehere[i] = dirs[i].length;
12377 total = (savehere[i] - saved[i]) * dirs[i].count;
12379 for (j = i + 1; j < ndirs; j++)
12382 if (saved[j] < dirs[i].length)
12384 /* Determine whether the dirs[i] path is a prefix of the
12388 k = dirs[j].prefix;
12389 while (k != -1 && k != (int) i)
12390 k = dirs[k].prefix;
12394 /* Yes it is. We can possibly save some memory by
12395 writing the filenames in dirs[j] relative to
12397 savehere[j] = dirs[i].length;
12398 total += (savehere[j] - saved[j]) * dirs[j].count;
12403 /* Check whether we can save enough to justify adding the dirs[i]
12405 if (total > dirs[i].length + 1)
12407 /* It's worthwhile adding. */
12408 for (j = i; j < ndirs; j++)
12409 if (savehere[j] > 0)
12411 /* Remember how much we saved for this directory so far. */
12412 saved[j] = savehere[j];
12414 /* Remember the prefix directory. */
12415 dirs[j].dir_idx = i;
12420 /* Emit the directory name table. */
12421 idx_offset = dirs[0].length > 0 ? 1 : 0;
12422 for (i = 1 - idx_offset; i < ndirs; i++)
12423 dw2_asm_output_nstring (dirs[i].path,
12425 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
12426 "Directory Entry: %#x", i + idx_offset);
12428 dw2_asm_output_data (1, 0, "End directory table");
12430 /* We have to emit them in the order of emitted_number since that's
12431 used in the debug info generation. To do this efficiently we
12432 generate a back-mapping of the indices first. */
12433 backmap = XALLOCAVEC (int, numfiles);
12434 for (i = 0; i < numfiles; i++)
12435 backmap[files[i].file_idx->emitted_number - 1] = i;
12437 /* Now write all the file names. */
12438 for (i = 0; i < numfiles; i++)
12440 int file_idx = backmap[i];
12441 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
12443 #ifdef VMS_DEBUGGING_INFO
12444 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12446 /* Setting these fields can lead to debugger miscomparisons,
12447 but VMS Debug requires them to be set correctly. */
12452 int maxfilelen = strlen (files[file_idx].path)
12453 + dirs[dir_idx].length
12454 + MAX_VMS_VERSION_LEN + 1;
12455 char *filebuf = XALLOCAVEC (char, maxfilelen);
12457 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
12458 snprintf (filebuf, maxfilelen, "%s;%d",
12459 files[file_idx].path + dirs[dir_idx].length, ver);
12461 dw2_asm_output_nstring
12462 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1);
12464 /* Include directory index. */
12465 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
12467 /* Modification time. */
12468 dw2_asm_output_data_uleb128
12469 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
12473 /* File length in bytes. */
12474 dw2_asm_output_data_uleb128
12475 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
12479 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
12480 "File Entry: %#x", (unsigned) i + 1);
12482 /* Include directory index. */
12483 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
12485 /* Modification time. */
12486 dw2_asm_output_data_uleb128 (0, NULL);
12488 /* File length in bytes. */
12489 dw2_asm_output_data_uleb128 (0, NULL);
12490 #endif /* VMS_DEBUGGING_INFO */
12493 dw2_asm_output_data (1, 0, "End file name table");
12497 /* Output one line number table into the .debug_line section. */
12500 output_one_line_info_table (dw_line_info_table *table)
12502 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
12503 unsigned int current_line = 1;
12504 bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
12505 dw_line_info_entry *ent;
12508 FOR_EACH_VEC_ELT (dw_line_info_entry, table->entries, i, ent)
12510 switch (ent->opcode)
12512 case LI_set_address:
12513 /* ??? Unfortunately, we have little choice here currently, and
12514 must always use the most general form. GCC does not know the
12515 address delta itself, so we can't use DW_LNS_advance_pc. Many
12516 ports do have length attributes which will give an upper bound
12517 on the address range. We could perhaps use length attributes
12518 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12519 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
12521 /* This can handle any delta. This takes
12522 4+DWARF2_ADDR_SIZE bytes. */
12523 dw2_asm_output_data (1, 0, "set address %s", line_label);
12524 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12525 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12526 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12530 if (ent->val == current_line)
12532 /* We still need to start a new row, so output a copy insn. */
12533 dw2_asm_output_data (1, DW_LNS_copy,
12534 "copy line %u", current_line);
12538 int line_offset = ent->val - current_line;
12539 int line_delta = line_offset - DWARF_LINE_BASE;
12541 current_line = ent->val;
12542 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
12544 /* This can handle deltas from -10 to 234, using the current
12545 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
12546 This takes 1 byte. */
12547 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
12548 "line %u", current_line);
12552 /* This can handle any delta. This takes at least 4 bytes,
12553 depending on the value being encoded. */
12554 dw2_asm_output_data (1, DW_LNS_advance_line,
12555 "advance to line %u", current_line);
12556 dw2_asm_output_data_sleb128 (line_offset, NULL);
12557 dw2_asm_output_data (1, DW_LNS_copy, NULL);
12563 dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val);
12564 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
12567 case LI_set_column:
12568 dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val);
12569 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
12572 case LI_negate_stmt:
12573 current_is_stmt = !current_is_stmt;
12574 dw2_asm_output_data (1, DW_LNS_negate_stmt,
12575 "is_stmt %d", current_is_stmt);
12578 case LI_set_prologue_end:
12579 dw2_asm_output_data (1, DW_LNS_set_prologue_end,
12580 "set prologue end");
12583 case LI_set_epilogue_begin:
12584 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin,
12585 "set epilogue begin");
12588 case LI_set_discriminator:
12589 dw2_asm_output_data (1, 0, "discriminator %u", ent->val);
12590 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL);
12591 dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL);
12592 dw2_asm_output_data_uleb128 (ent->val, NULL);
12597 /* Emit debug info for the address of the end of the table. */
12598 dw2_asm_output_data (1, 0, "set address %s", table->end_label);
12599 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12600 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12601 dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL);
12603 dw2_asm_output_data (1, 0, "end sequence");
12604 dw2_asm_output_data_uleb128 (1, NULL);
12605 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
12608 /* Output the source line number correspondence information. This
12609 information goes into the .debug_line section. */
12612 output_line_info (void)
12614 char l1[20], l2[20], p1[20], p2[20];
12615 int ver = dwarf_version;
12616 bool saw_one = false;
12619 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
12620 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
12621 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
12622 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
12624 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
12625 dw2_asm_output_data (4, 0xffffffff,
12626 "Initial length escape value indicating 64-bit DWARF extension");
12627 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
12628 "Length of Source Line Info");
12629 ASM_OUTPUT_LABEL (asm_out_file, l1);
12631 dw2_asm_output_data (2, ver, "DWARF Version");
12632 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
12633 ASM_OUTPUT_LABEL (asm_out_file, p1);
12635 /* Define the architecture-dependent minimum instruction length (in bytes).
12636 In this implementation of DWARF, this field is used for information
12637 purposes only. Since GCC generates assembly language, we have no
12638 a priori knowledge of how many instruction bytes are generated for each
12639 source line, and therefore can use only the DW_LNE_set_address and
12640 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12641 this as '1', which is "correct enough" for all architectures,
12642 and don't let the target override. */
12643 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12646 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
12647 "Maximum Operations Per Instruction");
12648 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
12649 "Default is_stmt_start flag");
12650 dw2_asm_output_data (1, DWARF_LINE_BASE,
12651 "Line Base Value (Special Opcodes)");
12652 dw2_asm_output_data (1, DWARF_LINE_RANGE,
12653 "Line Range Value (Special Opcodes)");
12654 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
12655 "Special Opcode Base");
12657 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
12662 case DW_LNS_advance_pc:
12663 case DW_LNS_advance_line:
12664 case DW_LNS_set_file:
12665 case DW_LNS_set_column:
12666 case DW_LNS_fixed_advance_pc:
12667 case DW_LNS_set_isa:
12675 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
12679 /* Write out the information about the files we use. */
12680 output_file_names ();
12681 ASM_OUTPUT_LABEL (asm_out_file, p2);
12683 if (separate_line_info)
12685 dw_line_info_table *table;
12688 FOR_EACH_VEC_ELT (dw_line_info_table_p, separate_line_info, i, table)
12691 output_one_line_info_table (table);
12695 if (cold_text_section_line_info && cold_text_section_line_info->in_use)
12697 output_one_line_info_table (cold_text_section_line_info);
12701 /* ??? Some Darwin linkers crash on a .debug_line section with no
12702 sequences. Further, merely a DW_LNE_end_sequence entry is not
12703 sufficient -- the address column must also be initialized.
12704 Make sure to output at least one set_address/end_sequence pair,
12705 choosing .text since that section is always present. */
12706 if (text_section_line_info->in_use || !saw_one)
12707 output_one_line_info_table (text_section_line_info);
12709 /* Output the marker for the end of the line number info. */
12710 ASM_OUTPUT_LABEL (asm_out_file, l2);
12713 /* Given a pointer to a tree node for some base type, return a pointer to
12714 a DIE that describes the given type.
12716 This routine must only be called for GCC type nodes that correspond to
12717 Dwarf base (fundamental) types. */
12720 base_type_die (tree type)
12722 dw_die_ref base_type_result;
12723 enum dwarf_type encoding;
12725 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
12728 /* If this is a subtype that should not be emitted as a subrange type,
12729 use the base type. See subrange_type_for_debug_p. */
12730 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
12731 type = TREE_TYPE (type);
12733 switch (TREE_CODE (type))
12736 if ((dwarf_version >= 4 || !dwarf_strict)
12737 && TYPE_NAME (type)
12738 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12739 && DECL_IS_BUILTIN (TYPE_NAME (type))
12740 && DECL_NAME (TYPE_NAME (type)))
12742 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
12743 if (strcmp (name, "char16_t") == 0
12744 || strcmp (name, "char32_t") == 0)
12746 encoding = DW_ATE_UTF;
12750 if (TYPE_STRING_FLAG (type))
12752 if (TYPE_UNSIGNED (type))
12753 encoding = DW_ATE_unsigned_char;
12755 encoding = DW_ATE_signed_char;
12757 else if (TYPE_UNSIGNED (type))
12758 encoding = DW_ATE_unsigned;
12760 encoding = DW_ATE_signed;
12764 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
12766 if (dwarf_version >= 3 || !dwarf_strict)
12767 encoding = DW_ATE_decimal_float;
12769 encoding = DW_ATE_lo_user;
12772 encoding = DW_ATE_float;
12775 case FIXED_POINT_TYPE:
12776 if (!(dwarf_version >= 3 || !dwarf_strict))
12777 encoding = DW_ATE_lo_user;
12778 else if (TYPE_UNSIGNED (type))
12779 encoding = DW_ATE_unsigned_fixed;
12781 encoding = DW_ATE_signed_fixed;
12784 /* Dwarf2 doesn't know anything about complex ints, so use
12785 a user defined type for it. */
12787 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
12788 encoding = DW_ATE_complex_float;
12790 encoding = DW_ATE_lo_user;
12794 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12795 encoding = DW_ATE_boolean;
12799 /* No other TREE_CODEs are Dwarf fundamental types. */
12800 gcc_unreachable ();
12803 base_type_result = new_die (DW_TAG_base_type, comp_unit_die (), type);
12805 add_AT_unsigned (base_type_result, DW_AT_byte_size,
12806 int_size_in_bytes (type));
12807 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
12809 return base_type_result;
12812 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12813 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12816 is_base_type (tree type)
12818 switch (TREE_CODE (type))
12824 case FIXED_POINT_TYPE:
12832 case QUAL_UNION_TYPE:
12833 case ENUMERAL_TYPE:
12834 case FUNCTION_TYPE:
12837 case REFERENCE_TYPE:
12845 gcc_unreachable ();
12851 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12852 node, return the size in bits for the type if it is a constant, or else
12853 return the alignment for the type if the type's size is not constant, or
12854 else return BITS_PER_WORD if the type actually turns out to be an
12855 ERROR_MARK node. */
12857 static inline unsigned HOST_WIDE_INT
12858 simple_type_size_in_bits (const_tree type)
12860 if (TREE_CODE (type) == ERROR_MARK)
12861 return BITS_PER_WORD;
12862 else if (TYPE_SIZE (type) == NULL_TREE)
12864 else if (host_integerp (TYPE_SIZE (type), 1))
12865 return tree_low_cst (TYPE_SIZE (type), 1);
12867 return TYPE_ALIGN (type);
12870 /* Similarly, but return a double_int instead of UHWI. */
12872 static inline double_int
12873 double_int_type_size_in_bits (const_tree type)
12875 if (TREE_CODE (type) == ERROR_MARK)
12876 return uhwi_to_double_int (BITS_PER_WORD);
12877 else if (TYPE_SIZE (type) == NULL_TREE)
12878 return double_int_zero;
12879 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
12880 return tree_to_double_int (TYPE_SIZE (type));
12882 return uhwi_to_double_int (TYPE_ALIGN (type));
12885 /* Given a pointer to a tree node for a subrange type, return a pointer
12886 to a DIE that describes the given type. */
12889 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
12891 dw_die_ref subrange_die;
12892 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
12894 if (context_die == NULL)
12895 context_die = comp_unit_die ();
12897 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
12899 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
12901 /* The size of the subrange type and its base type do not match,
12902 so we need to generate a size attribute for the subrange type. */
12903 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
12907 add_bound_info (subrange_die, DW_AT_lower_bound, low);
12909 add_bound_info (subrange_die, DW_AT_upper_bound, high);
12911 return subrange_die;
12914 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
12915 entry that chains various modifiers in front of the given type. */
12918 modified_type_die (tree type, int is_const_type, int is_volatile_type,
12919 dw_die_ref context_die)
12921 enum tree_code code = TREE_CODE (type);
12922 dw_die_ref mod_type_die;
12923 dw_die_ref sub_die = NULL;
12924 tree item_type = NULL;
12925 tree qualified_type;
12926 tree name, low, high;
12928 if (code == ERROR_MARK)
12931 /* See if we already have the appropriately qualified variant of
12934 = get_qualified_type (type,
12935 ((is_const_type ? TYPE_QUAL_CONST : 0)
12936 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
12938 if (qualified_type == sizetype
12939 && TYPE_NAME (qualified_type)
12940 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
12942 tree t = TREE_TYPE (TYPE_NAME (qualified_type));
12944 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE
12945 && TYPE_PRECISION (t)
12946 == TYPE_PRECISION (qualified_type)
12947 && TYPE_UNSIGNED (t)
12948 == TYPE_UNSIGNED (qualified_type));
12949 qualified_type = t;
12952 /* If we do, then we can just use its DIE, if it exists. */
12953 if (qualified_type)
12955 mod_type_die = lookup_type_die (qualified_type);
12957 return mod_type_die;
12960 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
12962 /* Handle C typedef types. */
12963 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)
12964 && !DECL_ARTIFICIAL (name))
12966 tree dtype = TREE_TYPE (name);
12968 if (qualified_type == dtype)
12970 /* For a named type, use the typedef. */
12971 gen_type_die (qualified_type, context_die);
12972 return lookup_type_die (qualified_type);
12974 else if (is_const_type < TYPE_READONLY (dtype)
12975 || is_volatile_type < TYPE_VOLATILE (dtype)
12976 || (is_const_type <= TYPE_READONLY (dtype)
12977 && is_volatile_type <= TYPE_VOLATILE (dtype)
12978 && DECL_ORIGINAL_TYPE (name) != type))
12979 /* cv-unqualified version of named type. Just use the unnamed
12980 type to which it refers. */
12981 return modified_type_die (DECL_ORIGINAL_TYPE (name),
12982 is_const_type, is_volatile_type,
12984 /* Else cv-qualified version of named type; fall through. */
12988 /* If both is_const_type and is_volatile_type, prefer the path
12989 which leads to a qualified type. */
12990 && (!is_volatile_type
12991 || get_qualified_type (type, TYPE_QUAL_CONST) == NULL_TREE
12992 || get_qualified_type (type, TYPE_QUAL_VOLATILE) != NULL_TREE))
12994 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die (), type);
12995 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
12997 else if (is_volatile_type)
12999 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die (), type);
13000 sub_die = modified_type_die (type, is_const_type, 0, context_die);
13002 else if (code == POINTER_TYPE)
13004 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die (), type);
13005 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
13006 simple_type_size_in_bits (type) / BITS_PER_UNIT);
13007 item_type = TREE_TYPE (type);
13008 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
13009 add_AT_unsigned (mod_type_die, DW_AT_address_class,
13010 TYPE_ADDR_SPACE (item_type));
13012 else if (code == REFERENCE_TYPE)
13014 if (TYPE_REF_IS_RVALUE (type) && use_debug_types)
13015 mod_type_die = new_die (DW_TAG_rvalue_reference_type, comp_unit_die (),
13018 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die (), type);
13019 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
13020 simple_type_size_in_bits (type) / BITS_PER_UNIT);
13021 item_type = TREE_TYPE (type);
13022 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
13023 add_AT_unsigned (mod_type_die, DW_AT_address_class,
13024 TYPE_ADDR_SPACE (item_type));
13026 else if (code == INTEGER_TYPE
13027 && TREE_TYPE (type) != NULL_TREE
13028 && subrange_type_for_debug_p (type, &low, &high))
13030 mod_type_die = subrange_type_die (type, low, high, context_die);
13031 item_type = TREE_TYPE (type);
13033 else if (is_base_type (type))
13034 mod_type_die = base_type_die (type);
13037 gen_type_die (type, context_die);
13039 /* We have to get the type_main_variant here (and pass that to the
13040 `lookup_type_die' routine) because the ..._TYPE node we have
13041 might simply be a *copy* of some original type node (where the
13042 copy was created to help us keep track of typedef names) and
13043 that copy might have a different TYPE_UID from the original
13045 if (TREE_CODE (type) != VECTOR_TYPE)
13046 return lookup_type_die (type_main_variant (type));
13048 /* Vectors have the debugging information in the type,
13049 not the main variant. */
13050 return lookup_type_die (type);
13053 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13054 don't output a DW_TAG_typedef, since there isn't one in the
13055 user's program; just attach a DW_AT_name to the type.
13056 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13057 if the base type already has the same name. */
13059 && ((TREE_CODE (name) != TYPE_DECL
13060 && (qualified_type == TYPE_MAIN_VARIANT (type)
13061 || (!is_const_type && !is_volatile_type)))
13062 || (TREE_CODE (name) == TYPE_DECL
13063 && TREE_TYPE (name) == qualified_type
13064 && DECL_NAME (name))))
13066 if (TREE_CODE (name) == TYPE_DECL)
13067 /* Could just call add_name_and_src_coords_attributes here,
13068 but since this is a builtin type it doesn't have any
13069 useful source coordinates anyway. */
13070 name = DECL_NAME (name);
13071 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
13072 add_gnat_descriptive_type_attribute (mod_type_die, type, context_die);
13074 /* This probably indicates a bug. */
13075 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
13076 add_name_attribute (mod_type_die, "__unknown__");
13078 if (qualified_type)
13079 equate_type_number_to_die (qualified_type, mod_type_die);
13082 /* We must do this after the equate_type_number_to_die call, in case
13083 this is a recursive type. This ensures that the modified_type_die
13084 recursion will terminate even if the type is recursive. Recursive
13085 types are possible in Ada. */
13086 sub_die = modified_type_die (item_type,
13087 TYPE_READONLY (item_type),
13088 TYPE_VOLATILE (item_type),
13091 if (sub_die != NULL)
13092 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
13094 return mod_type_die;
13097 /* Generate DIEs for the generic parameters of T.
13098 T must be either a generic type or a generic function.
13099 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
13102 gen_generic_params_dies (tree t)
13106 dw_die_ref die = NULL;
13108 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
13112 die = lookup_type_die (t);
13113 else if (DECL_P (t))
13114 die = lookup_decl_die (t);
13118 parms = lang_hooks.get_innermost_generic_parms (t);
13120 /* T has no generic parameter. It means T is neither a generic type
13121 or function. End of story. */
13124 parms_num = TREE_VEC_LENGTH (parms);
13125 args = lang_hooks.get_innermost_generic_args (t);
13126 for (i = 0; i < parms_num; i++)
13128 tree parm, arg, arg_pack_elems;
13130 parm = TREE_VEC_ELT (parms, i);
13131 arg = TREE_VEC_ELT (args, i);
13132 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
13133 gcc_assert (parm && TREE_VALUE (parm) && arg);
13135 if (parm && TREE_VALUE (parm) && arg)
13137 /* If PARM represents a template parameter pack,
13138 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
13139 by DW_TAG_template_*_parameter DIEs for the argument
13140 pack elements of ARG. Note that ARG would then be
13141 an argument pack. */
13142 if (arg_pack_elems)
13143 template_parameter_pack_die (TREE_VALUE (parm),
13147 generic_parameter_die (TREE_VALUE (parm), arg,
13148 true /* Emit DW_AT_name */, die);
13153 /* Create and return a DIE for PARM which should be
13154 the representation of a generic type parameter.
13155 For instance, in the C++ front end, PARM would be a template parameter.
13156 ARG is the argument to PARM.
13157 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
13159 PARENT_DIE is the parent DIE which the new created DIE should be added to,
13160 as a child node. */
13163 generic_parameter_die (tree parm, tree arg,
13165 dw_die_ref parent_die)
13167 dw_die_ref tmpl_die = NULL;
13168 const char *name = NULL;
13170 if (!parm || !DECL_NAME (parm) || !arg)
13173 /* We support non-type generic parameters and arguments,
13174 type generic parameters and arguments, as well as
13175 generic generic parameters (a.k.a. template template parameters in C++)
13177 if (TREE_CODE (parm) == PARM_DECL)
13178 /* PARM is a nontype generic parameter */
13179 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
13180 else if (TREE_CODE (parm) == TYPE_DECL)
13181 /* PARM is a type generic parameter. */
13182 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
13183 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
13184 /* PARM is a generic generic parameter.
13185 Its DIE is a GNU extension. It shall have a
13186 DW_AT_name attribute to represent the name of the template template
13187 parameter, and a DW_AT_GNU_template_name attribute to represent the
13188 name of the template template argument. */
13189 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
13192 gcc_unreachable ();
13198 /* If PARM is a generic parameter pack, it means we are
13199 emitting debug info for a template argument pack element.
13200 In other terms, ARG is a template argument pack element.
13201 In that case, we don't emit any DW_AT_name attribute for
13205 name = IDENTIFIER_POINTER (DECL_NAME (parm));
13207 add_AT_string (tmpl_die, DW_AT_name, name);
13210 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
13212 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
13213 TMPL_DIE should have a child DW_AT_type attribute that is set
13214 to the type of the argument to PARM, which is ARG.
13215 If PARM is a type generic parameter, TMPL_DIE should have a
13216 child DW_AT_type that is set to ARG. */
13217 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
13218 add_type_attribute (tmpl_die, tmpl_type, 0,
13219 TREE_THIS_VOLATILE (tmpl_type),
13224 /* So TMPL_DIE is a DIE representing a
13225 a generic generic template parameter, a.k.a template template
13226 parameter in C++ and arg is a template. */
13228 /* The DW_AT_GNU_template_name attribute of the DIE must be set
13229 to the name of the argument. */
13230 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
13232 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
13235 if (TREE_CODE (parm) == PARM_DECL)
13236 /* So PARM is a non-type generic parameter.
13237 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13238 attribute of TMPL_DIE which value represents the value
13240 We must be careful here:
13241 The value of ARG might reference some function decls.
13242 We might currently be emitting debug info for a generic
13243 type and types are emitted before function decls, we don't
13244 know if the function decls referenced by ARG will actually be
13245 emitted after cgraph computations.
13246 So must defer the generation of the DW_AT_const_value to
13247 after cgraph is ready. */
13248 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
13254 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13255 PARM_PACK must be a template parameter pack. The returned DIE
13256 will be child DIE of PARENT_DIE. */
13259 template_parameter_pack_die (tree parm_pack,
13260 tree parm_pack_args,
13261 dw_die_ref parent_die)
13266 gcc_assert (parent_die && parm_pack);
13268 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
13269 add_name_and_src_coords_attributes (die, parm_pack);
13270 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
13271 generic_parameter_die (parm_pack,
13272 TREE_VEC_ELT (parm_pack_args, j),
13273 false /* Don't emit DW_AT_name */,
13278 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
13279 an enumerated type. */
13282 type_is_enum (const_tree type)
13284 return TREE_CODE (type) == ENUMERAL_TYPE;
13287 /* Return the DBX register number described by a given RTL node. */
13289 static unsigned int
13290 dbx_reg_number (const_rtx rtl)
13292 unsigned regno = REGNO (rtl);
13294 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
13296 #ifdef LEAF_REG_REMAP
13297 if (current_function_uses_only_leaf_regs)
13299 int leaf_reg = LEAF_REG_REMAP (regno);
13300 if (leaf_reg != -1)
13301 regno = (unsigned) leaf_reg;
13305 return DBX_REGISTER_NUMBER (regno);
13308 /* Optionally add a DW_OP_piece term to a location description expression.
13309 DW_OP_piece is only added if the location description expression already
13310 doesn't end with DW_OP_piece. */
13313 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
13315 dw_loc_descr_ref loc;
13317 if (*list_head != NULL)
13319 /* Find the end of the chain. */
13320 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
13323 if (loc->dw_loc_opc != DW_OP_piece)
13324 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
13328 /* Return a location descriptor that designates a machine register or
13329 zero if there is none. */
13331 static dw_loc_descr_ref
13332 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
13336 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
13339 /* We only use "frame base" when we're sure we're talking about the
13340 post-prologue local stack frame. We do this by *not* running
13341 register elimination until this point, and recognizing the special
13342 argument pointer and soft frame pointer rtx's.
13343 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13344 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
13345 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
13347 dw_loc_descr_ref result = NULL;
13349 if (dwarf_version >= 4 || !dwarf_strict)
13351 result = mem_loc_descriptor (rtl, GET_MODE (rtl), VOIDmode,
13354 add_loc_descr (&result,
13355 new_loc_descr (DW_OP_stack_value, 0, 0));
13360 regs = targetm.dwarf_register_span (rtl);
13362 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
13363 return multiple_reg_loc_descriptor (rtl, regs, initialized);
13365 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
13368 /* Return a location descriptor that designates a machine register for
13369 a given hard register number. */
13371 static dw_loc_descr_ref
13372 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
13374 dw_loc_descr_ref reg_loc_descr;
13378 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
13380 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
13382 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13383 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13385 return reg_loc_descr;
13388 /* Given an RTL of a register, return a location descriptor that
13389 designates a value that spans more than one register. */
13391 static dw_loc_descr_ref
13392 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
13393 enum var_init_status initialized)
13395 int nregs, size, i;
13397 dw_loc_descr_ref loc_result = NULL;
13400 #ifdef LEAF_REG_REMAP
13401 if (current_function_uses_only_leaf_regs)
13403 int leaf_reg = LEAF_REG_REMAP (reg);
13404 if (leaf_reg != -1)
13405 reg = (unsigned) leaf_reg;
13408 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
13409 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
13411 /* Simple, contiguous registers. */
13412 if (regs == NULL_RTX)
13414 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
13419 dw_loc_descr_ref t;
13421 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
13422 VAR_INIT_STATUS_INITIALIZED);
13423 add_loc_descr (&loc_result, t);
13424 add_loc_descr_op_piece (&loc_result, size);
13430 /* Now onto stupid register sets in non contiguous locations. */
13432 gcc_assert (GET_CODE (regs) == PARALLEL);
13434 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
13437 for (i = 0; i < XVECLEN (regs, 0); ++i)
13439 dw_loc_descr_ref t;
13441 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
13442 VAR_INIT_STATUS_INITIALIZED);
13443 add_loc_descr (&loc_result, t);
13444 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
13445 add_loc_descr_op_piece (&loc_result, size);
13448 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13449 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13453 /* Return a location descriptor that designates a constant. */
13455 static dw_loc_descr_ref
13456 int_loc_descriptor (HOST_WIDE_INT i)
13458 enum dwarf_location_atom op;
13460 /* Pick the smallest representation of a constant, rather than just
13461 defaulting to the LEB encoding. */
13465 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
13466 else if (i <= 0xff)
13467 op = DW_OP_const1u;
13468 else if (i <= 0xffff)
13469 op = DW_OP_const2u;
13470 else if (HOST_BITS_PER_WIDE_INT == 32
13471 || i <= 0xffffffff)
13472 op = DW_OP_const4u;
13479 op = DW_OP_const1s;
13480 else if (i >= -0x8000)
13481 op = DW_OP_const2s;
13482 else if (HOST_BITS_PER_WIDE_INT == 32
13483 || i >= -0x80000000)
13484 op = DW_OP_const4s;
13489 return new_loc_descr (op, i, 0);
13492 /* Return loc description representing "address" of integer value.
13493 This can appear only as toplevel expression. */
13495 static dw_loc_descr_ref
13496 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
13499 dw_loc_descr_ref loc_result = NULL;
13501 if (!(dwarf_version >= 4 || !dwarf_strict))
13508 else if (i <= 0xff)
13510 else if (i <= 0xffff)
13512 else if (HOST_BITS_PER_WIDE_INT == 32
13513 || i <= 0xffffffff)
13516 litsize = 1 + size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
13522 else if (i >= -0x8000)
13524 else if (HOST_BITS_PER_WIDE_INT == 32
13525 || i >= -0x80000000)
13528 litsize = 1 + size_of_sleb128 (i);
13530 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
13531 is more compact. For DW_OP_stack_value we need:
13532 litsize + 1 (DW_OP_stack_value)
13533 and for DW_OP_implicit_value:
13534 1 (DW_OP_implicit_value) + 1 (length) + size. */
13535 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
13537 loc_result = int_loc_descriptor (i);
13538 add_loc_descr (&loc_result,
13539 new_loc_descr (DW_OP_stack_value, 0, 0));
13543 loc_result = new_loc_descr (DW_OP_implicit_value,
13545 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
13546 loc_result->dw_loc_oprnd2.v.val_int = i;
13550 /* Return a location descriptor that designates a base+offset location. */
13552 static dw_loc_descr_ref
13553 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
13554 enum var_init_status initialized)
13556 unsigned int regno;
13557 dw_loc_descr_ref result;
13558 dw_fde_ref fde = current_fde ();
13560 /* We only use "frame base" when we're sure we're talking about the
13561 post-prologue local stack frame. We do this by *not* running
13562 register elimination until this point, and recognizing the special
13563 argument pointer and soft frame pointer rtx's. */
13564 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
13566 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
13570 if (GET_CODE (elim) == PLUS)
13572 offset += INTVAL (XEXP (elim, 1));
13573 elim = XEXP (elim, 0);
13575 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
13576 && (elim == hard_frame_pointer_rtx
13577 || elim == stack_pointer_rtx))
13578 || elim == (frame_pointer_needed
13579 ? hard_frame_pointer_rtx
13580 : stack_pointer_rtx));
13582 /* If drap register is used to align stack, use frame
13583 pointer + offset to access stack variables. If stack
13584 is aligned without drap, use stack pointer + offset to
13585 access stack variables. */
13586 if (crtl->stack_realign_tried
13587 && reg == frame_pointer_rtx)
13590 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
13591 ? HARD_FRAME_POINTER_REGNUM
13593 return new_reg_loc_descr (base_reg, offset);
13596 offset += frame_pointer_fb_offset;
13597 return new_loc_descr (DW_OP_fbreg, offset, 0);
13602 && (fde->drap_reg == REGNO (reg)
13603 || fde->vdrap_reg == REGNO (reg)))
13605 /* Use cfa+offset to represent the location of arguments passed
13606 on the stack when drap is used to align stack.
13607 Only do this when not optimizing, for optimized code var-tracking
13608 is supposed to track where the arguments live and the register
13609 used as vdrap or drap in some spot might be used for something
13610 else in other part of the routine. */
13611 return new_loc_descr (DW_OP_fbreg, offset, 0);
13614 regno = dbx_reg_number (reg);
13616 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
13619 result = new_loc_descr (DW_OP_bregx, regno, offset);
13621 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13622 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13627 /* Return true if this RTL expression describes a base+offset calculation. */
13630 is_based_loc (const_rtx rtl)
13632 return (GET_CODE (rtl) == PLUS
13633 && ((REG_P (XEXP (rtl, 0))
13634 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
13635 && CONST_INT_P (XEXP (rtl, 1)))));
13638 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
13641 static dw_loc_descr_ref
13642 tls_mem_loc_descriptor (rtx mem)
13645 dw_loc_descr_ref loc_result;
13647 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
13650 base = get_base_address (MEM_EXPR (mem));
13652 || TREE_CODE (base) != VAR_DECL
13653 || !DECL_THREAD_LOCAL_P (base))
13656 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1);
13657 if (loc_result == NULL)
13660 if (INTVAL (MEM_OFFSET (mem)))
13661 loc_descr_plus_const (&loc_result, INTVAL (MEM_OFFSET (mem)));
13666 /* Output debug info about reason why we failed to expand expression as dwarf
13670 expansion_failed (tree expr, rtx rtl, char const *reason)
13672 if (dump_file && (dump_flags & TDF_DETAILS))
13674 fprintf (dump_file, "Failed to expand as dwarf: ");
13676 print_generic_expr (dump_file, expr, dump_flags);
13679 fprintf (dump_file, "\n");
13680 print_rtl (dump_file, rtl);
13682 fprintf (dump_file, "\nReason: %s\n", reason);
13686 /* Helper function for const_ok_for_output, called either directly
13687 or via for_each_rtx. */
13690 const_ok_for_output_1 (rtx *rtlp, void *data ATTRIBUTE_UNUSED)
13694 if (GET_CODE (rtl) == UNSPEC)
13696 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
13697 we can't express it in the debug info. */
13698 #ifdef ENABLE_CHECKING
13699 /* Don't complain about TLS UNSPECs, those are just too hard to
13701 if (XVECLEN (rtl, 0) != 1
13702 || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
13703 || SYMBOL_REF_DECL (XVECEXP (rtl, 0, 0)) == NULL
13704 || TREE_CODE (SYMBOL_REF_DECL (XVECEXP (rtl, 0, 0))) != VAR_DECL
13705 || !DECL_THREAD_LOCAL_P (SYMBOL_REF_DECL (XVECEXP (rtl, 0, 0))))
13706 inform (current_function_decl
13707 ? DECL_SOURCE_LOCATION (current_function_decl)
13708 : UNKNOWN_LOCATION,
13709 #if NUM_UNSPEC_VALUES > 0
13710 "non-delegitimized UNSPEC %s (%d) found in variable location",
13711 ((XINT (rtl, 1) >= 0 && XINT (rtl, 1) < NUM_UNSPEC_VALUES)
13712 ? unspec_strings[XINT (rtl, 1)] : "unknown"),
13715 "non-delegitimized UNSPEC %d found in variable location",
13719 expansion_failed (NULL_TREE, rtl,
13720 "UNSPEC hasn't been delegitimized.\n");
13724 if (GET_CODE (rtl) != SYMBOL_REF)
13727 if (CONSTANT_POOL_ADDRESS_P (rtl))
13730 get_pool_constant_mark (rtl, &marked);
13731 /* If all references to this pool constant were optimized away,
13732 it was not output and thus we can't represent it. */
13735 expansion_failed (NULL_TREE, rtl,
13736 "Constant was removed from constant pool.\n");
13741 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
13744 /* Avoid references to external symbols in debug info, on several targets
13745 the linker might even refuse to link when linking a shared library,
13746 and in many other cases the relocations for .debug_info/.debug_loc are
13747 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
13748 to be defined within the same shared library or executable are fine. */
13749 if (SYMBOL_REF_EXTERNAL_P (rtl))
13751 tree decl = SYMBOL_REF_DECL (rtl);
13753 if (decl == NULL || !targetm.binds_local_p (decl))
13755 expansion_failed (NULL_TREE, rtl,
13756 "Symbol not defined in current TU.\n");
13764 /* Return true if constant RTL can be emitted in DW_OP_addr or
13765 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
13766 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
13769 const_ok_for_output (rtx rtl)
13771 if (GET_CODE (rtl) == SYMBOL_REF)
13772 return const_ok_for_output_1 (&rtl, NULL) == 0;
13774 if (GET_CODE (rtl) == CONST)
13775 return for_each_rtx (&XEXP (rtl, 0), const_ok_for_output_1, NULL) == 0;
13780 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
13781 if possible, NULL otherwise. */
13784 base_type_for_mode (enum machine_mode mode, bool unsignedp)
13786 dw_die_ref type_die;
13787 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
13791 switch (TREE_CODE (type))
13799 type_die = lookup_type_die (type);
13801 type_die = modified_type_die (type, false, false, comp_unit_die ());
13802 if (type_die == NULL || type_die->die_tag != DW_TAG_base_type)
13807 /* The following routine converts the RTL for a variable or parameter
13808 (resident in memory) into an equivalent Dwarf representation of a
13809 mechanism for getting the address of that same variable onto the top of a
13810 hypothetical "address evaluation" stack.
13812 When creating memory location descriptors, we are effectively transforming
13813 the RTL for a memory-resident object into its Dwarf postfix expression
13814 equivalent. This routine recursively descends an RTL tree, turning
13815 it into Dwarf postfix code as it goes.
13817 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
13819 MEM_MODE is the mode of the memory reference, needed to handle some
13820 autoincrement addressing modes.
13822 Return 0 if we can't represent the location. */
13824 static dw_loc_descr_ref
13825 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
13826 enum machine_mode mem_mode,
13827 enum var_init_status initialized)
13829 dw_loc_descr_ref mem_loc_result = NULL;
13830 enum dwarf_location_atom op;
13831 dw_loc_descr_ref op0, op1;
13833 if (mode == VOIDmode)
13834 mode = GET_MODE (rtl);
13836 /* Note that for a dynamically sized array, the location we will generate a
13837 description of here will be the lowest numbered location which is
13838 actually within the array. That's *not* necessarily the same as the
13839 zeroth element of the array. */
13841 rtl = targetm.delegitimize_address (rtl);
13843 if (mode != GET_MODE (rtl) && GET_MODE (rtl) != VOIDmode)
13846 switch (GET_CODE (rtl))
13851 return mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, initialized);
13854 /* The case of a subreg may arise when we have a local (register)
13855 variable or a formal (register) parameter which doesn't quite fill
13856 up an entire register. For now, just assume that it is
13857 legitimate to make the Dwarf info refer to the whole register which
13858 contains the given subreg. */
13859 if (!subreg_lowpart_p (rtl))
13861 if (GET_MODE_CLASS (mode) == MODE_INT
13862 && GET_MODE_CLASS (GET_MODE (SUBREG_REG (rtl))) == MODE_INT
13863 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
13864 && GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl))) <= DWARF2_ADDR_SIZE)
13866 mem_loc_result = mem_loc_descriptor (SUBREG_REG (rtl),
13867 GET_MODE (SUBREG_REG (rtl)),
13868 mem_mode, initialized);
13873 if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl))))
13875 if (GET_MODE_SIZE (mode) != GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl)))
13876 && (GET_MODE_CLASS (mode) != MODE_INT
13877 || GET_MODE_CLASS (GET_MODE (SUBREG_REG (rtl))) != MODE_INT))
13881 dw_die_ref type_die;
13882 dw_loc_descr_ref cvt;
13884 mem_loc_result = mem_loc_descriptor (SUBREG_REG (rtl),
13885 GET_MODE (SUBREG_REG (rtl)),
13886 mem_mode, initialized);
13887 if (mem_loc_result == NULL)
13889 type_die = base_type_for_mode (mode, 0);
13890 if (type_die == NULL)
13892 mem_loc_result = NULL;
13895 if (GET_MODE_SIZE (mode)
13896 != GET_MODE_SIZE (GET_MODE (SUBREG_REG (rtl))))
13897 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13899 cvt = new_loc_descr (DW_OP_GNU_reinterpret, 0, 0);
13900 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13901 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
13902 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13903 add_loc_descr (&mem_loc_result, cvt);
13908 if (GET_MODE_CLASS (mode) != MODE_INT
13909 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
13910 #ifdef POINTERS_EXTEND_UNSIGNED
13911 && (mode != Pmode || mem_mode == VOIDmode)
13915 dw_die_ref type_die;
13919 if (REGNO (rtl) > FIRST_PSEUDO_REGISTER)
13921 type_die = base_type_for_mode (mode, 0);
13922 if (type_die == NULL)
13924 mem_loc_result = new_loc_descr (DW_OP_GNU_regval_type,
13925 dbx_reg_number (rtl), 0);
13926 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
13927 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die;
13928 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0;
13931 /* Whenever a register number forms a part of the description of the
13932 method for calculating the (dynamic) address of a memory resident
13933 object, DWARF rules require the register number be referred to as
13934 a "base register". This distinction is not based in any way upon
13935 what category of register the hardware believes the given register
13936 belongs to. This is strictly DWARF terminology we're dealing with
13937 here. Note that in cases where the location of a memory-resident
13938 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
13939 OP_CONST (0)) the actual DWARF location descriptor that we generate
13940 may just be OP_BASEREG (basereg). This may look deceptively like
13941 the object in question was allocated to a register (rather than in
13942 memory) so DWARF consumers need to be aware of the subtle
13943 distinction between OP_REG and OP_BASEREG. */
13944 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
13945 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
13946 else if (stack_realign_drap
13948 && crtl->args.internal_arg_pointer == rtl
13949 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
13951 /* If RTL is internal_arg_pointer, which has been optimized
13952 out, use DRAP instead. */
13953 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
13954 VAR_INIT_STATUS_INITIALIZED);
13960 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
13961 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
13962 mem_mode, VAR_INIT_STATUS_INITIALIZED);
13965 else if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
13967 int shift = DWARF2_ADDR_SIZE
13968 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
13969 shift *= BITS_PER_UNIT;
13970 if (GET_CODE (rtl) == SIGN_EXTEND)
13974 mem_loc_result = op0;
13975 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
13976 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
13977 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
13978 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13980 else if (!dwarf_strict)
13982 dw_die_ref type_die1, type_die2;
13983 dw_loc_descr_ref cvt;
13985 type_die1 = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
13986 GET_CODE (rtl) == ZERO_EXTEND);
13987 if (type_die1 == NULL)
13989 type_die2 = base_type_for_mode (mode, 0);
13990 if (type_die2 == NULL)
13992 mem_loc_result = op0;
13993 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13994 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
13995 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die1;
13996 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
13997 add_loc_descr (&mem_loc_result, cvt);
13998 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
13999 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14000 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die2;
14001 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14002 add_loc_descr (&mem_loc_result, cvt);
14007 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0),
14008 get_address_mode (rtl), mode,
14009 VAR_INIT_STATUS_INITIALIZED);
14010 if (mem_loc_result == NULL)
14011 mem_loc_result = tls_mem_loc_descriptor (rtl);
14012 if (mem_loc_result != 0)
14014 if (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
14015 || GET_MODE_CLASS (mode) != MODE_INT)
14017 dw_die_ref type_die;
14018 dw_loc_descr_ref deref;
14022 type_die = base_type_for_mode (mode, 0);
14023 if (type_die == NULL)
14025 deref = new_loc_descr (DW_OP_GNU_deref_type,
14026 GET_MODE_SIZE (mode), 0);
14027 deref->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
14028 deref->dw_loc_oprnd2.v.val_die_ref.die = type_die;
14029 deref->dw_loc_oprnd2.v.val_die_ref.external = 0;
14030 add_loc_descr (&mem_loc_result, deref);
14032 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
14033 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
14035 add_loc_descr (&mem_loc_result,
14036 new_loc_descr (DW_OP_deref_size,
14037 GET_MODE_SIZE (mode), 0));
14041 rtx new_rtl = avoid_constant_pool_reference (rtl);
14042 if (new_rtl != rtl)
14043 return mem_loc_descriptor (new_rtl, mode, mem_mode, initialized);
14048 return mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, initialized);
14051 /* Some ports can transform a symbol ref into a label ref, because
14052 the symbol ref is too far away and has to be dumped into a constant
14056 if (GET_MODE_CLASS (mode) != MODE_INT
14057 || (GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE
14058 #ifdef POINTERS_EXTEND_UNSIGNED
14059 && (mode != Pmode || mem_mode == VOIDmode)
14063 if (GET_CODE (rtl) == SYMBOL_REF
14064 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
14066 dw_loc_descr_ref temp;
14068 /* If this is not defined, we have no way to emit the data. */
14069 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
14072 /* We used to emit DW_OP_addr here, but that's wrong, since
14073 DW_OP_addr should be relocated by the debug info consumer,
14074 while DW_OP_GNU_push_tls_address operand should not. */
14075 temp = new_loc_descr (DWARF2_ADDR_SIZE == 4
14076 ? DW_OP_const4u : DW_OP_const8u, 0, 0);
14077 temp->dw_loc_oprnd1.val_class = dw_val_class_addr;
14078 temp->dw_loc_oprnd1.v.val_addr = rtl;
14079 temp->dtprel = true;
14081 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
14082 add_loc_descr (&mem_loc_result, temp);
14087 if (!const_ok_for_output (rtl))
14091 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
14092 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
14093 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
14094 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
14100 case DEBUG_IMPLICIT_PTR:
14101 expansion_failed (NULL_TREE, rtl,
14102 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
14108 if (REG_P (ENTRY_VALUE_EXP (rtl)))
14110 if (GET_MODE_CLASS (mode) != MODE_INT
14111 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE)
14112 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
14113 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14116 = one_reg_loc_descriptor (dbx_reg_number (ENTRY_VALUE_EXP (rtl)),
14117 VAR_INIT_STATUS_INITIALIZED);
14119 else if (MEM_P (ENTRY_VALUE_EXP (rtl))
14120 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl), 0)))
14122 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
14123 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14124 if (op0 && op0->dw_loc_opc == DW_OP_fbreg)
14128 gcc_unreachable ();
14131 mem_loc_result = new_loc_descr (DW_OP_GNU_entry_value, 0, 0);
14132 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_loc;
14133 mem_loc_result->dw_loc_oprnd1.v.val_loc = op0;
14134 return mem_loc_result;
14137 /* Extract the PLUS expression nested inside and fall into
14138 PLUS code below. */
14139 rtl = XEXP (rtl, 1);
14144 /* Turn these into a PLUS expression and fall into the PLUS code
14146 rtl = gen_rtx_PLUS (mode, XEXP (rtl, 0),
14147 GEN_INT (GET_CODE (rtl) == PRE_INC
14148 ? GET_MODE_UNIT_SIZE (mem_mode)
14149 : -GET_MODE_UNIT_SIZE (mem_mode)));
14151 /* ... fall through ... */
14155 if (is_based_loc (rtl)
14156 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
14157 && GET_MODE_CLASS (mode) == MODE_INT)
14158 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
14159 INTVAL (XEXP (rtl, 1)),
14160 VAR_INIT_STATUS_INITIALIZED);
14163 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
14164 VAR_INIT_STATUS_INITIALIZED);
14165 if (mem_loc_result == 0)
14168 if (CONST_INT_P (XEXP (rtl, 1))
14169 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
14170 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
14173 dw_loc_descr_ref mem_loc_result2
14174 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
14175 VAR_INIT_STATUS_INITIALIZED);
14176 if (mem_loc_result2 == 0)
14178 add_loc_descr (&mem_loc_result, mem_loc_result2);
14179 add_loc_descr (&mem_loc_result,
14180 new_loc_descr (DW_OP_plus, 0, 0));
14185 /* If a pseudo-reg is optimized away, it is possible for it to
14186 be replaced with a MEM containing a multiply or shift. */
14216 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
14217 VAR_INIT_STATUS_INITIALIZED);
14218 op1 = mem_loc_descriptor (XEXP (rtl, 1),
14219 GET_MODE (XEXP (rtl, 1)) == VOIDmode
14220 ? mode : GET_MODE (XEXP (rtl, 1)), mem_mode,
14221 VAR_INIT_STATUS_INITIALIZED);
14223 if (op0 == 0 || op1 == 0)
14226 mem_loc_result = op0;
14227 add_loc_descr (&mem_loc_result, op1);
14228 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14244 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
14245 VAR_INIT_STATUS_INITIALIZED);
14246 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
14247 VAR_INIT_STATUS_INITIALIZED);
14249 if (op0 == 0 || op1 == 0)
14252 mem_loc_result = op0;
14253 add_loc_descr (&mem_loc_result, op1);
14254 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14258 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
14259 VAR_INIT_STATUS_INITIALIZED);
14260 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
14261 VAR_INIT_STATUS_INITIALIZED);
14263 if (op0 == 0 || op1 == 0)
14266 mem_loc_result = op0;
14267 add_loc_descr (&mem_loc_result, op1);
14268 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
14269 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
14270 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
14271 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
14272 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
14288 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
14289 VAR_INIT_STATUS_INITIALIZED);
14294 mem_loc_result = op0;
14295 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14299 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
14300 #ifdef POINTERS_EXTEND_UNSIGNED
14302 && mem_mode != VOIDmode
14303 && trunc_int_for_mode (INTVAL (rtl), ptr_mode) == INTVAL (rtl))
14307 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
14311 && (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT
14312 || GET_MODE_BITSIZE (mode) == 2 * HOST_BITS_PER_WIDE_INT))
14314 dw_die_ref type_die = base_type_for_mode (mode, 0);
14315 if (type_die == NULL)
14317 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0,
14319 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14320 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14321 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
14322 if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
14323 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
14326 mem_loc_result->dw_loc_oprnd2.val_class
14327 = dw_val_class_const_double;
14328 mem_loc_result->dw_loc_oprnd2.v.val_double
14329 = shwi_to_double_int (INTVAL (rtl));
14337 dw_die_ref type_die;
14339 /* Note that a CONST_DOUBLE rtx could represent either an integer
14340 or a floating-point constant. A CONST_DOUBLE is used whenever
14341 the constant requires more than one word in order to be
14342 adequately represented. We output CONST_DOUBLEs as blocks. */
14343 if (mode == VOIDmode
14344 || (GET_MODE (rtl) == VOIDmode
14345 && GET_MODE_BITSIZE (mode) != 2 * HOST_BITS_PER_WIDE_INT))
14347 type_die = base_type_for_mode (mode, 0);
14348 if (type_die == NULL)
14350 mem_loc_result = new_loc_descr (DW_OP_GNU_const_type, 0, 0);
14351 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14352 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14353 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
14354 if (SCALAR_FLOAT_MODE_P (mode))
14356 unsigned int length = GET_MODE_SIZE (mode);
14357 unsigned char *array
14358 = (unsigned char*) ggc_alloc_atomic (length);
14360 insert_float (rtl, array);
14361 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
14362 mem_loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
14363 mem_loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
14364 mem_loc_result->dw_loc_oprnd2.v.val_vec.array = array;
14368 mem_loc_result->dw_loc_oprnd2.val_class
14369 = dw_val_class_const_double;
14370 mem_loc_result->dw_loc_oprnd2.v.val_double
14371 = rtx_to_double_int (rtl);
14402 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
14404 if (op_mode == VOIDmode)
14405 op_mode = GET_MODE (XEXP (rtl, 1));
14406 if (op_mode == VOIDmode)
14410 && (GET_MODE_CLASS (op_mode) != MODE_INT
14411 || GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE))
14414 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
14415 VAR_INIT_STATUS_INITIALIZED);
14416 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
14417 VAR_INIT_STATUS_INITIALIZED);
14419 if (op0 == 0 || op1 == 0)
14422 if (GET_MODE_CLASS (op_mode) == MODE_INT
14423 && GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
14425 int shift = DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode);
14426 shift *= BITS_PER_UNIT;
14427 /* For eq/ne, if the operands are known to be zero-extended,
14428 there is no need to do the fancy shifting up. */
14429 if (op == DW_OP_eq || op == DW_OP_ne)
14431 dw_loc_descr_ref last0, last1;
14433 last0->dw_loc_next != NULL;
14434 last0 = last0->dw_loc_next)
14437 last1->dw_loc_next != NULL;
14438 last1 = last1->dw_loc_next)
14440 /* deref_size zero extends, and for constants we can check
14441 whether they are zero extended or not. */
14442 if (((last0->dw_loc_opc == DW_OP_deref_size
14443 && last0->dw_loc_oprnd1.v.val_int
14444 <= GET_MODE_SIZE (op_mode))
14445 || (CONST_INT_P (XEXP (rtl, 0))
14446 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
14447 == (INTVAL (XEXP (rtl, 0))
14448 & GET_MODE_MASK (op_mode))))
14449 && ((last1->dw_loc_opc == DW_OP_deref_size
14450 && last1->dw_loc_oprnd1.v.val_int
14451 <= GET_MODE_SIZE (op_mode))
14452 || (CONST_INT_P (XEXP (rtl, 1))
14453 && (unsigned HOST_WIDE_INT)
14454 INTVAL (XEXP (rtl, 1))
14455 == (INTVAL (XEXP (rtl, 1))
14456 & GET_MODE_MASK (op_mode)))))
14459 add_loc_descr (&op0, int_loc_descriptor (shift));
14460 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
14461 if (CONST_INT_P (XEXP (rtl, 1)))
14462 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
14465 add_loc_descr (&op1, int_loc_descriptor (shift));
14466 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
14472 mem_loc_result = op0;
14473 add_loc_descr (&mem_loc_result, op1);
14474 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14475 if (STORE_FLAG_VALUE != 1)
14477 add_loc_descr (&mem_loc_result,
14478 int_loc_descriptor (STORE_FLAG_VALUE));
14479 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
14501 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
14503 if (op_mode == VOIDmode)
14504 op_mode = GET_MODE (XEXP (rtl, 1));
14505 if (op_mode == VOIDmode)
14507 if (GET_MODE_CLASS (op_mode) != MODE_INT)
14510 if (dwarf_strict && GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
14513 if (op_mode != VOIDmode && GET_MODE_CLASS (op_mode) != MODE_INT)
14516 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
14517 VAR_INIT_STATUS_INITIALIZED);
14518 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
14519 VAR_INIT_STATUS_INITIALIZED);
14521 if (op0 == 0 || op1 == 0)
14524 if (GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
14526 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
14527 dw_loc_descr_ref last0, last1;
14529 last0->dw_loc_next != NULL;
14530 last0 = last0->dw_loc_next)
14533 last1->dw_loc_next != NULL;
14534 last1 = last1->dw_loc_next)
14536 if (CONST_INT_P (XEXP (rtl, 0)))
14537 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
14538 /* deref_size zero extends, so no need to mask it again. */
14539 else if (last0->dw_loc_opc != DW_OP_deref_size
14540 || last0->dw_loc_oprnd1.v.val_int
14541 > GET_MODE_SIZE (op_mode))
14543 add_loc_descr (&op0, int_loc_descriptor (mask));
14544 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14546 if (CONST_INT_P (XEXP (rtl, 1)))
14547 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
14548 /* deref_size zero extends, so no need to mask it again. */
14549 else if (last1->dw_loc_opc != DW_OP_deref_size
14550 || last1->dw_loc_oprnd1.v.val_int
14551 > GET_MODE_SIZE (op_mode))
14553 add_loc_descr (&op1, int_loc_descriptor (mask));
14554 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
14557 else if (GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
14559 HOST_WIDE_INT bias = 1;
14560 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
14561 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14562 if (CONST_INT_P (XEXP (rtl, 1)))
14563 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
14564 + INTVAL (XEXP (rtl, 1)));
14566 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
14571 dw_die_ref type_die = base_type_for_mode (mode, 1);
14572 dw_loc_descr_ref cvt;
14574 if (type_die == NULL)
14576 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
14577 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14578 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14579 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14580 add_loc_descr (&op0, cvt);
14581 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
14582 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14583 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14584 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14585 add_loc_descr (&op1, cvt);
14592 if (GET_MODE_CLASS (mode) != MODE_INT)
14598 && (GET_MODE_CLASS (mode) != MODE_INT
14599 || GET_MODE_SIZE (mode) > DWARF2_ADDR_SIZE))
14602 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
14603 VAR_INIT_STATUS_INITIALIZED);
14604 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
14605 VAR_INIT_STATUS_INITIALIZED);
14607 if (op0 == 0 || op1 == 0)
14610 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
14611 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
14612 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
14613 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
14615 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
14617 HOST_WIDE_INT mask = GET_MODE_MASK (mode);
14618 add_loc_descr (&op0, int_loc_descriptor (mask));
14619 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14620 add_loc_descr (&op1, int_loc_descriptor (mask));
14621 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
14623 else if (GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
14625 HOST_WIDE_INT bias = 1;
14626 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
14627 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14628 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14632 dw_die_ref type_die = base_type_for_mode (mode, 1);
14633 dw_loc_descr_ref cvt;
14635 if (type_die == NULL)
14637 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
14638 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14639 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14640 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14641 add_loc_descr (&op0, cvt);
14642 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
14643 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14644 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14645 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14646 add_loc_descr (&op1, cvt);
14649 else if (GET_MODE_CLASS (mode) == MODE_INT
14650 && GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
14652 int shift = DWARF2_ADDR_SIZE - GET_MODE_SIZE (mode);
14653 shift *= BITS_PER_UNIT;
14654 add_loc_descr (&op0, int_loc_descriptor (shift));
14655 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
14656 add_loc_descr (&op1, int_loc_descriptor (shift));
14657 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
14660 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
14664 mem_loc_result = op0;
14665 add_loc_descr (&mem_loc_result, op1);
14666 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14668 dw_loc_descr_ref bra_node, drop_node;
14670 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14671 add_loc_descr (&mem_loc_result, bra_node);
14672 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
14673 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
14674 add_loc_descr (&mem_loc_result, drop_node);
14675 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14676 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
14682 if (CONST_INT_P (XEXP (rtl, 1))
14683 && CONST_INT_P (XEXP (rtl, 2))
14684 && ((unsigned) INTVAL (XEXP (rtl, 1))
14685 + (unsigned) INTVAL (XEXP (rtl, 2))
14686 <= GET_MODE_BITSIZE (mode))
14687 && GET_MODE_CLASS (mode) == MODE_INT
14688 && GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE
14689 && GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
14692 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
14693 mem_mode, VAR_INIT_STATUS_INITIALIZED);
14696 if (GET_CODE (rtl) == SIGN_EXTRACT)
14700 mem_loc_result = op0;
14701 size = INTVAL (XEXP (rtl, 1));
14702 shift = INTVAL (XEXP (rtl, 2));
14703 if (BITS_BIG_ENDIAN)
14704 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
14706 if (shift + size != (int) DWARF2_ADDR_SIZE)
14708 add_loc_descr (&mem_loc_result,
14709 int_loc_descriptor (DWARF2_ADDR_SIZE
14711 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
14713 if (size != (int) DWARF2_ADDR_SIZE)
14715 add_loc_descr (&mem_loc_result,
14716 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
14717 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14724 dw_loc_descr_ref op2, bra_node, drop_node;
14725 op0 = mem_loc_descriptor (XEXP (rtl, 0),
14726 GET_MODE (XEXP (rtl, 0)) == VOIDmode
14727 ? word_mode : GET_MODE (XEXP (rtl, 0)),
14728 mem_mode, VAR_INIT_STATUS_INITIALIZED);
14729 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
14730 VAR_INIT_STATUS_INITIALIZED);
14731 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode, mem_mode,
14732 VAR_INIT_STATUS_INITIALIZED);
14733 if (op0 == NULL || op1 == NULL || op2 == NULL)
14736 mem_loc_result = op1;
14737 add_loc_descr (&mem_loc_result, op2);
14738 add_loc_descr (&mem_loc_result, op0);
14739 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14740 add_loc_descr (&mem_loc_result, bra_node);
14741 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
14742 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
14743 add_loc_descr (&mem_loc_result, drop_node);
14744 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14745 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
14750 case FLOAT_TRUNCATE:
14752 case UNSIGNED_FLOAT:
14757 dw_die_ref type_die;
14758 dw_loc_descr_ref cvt;
14760 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
14761 mem_mode, VAR_INIT_STATUS_INITIALIZED);
14764 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) == MODE_INT
14765 && (GET_CODE (rtl) == UNSIGNED_FLOAT
14766 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)))
14767 <= DWARF2_ADDR_SIZE))
14769 type_die = base_type_for_mode (GET_MODE (XEXP (rtl, 0)),
14770 GET_CODE (rtl) == UNSIGNED_FLOAT);
14771 if (type_die == NULL)
14773 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
14774 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14775 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14776 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14777 add_loc_descr (&op0, cvt);
14779 type_die = base_type_for_mode (mode, GET_CODE (rtl) == UNSIGNED_FIX);
14780 if (type_die == NULL)
14782 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
14783 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14784 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14785 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14786 add_loc_descr (&op0, cvt);
14787 if (GET_MODE_CLASS (mode) == MODE_INT
14788 && (GET_CODE (rtl) == UNSIGNED_FIX
14789 || GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE))
14791 enum machine_mode outer_mode = mode;
14792 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
14794 outer_mode = mode_for_size (DWARF2_ADDR_SIZE * BITS_PER_UNIT,
14796 if (outer_mode == BLKmode
14797 || GET_MODE_SIZE (outer_mode) != DWARF2_ADDR_SIZE)
14800 type_die = base_type_for_mode (outer_mode, 0);
14801 if (type_die == NULL)
14803 cvt = new_loc_descr (DW_OP_GNU_convert, 0, 0);
14804 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14805 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14806 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14807 add_loc_descr (&op0, cvt);
14809 mem_loc_result = op0;
14817 /* In theory, we could implement the above. */
14818 /* DWARF cannot represent the unsigned compare operations
14844 case FRACT_CONVERT:
14845 case UNSIGNED_FRACT_CONVERT:
14847 case UNSIGNED_SAT_FRACT:
14859 case VEC_DUPLICATE:
14863 case STRICT_LOW_PART:
14866 /* If delegitimize_address couldn't do anything with the UNSPEC, we
14867 can't express it in the debug info. This can happen e.g. with some
14872 resolve_one_addr (&rtl, NULL);
14876 #ifdef ENABLE_CHECKING
14877 print_rtl (stderr, rtl);
14878 gcc_unreachable ();
14884 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
14885 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14887 return mem_loc_result;
14890 /* Return a descriptor that describes the concatenation of two locations.
14891 This is typically a complex variable. */
14893 static dw_loc_descr_ref
14894 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
14896 dw_loc_descr_ref cc_loc_result = NULL;
14897 dw_loc_descr_ref x0_ref
14898 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14899 dw_loc_descr_ref x1_ref
14900 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14902 if (x0_ref == 0 || x1_ref == 0)
14905 cc_loc_result = x0_ref;
14906 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
14908 add_loc_descr (&cc_loc_result, x1_ref);
14909 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
14911 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
14912 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14914 return cc_loc_result;
14917 /* Return a descriptor that describes the concatenation of N
14920 static dw_loc_descr_ref
14921 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
14924 dw_loc_descr_ref cc_loc_result = NULL;
14925 unsigned int n = XVECLEN (concatn, 0);
14927 for (i = 0; i < n; ++i)
14929 dw_loc_descr_ref ref;
14930 rtx x = XVECEXP (concatn, 0, i);
14932 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14936 add_loc_descr (&cc_loc_result, ref);
14937 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
14940 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
14941 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14943 return cc_loc_result;
14946 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
14947 for DEBUG_IMPLICIT_PTR RTL. */
14949 static dw_loc_descr_ref
14950 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
14952 dw_loc_descr_ref ret;
14957 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
14958 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
14959 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
14960 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
14961 ret = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
14962 ret->dw_loc_oprnd2.val_class = dw_val_class_const;
14965 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14966 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
14967 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
14971 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
14972 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl);
14977 /* Output a proper Dwarf location descriptor for a variable or parameter
14978 which is either allocated in a register or in a memory location. For a
14979 register, we just generate an OP_REG and the register number. For a
14980 memory location we provide a Dwarf postfix expression describing how to
14981 generate the (dynamic) address of the object onto the address stack.
14983 MODE is mode of the decl if this loc_descriptor is going to be used in
14984 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
14985 allowed, VOIDmode otherwise.
14987 If we don't know how to describe it, return 0. */
14989 static dw_loc_descr_ref
14990 loc_descriptor (rtx rtl, enum machine_mode mode,
14991 enum var_init_status initialized)
14993 dw_loc_descr_ref loc_result = NULL;
14995 switch (GET_CODE (rtl))
14998 /* The case of a subreg may arise when we have a local (register)
14999 variable or a formal (register) parameter which doesn't quite fill
15000 up an entire register. For now, just assume that it is
15001 legitimate to make the Dwarf info refer to the whole register which
15002 contains the given subreg. */
15003 if (REG_P (SUBREG_REG (rtl)) && subreg_lowpart_p (rtl))
15004 loc_result = loc_descriptor (SUBREG_REG (rtl), mode, initialized);
15010 loc_result = reg_loc_descriptor (rtl, initialized);
15014 loc_result = mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
15015 GET_MODE (rtl), initialized);
15016 if (loc_result == NULL)
15017 loc_result = tls_mem_loc_descriptor (rtl);
15018 if (loc_result == NULL)
15020 rtx new_rtl = avoid_constant_pool_reference (rtl);
15021 if (new_rtl != rtl)
15022 loc_result = loc_descriptor (new_rtl, mode, initialized);
15027 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
15032 loc_result = concatn_loc_descriptor (rtl, initialized);
15037 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
15039 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
15040 if (GET_CODE (loc) == EXPR_LIST)
15041 loc = XEXP (loc, 0);
15042 loc_result = loc_descriptor (loc, mode, initialized);
15046 rtl = XEXP (rtl, 1);
15051 rtvec par_elems = XVEC (rtl, 0);
15052 int num_elem = GET_NUM_ELEM (par_elems);
15053 enum machine_mode mode;
15056 /* Create the first one, so we have something to add to. */
15057 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
15058 VOIDmode, initialized);
15059 if (loc_result == NULL)
15061 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
15062 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
15063 for (i = 1; i < num_elem; i++)
15065 dw_loc_descr_ref temp;
15067 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
15068 VOIDmode, initialized);
15071 add_loc_descr (&loc_result, temp);
15072 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
15073 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
15079 if (mode != VOIDmode && mode != BLKmode)
15080 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
15085 if (mode == VOIDmode)
15086 mode = GET_MODE (rtl);
15088 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
15090 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
15092 /* Note that a CONST_DOUBLE rtx could represent either an integer
15093 or a floating-point constant. A CONST_DOUBLE is used whenever
15094 the constant requires more than one word in order to be
15095 adequately represented. We output CONST_DOUBLEs as blocks. */
15096 loc_result = new_loc_descr (DW_OP_implicit_value,
15097 GET_MODE_SIZE (mode), 0);
15098 if (SCALAR_FLOAT_MODE_P (mode))
15100 unsigned int length = GET_MODE_SIZE (mode);
15101 unsigned char *array
15102 = (unsigned char*) ggc_alloc_atomic (length);
15104 insert_float (rtl, array);
15105 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
15106 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
15107 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
15108 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
15112 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
15113 loc_result->dw_loc_oprnd2.v.val_double
15114 = rtx_to_double_int (rtl);
15120 if (mode == VOIDmode)
15121 mode = GET_MODE (rtl);
15123 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
15125 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
15126 unsigned int length = CONST_VECTOR_NUNITS (rtl);
15127 unsigned char *array = (unsigned char *)
15128 ggc_alloc_atomic (length * elt_size);
15132 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
15133 switch (GET_MODE_CLASS (mode))
15135 case MODE_VECTOR_INT:
15136 for (i = 0, p = array; i < length; i++, p += elt_size)
15138 rtx elt = CONST_VECTOR_ELT (rtl, i);
15139 double_int val = rtx_to_double_int (elt);
15141 if (elt_size <= sizeof (HOST_WIDE_INT))
15142 insert_int (double_int_to_shwi (val), elt_size, p);
15145 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
15146 insert_double (val, p);
15151 case MODE_VECTOR_FLOAT:
15152 for (i = 0, p = array; i < length; i++, p += elt_size)
15154 rtx elt = CONST_VECTOR_ELT (rtl, i);
15155 insert_float (elt, p);
15160 gcc_unreachable ();
15163 loc_result = new_loc_descr (DW_OP_implicit_value,
15164 length * elt_size, 0);
15165 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
15166 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
15167 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
15168 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
15173 if (mode == VOIDmode
15174 || GET_CODE (XEXP (rtl, 0)) == CONST_INT
15175 || GET_CODE (XEXP (rtl, 0)) == CONST_DOUBLE
15176 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
15178 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
15183 if (!const_ok_for_output (rtl))
15186 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
15187 && (dwarf_version >= 4 || !dwarf_strict))
15189 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
15190 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
15191 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
15192 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
15193 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
15197 case DEBUG_IMPLICIT_PTR:
15198 loc_result = implicit_ptr_descriptor (rtl, 0);
15202 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR
15203 && CONST_INT_P (XEXP (rtl, 1)))
15206 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1)));
15212 if ((GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
15213 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
15214 && dwarf_version >= 4)
15215 || (!dwarf_strict && mode != VOIDmode && mode != BLKmode))
15217 /* Value expression. */
15218 loc_result = mem_loc_descriptor (rtl, mode, VOIDmode, initialized);
15220 add_loc_descr (&loc_result,
15221 new_loc_descr (DW_OP_stack_value, 0, 0));
15229 /* We need to figure out what section we should use as the base for the
15230 address ranges where a given location is valid.
15231 1. If this particular DECL has a section associated with it, use that.
15232 2. If this function has a section associated with it, use that.
15233 3. Otherwise, use the text section.
15234 XXX: If you split a variable across multiple sections, we won't notice. */
15236 static const char *
15237 secname_for_decl (const_tree decl)
15239 const char *secname;
15241 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
15243 tree sectree = DECL_SECTION_NAME (decl);
15244 secname = TREE_STRING_POINTER (sectree);
15246 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
15248 tree sectree = DECL_SECTION_NAME (current_function_decl);
15249 secname = TREE_STRING_POINTER (sectree);
15251 else if (cfun && in_cold_section_p)
15252 secname = crtl->subsections.cold_section_label;
15254 secname = text_section_label;
15259 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
15262 decl_by_reference_p (tree decl)
15264 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
15265 || TREE_CODE (decl) == VAR_DECL)
15266 && DECL_BY_REFERENCE (decl));
15269 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
15272 static dw_loc_descr_ref
15273 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
15274 enum var_init_status initialized)
15276 int have_address = 0;
15277 dw_loc_descr_ref descr;
15278 enum machine_mode mode;
15280 if (want_address != 2)
15282 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
15284 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
15286 varloc = PAT_VAR_LOCATION_LOC (varloc);
15287 if (GET_CODE (varloc) == EXPR_LIST)
15288 varloc = XEXP (varloc, 0);
15289 mode = GET_MODE (varloc);
15290 if (MEM_P (varloc))
15292 rtx addr = XEXP (varloc, 0);
15293 descr = mem_loc_descriptor (addr, get_address_mode (varloc),
15294 mode, initialized);
15299 rtx x = avoid_constant_pool_reference (varloc);
15301 descr = mem_loc_descriptor (x, mode, VOIDmode,
15306 descr = mem_loc_descriptor (varloc, mode, VOIDmode, initialized);
15313 if (GET_CODE (varloc) == VAR_LOCATION)
15314 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
15316 mode = DECL_MODE (loc);
15317 descr = loc_descriptor (varloc, mode, initialized);
15324 if (want_address == 2 && !have_address
15325 && (dwarf_version >= 4 || !dwarf_strict))
15327 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
15329 expansion_failed (loc, NULL_RTX,
15330 "DWARF address size mismatch");
15333 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
15336 /* Show if we can't fill the request for an address. */
15337 if (want_address && !have_address)
15339 expansion_failed (loc, NULL_RTX,
15340 "Want address and only have value");
15344 /* If we've got an address and don't want one, dereference. */
15345 if (!want_address && have_address)
15347 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
15348 enum dwarf_location_atom op;
15350 if (size > DWARF2_ADDR_SIZE || size == -1)
15352 expansion_failed (loc, NULL_RTX,
15353 "DWARF address size mismatch");
15356 else if (size == DWARF2_ADDR_SIZE)
15359 op = DW_OP_deref_size;
15361 add_loc_descr (&descr, new_loc_descr (op, size, 0));
15367 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
15368 if it is not possible. */
15370 static dw_loc_descr_ref
15371 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
15373 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
15374 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
15375 else if (dwarf_version >= 3 || !dwarf_strict)
15376 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
15381 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
15382 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
15384 static dw_loc_descr_ref
15385 dw_sra_loc_expr (tree decl, rtx loc)
15388 unsigned int padsize = 0;
15389 dw_loc_descr_ref descr, *descr_tail;
15390 unsigned HOST_WIDE_INT decl_size;
15392 enum var_init_status initialized;
15394 if (DECL_SIZE (decl) == NULL
15395 || !host_integerp (DECL_SIZE (decl), 1))
15398 decl_size = tree_low_cst (DECL_SIZE (decl), 1);
15400 descr_tail = &descr;
15402 for (p = loc; p; p = XEXP (p, 1))
15404 unsigned int bitsize = decl_piece_bitsize (p);
15405 rtx loc_note = *decl_piece_varloc_ptr (p);
15406 dw_loc_descr_ref cur_descr;
15407 dw_loc_descr_ref *tail, last = NULL;
15408 unsigned int opsize = 0;
15410 if (loc_note == NULL_RTX
15411 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
15413 padsize += bitsize;
15416 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
15417 varloc = NOTE_VAR_LOCATION (loc_note);
15418 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
15419 if (cur_descr == NULL)
15421 padsize += bitsize;
15425 /* Check that cur_descr either doesn't use
15426 DW_OP_*piece operations, or their sum is equal
15427 to bitsize. Otherwise we can't embed it. */
15428 for (tail = &cur_descr; *tail != NULL;
15429 tail = &(*tail)->dw_loc_next)
15430 if ((*tail)->dw_loc_opc == DW_OP_piece)
15432 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
15436 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
15438 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
15442 if (last != NULL && opsize != bitsize)
15444 padsize += bitsize;
15448 /* If there is a hole, add DW_OP_*piece after empty DWARF
15449 expression, which means that those bits are optimized out. */
15452 if (padsize > decl_size)
15454 decl_size -= padsize;
15455 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
15456 if (*descr_tail == NULL)
15458 descr_tail = &(*descr_tail)->dw_loc_next;
15461 *descr_tail = cur_descr;
15463 if (bitsize > decl_size)
15465 decl_size -= bitsize;
15468 HOST_WIDE_INT offset = 0;
15469 if (GET_CODE (varloc) == VAR_LOCATION
15470 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
15472 varloc = PAT_VAR_LOCATION_LOC (varloc);
15473 if (GET_CODE (varloc) == EXPR_LIST)
15474 varloc = XEXP (varloc, 0);
15478 if (GET_CODE (varloc) == CONST
15479 || GET_CODE (varloc) == SIGN_EXTEND
15480 || GET_CODE (varloc) == ZERO_EXTEND)
15481 varloc = XEXP (varloc, 0);
15482 else if (GET_CODE (varloc) == SUBREG)
15483 varloc = SUBREG_REG (varloc);
15488 /* DW_OP_bit_size offset should be zero for register
15489 or implicit location descriptions and empty location
15490 descriptions, but for memory addresses needs big endian
15492 if (MEM_P (varloc))
15494 unsigned HOST_WIDE_INT memsize
15495 = INTVAL (MEM_SIZE (varloc)) * BITS_PER_UNIT;
15496 if (memsize != bitsize)
15498 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
15499 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
15501 if (memsize < bitsize)
15503 if (BITS_BIG_ENDIAN)
15504 offset = memsize - bitsize;
15508 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
15509 if (*descr_tail == NULL)
15511 descr_tail = &(*descr_tail)->dw_loc_next;
15515 /* If there were any non-empty expressions, add padding till the end of
15517 if (descr != NULL && decl_size != 0)
15519 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
15520 if (*descr_tail == NULL)
15526 /* Return the dwarf representation of the location list LOC_LIST of
15527 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
15530 static dw_loc_list_ref
15531 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
15533 const char *endname, *secname;
15535 enum var_init_status initialized;
15536 struct var_loc_node *node;
15537 dw_loc_descr_ref descr;
15538 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
15539 dw_loc_list_ref list = NULL;
15540 dw_loc_list_ref *listp = &list;
15542 /* Now that we know what section we are using for a base,
15543 actually construct the list of locations.
15544 The first location information is what is passed to the
15545 function that creates the location list, and the remaining
15546 locations just get added on to that list.
15547 Note that we only know the start address for a location
15548 (IE location changes), so to build the range, we use
15549 the range [current location start, next location start].
15550 This means we have to special case the last node, and generate
15551 a range of [last location start, end of function label]. */
15553 secname = secname_for_decl (decl);
15555 for (node = loc_list->first; node; node = node->next)
15556 if (GET_CODE (node->loc) == EXPR_LIST
15557 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
15559 if (GET_CODE (node->loc) == EXPR_LIST)
15561 /* This requires DW_OP_{,bit_}piece, which is not usable
15562 inside DWARF expressions. */
15563 if (want_address != 2)
15565 descr = dw_sra_loc_expr (decl, node->loc);
15571 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
15572 varloc = NOTE_VAR_LOCATION (node->loc);
15573 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
15577 bool range_across_switch = false;
15578 /* If section switch happens in between node->label
15579 and node->next->label (or end of function) and
15580 we can't emit it as a single entry list,
15581 emit two ranges, first one ending at the end
15582 of first partition and second one starting at the
15583 beginning of second partition. */
15584 if (node == loc_list->last_before_switch
15585 && (node != loc_list->first || loc_list->first->next)
15586 && current_function_decl)
15588 endname = current_fde ()->dw_fde_end;
15589 range_across_switch = true;
15591 /* The variable has a location between NODE->LABEL and
15592 NODE->NEXT->LABEL. */
15593 else if (node->next)
15594 endname = node->next->label;
15595 /* If the variable has a location at the last label
15596 it keeps its location until the end of function. */
15597 else if (!current_function_decl)
15598 endname = text_end_label;
15601 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
15602 current_function_funcdef_no);
15603 endname = ggc_strdup (label_id);
15606 *listp = new_loc_list (descr, node->label, endname, secname);
15607 listp = &(*listp)->dw_loc_next;
15609 if (range_across_switch)
15611 if (GET_CODE (node->loc) == EXPR_LIST)
15612 descr = dw_sra_loc_expr (decl, node->loc);
15615 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
15616 varloc = NOTE_VAR_LOCATION (node->loc);
15617 descr = dw_loc_list_1 (decl, varloc, want_address,
15620 gcc_assert (descr);
15621 /* The variable has a location between NODE->LABEL and
15622 NODE->NEXT->LABEL. */
15624 endname = node->next->label;
15626 endname = current_fde ()->dw_fde_second_end;
15627 *listp = new_loc_list (descr,
15628 current_fde ()->dw_fde_second_begin,
15630 listp = &(*listp)->dw_loc_next;
15635 /* Try to avoid the overhead of a location list emitting a location
15636 expression instead, but only if we didn't have more than one
15637 location entry in the first place. If some entries were not
15638 representable, we don't want to pretend a single entry that was
15639 applies to the entire scope in which the variable is
15641 if (list && loc_list->first->next)
15647 /* Return if the loc_list has only single element and thus can be represented
15648 as location description. */
15651 single_element_loc_list_p (dw_loc_list_ref list)
15653 gcc_assert (!list->dw_loc_next || list->ll_symbol);
15654 return !list->ll_symbol;
15657 /* To each location in list LIST add loc descr REF. */
15660 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
15662 dw_loc_descr_ref copy;
15663 add_loc_descr (&list->expr, ref);
15664 list = list->dw_loc_next;
15667 copy = ggc_alloc_dw_loc_descr_node ();
15668 memcpy (copy, ref, sizeof (dw_loc_descr_node));
15669 add_loc_descr (&list->expr, copy);
15670 while (copy->dw_loc_next)
15672 dw_loc_descr_ref new_copy = ggc_alloc_dw_loc_descr_node ();
15673 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
15674 copy->dw_loc_next = new_copy;
15677 list = list->dw_loc_next;
15681 /* Given two lists RET and LIST
15682 produce location list that is result of adding expression in LIST
15683 to expression in RET on each possition in program.
15684 Might be destructive on both RET and LIST.
15686 TODO: We handle only simple cases of RET or LIST having at most one
15687 element. General case would inolve sorting the lists in program order
15688 and merging them that will need some additional work.
15689 Adding that will improve quality of debug info especially for SRA-ed
15693 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
15702 if (!list->dw_loc_next)
15704 add_loc_descr_to_each (*ret, list->expr);
15707 if (!(*ret)->dw_loc_next)
15709 add_loc_descr_to_each (list, (*ret)->expr);
15713 expansion_failed (NULL_TREE, NULL_RTX,
15714 "Don't know how to merge two non-trivial"
15715 " location lists.\n");
15720 /* LOC is constant expression. Try a luck, look it up in constant
15721 pool and return its loc_descr of its address. */
15723 static dw_loc_descr_ref
15724 cst_pool_loc_descr (tree loc)
15726 /* Get an RTL for this, if something has been emitted. */
15727 rtx rtl = lookup_constant_def (loc);
15729 if (!rtl || !MEM_P (rtl))
15734 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
15736 /* TODO: We might get more coverage if we was actually delaying expansion
15737 of all expressions till end of compilation when constant pools are fully
15739 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
15741 expansion_failed (loc, NULL_RTX,
15742 "CST value in contant pool but not marked.");
15745 return mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
15746 GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED);
15749 /* Return dw_loc_list representing address of addr_expr LOC
15750 by looking for innder INDIRECT_REF expression and turing it
15751 into simple arithmetics. */
15753 static dw_loc_list_ref
15754 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev)
15757 HOST_WIDE_INT bitsize, bitpos, bytepos;
15758 enum machine_mode mode;
15760 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
15761 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
15763 obj = get_inner_reference (TREE_OPERAND (loc, 0),
15764 &bitsize, &bitpos, &offset, &mode,
15765 &unsignedp, &volatilep, false);
15767 if (bitpos % BITS_PER_UNIT)
15769 expansion_failed (loc, NULL_RTX, "bitfield access");
15772 if (!INDIRECT_REF_P (obj))
15774 expansion_failed (obj,
15775 NULL_RTX, "no indirect ref in inner refrence");
15778 if (!offset && !bitpos)
15779 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1);
15781 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
15782 && (dwarf_version >= 4 || !dwarf_strict))
15784 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0);
15789 /* Variable offset. */
15790 list_ret1 = loc_list_from_tree (offset, 0);
15791 if (list_ret1 == 0)
15793 add_loc_list (&list_ret, list_ret1);
15796 add_loc_descr_to_each (list_ret,
15797 new_loc_descr (DW_OP_plus, 0, 0));
15799 bytepos = bitpos / BITS_PER_UNIT;
15801 add_loc_descr_to_each (list_ret,
15802 new_loc_descr (DW_OP_plus_uconst,
15804 else if (bytepos < 0)
15805 loc_list_plus_const (list_ret, bytepos);
15806 add_loc_descr_to_each (list_ret,
15807 new_loc_descr (DW_OP_stack_value, 0, 0));
15813 /* Generate Dwarf location list representing LOC.
15814 If WANT_ADDRESS is false, expression computing LOC will be computed
15815 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
15816 if WANT_ADDRESS is 2, expression computing address useable in location
15817 will be returned (i.e. DW_OP_reg can be used
15818 to refer to register values). */
15820 static dw_loc_list_ref
15821 loc_list_from_tree (tree loc, int want_address)
15823 dw_loc_descr_ref ret = NULL, ret1 = NULL;
15824 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
15825 int have_address = 0;
15826 enum dwarf_location_atom op;
15828 /* ??? Most of the time we do not take proper care for sign/zero
15829 extending the values properly. Hopefully this won't be a real
15832 switch (TREE_CODE (loc))
15835 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
15838 case PLACEHOLDER_EXPR:
15839 /* This case involves extracting fields from an object to determine the
15840 position of other fields. We don't try to encode this here. The
15841 only user of this is Ada, which encodes the needed information using
15842 the names of types. */
15843 expansion_failed (loc, NULL_RTX, "PLACEHOLDER_EXPR");
15847 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
15848 /* There are no opcodes for these operations. */
15851 case PREINCREMENT_EXPR:
15852 case PREDECREMENT_EXPR:
15853 case POSTINCREMENT_EXPR:
15854 case POSTDECREMENT_EXPR:
15855 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
15856 /* There are no opcodes for these operations. */
15860 /* If we already want an address, see if there is INDIRECT_REF inside
15861 e.g. for &this->field. */
15864 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
15865 (loc, want_address == 2);
15868 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
15869 && (ret = cst_pool_loc_descr (loc)))
15872 /* Otherwise, process the argument and look for the address. */
15873 if (!list_ret && !ret)
15874 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1);
15878 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
15884 if (DECL_THREAD_LOCAL_P (loc))
15887 enum dwarf_location_atom first_op;
15888 enum dwarf_location_atom second_op;
15889 bool dtprel = false;
15891 if (targetm.have_tls)
15893 /* If this is not defined, we have no way to emit the
15895 if (!targetm.asm_out.output_dwarf_dtprel)
15898 /* The way DW_OP_GNU_push_tls_address is specified, we
15899 can only look up addresses of objects in the current
15900 module. We used DW_OP_addr as first op, but that's
15901 wrong, because DW_OP_addr is relocated by the debug
15902 info consumer, while DW_OP_GNU_push_tls_address
15903 operand shouldn't be. */
15904 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
15906 first_op = DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u;
15908 second_op = DW_OP_GNU_push_tls_address;
15912 if (!targetm.emutls.debug_form_tls_address
15913 || !(dwarf_version >= 3 || !dwarf_strict))
15915 /* We stuffed the control variable into the DECL_VALUE_EXPR
15916 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
15917 no longer appear in gimple code. We used the control
15918 variable in specific so that we could pick it up here. */
15919 loc = DECL_VALUE_EXPR (loc);
15920 first_op = DW_OP_addr;
15921 second_op = DW_OP_form_tls_address;
15924 rtl = rtl_for_decl_location (loc);
15925 if (rtl == NULL_RTX)
15930 rtl = XEXP (rtl, 0);
15931 if (! CONSTANT_P (rtl))
15934 ret = new_loc_descr (first_op, 0, 0);
15935 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
15936 ret->dw_loc_oprnd1.v.val_addr = rtl;
15937 ret->dtprel = dtprel;
15939 ret1 = new_loc_descr (second_op, 0, 0);
15940 add_loc_descr (&ret, ret1);
15949 if (DECL_HAS_VALUE_EXPR_P (loc))
15950 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
15954 case FUNCTION_DECL:
15957 var_loc_list *loc_list = lookup_decl_loc (loc);
15959 if (loc_list && loc_list->first)
15961 list_ret = dw_loc_list (loc_list, loc, want_address);
15962 have_address = want_address != 0;
15965 rtl = rtl_for_decl_location (loc);
15966 if (rtl == NULL_RTX)
15968 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
15971 else if (CONST_INT_P (rtl))
15973 HOST_WIDE_INT val = INTVAL (rtl);
15974 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
15975 val &= GET_MODE_MASK (DECL_MODE (loc));
15976 ret = int_loc_descriptor (val);
15978 else if (GET_CODE (rtl) == CONST_STRING)
15980 expansion_failed (loc, NULL_RTX, "CONST_STRING");
15983 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
15985 ret = new_loc_descr (DW_OP_addr, 0, 0);
15986 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
15987 ret->dw_loc_oprnd1.v.val_addr = rtl;
15991 enum machine_mode mode, mem_mode;
15993 /* Certain constructs can only be represented at top-level. */
15994 if (want_address == 2)
15996 ret = loc_descriptor (rtl, VOIDmode,
15997 VAR_INIT_STATUS_INITIALIZED);
16002 mode = GET_MODE (rtl);
16003 mem_mode = VOIDmode;
16007 mode = get_address_mode (rtl);
16008 rtl = XEXP (rtl, 0);
16011 ret = mem_loc_descriptor (rtl, mode, mem_mode,
16012 VAR_INIT_STATUS_INITIALIZED);
16015 expansion_failed (loc, rtl,
16016 "failed to produce loc descriptor for rtl");
16023 if (!integer_zerop (TREE_OPERAND (loc, 1)))
16027 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
16031 case COMPOUND_EXPR:
16032 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address);
16035 case VIEW_CONVERT_EXPR:
16038 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address);
16040 case COMPONENT_REF:
16041 case BIT_FIELD_REF:
16043 case ARRAY_RANGE_REF:
16044 case REALPART_EXPR:
16045 case IMAGPART_EXPR:
16048 HOST_WIDE_INT bitsize, bitpos, bytepos;
16049 enum machine_mode mode;
16051 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
16053 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
16054 &unsignedp, &volatilep, false);
16056 gcc_assert (obj != loc);
16058 list_ret = loc_list_from_tree (obj,
16060 && !bitpos && !offset ? 2 : 1);
16061 /* TODO: We can extract value of the small expression via shifting even
16062 for nonzero bitpos. */
16065 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
16067 expansion_failed (loc, NULL_RTX,
16068 "bitfield access");
16072 if (offset != NULL_TREE)
16074 /* Variable offset. */
16075 list_ret1 = loc_list_from_tree (offset, 0);
16076 if (list_ret1 == 0)
16078 add_loc_list (&list_ret, list_ret1);
16081 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
16084 bytepos = bitpos / BITS_PER_UNIT;
16086 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
16087 else if (bytepos < 0)
16088 loc_list_plus_const (list_ret, bytepos);
16095 if ((want_address || !host_integerp (loc, 0))
16096 && (ret = cst_pool_loc_descr (loc)))
16098 else if (want_address == 2
16099 && host_integerp (loc, 0)
16100 && (ret = address_of_int_loc_descriptor
16101 (int_size_in_bytes (TREE_TYPE (loc)),
16102 tree_low_cst (loc, 0))))
16104 else if (host_integerp (loc, 0))
16105 ret = int_loc_descriptor (tree_low_cst (loc, 0));
16108 expansion_failed (loc, NULL_RTX,
16109 "Integer operand is not host integer");
16118 if ((ret = cst_pool_loc_descr (loc)))
16121 /* We can construct small constants here using int_loc_descriptor. */
16122 expansion_failed (loc, NULL_RTX,
16123 "constructor or constant not in constant pool");
16126 case TRUTH_AND_EXPR:
16127 case TRUTH_ANDIF_EXPR:
16132 case TRUTH_XOR_EXPR:
16137 case TRUTH_OR_EXPR:
16138 case TRUTH_ORIF_EXPR:
16143 case FLOOR_DIV_EXPR:
16144 case CEIL_DIV_EXPR:
16145 case ROUND_DIV_EXPR:
16146 case TRUNC_DIV_EXPR:
16147 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
16156 case FLOOR_MOD_EXPR:
16157 case CEIL_MOD_EXPR:
16158 case ROUND_MOD_EXPR:
16159 case TRUNC_MOD_EXPR:
16160 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
16165 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
16166 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
16167 if (list_ret == 0 || list_ret1 == 0)
16170 add_loc_list (&list_ret, list_ret1);
16173 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
16174 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
16175 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
16176 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
16177 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
16189 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
16192 case POINTER_PLUS_EXPR:
16194 if (host_integerp (TREE_OPERAND (loc, 1), 0))
16196 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
16200 loc_list_plus_const (list_ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
16208 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
16215 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
16222 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
16229 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
16244 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
16245 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
16246 if (list_ret == 0 || list_ret1 == 0)
16249 add_loc_list (&list_ret, list_ret1);
16252 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
16255 case TRUTH_NOT_EXPR:
16269 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
16273 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
16279 const enum tree_code code =
16280 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
16282 loc = build3 (COND_EXPR, TREE_TYPE (loc),
16283 build2 (code, integer_type_node,
16284 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
16285 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
16288 /* ... fall through ... */
16292 dw_loc_descr_ref lhs
16293 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
16294 dw_loc_list_ref rhs
16295 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0);
16296 dw_loc_descr_ref bra_node, jump_node, tmp;
16298 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
16299 if (list_ret == 0 || lhs == 0 || rhs == 0)
16302 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
16303 add_loc_descr_to_each (list_ret, bra_node);
16305 add_loc_list (&list_ret, rhs);
16306 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
16307 add_loc_descr_to_each (list_ret, jump_node);
16309 add_loc_descr_to_each (list_ret, lhs);
16310 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
16311 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
16313 /* ??? Need a node to point the skip at. Use a nop. */
16314 tmp = new_loc_descr (DW_OP_nop, 0, 0);
16315 add_loc_descr_to_each (list_ret, tmp);
16316 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
16317 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
16321 case FIX_TRUNC_EXPR:
16325 /* Leave front-end specific codes as simply unknown. This comes
16326 up, for instance, with the C STMT_EXPR. */
16327 if ((unsigned int) TREE_CODE (loc)
16328 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
16330 expansion_failed (loc, NULL_RTX,
16331 "language specific tree node");
16335 #ifdef ENABLE_CHECKING
16336 /* Otherwise this is a generic code; we should just lists all of
16337 these explicitly. We forgot one. */
16338 gcc_unreachable ();
16340 /* In a release build, we want to degrade gracefully: better to
16341 generate incomplete debugging information than to crash. */
16346 if (!ret && !list_ret)
16349 if (want_address == 2 && !have_address
16350 && (dwarf_version >= 4 || !dwarf_strict))
16352 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
16354 expansion_failed (loc, NULL_RTX,
16355 "DWARF address size mismatch");
16359 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
16361 add_loc_descr_to_each (list_ret,
16362 new_loc_descr (DW_OP_stack_value, 0, 0));
16365 /* Show if we can't fill the request for an address. */
16366 if (want_address && !have_address)
16368 expansion_failed (loc, NULL_RTX,
16369 "Want address and only have value");
16373 gcc_assert (!ret || !list_ret);
16375 /* If we've got an address and don't want one, dereference. */
16376 if (!want_address && have_address)
16378 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
16380 if (size > DWARF2_ADDR_SIZE || size == -1)
16382 expansion_failed (loc, NULL_RTX,
16383 "DWARF address size mismatch");
16386 else if (size == DWARF2_ADDR_SIZE)
16389 op = DW_OP_deref_size;
16392 add_loc_descr (&ret, new_loc_descr (op, size, 0));
16394 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
16397 list_ret = new_loc_list (ret, NULL, NULL, NULL);
16402 /* Same as above but return only single location expression. */
16403 static dw_loc_descr_ref
16404 loc_descriptor_from_tree (tree loc, int want_address)
16406 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address);
16409 if (ret->dw_loc_next)
16411 expansion_failed (loc, NULL_RTX,
16412 "Location list where only loc descriptor needed");
16418 /* Given a value, round it up to the lowest multiple of `boundary'
16419 which is not less than the value itself. */
16421 static inline HOST_WIDE_INT
16422 ceiling (HOST_WIDE_INT value, unsigned int boundary)
16424 return (((value + boundary - 1) / boundary) * boundary);
16427 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
16428 pointer to the declared type for the relevant field variable, or return
16429 `integer_type_node' if the given node turns out to be an
16430 ERROR_MARK node. */
16433 field_type (const_tree decl)
16437 if (TREE_CODE (decl) == ERROR_MARK)
16438 return integer_type_node;
16440 type = DECL_BIT_FIELD_TYPE (decl);
16441 if (type == NULL_TREE)
16442 type = TREE_TYPE (decl);
16447 /* Given a pointer to a tree node, return the alignment in bits for
16448 it, or else return BITS_PER_WORD if the node actually turns out to
16449 be an ERROR_MARK node. */
16451 static inline unsigned
16452 simple_type_align_in_bits (const_tree type)
16454 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
16457 static inline unsigned
16458 simple_decl_align_in_bits (const_tree decl)
16460 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
16463 /* Return the result of rounding T up to ALIGN. */
16465 static inline double_int
16466 round_up_to_align (double_int t, unsigned int align)
16468 double_int alignd = uhwi_to_double_int (align);
16469 t = double_int_add (t, alignd);
16470 t = double_int_add (t, double_int_minus_one);
16471 t = double_int_div (t, alignd, true, TRUNC_DIV_EXPR);
16472 t = double_int_mul (t, alignd);
16476 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
16477 lowest addressed byte of the "containing object" for the given FIELD_DECL,
16478 or return 0 if we are unable to determine what that offset is, either
16479 because the argument turns out to be a pointer to an ERROR_MARK node, or
16480 because the offset is actually variable. (We can't handle the latter case
16483 static HOST_WIDE_INT
16484 field_byte_offset (const_tree decl)
16486 double_int object_offset_in_bits;
16487 double_int object_offset_in_bytes;
16488 double_int bitpos_int;
16490 if (TREE_CODE (decl) == ERROR_MARK)
16493 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
16495 /* We cannot yet cope with fields whose positions are variable, so
16496 for now, when we see such things, we simply return 0. Someday, we may
16497 be able to handle such cases, but it will be damn difficult. */
16498 if (TREE_CODE (bit_position (decl)) != INTEGER_CST)
16501 bitpos_int = tree_to_double_int (bit_position (decl));
16503 #ifdef PCC_BITFIELD_TYPE_MATTERS
16504 if (PCC_BITFIELD_TYPE_MATTERS)
16507 tree field_size_tree;
16508 double_int deepest_bitpos;
16509 double_int field_size_in_bits;
16510 unsigned int type_align_in_bits;
16511 unsigned int decl_align_in_bits;
16512 double_int type_size_in_bits;
16514 type = field_type (decl);
16515 type_size_in_bits = double_int_type_size_in_bits (type);
16516 type_align_in_bits = simple_type_align_in_bits (type);
16518 field_size_tree = DECL_SIZE (decl);
16520 /* The size could be unspecified if there was an error, or for
16521 a flexible array member. */
16522 if (!field_size_tree)
16523 field_size_tree = bitsize_zero_node;
16525 /* If the size of the field is not constant, use the type size. */
16526 if (TREE_CODE (field_size_tree) == INTEGER_CST)
16527 field_size_in_bits = tree_to_double_int (field_size_tree);
16529 field_size_in_bits = type_size_in_bits;
16531 decl_align_in_bits = simple_decl_align_in_bits (decl);
16533 /* The GCC front-end doesn't make any attempt to keep track of the
16534 starting bit offset (relative to the start of the containing
16535 structure type) of the hypothetical "containing object" for a
16536 bit-field. Thus, when computing the byte offset value for the
16537 start of the "containing object" of a bit-field, we must deduce
16538 this information on our own. This can be rather tricky to do in
16539 some cases. For example, handling the following structure type
16540 definition when compiling for an i386/i486 target (which only
16541 aligns long long's to 32-bit boundaries) can be very tricky:
16543 struct S { int field1; long long field2:31; };
16545 Fortunately, there is a simple rule-of-thumb which can be used
16546 in such cases. When compiling for an i386/i486, GCC will
16547 allocate 8 bytes for the structure shown above. It decides to
16548 do this based upon one simple rule for bit-field allocation.
16549 GCC allocates each "containing object" for each bit-field at
16550 the first (i.e. lowest addressed) legitimate alignment boundary
16551 (based upon the required minimum alignment for the declared
16552 type of the field) which it can possibly use, subject to the
16553 condition that there is still enough available space remaining
16554 in the containing object (when allocated at the selected point)
16555 to fully accommodate all of the bits of the bit-field itself.
16557 This simple rule makes it obvious why GCC allocates 8 bytes for
16558 each object of the structure type shown above. When looking
16559 for a place to allocate the "containing object" for `field2',
16560 the compiler simply tries to allocate a 64-bit "containing
16561 object" at each successive 32-bit boundary (starting at zero)
16562 until it finds a place to allocate that 64- bit field such that
16563 at least 31 contiguous (and previously unallocated) bits remain
16564 within that selected 64 bit field. (As it turns out, for the
16565 example above, the compiler finds it is OK to allocate the
16566 "containing object" 64-bit field at bit-offset zero within the
16569 Here we attempt to work backwards from the limited set of facts
16570 we're given, and we try to deduce from those facts, where GCC
16571 must have believed that the containing object started (within
16572 the structure type). The value we deduce is then used (by the
16573 callers of this routine) to generate DW_AT_location and
16574 DW_AT_bit_offset attributes for fields (both bit-fields and, in
16575 the case of DW_AT_location, regular fields as well). */
16577 /* Figure out the bit-distance from the start of the structure to
16578 the "deepest" bit of the bit-field. */
16579 deepest_bitpos = double_int_add (bitpos_int, field_size_in_bits);
16581 /* This is the tricky part. Use some fancy footwork to deduce
16582 where the lowest addressed bit of the containing object must
16584 object_offset_in_bits
16585 = double_int_sub (deepest_bitpos, type_size_in_bits);
16587 /* Round up to type_align by default. This works best for
16589 object_offset_in_bits
16590 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
16592 if (double_int_ucmp (object_offset_in_bits, bitpos_int) > 0)
16594 object_offset_in_bits
16595 = double_int_sub (deepest_bitpos, type_size_in_bits);
16597 /* Round up to decl_align instead. */
16598 object_offset_in_bits
16599 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
16603 #endif /* PCC_BITFIELD_TYPE_MATTERS */
16604 object_offset_in_bits = bitpos_int;
16606 object_offset_in_bytes
16607 = double_int_div (object_offset_in_bits,
16608 uhwi_to_double_int (BITS_PER_UNIT), true,
16610 return double_int_to_shwi (object_offset_in_bytes);
16613 /* The following routines define various Dwarf attributes and any data
16614 associated with them. */
16616 /* Add a location description attribute value to a DIE.
16618 This emits location attributes suitable for whole variables and
16619 whole parameters. Note that the location attributes for struct fields are
16620 generated by the routine `data_member_location_attribute' below. */
16623 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
16624 dw_loc_list_ref descr)
16628 if (single_element_loc_list_p (descr))
16629 add_AT_loc (die, attr_kind, descr->expr);
16631 add_AT_loc_list (die, attr_kind, descr);
16634 /* Add DW_AT_accessibility attribute to DIE if needed. */
16637 add_accessibility_attribute (dw_die_ref die, tree decl)
16639 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
16640 children, otherwise the default is DW_ACCESS_public. In DWARF2
16641 the default has always been DW_ACCESS_public. */
16642 if (TREE_PROTECTED (decl))
16643 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
16644 else if (TREE_PRIVATE (decl))
16646 if (dwarf_version == 2
16647 || die->die_parent == NULL
16648 || die->die_parent->die_tag != DW_TAG_class_type)
16649 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
16651 else if (dwarf_version > 2
16653 && die->die_parent->die_tag == DW_TAG_class_type)
16654 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
16657 /* Attach the specialized form of location attribute used for data members of
16658 struct and union types. In the special case of a FIELD_DECL node which
16659 represents a bit-field, the "offset" part of this special location
16660 descriptor must indicate the distance in bytes from the lowest-addressed
16661 byte of the containing struct or union type to the lowest-addressed byte of
16662 the "containing object" for the bit-field. (See the `field_byte_offset'
16665 For any given bit-field, the "containing object" is a hypothetical object
16666 (of some integral or enum type) within which the given bit-field lives. The
16667 type of this hypothetical "containing object" is always the same as the
16668 declared type of the individual bit-field itself (for GCC anyway... the
16669 DWARF spec doesn't actually mandate this). Note that it is the size (in
16670 bytes) of the hypothetical "containing object" which will be given in the
16671 DW_AT_byte_size attribute for this bit-field. (See the
16672 `byte_size_attribute' function below.) It is also used when calculating the
16673 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
16674 function below.) */
16677 add_data_member_location_attribute (dw_die_ref die, tree decl)
16679 HOST_WIDE_INT offset;
16680 dw_loc_descr_ref loc_descr = 0;
16682 if (TREE_CODE (decl) == TREE_BINFO)
16684 /* We're working on the TAG_inheritance for a base class. */
16685 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
16687 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
16688 aren't at a fixed offset from all (sub)objects of the same
16689 type. We need to extract the appropriate offset from our
16690 vtable. The following dwarf expression means
16692 BaseAddr = ObAddr + *((*ObAddr) - Offset)
16694 This is specific to the V3 ABI, of course. */
16696 dw_loc_descr_ref tmp;
16698 /* Make a copy of the object address. */
16699 tmp = new_loc_descr (DW_OP_dup, 0, 0);
16700 add_loc_descr (&loc_descr, tmp);
16702 /* Extract the vtable address. */
16703 tmp = new_loc_descr (DW_OP_deref, 0, 0);
16704 add_loc_descr (&loc_descr, tmp);
16706 /* Calculate the address of the offset. */
16707 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
16708 gcc_assert (offset < 0);
16710 tmp = int_loc_descriptor (-offset);
16711 add_loc_descr (&loc_descr, tmp);
16712 tmp = new_loc_descr (DW_OP_minus, 0, 0);
16713 add_loc_descr (&loc_descr, tmp);
16715 /* Extract the offset. */
16716 tmp = new_loc_descr (DW_OP_deref, 0, 0);
16717 add_loc_descr (&loc_descr, tmp);
16719 /* Add it to the object address. */
16720 tmp = new_loc_descr (DW_OP_plus, 0, 0);
16721 add_loc_descr (&loc_descr, tmp);
16724 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
16727 offset = field_byte_offset (decl);
16731 if (dwarf_version > 2)
16733 /* Don't need to output a location expression, just the constant. */
16735 add_AT_int (die, DW_AT_data_member_location, offset);
16737 add_AT_unsigned (die, DW_AT_data_member_location, offset);
16742 enum dwarf_location_atom op;
16744 /* The DWARF2 standard says that we should assume that the structure
16745 address is already on the stack, so we can specify a structure
16746 field address by using DW_OP_plus_uconst. */
16748 #ifdef MIPS_DEBUGGING_INFO
16749 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
16750 operator correctly. It works only if we leave the offset on the
16754 op = DW_OP_plus_uconst;
16757 loc_descr = new_loc_descr (op, offset, 0);
16761 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
16764 /* Writes integer values to dw_vec_const array. */
16767 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
16771 *dest++ = val & 0xff;
16777 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
16779 static HOST_WIDE_INT
16780 extract_int (const unsigned char *src, unsigned int size)
16782 HOST_WIDE_INT val = 0;
16788 val |= *--src & 0xff;
16794 /* Writes double_int values to dw_vec_const array. */
16797 insert_double (double_int val, unsigned char *dest)
16799 unsigned char *p0 = dest;
16800 unsigned char *p1 = dest + sizeof (HOST_WIDE_INT);
16802 if (WORDS_BIG_ENDIAN)
16808 insert_int ((HOST_WIDE_INT) val.low, sizeof (HOST_WIDE_INT), p0);
16809 insert_int ((HOST_WIDE_INT) val.high, sizeof (HOST_WIDE_INT), p1);
16812 /* Writes floating point values to dw_vec_const array. */
16815 insert_float (const_rtx rtl, unsigned char *array)
16817 REAL_VALUE_TYPE rv;
16821 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
16822 real_to_target (val, &rv, GET_MODE (rtl));
16824 /* real_to_target puts 32-bit pieces in each long. Pack them. */
16825 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
16827 insert_int (val[i], 4, array);
16832 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
16833 does not have a "location" either in memory or in a register. These
16834 things can arise in GNU C when a constant is passed as an actual parameter
16835 to an inlined function. They can also arise in C++ where declared
16836 constants do not necessarily get memory "homes". */
16839 add_const_value_attribute (dw_die_ref die, rtx rtl)
16841 switch (GET_CODE (rtl))
16845 HOST_WIDE_INT val = INTVAL (rtl);
16848 add_AT_int (die, DW_AT_const_value, val);
16850 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
16855 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
16856 floating-point constant. A CONST_DOUBLE is used whenever the
16857 constant requires more than one word in order to be adequately
16860 enum machine_mode mode = GET_MODE (rtl);
16862 if (SCALAR_FLOAT_MODE_P (mode))
16864 unsigned int length = GET_MODE_SIZE (mode);
16865 unsigned char *array = (unsigned char *) ggc_alloc_atomic (length);
16867 insert_float (rtl, array);
16868 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
16871 add_AT_double (die, DW_AT_const_value,
16872 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
16878 enum machine_mode mode = GET_MODE (rtl);
16879 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
16880 unsigned int length = CONST_VECTOR_NUNITS (rtl);
16881 unsigned char *array = (unsigned char *) ggc_alloc_atomic
16882 (length * elt_size);
16886 switch (GET_MODE_CLASS (mode))
16888 case MODE_VECTOR_INT:
16889 for (i = 0, p = array; i < length; i++, p += elt_size)
16891 rtx elt = CONST_VECTOR_ELT (rtl, i);
16892 double_int val = rtx_to_double_int (elt);
16894 if (elt_size <= sizeof (HOST_WIDE_INT))
16895 insert_int (double_int_to_shwi (val), elt_size, p);
16898 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
16899 insert_double (val, p);
16904 case MODE_VECTOR_FLOAT:
16905 for (i = 0, p = array; i < length; i++, p += elt_size)
16907 rtx elt = CONST_VECTOR_ELT (rtl, i);
16908 insert_float (elt, p);
16913 gcc_unreachable ();
16916 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
16921 if (dwarf_version >= 4 || !dwarf_strict)
16923 dw_loc_descr_ref loc_result;
16924 resolve_one_addr (&rtl, NULL);
16926 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
16927 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
16928 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
16929 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
16930 add_AT_loc (die, DW_AT_location, loc_result);
16931 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
16937 if (CONSTANT_P (XEXP (rtl, 0)))
16938 return add_const_value_attribute (die, XEXP (rtl, 0));
16941 if (!const_ok_for_output (rtl))
16944 if (dwarf_version >= 4 || !dwarf_strict)
16949 /* In cases where an inlined instance of an inline function is passed
16950 the address of an `auto' variable (which is local to the caller) we
16951 can get a situation where the DECL_RTL of the artificial local
16952 variable (for the inlining) which acts as a stand-in for the
16953 corresponding formal parameter (of the inline function) will look
16954 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
16955 exactly a compile-time constant expression, but it isn't the address
16956 of the (artificial) local variable either. Rather, it represents the
16957 *value* which the artificial local variable always has during its
16958 lifetime. We currently have no way to represent such quasi-constant
16959 values in Dwarf, so for now we just punt and generate nothing. */
16967 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
16968 && MEM_READONLY_P (rtl)
16969 && GET_MODE (rtl) == BLKmode)
16971 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
16977 /* No other kinds of rtx should be possible here. */
16978 gcc_unreachable ();
16983 /* Determine whether the evaluation of EXPR references any variables
16984 or functions which aren't otherwise used (and therefore may not be
16987 reference_to_unused (tree * tp, int * walk_subtrees,
16988 void * data ATTRIBUTE_UNUSED)
16990 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
16991 *walk_subtrees = 0;
16993 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
16994 && ! TREE_ASM_WRITTEN (*tp))
16996 /* ??? The C++ FE emits debug information for using decls, so
16997 putting gcc_unreachable here falls over. See PR31899. For now
16998 be conservative. */
16999 else if (!cgraph_global_info_ready
17000 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
17002 else if (TREE_CODE (*tp) == VAR_DECL)
17004 struct varpool_node *node = varpool_get_node (*tp);
17005 if (!node || !node->needed)
17008 else if (TREE_CODE (*tp) == FUNCTION_DECL
17009 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
17011 /* The call graph machinery must have finished analyzing,
17012 optimizing and gimplifying the CU by now.
17013 So if *TP has no call graph node associated
17014 to it, it means *TP will not be emitted. */
17015 if (!cgraph_get_node (*tp))
17018 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
17024 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
17025 for use in a later add_const_value_attribute call. */
17028 rtl_for_decl_init (tree init, tree type)
17030 rtx rtl = NULL_RTX;
17034 /* If a variable is initialized with a string constant without embedded
17035 zeros, build CONST_STRING. */
17036 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
17038 tree enttype = TREE_TYPE (type);
17039 tree domain = TYPE_DOMAIN (type);
17040 enum machine_mode mode = TYPE_MODE (enttype);
17042 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
17044 && integer_zerop (TYPE_MIN_VALUE (domain))
17045 && compare_tree_int (TYPE_MAX_VALUE (domain),
17046 TREE_STRING_LENGTH (init) - 1) == 0
17047 && ((size_t) TREE_STRING_LENGTH (init)
17048 == strlen (TREE_STRING_POINTER (init)) + 1))
17050 rtl = gen_rtx_CONST_STRING (VOIDmode,
17051 ggc_strdup (TREE_STRING_POINTER (init)));
17052 rtl = gen_rtx_MEM (BLKmode, rtl);
17053 MEM_READONLY_P (rtl) = 1;
17056 /* Other aggregates, and complex values, could be represented using
17058 else if (AGGREGATE_TYPE_P (type)
17059 || (TREE_CODE (init) == VIEW_CONVERT_EXPR
17060 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init, 0))))
17061 || TREE_CODE (type) == COMPLEX_TYPE)
17063 /* Vectors only work if their mode is supported by the target.
17064 FIXME: generic vectors ought to work too. */
17065 else if (TREE_CODE (type) == VECTOR_TYPE
17066 && !VECTOR_MODE_P (TYPE_MODE (type)))
17068 /* If the initializer is something that we know will expand into an
17069 immediate RTL constant, expand it now. We must be careful not to
17070 reference variables which won't be output. */
17071 else if (initializer_constant_valid_p (init, type)
17072 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
17074 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
17076 if (TREE_CODE (type) == VECTOR_TYPE)
17077 switch (TREE_CODE (init))
17082 if (TREE_CONSTANT (init))
17084 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
17085 bool constant_p = true;
17087 unsigned HOST_WIDE_INT ix;
17089 /* Even when ctor is constant, it might contain non-*_CST
17090 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
17091 belong into VECTOR_CST nodes. */
17092 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
17093 if (!CONSTANT_CLASS_P (value))
17095 constant_p = false;
17101 init = build_vector_from_ctor (type, elts);
17111 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
17113 /* If expand_expr returns a MEM, it wasn't immediate. */
17114 gcc_assert (!rtl || !MEM_P (rtl));
17120 /* Generate RTL for the variable DECL to represent its location. */
17123 rtl_for_decl_location (tree decl)
17127 /* Here we have to decide where we are going to say the parameter "lives"
17128 (as far as the debugger is concerned). We only have a couple of
17129 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
17131 DECL_RTL normally indicates where the parameter lives during most of the
17132 activation of the function. If optimization is enabled however, this
17133 could be either NULL or else a pseudo-reg. Both of those cases indicate
17134 that the parameter doesn't really live anywhere (as far as the code
17135 generation parts of GCC are concerned) during most of the function's
17136 activation. That will happen (for example) if the parameter is never
17137 referenced within the function.
17139 We could just generate a location descriptor here for all non-NULL
17140 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
17141 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
17142 where DECL_RTL is NULL or is a pseudo-reg.
17144 Note however that we can only get away with using DECL_INCOMING_RTL as
17145 a backup substitute for DECL_RTL in certain limited cases. In cases
17146 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
17147 we can be sure that the parameter was passed using the same type as it is
17148 declared to have within the function, and that its DECL_INCOMING_RTL
17149 points us to a place where a value of that type is passed.
17151 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
17152 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
17153 because in these cases DECL_INCOMING_RTL points us to a value of some
17154 type which is *different* from the type of the parameter itself. Thus,
17155 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
17156 such cases, the debugger would end up (for example) trying to fetch a
17157 `float' from a place which actually contains the first part of a
17158 `double'. That would lead to really incorrect and confusing
17159 output at debug-time.
17161 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
17162 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
17163 are a couple of exceptions however. On little-endian machines we can
17164 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
17165 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
17166 an integral type that is smaller than TREE_TYPE (decl). These cases arise
17167 when (on a little-endian machine) a non-prototyped function has a
17168 parameter declared to be of type `short' or `char'. In such cases,
17169 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
17170 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
17171 passed `int' value. If the debugger then uses that address to fetch
17172 a `short' or a `char' (on a little-endian machine) the result will be
17173 the correct data, so we allow for such exceptional cases below.
17175 Note that our goal here is to describe the place where the given formal
17176 parameter lives during most of the function's activation (i.e. between the
17177 end of the prologue and the start of the epilogue). We'll do that as best
17178 as we can. Note however that if the given formal parameter is modified
17179 sometime during the execution of the function, then a stack backtrace (at
17180 debug-time) will show the function as having been called with the *new*
17181 value rather than the value which was originally passed in. This happens
17182 rarely enough that it is not a major problem, but it *is* a problem, and
17183 I'd like to fix it.
17185 A future version of dwarf2out.c may generate two additional attributes for
17186 any given DW_TAG_formal_parameter DIE which will describe the "passed
17187 type" and the "passed location" for the given formal parameter in addition
17188 to the attributes we now generate to indicate the "declared type" and the
17189 "active location" for each parameter. This additional set of attributes
17190 could be used by debuggers for stack backtraces. Separately, note that
17191 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
17192 This happens (for example) for inlined-instances of inline function formal
17193 parameters which are never referenced. This really shouldn't be
17194 happening. All PARM_DECL nodes should get valid non-NULL
17195 DECL_INCOMING_RTL values. FIXME. */
17197 /* Use DECL_RTL as the "location" unless we find something better. */
17198 rtl = DECL_RTL_IF_SET (decl);
17200 /* When generating abstract instances, ignore everything except
17201 constants, symbols living in memory, and symbols living in
17202 fixed registers. */
17203 if (! reload_completed)
17206 && (CONSTANT_P (rtl)
17208 && CONSTANT_P (XEXP (rtl, 0)))
17210 && TREE_CODE (decl) == VAR_DECL
17211 && TREE_STATIC (decl))))
17213 rtl = targetm.delegitimize_address (rtl);
17218 else if (TREE_CODE (decl) == PARM_DECL)
17220 if (rtl == NULL_RTX
17221 || is_pseudo_reg (rtl)
17223 && is_pseudo_reg (XEXP (rtl, 0))
17224 && DECL_INCOMING_RTL (decl)
17225 && MEM_P (DECL_INCOMING_RTL (decl))
17226 && GET_MODE (rtl) == GET_MODE (DECL_INCOMING_RTL (decl))))
17228 tree declared_type = TREE_TYPE (decl);
17229 tree passed_type = DECL_ARG_TYPE (decl);
17230 enum machine_mode dmode = TYPE_MODE (declared_type);
17231 enum machine_mode pmode = TYPE_MODE (passed_type);
17233 /* This decl represents a formal parameter which was optimized out.
17234 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
17235 all cases where (rtl == NULL_RTX) just below. */
17236 if (dmode == pmode)
17237 rtl = DECL_INCOMING_RTL (decl);
17238 else if ((rtl == NULL_RTX || is_pseudo_reg (rtl))
17239 && SCALAR_INT_MODE_P (dmode)
17240 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
17241 && DECL_INCOMING_RTL (decl))
17243 rtx inc = DECL_INCOMING_RTL (decl);
17246 else if (MEM_P (inc))
17248 if (BYTES_BIG_ENDIAN)
17249 rtl = adjust_address_nv (inc, dmode,
17250 GET_MODE_SIZE (pmode)
17251 - GET_MODE_SIZE (dmode));
17258 /* If the parm was passed in registers, but lives on the stack, then
17259 make a big endian correction if the mode of the type of the
17260 parameter is not the same as the mode of the rtl. */
17261 /* ??? This is the same series of checks that are made in dbxout.c before
17262 we reach the big endian correction code there. It isn't clear if all
17263 of these checks are necessary here, but keeping them all is the safe
17265 else if (MEM_P (rtl)
17266 && XEXP (rtl, 0) != const0_rtx
17267 && ! CONSTANT_P (XEXP (rtl, 0))
17268 /* Not passed in memory. */
17269 && !MEM_P (DECL_INCOMING_RTL (decl))
17270 /* Not passed by invisible reference. */
17271 && (!REG_P (XEXP (rtl, 0))
17272 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
17273 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
17274 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
17275 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
17278 /* Big endian correction check. */
17279 && BYTES_BIG_ENDIAN
17280 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
17281 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
17284 int offset = (UNITS_PER_WORD
17285 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
17287 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
17288 plus_constant (XEXP (rtl, 0), offset));
17291 else if (TREE_CODE (decl) == VAR_DECL
17294 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
17295 && BYTES_BIG_ENDIAN)
17297 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
17298 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
17300 /* If a variable is declared "register" yet is smaller than
17301 a register, then if we store the variable to memory, it
17302 looks like we're storing a register-sized value, when in
17303 fact we are not. We need to adjust the offset of the
17304 storage location to reflect the actual value's bytes,
17305 else gdb will not be able to display it. */
17307 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
17308 plus_constant (XEXP (rtl, 0), rsize-dsize));
17311 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
17312 and will have been substituted directly into all expressions that use it.
17313 C does not have such a concept, but C++ and other languages do. */
17314 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
17315 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
17318 rtl = targetm.delegitimize_address (rtl);
17320 /* If we don't look past the constant pool, we risk emitting a
17321 reference to a constant pool entry that isn't referenced from
17322 code, and thus is not emitted. */
17324 rtl = avoid_constant_pool_reference (rtl);
17326 /* Try harder to get a rtl. If this symbol ends up not being emitted
17327 in the current CU, resolve_addr will remove the expression referencing
17329 if (rtl == NULL_RTX
17330 && TREE_CODE (decl) == VAR_DECL
17331 && !DECL_EXTERNAL (decl)
17332 && TREE_STATIC (decl)
17333 && DECL_NAME (decl)
17334 && !DECL_HARD_REGISTER (decl)
17335 && DECL_MODE (decl) != VOIDmode)
17337 rtl = make_decl_rtl_for_debug (decl);
17339 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
17340 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
17347 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
17348 returned. If so, the decl for the COMMON block is returned, and the
17349 value is the offset into the common block for the symbol. */
17352 fortran_common (tree decl, HOST_WIDE_INT *value)
17354 tree val_expr, cvar;
17355 enum machine_mode mode;
17356 HOST_WIDE_INT bitsize, bitpos;
17358 int volatilep = 0, unsignedp = 0;
17360 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
17361 it does not have a value (the offset into the common area), or if it
17362 is thread local (as opposed to global) then it isn't common, and shouldn't
17363 be handled as such. */
17364 if (TREE_CODE (decl) != VAR_DECL
17365 || !TREE_STATIC (decl)
17366 || !DECL_HAS_VALUE_EXPR_P (decl)
17370 val_expr = DECL_VALUE_EXPR (decl);
17371 if (TREE_CODE (val_expr) != COMPONENT_REF)
17374 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
17375 &mode, &unsignedp, &volatilep, true);
17377 if (cvar == NULL_TREE
17378 || TREE_CODE (cvar) != VAR_DECL
17379 || DECL_ARTIFICIAL (cvar)
17380 || !TREE_PUBLIC (cvar))
17384 if (offset != NULL)
17386 if (!host_integerp (offset, 0))
17388 *value = tree_low_cst (offset, 0);
17391 *value += bitpos / BITS_PER_UNIT;
17396 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
17397 data attribute for a variable or a parameter. We generate the
17398 DW_AT_const_value attribute only in those cases where the given variable
17399 or parameter does not have a true "location" either in memory or in a
17400 register. This can happen (for example) when a constant is passed as an
17401 actual argument in a call to an inline function. (It's possible that
17402 these things can crop up in other ways also.) Note that one type of
17403 constant value which can be passed into an inlined function is a constant
17404 pointer. This can happen for example if an actual argument in an inlined
17405 function call evaluates to a compile-time constant address.
17407 CACHE_P is true if it is worth caching the location list for DECL,
17408 so that future calls can reuse it rather than regenerate it from scratch.
17409 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
17410 since we will need to refer to them each time the function is inlined. */
17413 add_location_or_const_value_attribute (dw_die_ref die, tree decl, bool cache_p,
17414 enum dwarf_attribute attr)
17417 dw_loc_list_ref list;
17418 var_loc_list *loc_list;
17419 cached_dw_loc_list *cache;
17422 if (TREE_CODE (decl) == ERROR_MARK)
17425 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
17426 || TREE_CODE (decl) == RESULT_DECL);
17428 /* Try to get some constant RTL for this decl, and use that as the value of
17431 rtl = rtl_for_decl_location (decl);
17432 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
17433 && add_const_value_attribute (die, rtl))
17436 /* See if we have single element location list that is equivalent to
17437 a constant value. That way we are better to use add_const_value_attribute
17438 rather than expanding constant value equivalent. */
17439 loc_list = lookup_decl_loc (decl);
17442 && loc_list->first->next == NULL
17443 && NOTE_P (loc_list->first->loc)
17444 && NOTE_VAR_LOCATION (loc_list->first->loc)
17445 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
17447 struct var_loc_node *node;
17449 node = loc_list->first;
17450 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
17451 if (GET_CODE (rtl) == EXPR_LIST)
17452 rtl = XEXP (rtl, 0);
17453 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
17454 && add_const_value_attribute (die, rtl))
17457 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
17458 list several times. See if we've already cached the contents. */
17460 if (loc_list == NULL || cached_dw_loc_list_table == NULL)
17464 cache = (cached_dw_loc_list *)
17465 htab_find_with_hash (cached_dw_loc_list_table, decl, DECL_UID (decl));
17467 list = cache->loc_list;
17471 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2);
17472 /* It is usually worth caching this result if the decl is from
17473 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
17474 if (cache_p && list && list->dw_loc_next)
17476 slot = htab_find_slot_with_hash (cached_dw_loc_list_table, decl,
17477 DECL_UID (decl), INSERT);
17478 cache = ggc_alloc_cleared_cached_dw_loc_list ();
17479 cache->decl_id = DECL_UID (decl);
17480 cache->loc_list = list;
17486 add_AT_location_description (die, attr, list);
17489 /* None of that worked, so it must not really have a location;
17490 try adding a constant value attribute from the DECL_INITIAL. */
17491 return tree_add_const_value_attribute_for_decl (die, decl);
17494 /* Add VARIABLE and DIE into deferred locations list. */
17497 defer_location (tree variable, dw_die_ref die)
17499 deferred_locations entry;
17500 entry.variable = variable;
17502 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
17505 /* Helper function for tree_add_const_value_attribute. Natively encode
17506 initializer INIT into an array. Return true if successful. */
17509 native_encode_initializer (tree init, unsigned char *array, int size)
17513 if (init == NULL_TREE)
17517 switch (TREE_CODE (init))
17520 type = TREE_TYPE (init);
17521 if (TREE_CODE (type) == ARRAY_TYPE)
17523 tree enttype = TREE_TYPE (type);
17524 enum machine_mode mode = TYPE_MODE (enttype);
17526 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
17528 if (int_size_in_bytes (type) != size)
17530 if (size > TREE_STRING_LENGTH (init))
17532 memcpy (array, TREE_STRING_POINTER (init),
17533 TREE_STRING_LENGTH (init));
17534 memset (array + TREE_STRING_LENGTH (init),
17535 '\0', size - TREE_STRING_LENGTH (init));
17538 memcpy (array, TREE_STRING_POINTER (init), size);
17543 type = TREE_TYPE (init);
17544 if (int_size_in_bytes (type) != size)
17546 if (TREE_CODE (type) == ARRAY_TYPE)
17548 HOST_WIDE_INT min_index;
17549 unsigned HOST_WIDE_INT cnt;
17550 int curpos = 0, fieldsize;
17551 constructor_elt *ce;
17553 if (TYPE_DOMAIN (type) == NULL_TREE
17554 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
17557 fieldsize = int_size_in_bytes (TREE_TYPE (type));
17558 if (fieldsize <= 0)
17561 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
17562 memset (array, '\0', size);
17563 FOR_EACH_VEC_ELT (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce)
17565 tree val = ce->value;
17566 tree index = ce->index;
17568 if (index && TREE_CODE (index) == RANGE_EXPR)
17569 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
17572 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
17577 if (!native_encode_initializer (val, array + pos, fieldsize))
17580 curpos = pos + fieldsize;
17581 if (index && TREE_CODE (index) == RANGE_EXPR)
17583 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
17584 - tree_low_cst (TREE_OPERAND (index, 0), 0);
17588 memcpy (array + curpos, array + pos, fieldsize);
17589 curpos += fieldsize;
17592 gcc_assert (curpos <= size);
17596 else if (TREE_CODE (type) == RECORD_TYPE
17597 || TREE_CODE (type) == UNION_TYPE)
17599 tree field = NULL_TREE;
17600 unsigned HOST_WIDE_INT cnt;
17601 constructor_elt *ce;
17603 if (int_size_in_bytes (type) != size)
17606 if (TREE_CODE (type) == RECORD_TYPE)
17607 field = TYPE_FIELDS (type);
17609 FOR_EACH_VEC_ELT (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce)
17611 tree val = ce->value;
17612 int pos, fieldsize;
17614 if (ce->index != 0)
17620 if (field == NULL_TREE || DECL_BIT_FIELD (field))
17623 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
17624 && TYPE_DOMAIN (TREE_TYPE (field))
17625 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
17627 else if (DECL_SIZE_UNIT (field) == NULL_TREE
17628 || !host_integerp (DECL_SIZE_UNIT (field), 0))
17630 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
17631 pos = int_byte_position (field);
17632 gcc_assert (pos + fieldsize <= size);
17634 && !native_encode_initializer (val, array + pos, fieldsize))
17640 case VIEW_CONVERT_EXPR:
17641 case NON_LVALUE_EXPR:
17642 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
17644 return native_encode_expr (init, array, size) == size;
17648 /* Attach a DW_AT_const_value attribute to DIE. The value of the
17649 attribute is the const value T. */
17652 tree_add_const_value_attribute (dw_die_ref die, tree t)
17655 tree type = TREE_TYPE (t);
17658 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
17662 gcc_assert (!DECL_P (init));
17664 rtl = rtl_for_decl_init (init, type);
17666 return add_const_value_attribute (die, rtl);
17667 /* If the host and target are sane, try harder. */
17668 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
17669 && initializer_constant_valid_p (init, type))
17671 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
17672 if (size > 0 && (int) size == size)
17674 unsigned char *array = (unsigned char *)
17675 ggc_alloc_cleared_atomic (size);
17677 if (native_encode_initializer (init, array, size))
17679 add_AT_vec (die, DW_AT_const_value, size, 1, array);
17687 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
17688 attribute is the const value of T, where T is an integral constant
17689 variable with static storage duration
17690 (so it can't be a PARM_DECL or a RESULT_DECL). */
17693 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
17697 || (TREE_CODE (decl) != VAR_DECL
17698 && TREE_CODE (decl) != CONST_DECL))
17701 if (TREE_READONLY (decl)
17702 && ! TREE_THIS_VOLATILE (decl)
17703 && DECL_INITIAL (decl))
17708 /* Don't add DW_AT_const_value if abstract origin already has one. */
17709 if (get_AT (var_die, DW_AT_const_value))
17712 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
17715 /* Convert the CFI instructions for the current function into a
17716 location list. This is used for DW_AT_frame_base when we targeting
17717 a dwarf2 consumer that does not support the dwarf3
17718 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
17721 static dw_loc_list_ref
17722 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
17726 dw_loc_list_ref list, *list_tail;
17728 dw_cfa_location last_cfa, next_cfa;
17729 const char *start_label, *last_label, *section;
17730 dw_cfa_location remember;
17732 fde = current_fde ();
17733 gcc_assert (fde != NULL);
17735 section = secname_for_decl (current_function_decl);
17739 memset (&next_cfa, 0, sizeof (next_cfa));
17740 next_cfa.reg = INVALID_REGNUM;
17741 remember = next_cfa;
17743 start_label = fde->dw_fde_begin;
17745 /* ??? Bald assumption that the CIE opcode list does not contain
17746 advance opcodes. */
17747 FOR_EACH_VEC_ELT (dw_cfi_ref, cie_cfi_vec, ix, cfi)
17748 lookup_cfa_1 (cfi, &next_cfa, &remember);
17750 last_cfa = next_cfa;
17751 last_label = start_label;
17753 if (fde->dw_fde_second_begin && fde->dw_fde_switch_cfi_index == 0)
17755 /* If the first partition contained no CFI adjustments, the
17756 CIE opcodes apply to the whole first partition. */
17757 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
17758 fde->dw_fde_begin, fde->dw_fde_end, section);
17759 list_tail =&(*list_tail)->dw_loc_next;
17760 start_label = last_label = fde->dw_fde_second_begin;
17763 FOR_EACH_VEC_ELT (dw_cfi_ref, fde->dw_fde_cfi, ix, cfi)
17765 switch (cfi->dw_cfi_opc)
17767 case DW_CFA_set_loc:
17768 case DW_CFA_advance_loc1:
17769 case DW_CFA_advance_loc2:
17770 case DW_CFA_advance_loc4:
17771 if (!cfa_equal_p (&last_cfa, &next_cfa))
17773 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
17774 start_label, last_label, section);
17776 list_tail = &(*list_tail)->dw_loc_next;
17777 last_cfa = next_cfa;
17778 start_label = last_label;
17780 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
17783 case DW_CFA_advance_loc:
17784 /* The encoding is complex enough that we should never emit this. */
17785 gcc_unreachable ();
17788 lookup_cfa_1 (cfi, &next_cfa, &remember);
17791 if (ix + 1 == fde->dw_fde_switch_cfi_index)
17793 if (!cfa_equal_p (&last_cfa, &next_cfa))
17795 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
17796 start_label, last_label, section);
17798 list_tail = &(*list_tail)->dw_loc_next;
17799 last_cfa = next_cfa;
17800 start_label = last_label;
17802 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
17803 start_label, fde->dw_fde_end, section);
17804 list_tail = &(*list_tail)->dw_loc_next;
17805 start_label = last_label = fde->dw_fde_second_begin;
17809 if (!cfa_equal_p (&last_cfa, &next_cfa))
17811 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
17812 start_label, last_label, section);
17813 list_tail = &(*list_tail)->dw_loc_next;
17814 start_label = last_label;
17817 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
17819 fde->dw_fde_second_begin
17820 ? fde->dw_fde_second_end : fde->dw_fde_end,
17823 if (list && list->dw_loc_next)
17829 /* Compute a displacement from the "steady-state frame pointer" to the
17830 frame base (often the same as the CFA), and store it in
17831 frame_pointer_fb_offset. OFFSET is added to the displacement
17832 before the latter is negated. */
17835 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
17839 #ifdef FRAME_POINTER_CFA_OFFSET
17840 reg = frame_pointer_rtx;
17841 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
17843 reg = arg_pointer_rtx;
17844 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
17847 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
17848 if (GET_CODE (elim) == PLUS)
17850 offset += INTVAL (XEXP (elim, 1));
17851 elim = XEXP (elim, 0);
17854 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
17855 && (elim == hard_frame_pointer_rtx
17856 || elim == stack_pointer_rtx))
17857 || elim == (frame_pointer_needed
17858 ? hard_frame_pointer_rtx
17859 : stack_pointer_rtx));
17861 frame_pointer_fb_offset = -offset;
17864 /* Generate a DW_AT_name attribute given some string value to be included as
17865 the value of the attribute. */
17868 add_name_attribute (dw_die_ref die, const char *name_string)
17870 if (name_string != NULL && *name_string != 0)
17872 if (demangle_name_func)
17873 name_string = (*demangle_name_func) (name_string);
17875 add_AT_string (die, DW_AT_name, name_string);
17879 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
17880 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
17881 of TYPE accordingly.
17883 ??? This is a temporary measure until after we're able to generate
17884 regular DWARF for the complex Ada type system. */
17887 add_gnat_descriptive_type_attribute (dw_die_ref die, tree type,
17888 dw_die_ref context_die)
17891 dw_die_ref dtype_die;
17893 if (!lang_hooks.types.descriptive_type)
17896 dtype = lang_hooks.types.descriptive_type (type);
17900 dtype_die = lookup_type_die (dtype);
17903 gen_type_die (dtype, context_die);
17904 dtype_die = lookup_type_die (dtype);
17905 gcc_assert (dtype_die);
17908 add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die);
17911 /* Generate a DW_AT_comp_dir attribute for DIE. */
17914 add_comp_dir_attribute (dw_die_ref die)
17916 const char *wd = get_src_pwd ();
17922 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
17926 wdlen = strlen (wd);
17927 wd1 = (char *) ggc_alloc_atomic (wdlen + 2);
17929 wd1 [wdlen] = DIR_SEPARATOR;
17930 wd1 [wdlen + 1] = 0;
17934 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
17937 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
17941 lower_bound_default (void)
17943 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
17948 case DW_LANG_C_plus_plus:
17950 case DW_LANG_ObjC_plus_plus:
17953 case DW_LANG_Fortran77:
17954 case DW_LANG_Fortran90:
17955 case DW_LANG_Fortran95:
17959 case DW_LANG_Python:
17960 return dwarf_version >= 4 ? 0 : -1;
17961 case DW_LANG_Ada95:
17962 case DW_LANG_Ada83:
17963 case DW_LANG_Cobol74:
17964 case DW_LANG_Cobol85:
17965 case DW_LANG_Pascal83:
17966 case DW_LANG_Modula2:
17968 return dwarf_version >= 4 ? 1 : -1;
17974 /* Given a tree node describing an array bound (either lower or upper) output
17975 a representation for that bound. */
17978 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
17980 switch (TREE_CODE (bound))
17985 /* All fixed-bounds are represented by INTEGER_CST nodes. */
17988 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (bound));
17991 /* Use the default if possible. */
17992 if (bound_attr == DW_AT_lower_bound
17993 && host_integerp (bound, 0)
17994 && (dflt = lower_bound_default ()) != -1
17995 && tree_low_cst (bound, 0) == dflt)
17998 /* Otherwise represent the bound as an unsigned value with the
17999 precision of its type. The precision and signedness of the
18000 type will be necessary to re-interpret it unambiguously. */
18001 else if (prec < HOST_BITS_PER_WIDE_INT)
18003 unsigned HOST_WIDE_INT mask
18004 = ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
18005 add_AT_unsigned (subrange_die, bound_attr,
18006 TREE_INT_CST_LOW (bound) & mask);
18008 else if (prec == HOST_BITS_PER_WIDE_INT
18009 || TREE_INT_CST_HIGH (bound) == 0)
18010 add_AT_unsigned (subrange_die, bound_attr,
18011 TREE_INT_CST_LOW (bound));
18013 add_AT_double (subrange_die, bound_attr, TREE_INT_CST_HIGH (bound),
18014 TREE_INT_CST_LOW (bound));
18019 case VIEW_CONVERT_EXPR:
18020 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
18030 dw_die_ref decl_die = lookup_decl_die (bound);
18032 /* ??? Can this happen, or should the variable have been bound
18033 first? Probably it can, since I imagine that we try to create
18034 the types of parameters in the order in which they exist in
18035 the list, and won't have created a forward reference to a
18036 later parameter. */
18037 if (decl_die != NULL)
18039 add_AT_die_ref (subrange_die, bound_attr, decl_die);
18047 /* Otherwise try to create a stack operation procedure to
18048 evaluate the value of the array bound. */
18050 dw_die_ref ctx, decl_die;
18051 dw_loc_list_ref list;
18053 list = loc_list_from_tree (bound, 2);
18054 if (list == NULL || single_element_loc_list_p (list))
18056 /* If DW_AT_*bound is not a reference nor constant, it is
18057 a DWARF expression rather than location description.
18058 For that loc_list_from_tree (bound, 0) is needed.
18059 If that fails to give a single element list,
18060 fall back to outputting this as a reference anyway. */
18061 dw_loc_list_ref list2 = loc_list_from_tree (bound, 0);
18062 if (list2 && single_element_loc_list_p (list2))
18064 add_AT_loc (subrange_die, bound_attr, list2->expr);
18071 if (current_function_decl == 0)
18072 ctx = comp_unit_die ();
18074 ctx = lookup_decl_die (current_function_decl);
18076 decl_die = new_die (DW_TAG_variable, ctx, bound);
18077 add_AT_flag (decl_die, DW_AT_artificial, 1);
18078 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
18079 add_AT_location_description (decl_die, DW_AT_location, list);
18080 add_AT_die_ref (subrange_die, bound_attr, decl_die);
18086 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
18087 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
18088 Note that the block of subscript information for an array type also
18089 includes information about the element type of the given array type. */
18092 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
18094 unsigned dimension_number;
18096 dw_die_ref subrange_die;
18098 for (dimension_number = 0;
18099 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
18100 type = TREE_TYPE (type), dimension_number++)
18102 tree domain = TYPE_DOMAIN (type);
18104 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
18107 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
18108 and (in GNU C only) variable bounds. Handle all three forms
18110 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
18113 /* We have an array type with specified bounds. */
18114 lower = TYPE_MIN_VALUE (domain);
18115 upper = TYPE_MAX_VALUE (domain);
18117 /* Define the index type. */
18118 if (TREE_TYPE (domain))
18120 /* ??? This is probably an Ada unnamed subrange type. Ignore the
18121 TREE_TYPE field. We can't emit debug info for this
18122 because it is an unnamed integral type. */
18123 if (TREE_CODE (domain) == INTEGER_TYPE
18124 && TYPE_NAME (domain) == NULL_TREE
18125 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
18126 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
18129 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
18133 /* ??? If upper is NULL, the array has unspecified length,
18134 but it does have a lower bound. This happens with Fortran
18136 Since the debugger is definitely going to need to know N
18137 to produce useful results, go ahead and output the lower
18138 bound solo, and hope the debugger can cope. */
18140 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
18142 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
18145 /* Otherwise we have an array type with an unspecified length. The
18146 DWARF-2 spec does not say how to handle this; let's just leave out the
18152 add_byte_size_attribute (dw_die_ref die, tree tree_node)
18156 switch (TREE_CODE (tree_node))
18161 case ENUMERAL_TYPE:
18164 case QUAL_UNION_TYPE:
18165 size = int_size_in_bytes (tree_node);
18168 /* For a data member of a struct or union, the DW_AT_byte_size is
18169 generally given as the number of bytes normally allocated for an
18170 object of the *declared* type of the member itself. This is true
18171 even for bit-fields. */
18172 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
18175 gcc_unreachable ();
18178 /* Note that `size' might be -1 when we get to this point. If it is, that
18179 indicates that the byte size of the entity in question is variable. We
18180 have no good way of expressing this fact in Dwarf at the present time,
18181 so just let the -1 pass on through. */
18182 add_AT_unsigned (die, DW_AT_byte_size, size);
18185 /* For a FIELD_DECL node which represents a bit-field, output an attribute
18186 which specifies the distance in bits from the highest order bit of the
18187 "containing object" for the bit-field to the highest order bit of the
18190 For any given bit-field, the "containing object" is a hypothetical object
18191 (of some integral or enum type) within which the given bit-field lives. The
18192 type of this hypothetical "containing object" is always the same as the
18193 declared type of the individual bit-field itself. The determination of the
18194 exact location of the "containing object" for a bit-field is rather
18195 complicated. It's handled by the `field_byte_offset' function (above).
18197 Note that it is the size (in bytes) of the hypothetical "containing object"
18198 which will be given in the DW_AT_byte_size attribute for this bit-field.
18199 (See `byte_size_attribute' above). */
18202 add_bit_offset_attribute (dw_die_ref die, tree decl)
18204 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
18205 tree type = DECL_BIT_FIELD_TYPE (decl);
18206 HOST_WIDE_INT bitpos_int;
18207 HOST_WIDE_INT highest_order_object_bit_offset;
18208 HOST_WIDE_INT highest_order_field_bit_offset;
18209 HOST_WIDE_INT bit_offset;
18211 /* Must be a field and a bit field. */
18212 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
18214 /* We can't yet handle bit-fields whose offsets are variable, so if we
18215 encounter such things, just return without generating any attribute
18216 whatsoever. Likewise for variable or too large size. */
18217 if (! host_integerp (bit_position (decl), 0)
18218 || ! host_integerp (DECL_SIZE (decl), 1))
18221 bitpos_int = int_bit_position (decl);
18223 /* Note that the bit offset is always the distance (in bits) from the
18224 highest-order bit of the "containing object" to the highest-order bit of
18225 the bit-field itself. Since the "high-order end" of any object or field
18226 is different on big-endian and little-endian machines, the computation
18227 below must take account of these differences. */
18228 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
18229 highest_order_field_bit_offset = bitpos_int;
18231 if (! BYTES_BIG_ENDIAN)
18233 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
18234 highest_order_object_bit_offset += simple_type_size_in_bits (type);
18238 = (! BYTES_BIG_ENDIAN
18239 ? highest_order_object_bit_offset - highest_order_field_bit_offset
18240 : highest_order_field_bit_offset - highest_order_object_bit_offset);
18242 if (bit_offset < 0)
18243 add_AT_int (die, DW_AT_bit_offset, bit_offset);
18245 add_AT_unsigned (die, DW_AT_bit_offset, (unsigned HOST_WIDE_INT) bit_offset);
18248 /* For a FIELD_DECL node which represents a bit field, output an attribute
18249 which specifies the length in bits of the given field. */
18252 add_bit_size_attribute (dw_die_ref die, tree decl)
18254 /* Must be a field and a bit field. */
18255 gcc_assert (TREE_CODE (decl) == FIELD_DECL
18256 && DECL_BIT_FIELD_TYPE (decl));
18258 if (host_integerp (DECL_SIZE (decl), 1))
18259 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
18262 /* If the compiled language is ANSI C, then add a 'prototyped'
18263 attribute, if arg types are given for the parameters of a function. */
18266 add_prototyped_attribute (dw_die_ref die, tree func_type)
18268 if (get_AT_unsigned (comp_unit_die (), DW_AT_language) == DW_LANG_C89
18269 && prototype_p (func_type))
18270 add_AT_flag (die, DW_AT_prototyped, 1);
18273 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
18274 by looking in either the type declaration or object declaration
18277 static inline dw_die_ref
18278 add_abstract_origin_attribute (dw_die_ref die, tree origin)
18280 dw_die_ref origin_die = NULL;
18282 if (TREE_CODE (origin) != FUNCTION_DECL)
18284 /* We may have gotten separated from the block for the inlined
18285 function, if we're in an exception handler or some such; make
18286 sure that the abstract function has been written out.
18288 Doing this for nested functions is wrong, however; functions are
18289 distinct units, and our context might not even be inline. */
18293 fn = TYPE_STUB_DECL (fn);
18295 fn = decl_function_context (fn);
18297 dwarf2out_abstract_function (fn);
18300 if (DECL_P (origin))
18301 origin_die = lookup_decl_die (origin);
18302 else if (TYPE_P (origin))
18303 origin_die = lookup_type_die (origin);
18305 /* XXX: Functions that are never lowered don't always have correct block
18306 trees (in the case of java, they simply have no block tree, in some other
18307 languages). For these functions, there is nothing we can really do to
18308 output correct debug info for inlined functions in all cases. Rather
18309 than die, we'll just produce deficient debug info now, in that we will
18310 have variables without a proper abstract origin. In the future, when all
18311 functions are lowered, we should re-add a gcc_assert (origin_die)
18315 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
18319 /* We do not currently support the pure_virtual attribute. */
18322 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
18324 if (DECL_VINDEX (func_decl))
18326 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
18328 if (host_integerp (DECL_VINDEX (func_decl), 0))
18329 add_AT_loc (die, DW_AT_vtable_elem_location,
18330 new_loc_descr (DW_OP_constu,
18331 tree_low_cst (DECL_VINDEX (func_decl), 0),
18334 /* GNU extension: Record what type this method came from originally. */
18335 if (debug_info_level > DINFO_LEVEL_TERSE
18336 && DECL_CONTEXT (func_decl))
18337 add_AT_die_ref (die, DW_AT_containing_type,
18338 lookup_type_die (DECL_CONTEXT (func_decl)));
18342 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
18343 given decl. This used to be a vendor extension until after DWARF 4
18344 standardized it. */
18347 add_linkage_attr (dw_die_ref die, tree decl)
18349 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
18351 /* Mimic what assemble_name_raw does with a leading '*'. */
18352 if (name[0] == '*')
18355 if (dwarf_version >= 4)
18356 add_AT_string (die, DW_AT_linkage_name, name);
18358 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
18361 /* Add source coordinate attributes for the given decl. */
18364 add_src_coords_attributes (dw_die_ref die, tree decl)
18366 expanded_location s;
18368 if (DECL_SOURCE_LOCATION (decl) == UNKNOWN_LOCATION)
18370 s = expand_location (DECL_SOURCE_LOCATION (decl));
18371 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
18372 add_AT_unsigned (die, DW_AT_decl_line, s.line);
18375 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
18378 add_linkage_name (dw_die_ref die, tree decl)
18380 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
18381 && TREE_PUBLIC (decl)
18382 && !DECL_ABSTRACT (decl)
18383 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
18384 && die->die_tag != DW_TAG_member)
18386 /* Defer until we have an assembler name set. */
18387 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
18389 limbo_die_node *asm_name;
18391 asm_name = ggc_alloc_cleared_limbo_die_node ();
18392 asm_name->die = die;
18393 asm_name->created_for = decl;
18394 asm_name->next = deferred_asm_name;
18395 deferred_asm_name = asm_name;
18397 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
18398 add_linkage_attr (die, decl);
18402 /* Add a DW_AT_name attribute and source coordinate attribute for the
18403 given decl, but only if it actually has a name. */
18406 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
18410 decl_name = DECL_NAME (decl);
18411 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
18413 const char *name = dwarf2_name (decl, 0);
18415 add_name_attribute (die, name);
18416 if (! DECL_ARTIFICIAL (decl))
18417 add_src_coords_attributes (die, decl);
18419 add_linkage_name (die, decl);
18422 #ifdef VMS_DEBUGGING_INFO
18423 /* Get the function's name, as described by its RTL. This may be different
18424 from the DECL_NAME name used in the source file. */
18425 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
18427 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
18428 XEXP (DECL_RTL (decl), 0));
18429 VEC_safe_push (rtx, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
18431 #endif /* VMS_DEBUGGING_INFO */
18434 #ifdef VMS_DEBUGGING_INFO
18435 /* Output the debug main pointer die for VMS */
18438 dwarf2out_vms_debug_main_pointer (void)
18440 char label[MAX_ARTIFICIAL_LABEL_BYTES];
18443 /* Allocate the VMS debug main subprogram die. */
18444 die = ggc_alloc_cleared_die_node ();
18445 die->die_tag = DW_TAG_subprogram;
18446 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
18447 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
18448 current_function_funcdef_no);
18449 add_AT_lbl_id (die, DW_AT_entry_pc, label);
18451 /* Make it the first child of comp_unit_die (). */
18452 die->die_parent = comp_unit_die ();
18453 if (comp_unit_die ()->die_child)
18455 die->die_sib = comp_unit_die ()->die_child->die_sib;
18456 comp_unit_die ()->die_child->die_sib = die;
18460 die->die_sib = die;
18461 comp_unit_die ()->die_child = die;
18464 #endif /* VMS_DEBUGGING_INFO */
18466 /* Push a new declaration scope. */
18469 push_decl_scope (tree scope)
18471 VEC_safe_push (tree, gc, decl_scope_table, scope);
18474 /* Pop a declaration scope. */
18477 pop_decl_scope (void)
18479 VEC_pop (tree, decl_scope_table);
18482 /* Return the DIE for the scope that immediately contains this type.
18483 Non-named types get global scope. Named types nested in other
18484 types get their containing scope if it's open, or global scope
18485 otherwise. All other types (i.e. function-local named types) get
18486 the current active scope. */
18489 scope_die_for (tree t, dw_die_ref context_die)
18491 dw_die_ref scope_die = NULL;
18492 tree containing_scope;
18495 /* Non-types always go in the current scope. */
18496 gcc_assert (TYPE_P (t));
18498 containing_scope = TYPE_CONTEXT (t);
18500 /* Use the containing namespace if it was passed in (for a declaration). */
18501 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
18503 if (context_die == lookup_decl_die (containing_scope))
18506 containing_scope = NULL_TREE;
18509 /* Ignore function type "scopes" from the C frontend. They mean that
18510 a tagged type is local to a parmlist of a function declarator, but
18511 that isn't useful to DWARF. */
18512 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
18513 containing_scope = NULL_TREE;
18515 if (SCOPE_FILE_SCOPE_P (containing_scope))
18516 scope_die = comp_unit_die ();
18517 else if (TYPE_P (containing_scope))
18519 /* For types, we can just look up the appropriate DIE. But
18520 first we check to see if we're in the middle of emitting it
18521 so we know where the new DIE should go. */
18522 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
18523 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
18528 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
18529 || TREE_ASM_WRITTEN (containing_scope));
18530 /*We are not in the middle of emitting the type
18531 CONTAINING_SCOPE. Let's see if it's emitted already. */
18532 scope_die = lookup_type_die (containing_scope);
18534 /* If none of the current dies are suitable, we get file scope. */
18535 if (scope_die == NULL)
18536 scope_die = comp_unit_die ();
18539 scope_die = lookup_type_die_strip_naming_typedef (containing_scope);
18542 scope_die = context_die;
18547 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
18550 local_scope_p (dw_die_ref context_die)
18552 for (; context_die; context_die = context_die->die_parent)
18553 if (context_die->die_tag == DW_TAG_inlined_subroutine
18554 || context_die->die_tag == DW_TAG_subprogram)
18560 /* Returns nonzero if CONTEXT_DIE is a class. */
18563 class_scope_p (dw_die_ref context_die)
18565 return (context_die
18566 && (context_die->die_tag == DW_TAG_structure_type
18567 || context_die->die_tag == DW_TAG_class_type
18568 || context_die->die_tag == DW_TAG_interface_type
18569 || context_die->die_tag == DW_TAG_union_type));
18572 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
18573 whether or not to treat a DIE in this context as a declaration. */
18576 class_or_namespace_scope_p (dw_die_ref context_die)
18578 return (class_scope_p (context_die)
18579 || (context_die && context_die->die_tag == DW_TAG_namespace));
18582 /* Many forms of DIEs require a "type description" attribute. This
18583 routine locates the proper "type descriptor" die for the type given
18584 by 'type', and adds a DW_AT_type attribute below the given die. */
18587 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
18588 int decl_volatile, dw_die_ref context_die)
18590 enum tree_code code = TREE_CODE (type);
18591 dw_die_ref type_die = NULL;
18593 /* ??? If this type is an unnamed subrange type of an integral, floating-point
18594 or fixed-point type, use the inner type. This is because we have no
18595 support for unnamed types in base_type_die. This can happen if this is
18596 an Ada subrange type. Correct solution is emit a subrange type die. */
18597 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
18598 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
18599 type = TREE_TYPE (type), code = TREE_CODE (type);
18601 if (code == ERROR_MARK
18602 /* Handle a special case. For functions whose return type is void, we
18603 generate *no* type attribute. (Note that no object may have type
18604 `void', so this only applies to function return types). */
18605 || code == VOID_TYPE)
18608 type_die = modified_type_die (type,
18609 decl_const || TYPE_READONLY (type),
18610 decl_volatile || TYPE_VOLATILE (type),
18613 if (type_die != NULL)
18614 add_AT_die_ref (object_die, DW_AT_type, type_die);
18617 /* Given an object die, add the calling convention attribute for the
18618 function call type. */
18620 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
18622 enum dwarf_calling_convention value = DW_CC_normal;
18624 value = ((enum dwarf_calling_convention)
18625 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
18628 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
18630 /* DWARF 2 doesn't provide a way to identify a program's source-level
18631 entry point. DW_AT_calling_convention attributes are only meant
18632 to describe functions' calling conventions. However, lacking a
18633 better way to signal the Fortran main program, we used this for
18634 a long time, following existing custom. Now, DWARF 4 has
18635 DW_AT_main_subprogram, which we add below, but some tools still
18636 rely on the old way, which we thus keep. */
18637 value = DW_CC_program;
18639 if (dwarf_version >= 4 || !dwarf_strict)
18640 add_AT_flag (subr_die, DW_AT_main_subprogram, 1);
18643 /* Only add the attribute if the backend requests it, and
18644 is not DW_CC_normal. */
18645 if (value && (value != DW_CC_normal))
18646 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
18649 /* Given a tree pointer to a struct, class, union, or enum type node, return
18650 a pointer to the (string) tag name for the given type, or zero if the type
18651 was declared without a tag. */
18653 static const char *
18654 type_tag (const_tree type)
18656 const char *name = 0;
18658 if (TYPE_NAME (type) != 0)
18662 /* Find the IDENTIFIER_NODE for the type name. */
18663 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
18664 && !TYPE_NAMELESS (type))
18665 t = TYPE_NAME (type);
18667 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
18668 a TYPE_DECL node, regardless of whether or not a `typedef' was
18670 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
18671 && ! DECL_IGNORED_P (TYPE_NAME (type)))
18673 /* We want to be extra verbose. Don't call dwarf_name if
18674 DECL_NAME isn't set. The default hook for decl_printable_name
18675 doesn't like that, and in this context it's correct to return
18676 0, instead of "<anonymous>" or the like. */
18677 if (DECL_NAME (TYPE_NAME (type))
18678 && !DECL_NAMELESS (TYPE_NAME (type)))
18679 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
18682 /* Now get the name as a string, or invent one. */
18683 if (!name && t != 0)
18684 name = IDENTIFIER_POINTER (t);
18687 return (name == 0 || *name == '\0') ? 0 : name;
18690 /* Return the type associated with a data member, make a special check
18691 for bit field types. */
18694 member_declared_type (const_tree member)
18696 return (DECL_BIT_FIELD_TYPE (member)
18697 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
18700 /* Get the decl's label, as described by its RTL. This may be different
18701 from the DECL_NAME name used in the source file. */
18704 static const char *
18705 decl_start_label (tree decl)
18708 const char *fnname;
18710 x = DECL_RTL (decl);
18711 gcc_assert (MEM_P (x));
18714 gcc_assert (GET_CODE (x) == SYMBOL_REF);
18716 fnname = XSTR (x, 0);
18721 /* These routines generate the internal representation of the DIE's for
18722 the compilation unit. Debugging information is collected by walking
18723 the declaration trees passed in from dwarf2out_decl(). */
18726 gen_array_type_die (tree type, dw_die_ref context_die)
18728 dw_die_ref scope_die = scope_die_for (type, context_die);
18729 dw_die_ref array_die;
18731 /* GNU compilers represent multidimensional array types as sequences of one
18732 dimensional array types whose element types are themselves array types.
18733 We sometimes squish that down to a single array_type DIE with multiple
18734 subscripts in the Dwarf debugging info. The draft Dwarf specification
18735 say that we are allowed to do this kind of compression in C, because
18736 there is no difference between an array of arrays and a multidimensional
18737 array. We don't do this for Ada to remain as close as possible to the
18738 actual representation, which is especially important against the language
18739 flexibilty wrt arrays of variable size. */
18741 bool collapse_nested_arrays = !is_ada ();
18744 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
18745 DW_TAG_string_type doesn't have DW_AT_type attribute). */
18746 if (TYPE_STRING_FLAG (type)
18747 && TREE_CODE (type) == ARRAY_TYPE
18749 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
18751 HOST_WIDE_INT size;
18753 array_die = new_die (DW_TAG_string_type, scope_die, type);
18754 add_name_attribute (array_die, type_tag (type));
18755 equate_type_number_to_die (type, array_die);
18756 size = int_size_in_bytes (type);
18758 add_AT_unsigned (array_die, DW_AT_byte_size, size);
18759 else if (TYPE_DOMAIN (type) != NULL_TREE
18760 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
18761 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
18763 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
18764 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2);
18766 size = int_size_in_bytes (TREE_TYPE (szdecl));
18767 if (loc && size > 0)
18769 add_AT_location_description (array_die, DW_AT_string_length, loc);
18770 if (size != DWARF2_ADDR_SIZE)
18771 add_AT_unsigned (array_die, DW_AT_byte_size, size);
18777 /* ??? The SGI dwarf reader fails for array of array of enum types
18778 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
18779 array type comes before the outer array type. We thus call gen_type_die
18780 before we new_die and must prevent nested array types collapsing for this
18783 #ifdef MIPS_DEBUGGING_INFO
18784 gen_type_die (TREE_TYPE (type), context_die);
18785 collapse_nested_arrays = false;
18788 array_die = new_die (DW_TAG_array_type, scope_die, type);
18789 add_name_attribute (array_die, type_tag (type));
18790 add_gnat_descriptive_type_attribute (array_die, type, context_die);
18791 equate_type_number_to_die (type, array_die);
18793 if (TREE_CODE (type) == VECTOR_TYPE)
18794 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
18796 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
18798 && TREE_CODE (type) == ARRAY_TYPE
18799 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
18800 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
18801 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
18804 /* We default the array ordering. SDB will probably do
18805 the right things even if DW_AT_ordering is not present. It's not even
18806 an issue until we start to get into multidimensional arrays anyway. If
18807 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
18808 then we'll have to put the DW_AT_ordering attribute back in. (But if
18809 and when we find out that we need to put these in, we will only do so
18810 for multidimensional arrays. */
18811 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
18814 #ifdef MIPS_DEBUGGING_INFO
18815 /* The SGI compilers handle arrays of unknown bound by setting
18816 AT_declaration and not emitting any subrange DIEs. */
18817 if (TREE_CODE (type) == ARRAY_TYPE
18818 && ! TYPE_DOMAIN (type))
18819 add_AT_flag (array_die, DW_AT_declaration, 1);
18822 if (TREE_CODE (type) == VECTOR_TYPE)
18824 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
18825 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
18826 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node);
18827 add_bound_info (subrange_die, DW_AT_upper_bound,
18828 size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
18831 add_subscript_info (array_die, type, collapse_nested_arrays);
18833 /* Add representation of the type of the elements of this array type and
18834 emit the corresponding DIE if we haven't done it already. */
18835 element_type = TREE_TYPE (type);
18836 if (collapse_nested_arrays)
18837 while (TREE_CODE (element_type) == ARRAY_TYPE)
18839 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
18841 element_type = TREE_TYPE (element_type);
18844 #ifndef MIPS_DEBUGGING_INFO
18845 gen_type_die (element_type, context_die);
18848 add_type_attribute (array_die, element_type, 0, 0, context_die);
18850 if (get_AT (array_die, DW_AT_name))
18851 add_pubtype (type, array_die);
18854 static dw_loc_descr_ref
18855 descr_info_loc (tree val, tree base_decl)
18857 HOST_WIDE_INT size;
18858 dw_loc_descr_ref loc, loc2;
18859 enum dwarf_location_atom op;
18861 if (val == base_decl)
18862 return new_loc_descr (DW_OP_push_object_address, 0, 0);
18864 switch (TREE_CODE (val))
18867 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18869 return loc_descriptor_from_tree (val, 0);
18871 if (host_integerp (val, 0))
18872 return int_loc_descriptor (tree_low_cst (val, 0));
18875 size = int_size_in_bytes (TREE_TYPE (val));
18878 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18881 if (size == DWARF2_ADDR_SIZE)
18882 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
18884 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
18886 case POINTER_PLUS_EXPR:
18888 if (host_integerp (TREE_OPERAND (val, 1), 1)
18889 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
18892 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18895 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
18901 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18904 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
18907 add_loc_descr (&loc, loc2);
18908 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
18930 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
18931 tree val, tree base_decl)
18933 dw_loc_descr_ref loc;
18935 if (host_integerp (val, 0))
18937 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
18941 loc = descr_info_loc (val, base_decl);
18945 add_AT_loc (die, attr, loc);
18948 /* This routine generates DIE for array with hidden descriptor, details
18949 are filled into *info by a langhook. */
18952 gen_descr_array_type_die (tree type, struct array_descr_info *info,
18953 dw_die_ref context_die)
18955 dw_die_ref scope_die = scope_die_for (type, context_die);
18956 dw_die_ref array_die;
18959 array_die = new_die (DW_TAG_array_type, scope_die, type);
18960 add_name_attribute (array_die, type_tag (type));
18961 equate_type_number_to_die (type, array_die);
18963 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
18965 && info->ndimensions >= 2)
18966 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
18968 if (info->data_location)
18969 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
18971 if (info->associated)
18972 add_descr_info_field (array_die, DW_AT_associated, info->associated,
18974 if (info->allocated)
18975 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
18978 for (dim = 0; dim < info->ndimensions; dim++)
18980 dw_die_ref subrange_die
18981 = new_die (DW_TAG_subrange_type, array_die, NULL);
18983 if (info->dimen[dim].lower_bound)
18985 /* If it is the default value, omit it. */
18988 if (host_integerp (info->dimen[dim].lower_bound, 0)
18989 && (dflt = lower_bound_default ()) != -1
18990 && tree_low_cst (info->dimen[dim].lower_bound, 0) == dflt)
18993 add_descr_info_field (subrange_die, DW_AT_lower_bound,
18994 info->dimen[dim].lower_bound,
18997 if (info->dimen[dim].upper_bound)
18998 add_descr_info_field (subrange_die, DW_AT_upper_bound,
18999 info->dimen[dim].upper_bound,
19001 if (info->dimen[dim].stride)
19002 add_descr_info_field (subrange_die, DW_AT_byte_stride,
19003 info->dimen[dim].stride,
19007 gen_type_die (info->element_type, context_die);
19008 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
19010 if (get_AT (array_die, DW_AT_name))
19011 add_pubtype (type, array_die);
19016 gen_entry_point_die (tree decl, dw_die_ref context_die)
19018 tree origin = decl_ultimate_origin (decl);
19019 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
19021 if (origin != NULL)
19022 add_abstract_origin_attribute (decl_die, origin);
19025 add_name_and_src_coords_attributes (decl_die, decl);
19026 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
19027 0, 0, context_die);
19030 if (DECL_ABSTRACT (decl))
19031 equate_decl_number_to_die (decl, decl_die);
19033 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
19037 /* Walk through the list of incomplete types again, trying once more to
19038 emit full debugging info for them. */
19041 retry_incomplete_types (void)
19045 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
19046 if (should_emit_struct_debug (VEC_index (tree, incomplete_types, i),
19047 DINFO_USAGE_DIR_USE))
19048 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die ());
19051 /* Determine what tag to use for a record type. */
19053 static enum dwarf_tag
19054 record_type_tag (tree type)
19056 if (! lang_hooks.types.classify_record)
19057 return DW_TAG_structure_type;
19059 switch (lang_hooks.types.classify_record (type))
19061 case RECORD_IS_STRUCT:
19062 return DW_TAG_structure_type;
19064 case RECORD_IS_CLASS:
19065 return DW_TAG_class_type;
19067 case RECORD_IS_INTERFACE:
19068 if (dwarf_version >= 3 || !dwarf_strict)
19069 return DW_TAG_interface_type;
19070 return DW_TAG_structure_type;
19073 gcc_unreachable ();
19077 /* Generate a DIE to represent an enumeration type. Note that these DIEs
19078 include all of the information about the enumeration values also. Each
19079 enumerated type name/value is listed as a child of the enumerated type
19083 gen_enumeration_type_die (tree type, dw_die_ref context_die)
19085 dw_die_ref type_die = lookup_type_die (type);
19087 if (type_die == NULL)
19089 type_die = new_die (DW_TAG_enumeration_type,
19090 scope_die_for (type, context_die), type);
19091 equate_type_number_to_die (type, type_die);
19092 add_name_attribute (type_die, type_tag (type));
19093 add_gnat_descriptive_type_attribute (type_die, type, context_die);
19094 if (dwarf_version >= 4 || !dwarf_strict)
19096 if (ENUM_IS_SCOPED (type))
19097 add_AT_flag (type_die, DW_AT_enum_class, 1);
19098 if (ENUM_IS_OPAQUE (type))
19099 add_AT_flag (type_die, DW_AT_declaration, 1);
19102 else if (! TYPE_SIZE (type))
19105 remove_AT (type_die, DW_AT_declaration);
19107 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
19108 given enum type is incomplete, do not generate the DW_AT_byte_size
19109 attribute or the DW_AT_element_list attribute. */
19110 if (TYPE_SIZE (type))
19114 TREE_ASM_WRITTEN (type) = 1;
19115 add_byte_size_attribute (type_die, type);
19116 if (TYPE_STUB_DECL (type) != NULL_TREE)
19118 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
19119 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
19122 /* If the first reference to this type was as the return type of an
19123 inline function, then it may not have a parent. Fix this now. */
19124 if (type_die->die_parent == NULL)
19125 add_child_die (scope_die_for (type, context_die), type_die);
19127 for (link = TYPE_VALUES (type);
19128 link != NULL; link = TREE_CHAIN (link))
19130 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
19131 tree value = TREE_VALUE (link);
19133 add_name_attribute (enum_die,
19134 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
19136 if (TREE_CODE (value) == CONST_DECL)
19137 value = DECL_INITIAL (value);
19139 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
19140 /* DWARF2 does not provide a way of indicating whether or
19141 not enumeration constants are signed or unsigned. GDB
19142 always assumes the values are signed, so we output all
19143 values as if they were signed. That means that
19144 enumeration constants with very large unsigned values
19145 will appear to have negative values in the debugger. */
19146 add_AT_int (enum_die, DW_AT_const_value,
19147 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
19151 add_AT_flag (type_die, DW_AT_declaration, 1);
19153 if (get_AT (type_die, DW_AT_name))
19154 add_pubtype (type, type_die);
19159 /* Generate a DIE to represent either a real live formal parameter decl or to
19160 represent just the type of some formal parameter position in some function
19163 Note that this routine is a bit unusual because its argument may be a
19164 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
19165 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
19166 node. If it's the former then this function is being called to output a
19167 DIE to represent a formal parameter object (or some inlining thereof). If
19168 it's the latter, then this function is only being called to output a
19169 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
19170 argument type of some subprogram type.
19171 If EMIT_NAME_P is true, name and source coordinate attributes
19175 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
19176 dw_die_ref context_die)
19178 tree node_or_origin = node ? node : origin;
19179 tree ultimate_origin;
19180 dw_die_ref parm_die
19181 = new_die (DW_TAG_formal_parameter, context_die, node);
19183 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
19185 case tcc_declaration:
19186 ultimate_origin = decl_ultimate_origin (node_or_origin);
19187 if (node || ultimate_origin)
19188 origin = ultimate_origin;
19189 if (origin != NULL)
19190 add_abstract_origin_attribute (parm_die, origin);
19191 else if (emit_name_p)
19192 add_name_and_src_coords_attributes (parm_die, node);
19194 || (! DECL_ABSTRACT (node_or_origin)
19195 && variably_modified_type_p (TREE_TYPE (node_or_origin),
19196 decl_function_context
19197 (node_or_origin))))
19199 tree type = TREE_TYPE (node_or_origin);
19200 if (decl_by_reference_p (node_or_origin))
19201 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
19204 add_type_attribute (parm_die, type,
19205 TREE_READONLY (node_or_origin),
19206 TREE_THIS_VOLATILE (node_or_origin),
19209 if (origin == NULL && DECL_ARTIFICIAL (node))
19210 add_AT_flag (parm_die, DW_AT_artificial, 1);
19212 if (node && node != origin)
19213 equate_decl_number_to_die (node, parm_die);
19214 if (! DECL_ABSTRACT (node_or_origin))
19215 add_location_or_const_value_attribute (parm_die, node_or_origin,
19216 node == NULL, DW_AT_location);
19221 /* We were called with some kind of a ..._TYPE node. */
19222 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
19226 gcc_unreachable ();
19232 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
19233 children DW_TAG_formal_parameter DIEs representing the arguments of the
19236 PARM_PACK must be a function parameter pack.
19237 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
19238 must point to the subsequent arguments of the function PACK_ARG belongs to.
19239 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
19240 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
19241 following the last one for which a DIE was generated. */
19244 gen_formal_parameter_pack_die (tree parm_pack,
19246 dw_die_ref subr_die,
19250 dw_die_ref parm_pack_die;
19252 gcc_assert (parm_pack
19253 && lang_hooks.function_parameter_pack_p (parm_pack)
19256 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
19257 add_src_coords_attributes (parm_pack_die, parm_pack);
19259 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg))
19261 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
19264 gen_formal_parameter_die (arg, NULL,
19265 false /* Don't emit name attribute. */,
19270 return parm_pack_die;
19273 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
19274 at the end of an (ANSI prototyped) formal parameters list. */
19277 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
19279 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
19282 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
19283 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
19284 parameters as specified in some function type specification (except for
19285 those which appear as part of a function *definition*). */
19288 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
19291 tree formal_type = NULL;
19292 tree first_parm_type;
19295 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
19297 arg = DECL_ARGUMENTS (function_or_method_type);
19298 function_or_method_type = TREE_TYPE (function_or_method_type);
19303 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
19305 /* Make our first pass over the list of formal parameter types and output a
19306 DW_TAG_formal_parameter DIE for each one. */
19307 for (link = first_parm_type; link; )
19309 dw_die_ref parm_die;
19311 formal_type = TREE_VALUE (link);
19312 if (formal_type == void_type_node)
19315 /* Output a (nameless) DIE to represent the formal parameter itself. */
19316 parm_die = gen_formal_parameter_die (formal_type, NULL,
19317 true /* Emit name attribute. */,
19319 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
19320 && link == first_parm_type)
19322 add_AT_flag (parm_die, DW_AT_artificial, 1);
19323 if (dwarf_version >= 3 || !dwarf_strict)
19324 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die);
19326 else if (arg && DECL_ARTIFICIAL (arg))
19327 add_AT_flag (parm_die, DW_AT_artificial, 1);
19329 link = TREE_CHAIN (link);
19331 arg = DECL_CHAIN (arg);
19334 /* If this function type has an ellipsis, add a
19335 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
19336 if (formal_type != void_type_node)
19337 gen_unspecified_parameters_die (function_or_method_type, context_die);
19339 /* Make our second (and final) pass over the list of formal parameter types
19340 and output DIEs to represent those types (as necessary). */
19341 for (link = TYPE_ARG_TYPES (function_or_method_type);
19342 link && TREE_VALUE (link);
19343 link = TREE_CHAIN (link))
19344 gen_type_die (TREE_VALUE (link), context_die);
19347 /* We want to generate the DIE for TYPE so that we can generate the
19348 die for MEMBER, which has been defined; we will need to refer back
19349 to the member declaration nested within TYPE. If we're trying to
19350 generate minimal debug info for TYPE, processing TYPE won't do the
19351 trick; we need to attach the member declaration by hand. */
19354 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
19356 gen_type_die (type, context_die);
19358 /* If we're trying to avoid duplicate debug info, we may not have
19359 emitted the member decl for this function. Emit it now. */
19360 if (TYPE_STUB_DECL (type)
19361 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
19362 && ! lookup_decl_die (member))
19364 dw_die_ref type_die;
19365 gcc_assert (!decl_ultimate_origin (member));
19367 push_decl_scope (type);
19368 type_die = lookup_type_die_strip_naming_typedef (type);
19369 if (TREE_CODE (member) == FUNCTION_DECL)
19370 gen_subprogram_die (member, type_die);
19371 else if (TREE_CODE (member) == FIELD_DECL)
19373 /* Ignore the nameless fields that are used to skip bits but handle
19374 C++ anonymous unions and structs. */
19375 if (DECL_NAME (member) != NULL_TREE
19376 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
19377 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
19379 gen_type_die (member_declared_type (member), type_die);
19380 gen_field_die (member, type_die);
19384 gen_variable_die (member, NULL_TREE, type_die);
19390 /* Generate the DWARF2 info for the "abstract" instance of a function which we
19391 may later generate inlined and/or out-of-line instances of. */
19394 dwarf2out_abstract_function (tree decl)
19396 dw_die_ref old_die;
19400 htab_t old_decl_loc_table;
19401 htab_t old_cached_dw_loc_list_table;
19402 int old_call_site_count, old_tail_call_site_count;
19403 struct call_arg_loc_node *old_call_arg_locations;
19405 /* Make sure we have the actual abstract inline, not a clone. */
19406 decl = DECL_ORIGIN (decl);
19408 old_die = lookup_decl_die (decl);
19409 if (old_die && get_AT (old_die, DW_AT_inline))
19410 /* We've already generated the abstract instance. */
19413 /* We can be called while recursively when seeing block defining inlined subroutine
19414 DIE. Be sure to not clobber the outer location table nor use it or we would
19415 get locations in abstract instantces. */
19416 old_decl_loc_table = decl_loc_table;
19417 decl_loc_table = NULL;
19418 old_cached_dw_loc_list_table = cached_dw_loc_list_table;
19419 cached_dw_loc_list_table = NULL;
19420 old_call_arg_locations = call_arg_locations;
19421 call_arg_locations = NULL;
19422 old_call_site_count = call_site_count;
19423 call_site_count = -1;
19424 old_tail_call_site_count = tail_call_site_count;
19425 tail_call_site_count = -1;
19427 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
19428 we don't get confused by DECL_ABSTRACT. */
19429 if (debug_info_level > DINFO_LEVEL_TERSE)
19431 context = decl_class_context (decl);
19433 gen_type_die_for_member
19434 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ());
19437 /* Pretend we've just finished compiling this function. */
19438 save_fn = current_function_decl;
19439 current_function_decl = decl;
19440 push_cfun (DECL_STRUCT_FUNCTION (decl));
19442 was_abstract = DECL_ABSTRACT (decl);
19443 set_decl_abstract_flags (decl, 1);
19444 dwarf2out_decl (decl);
19445 if (! was_abstract)
19446 set_decl_abstract_flags (decl, 0);
19448 current_function_decl = save_fn;
19449 decl_loc_table = old_decl_loc_table;
19450 cached_dw_loc_list_table = old_cached_dw_loc_list_table;
19451 call_arg_locations = old_call_arg_locations;
19452 call_site_count = old_call_site_count;
19453 tail_call_site_count = old_tail_call_site_count;
19457 /* Helper function of premark_used_types() which gets called through
19460 Marks the DIE of a given type in *SLOT as perennial, so it never gets
19461 marked as unused by prune_unused_types. */
19464 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
19469 type = (tree) *slot;
19470 die = lookup_type_die (type);
19472 die->die_perennial_p = 1;
19476 /* Helper function of premark_types_used_by_global_vars which gets called
19477 through htab_traverse.
19479 Marks the DIE of a given type in *SLOT as perennial, so it never gets
19480 marked as unused by prune_unused_types. The DIE of the type is marked
19481 only if the global variable using the type will actually be emitted. */
19484 premark_types_used_by_global_vars_helper (void **slot,
19485 void *data ATTRIBUTE_UNUSED)
19487 struct types_used_by_vars_entry *entry;
19490 entry = (struct types_used_by_vars_entry *) *slot;
19491 gcc_assert (entry->type != NULL
19492 && entry->var_decl != NULL);
19493 die = lookup_type_die (entry->type);
19496 /* Ask cgraph if the global variable really is to be emitted.
19497 If yes, then we'll keep the DIE of ENTRY->TYPE. */
19498 struct varpool_node *node = varpool_get_node (entry->var_decl);
19499 if (node && node->needed)
19501 die->die_perennial_p = 1;
19502 /* Keep the parent DIEs as well. */
19503 while ((die = die->die_parent) && die->die_perennial_p == 0)
19504 die->die_perennial_p = 1;
19510 /* Mark all members of used_types_hash as perennial. */
19513 premark_used_types (void)
19515 if (cfun && cfun->used_types_hash)
19516 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
19519 /* Mark all members of types_used_by_vars_entry as perennial. */
19522 premark_types_used_by_global_vars (void)
19524 if (types_used_by_vars_hash)
19525 htab_traverse (types_used_by_vars_hash,
19526 premark_types_used_by_global_vars_helper, NULL);
19529 /* Generate a DW_TAG_GNU_call_site DIE in function DECL under SUBR_DIE
19530 for CA_LOC call arg loc node. */
19533 gen_call_site_die (tree decl, dw_die_ref subr_die,
19534 struct call_arg_loc_node *ca_loc)
19536 dw_die_ref stmt_die = NULL, die;
19537 tree block = ca_loc->block;
19540 && block != DECL_INITIAL (decl)
19541 && TREE_CODE (block) == BLOCK)
19543 if (VEC_length (dw_die_ref, block_map) > BLOCK_NUMBER (block))
19544 stmt_die = VEC_index (dw_die_ref, block_map, BLOCK_NUMBER (block));
19547 block = BLOCK_SUPERCONTEXT (block);
19549 if (stmt_die == NULL)
19550 stmt_die = subr_die;
19551 die = new_die (DW_TAG_GNU_call_site, stmt_die, NULL_TREE);
19552 add_AT_lbl_id (die, DW_AT_low_pc, ca_loc->label);
19553 if (ca_loc->tail_call_p)
19554 add_AT_flag (die, DW_AT_GNU_tail_call, 1);
19555 if (ca_loc->symbol_ref)
19557 dw_die_ref tdie = lookup_decl_die (SYMBOL_REF_DECL (ca_loc->symbol_ref));
19559 add_AT_die_ref (die, DW_AT_abstract_origin, tdie);
19561 add_AT_addr (die, DW_AT_abstract_origin, ca_loc->symbol_ref);
19566 /* Generate a DIE to represent a declared function (either file-scope or
19570 gen_subprogram_die (tree decl, dw_die_ref context_die)
19572 tree origin = decl_ultimate_origin (decl);
19573 dw_die_ref subr_die;
19575 dw_die_ref old_die = lookup_decl_die (decl);
19576 int declaration = (current_function_decl != decl
19577 || class_or_namespace_scope_p (context_die));
19579 premark_used_types ();
19581 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
19582 started to generate the abstract instance of an inline, decided to output
19583 its containing class, and proceeded to emit the declaration of the inline
19584 from the member list for the class. If so, DECLARATION takes priority;
19585 we'll get back to the abstract instance when done with the class. */
19587 /* The class-scope declaration DIE must be the primary DIE. */
19588 if (origin && declaration && class_or_namespace_scope_p (context_die))
19591 gcc_assert (!old_die);
19594 /* Now that the C++ front end lazily declares artificial member fns, we
19595 might need to retrofit the declaration into its class. */
19596 if (!declaration && !origin && !old_die
19597 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
19598 && !class_or_namespace_scope_p (context_die)
19599 && debug_info_level > DINFO_LEVEL_TERSE)
19600 old_die = force_decl_die (decl);
19602 if (origin != NULL)
19604 gcc_assert (!declaration || local_scope_p (context_die));
19606 /* Fixup die_parent for the abstract instance of a nested
19607 inline function. */
19608 if (old_die && old_die->die_parent == NULL)
19609 add_child_die (context_die, old_die);
19611 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
19612 add_abstract_origin_attribute (subr_die, origin);
19616 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
19617 struct dwarf_file_data * file_index = lookup_filename (s.file);
19619 if (!get_AT_flag (old_die, DW_AT_declaration)
19620 /* We can have a normal definition following an inline one in the
19621 case of redefinition of GNU C extern inlines.
19622 It seems reasonable to use AT_specification in this case. */
19623 && !get_AT (old_die, DW_AT_inline))
19625 /* Detect and ignore this case, where we are trying to output
19626 something we have already output. */
19630 /* If the definition comes from the same place as the declaration,
19631 maybe use the old DIE. We always want the DIE for this function
19632 that has the *_pc attributes to be under comp_unit_die so the
19633 debugger can find it. We also need to do this for abstract
19634 instances of inlines, since the spec requires the out-of-line copy
19635 to have the same parent. For local class methods, this doesn't
19636 apply; we just use the old DIE. */
19637 if ((is_cu_die (old_die->die_parent) || context_die == NULL)
19638 && (DECL_ARTIFICIAL (decl)
19639 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
19640 && (get_AT_unsigned (old_die, DW_AT_decl_line)
19641 == (unsigned) s.line))))
19643 subr_die = old_die;
19645 /* Clear out the declaration attribute and the formal parameters.
19646 Do not remove all children, because it is possible that this
19647 declaration die was forced using force_decl_die(). In such
19648 cases die that forced declaration die (e.g. TAG_imported_module)
19649 is one of the children that we do not want to remove. */
19650 remove_AT (subr_die, DW_AT_declaration);
19651 remove_AT (subr_die, DW_AT_object_pointer);
19652 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
19656 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
19657 add_AT_specification (subr_die, old_die);
19658 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
19659 add_AT_file (subr_die, DW_AT_decl_file, file_index);
19660 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
19661 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
19666 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
19668 if (TREE_PUBLIC (decl))
19669 add_AT_flag (subr_die, DW_AT_external, 1);
19671 add_name_and_src_coords_attributes (subr_die, decl);
19672 if (debug_info_level > DINFO_LEVEL_TERSE)
19674 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
19675 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
19676 0, 0, context_die);
19679 add_pure_or_virtual_attribute (subr_die, decl);
19680 if (DECL_ARTIFICIAL (decl))
19681 add_AT_flag (subr_die, DW_AT_artificial, 1);
19683 add_accessibility_attribute (subr_die, decl);
19688 if (!old_die || !get_AT (old_die, DW_AT_inline))
19690 add_AT_flag (subr_die, DW_AT_declaration, 1);
19692 /* If this is an explicit function declaration then generate
19693 a DW_AT_explicit attribute. */
19694 if (lang_hooks.decls.function_decl_explicit_p (decl)
19695 && (dwarf_version >= 3 || !dwarf_strict))
19696 add_AT_flag (subr_die, DW_AT_explicit, 1);
19698 /* The first time we see a member function, it is in the context of
19699 the class to which it belongs. We make sure of this by emitting
19700 the class first. The next time is the definition, which is
19701 handled above. The two may come from the same source text.
19703 Note that force_decl_die() forces function declaration die. It is
19704 later reused to represent definition. */
19705 equate_decl_number_to_die (decl, subr_die);
19708 else if (DECL_ABSTRACT (decl))
19710 if (DECL_DECLARED_INLINE_P (decl))
19712 if (cgraph_function_possibly_inlined_p (decl))
19713 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
19715 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
19719 if (cgraph_function_possibly_inlined_p (decl))
19720 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
19722 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
19725 if (DECL_DECLARED_INLINE_P (decl)
19726 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
19727 add_AT_flag (subr_die, DW_AT_artificial, 1);
19729 equate_decl_number_to_die (decl, subr_die);
19731 else if (!DECL_EXTERNAL (decl))
19733 HOST_WIDE_INT cfa_fb_offset;
19735 if (!old_die || !get_AT (old_die, DW_AT_inline))
19736 equate_decl_number_to_die (decl, subr_die);
19738 if (!flag_reorder_blocks_and_partition)
19740 dw_fde_ref fde = &fde_table[current_funcdef_fde];
19741 if (fde->dw_fde_begin)
19743 /* We have already generated the labels. */
19744 add_AT_lbl_id (subr_die, DW_AT_low_pc, fde->dw_fde_begin);
19745 add_AT_lbl_id (subr_die, DW_AT_high_pc, fde->dw_fde_end);
19749 /* Create start/end labels and add the range. */
19750 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
19751 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
19752 current_function_funcdef_no);
19753 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
19754 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
19755 current_function_funcdef_no);
19756 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
19759 #if VMS_DEBUGGING_INFO
19760 /* HP OpenVMS Industry Standard 64: DWARF Extensions
19761 Section 2.3 Prologue and Epilogue Attributes:
19762 When a breakpoint is set on entry to a function, it is generally
19763 desirable for execution to be suspended, not on the very first
19764 instruction of the function, but rather at a point after the
19765 function's frame has been set up, after any language defined local
19766 declaration processing has been completed, and before execution of
19767 the first statement of the function begins. Debuggers generally
19768 cannot properly determine where this point is. Similarly for a
19769 breakpoint set on exit from a function. The prologue and epilogue
19770 attributes allow a compiler to communicate the location(s) to use. */
19773 if (fde->dw_fde_vms_end_prologue)
19774 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
19775 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
19777 if (fde->dw_fde_vms_begin_epilogue)
19778 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
19779 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
19783 add_pubname (decl, subr_die);
19786 { /* Generate pubnames entries for the split function code
19788 dw_fde_ref fde = &fde_table[current_funcdef_fde];
19790 if (fde->dw_fde_second_begin)
19792 if (dwarf_version >= 3 || !dwarf_strict)
19794 /* We should use ranges for non-contiguous code section
19795 addresses. Use the actual code range for the initial
19796 section, since the HOT/COLD labels might precede an
19797 alignment offset. */
19798 bool range_list_added = false;
19799 add_ranges_by_labels (subr_die, fde->dw_fde_begin,
19800 fde->dw_fde_end, &range_list_added);
19801 add_ranges_by_labels (subr_die, fde->dw_fde_second_begin,
19802 fde->dw_fde_second_end,
19803 &range_list_added);
19804 add_pubname (decl, subr_die);
19805 if (range_list_added)
19810 /* There is no real support in DW2 for this .. so we make
19811 a work-around. First, emit the pub name for the segment
19812 containing the function label. Then make and emit a
19813 simplified subprogram DIE for the second segment with the
19814 name pre-fixed by __hot/cold_sect_of_. We use the same
19815 linkage name for the second die so that gdb will find both
19816 sections when given "b foo". */
19817 const char *name = NULL;
19818 tree decl_name = DECL_NAME (decl);
19819 dw_die_ref seg_die;
19821 /* Do the 'primary' section. */
19822 add_AT_lbl_id (subr_die, DW_AT_low_pc,
19823 fde->dw_fde_begin);
19824 add_AT_lbl_id (subr_die, DW_AT_high_pc,
19827 add_pubname (decl, subr_die);
19829 /* Build a minimal DIE for the secondary section. */
19830 seg_die = new_die (DW_TAG_subprogram,
19831 subr_die->die_parent, decl);
19833 if (TREE_PUBLIC (decl))
19834 add_AT_flag (seg_die, DW_AT_external, 1);
19836 if (decl_name != NULL
19837 && IDENTIFIER_POINTER (decl_name) != NULL)
19839 name = dwarf2_name (decl, 1);
19840 if (! DECL_ARTIFICIAL (decl))
19841 add_src_coords_attributes (seg_die, decl);
19843 add_linkage_name (seg_die, decl);
19845 gcc_assert (name != NULL);
19846 add_pure_or_virtual_attribute (seg_die, decl);
19847 if (DECL_ARTIFICIAL (decl))
19848 add_AT_flag (seg_die, DW_AT_artificial, 1);
19850 name = concat ("__second_sect_of_", name, NULL);
19851 add_AT_lbl_id (seg_die, DW_AT_low_pc,
19852 fde->dw_fde_second_begin);
19853 add_AT_lbl_id (seg_die, DW_AT_high_pc,
19854 fde->dw_fde_second_end);
19855 add_name_attribute (seg_die, name);
19856 add_pubname_string (name, seg_die);
19861 add_AT_lbl_id (subr_die, DW_AT_low_pc, fde->dw_fde_begin);
19862 add_AT_lbl_id (subr_die, DW_AT_high_pc, fde->dw_fde_end);
19863 add_pubname (decl, subr_die);
19867 #ifdef MIPS_DEBUGGING_INFO
19868 /* Add a reference to the FDE for this routine. */
19869 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
19872 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
19874 /* We define the "frame base" as the function's CFA. This is more
19875 convenient for several reasons: (1) It's stable across the prologue
19876 and epilogue, which makes it better than just a frame pointer,
19877 (2) With dwarf3, there exists a one-byte encoding that allows us
19878 to reference the .debug_frame data by proxy, but failing that,
19879 (3) We can at least reuse the code inspection and interpretation
19880 code that determines the CFA position at various points in the
19882 if (dwarf_version >= 3)
19884 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
19885 add_AT_loc (subr_die, DW_AT_frame_base, op);
19889 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
19890 if (list->dw_loc_next)
19891 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
19893 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
19896 /* Compute a displacement from the "steady-state frame pointer" to
19897 the CFA. The former is what all stack slots and argument slots
19898 will reference in the rtl; the later is what we've told the
19899 debugger about. We'll need to adjust all frame_base references
19900 by this displacement. */
19901 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
19903 if (cfun->static_chain_decl)
19904 add_AT_location_description (subr_die, DW_AT_static_link,
19905 loc_list_from_tree (cfun->static_chain_decl, 2));
19908 /* Generate child dies for template paramaters. */
19909 if (debug_info_level > DINFO_LEVEL_TERSE)
19910 gen_generic_params_dies (decl);
19912 /* Now output descriptions of the arguments for this function. This gets
19913 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
19914 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
19915 `...' at the end of the formal parameter list. In order to find out if
19916 there was a trailing ellipsis or not, we must instead look at the type
19917 associated with the FUNCTION_DECL. This will be a node of type
19918 FUNCTION_TYPE. If the chain of type nodes hanging off of this
19919 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
19920 an ellipsis at the end. */
19922 /* In the case where we are describing a mere function declaration, all we
19923 need to do here (and all we *can* do here) is to describe the *types* of
19924 its formal parameters. */
19925 if (debug_info_level <= DINFO_LEVEL_TERSE)
19927 else if (declaration)
19928 gen_formal_types_die (decl, subr_die);
19931 /* Generate DIEs to represent all known formal parameters. */
19932 tree parm = DECL_ARGUMENTS (decl);
19933 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
19934 tree generic_decl_parm = generic_decl
19935 ? DECL_ARGUMENTS (generic_decl)
19938 /* Now we want to walk the list of parameters of the function and
19939 emit their relevant DIEs.
19941 We consider the case of DECL being an instance of a generic function
19942 as well as it being a normal function.
19944 If DECL is an instance of a generic function we walk the
19945 parameters of the generic function declaration _and_ the parameters of
19946 DECL itself. This is useful because we want to emit specific DIEs for
19947 function parameter packs and those are declared as part of the
19948 generic function declaration. In that particular case,
19949 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
19950 That DIE has children DIEs representing the set of arguments
19951 of the pack. Note that the set of pack arguments can be empty.
19952 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
19955 Otherwise, we just consider the parameters of DECL. */
19956 while (generic_decl_parm || parm)
19958 if (generic_decl_parm
19959 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
19960 gen_formal_parameter_pack_die (generic_decl_parm,
19965 dw_die_ref parm_die = gen_decl_die (parm, NULL, subr_die);
19967 if (parm == DECL_ARGUMENTS (decl)
19968 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
19970 && (dwarf_version >= 3 || !dwarf_strict))
19971 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die);
19973 parm = DECL_CHAIN (parm);
19976 if (generic_decl_parm)
19977 generic_decl_parm = DECL_CHAIN (generic_decl_parm);
19980 /* Decide whether we need an unspecified_parameters DIE at the end.
19981 There are 2 more cases to do this for: 1) the ansi ... declaration -
19982 this is detectable when the end of the arg list is not a
19983 void_type_node 2) an unprototyped function declaration (not a
19984 definition). This just means that we have no info about the
19985 parameters at all. */
19986 if (prototype_p (TREE_TYPE (decl)))
19988 /* This is the prototyped case, check for.... */
19989 if (stdarg_p (TREE_TYPE (decl)))
19990 gen_unspecified_parameters_die (decl, subr_die);
19992 else if (DECL_INITIAL (decl) == NULL_TREE)
19993 gen_unspecified_parameters_die (decl, subr_die);
19996 /* Output Dwarf info for all of the stuff within the body of the function
19997 (if it has one - it may be just a declaration). */
19998 outer_scope = DECL_INITIAL (decl);
20000 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
20001 a function. This BLOCK actually represents the outermost binding contour
20002 for the function, i.e. the contour in which the function's formal
20003 parameters and labels get declared. Curiously, it appears that the front
20004 end doesn't actually put the PARM_DECL nodes for the current function onto
20005 the BLOCK_VARS list for this outer scope, but are strung off of the
20006 DECL_ARGUMENTS list for the function instead.
20008 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
20009 the LABEL_DECL nodes for the function however, and we output DWARF info
20010 for those in decls_for_scope. Just within the `outer_scope' there will be
20011 a BLOCK node representing the function's outermost pair of curly braces,
20012 and any blocks used for the base and member initializers of a C++
20013 constructor function. */
20014 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
20016 int call_site_note_count = 0;
20017 int tail_call_site_note_count = 0;
20019 /* Emit a DW_TAG_variable DIE for a named return value. */
20020 if (DECL_NAME (DECL_RESULT (decl)))
20021 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
20023 current_function_has_inlines = 0;
20024 decls_for_scope (outer_scope, subr_die, 0);
20026 if (call_arg_locations && !dwarf_strict)
20028 struct call_arg_loc_node *ca_loc;
20029 for (ca_loc = call_arg_locations; ca_loc; ca_loc = ca_loc->next)
20031 dw_die_ref die = NULL;
20032 rtx tloc = NULL_RTX, tlocc = NULL_RTX;
20035 for (arg = NOTE_VAR_LOCATION (ca_loc->call_arg_loc_note);
20036 arg; arg = next_arg)
20038 dw_loc_descr_ref reg, val;
20039 enum machine_mode mode = GET_MODE (XEXP (XEXP (arg, 0), 1));
20042 next_arg = XEXP (arg, 1);
20043 if (REG_P (XEXP (XEXP (arg, 0), 0))
20045 && MEM_P (XEXP (XEXP (next_arg, 0), 0))
20046 && REG_P (XEXP (XEXP (XEXP (next_arg, 0), 0), 0))
20047 && REGNO (XEXP (XEXP (arg, 0), 0))
20048 == REGNO (XEXP (XEXP (XEXP (next_arg, 0), 0), 0)))
20049 next_arg = XEXP (next_arg, 1);
20050 if (mode == VOIDmode)
20052 mode = GET_MODE (XEXP (XEXP (arg, 0), 0));
20053 if (mode == VOIDmode)
20054 mode = GET_MODE (XEXP (arg, 0));
20056 if (mode == VOIDmode || mode == BLKmode)
20058 if (XEXP (XEXP (arg, 0), 0) == pc_rtx)
20060 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
20061 tloc = XEXP (XEXP (arg, 0), 1);
20064 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) == CLOBBER
20065 && XEXP (XEXP (XEXP (arg, 0), 0), 0) == pc_rtx)
20067 gcc_assert (ca_loc->symbol_ref == NULL_RTX);
20068 tlocc = XEXP (XEXP (arg, 0), 1);
20071 if (REG_P (XEXP (XEXP (arg, 0), 0)))
20072 reg = reg_loc_descriptor (XEXP (XEXP (arg, 0), 0),
20073 VAR_INIT_STATUS_INITIALIZED);
20074 else if (MEM_P (XEXP (XEXP (arg, 0), 0)))
20076 rtx mem = XEXP (XEXP (arg, 0), 0);
20077 reg = mem_loc_descriptor (XEXP (mem, 0),
20078 get_address_mode (mem),
20080 VAR_INIT_STATUS_INITIALIZED);
20086 val = mem_loc_descriptor (XEXP (XEXP (arg, 0), 1), mode,
20088 VAR_INIT_STATUS_INITIALIZED);
20092 die = gen_call_site_die (decl, subr_die, ca_loc);
20093 cdie = new_die (DW_TAG_GNU_call_site_parameter, die,
20095 add_AT_loc (cdie, DW_AT_location, reg);
20096 add_AT_loc (cdie, DW_AT_GNU_call_site_value, val);
20097 if (next_arg != XEXP (arg, 1))
20099 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 1));
20100 if (mode == VOIDmode)
20101 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 0));
20102 val = mem_loc_descriptor (XEXP (XEXP (XEXP (arg, 1),
20105 VAR_INIT_STATUS_INITIALIZED);
20107 add_AT_loc (cdie, DW_AT_GNU_call_site_data_value, val);
20111 && (ca_loc->symbol_ref || tloc))
20112 die = gen_call_site_die (decl, subr_die, ca_loc);
20113 if (die != NULL && (tloc != NULL_RTX || tlocc != NULL_RTX))
20115 dw_loc_descr_ref tval = NULL;
20117 if (tloc != NULL_RTX)
20118 tval = mem_loc_descriptor (tloc,
20119 GET_MODE (tloc) == VOIDmode
20120 ? Pmode : GET_MODE (tloc),
20122 VAR_INIT_STATUS_INITIALIZED);
20124 add_AT_loc (die, DW_AT_GNU_call_site_target, tval);
20125 else if (tlocc != NULL_RTX)
20127 tval = mem_loc_descriptor (tlocc,
20128 GET_MODE (tlocc) == VOIDmode
20129 ? Pmode : GET_MODE (tlocc),
20131 VAR_INIT_STATUS_INITIALIZED);
20133 add_AT_loc (die, DW_AT_GNU_call_site_target_clobbered,
20139 call_site_note_count++;
20140 if (ca_loc->tail_call_p)
20141 tail_call_site_note_count++;
20145 call_arg_locations = NULL;
20146 call_arg_loc_last = NULL;
20147 if (tail_call_site_count >= 0
20148 && tail_call_site_count == tail_call_site_note_count
20151 if (call_site_count >= 0
20152 && call_site_count == call_site_note_count)
20153 add_AT_flag (subr_die, DW_AT_GNU_all_call_sites, 1);
20155 add_AT_flag (subr_die, DW_AT_GNU_all_tail_call_sites, 1);
20157 call_site_count = -1;
20158 tail_call_site_count = -1;
20160 /* Add the calling convention attribute if requested. */
20161 add_calling_convention_attribute (subr_die, decl);
20165 /* Returns a hash value for X (which really is a die_struct). */
20168 common_block_die_table_hash (const void *x)
20170 const_dw_die_ref d = (const_dw_die_ref) x;
20171 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
20174 /* Return nonzero if decl_id and die_parent of die_struct X is the same
20175 as decl_id and die_parent of die_struct Y. */
20178 common_block_die_table_eq (const void *x, const void *y)
20180 const_dw_die_ref d = (const_dw_die_ref) x;
20181 const_dw_die_ref e = (const_dw_die_ref) y;
20182 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
20185 /* Generate a DIE to represent a declared data object.
20186 Either DECL or ORIGIN must be non-null. */
20189 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
20193 tree decl_or_origin = decl ? decl : origin;
20194 tree ultimate_origin;
20195 dw_die_ref var_die;
20196 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
20197 dw_die_ref origin_die;
20198 bool declaration = (DECL_EXTERNAL (decl_or_origin)
20199 || class_or_namespace_scope_p (context_die));
20200 bool specialization_p = false;
20202 ultimate_origin = decl_ultimate_origin (decl_or_origin);
20203 if (decl || ultimate_origin)
20204 origin = ultimate_origin;
20205 com_decl = fortran_common (decl_or_origin, &off);
20207 /* Symbol in common gets emitted as a child of the common block, in the form
20208 of a data member. */
20211 dw_die_ref com_die;
20212 dw_loc_list_ref loc;
20213 die_node com_die_arg;
20215 var_die = lookup_decl_die (decl_or_origin);
20218 if (get_AT (var_die, DW_AT_location) == NULL)
20220 loc = loc_list_from_tree (com_decl, off ? 1 : 2);
20225 /* Optimize the common case. */
20226 if (single_element_loc_list_p (loc)
20227 && loc->expr->dw_loc_opc == DW_OP_addr
20228 && loc->expr->dw_loc_next == NULL
20229 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
20231 loc->expr->dw_loc_oprnd1.v.val_addr
20232 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
20234 loc_list_plus_const (loc, off);
20236 add_AT_location_description (var_die, DW_AT_location, loc);
20237 remove_AT (var_die, DW_AT_declaration);
20243 if (common_block_die_table == NULL)
20244 common_block_die_table
20245 = htab_create_ggc (10, common_block_die_table_hash,
20246 common_block_die_table_eq, NULL);
20248 com_die_arg.decl_id = DECL_UID (com_decl);
20249 com_die_arg.die_parent = context_die;
20250 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
20251 loc = loc_list_from_tree (com_decl, 2);
20252 if (com_die == NULL)
20255 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
20258 com_die = new_die (DW_TAG_common_block, context_die, decl);
20259 add_name_and_src_coords_attributes (com_die, com_decl);
20262 add_AT_location_description (com_die, DW_AT_location, loc);
20263 /* Avoid sharing the same loc descriptor between
20264 DW_TAG_common_block and DW_TAG_variable. */
20265 loc = loc_list_from_tree (com_decl, 2);
20267 else if (DECL_EXTERNAL (decl))
20268 add_AT_flag (com_die, DW_AT_declaration, 1);
20269 add_pubname_string (cnam, com_die); /* ??? needed? */
20270 com_die->decl_id = DECL_UID (com_decl);
20271 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
20272 *slot = (void *) com_die;
20274 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
20276 add_AT_location_description (com_die, DW_AT_location, loc);
20277 loc = loc_list_from_tree (com_decl, 2);
20278 remove_AT (com_die, DW_AT_declaration);
20280 var_die = new_die (DW_TAG_variable, com_die, decl);
20281 add_name_and_src_coords_attributes (var_die, decl);
20282 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
20283 TREE_THIS_VOLATILE (decl), context_die);
20284 add_AT_flag (var_die, DW_AT_external, 1);
20289 /* Optimize the common case. */
20290 if (single_element_loc_list_p (loc)
20291 && loc->expr->dw_loc_opc == DW_OP_addr
20292 && loc->expr->dw_loc_next == NULL
20293 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
20294 loc->expr->dw_loc_oprnd1.v.val_addr
20295 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
20297 loc_list_plus_const (loc, off);
20299 add_AT_location_description (var_die, DW_AT_location, loc);
20301 else if (DECL_EXTERNAL (decl))
20302 add_AT_flag (var_die, DW_AT_declaration, 1);
20303 equate_decl_number_to_die (decl, var_die);
20307 /* If the compiler emitted a definition for the DECL declaration
20308 and if we already emitted a DIE for it, don't emit a second
20309 DIE for it again. Allow re-declarations of DECLs that are
20310 inside functions, though. */
20311 if (old_die && declaration && !local_scope_p (context_die))
20314 /* For static data members, the declaration in the class is supposed
20315 to have DW_TAG_member tag; the specification should still be
20316 DW_TAG_variable referencing the DW_TAG_member DIE. */
20317 if (declaration && class_scope_p (context_die))
20318 var_die = new_die (DW_TAG_member, context_die, decl);
20320 var_die = new_die (DW_TAG_variable, context_die, decl);
20323 if (origin != NULL)
20324 origin_die = add_abstract_origin_attribute (var_die, origin);
20326 /* Loop unrolling can create multiple blocks that refer to the same
20327 static variable, so we must test for the DW_AT_declaration flag.
20329 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
20330 copy decls and set the DECL_ABSTRACT flag on them instead of
20333 ??? Duplicated blocks have been rewritten to use .debug_ranges.
20335 ??? The declare_in_namespace support causes us to get two DIEs for one
20336 variable, both of which are declarations. We want to avoid considering
20337 one to be a specification, so we must test that this DIE is not a
20339 else if (old_die && TREE_STATIC (decl) && ! declaration
20340 && get_AT_flag (old_die, DW_AT_declaration) == 1)
20342 /* This is a definition of a C++ class level static. */
20343 add_AT_specification (var_die, old_die);
20344 specialization_p = true;
20345 if (DECL_NAME (decl))
20347 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
20348 struct dwarf_file_data * file_index = lookup_filename (s.file);
20350 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
20351 add_AT_file (var_die, DW_AT_decl_file, file_index);
20353 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
20354 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
20356 if (old_die->die_tag == DW_TAG_member)
20357 add_linkage_name (var_die, decl);
20361 add_name_and_src_coords_attributes (var_die, decl);
20363 if ((origin == NULL && !specialization_p)
20365 && !DECL_ABSTRACT (decl_or_origin)
20366 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
20367 decl_function_context
20368 (decl_or_origin))))
20370 tree type = TREE_TYPE (decl_or_origin);
20372 if (decl_by_reference_p (decl_or_origin))
20373 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
20375 add_type_attribute (var_die, type, TREE_READONLY (decl_or_origin),
20376 TREE_THIS_VOLATILE (decl_or_origin), context_die);
20379 if (origin == NULL && !specialization_p)
20381 if (TREE_PUBLIC (decl))
20382 add_AT_flag (var_die, DW_AT_external, 1);
20384 if (DECL_ARTIFICIAL (decl))
20385 add_AT_flag (var_die, DW_AT_artificial, 1);
20387 add_accessibility_attribute (var_die, decl);
20391 add_AT_flag (var_die, DW_AT_declaration, 1);
20393 if (decl && (DECL_ABSTRACT (decl) || declaration || old_die == NULL))
20394 equate_decl_number_to_die (decl, var_die);
20397 && (! DECL_ABSTRACT (decl_or_origin)
20398 /* Local static vars are shared between all clones/inlines,
20399 so emit DW_AT_location on the abstract DIE if DECL_RTL is
20401 || (TREE_CODE (decl_or_origin) == VAR_DECL
20402 && TREE_STATIC (decl_or_origin)
20403 && DECL_RTL_SET_P (decl_or_origin)))
20404 /* When abstract origin already has DW_AT_location attribute, no need
20405 to add it again. */
20406 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
20408 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
20409 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
20410 defer_location (decl_or_origin, var_die);
20412 add_location_or_const_value_attribute (var_die, decl_or_origin,
20413 decl == NULL, DW_AT_location);
20414 add_pubname (decl_or_origin, var_die);
20417 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
20420 /* Generate a DIE to represent a named constant. */
20423 gen_const_die (tree decl, dw_die_ref context_die)
20425 dw_die_ref const_die;
20426 tree type = TREE_TYPE (decl);
20428 const_die = new_die (DW_TAG_constant, context_die, decl);
20429 add_name_and_src_coords_attributes (const_die, decl);
20430 add_type_attribute (const_die, type, 1, 0, context_die);
20431 if (TREE_PUBLIC (decl))
20432 add_AT_flag (const_die, DW_AT_external, 1);
20433 if (DECL_ARTIFICIAL (decl))
20434 add_AT_flag (const_die, DW_AT_artificial, 1);
20435 tree_add_const_value_attribute_for_decl (const_die, decl);
20438 /* Generate a DIE to represent a label identifier. */
20441 gen_label_die (tree decl, dw_die_ref context_die)
20443 tree origin = decl_ultimate_origin (decl);
20444 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
20446 char label[MAX_ARTIFICIAL_LABEL_BYTES];
20448 if (origin != NULL)
20449 add_abstract_origin_attribute (lbl_die, origin);
20451 add_name_and_src_coords_attributes (lbl_die, decl);
20453 if (DECL_ABSTRACT (decl))
20454 equate_decl_number_to_die (decl, lbl_die);
20457 insn = DECL_RTL_IF_SET (decl);
20459 /* Deleted labels are programmer specified labels which have been
20460 eliminated because of various optimizations. We still emit them
20461 here so that it is possible to put breakpoints on them. */
20465 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
20467 /* When optimization is enabled (via -O) some parts of the compiler
20468 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
20469 represent source-level labels which were explicitly declared by
20470 the user. This really shouldn't be happening though, so catch
20471 it if it ever does happen. */
20472 gcc_assert (!INSN_DELETED_P (insn));
20474 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
20475 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
20480 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
20481 attributes to the DIE for a block STMT, to describe where the inlined
20482 function was called from. This is similar to add_src_coords_attributes. */
20485 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
20487 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
20489 if (dwarf_version >= 3 || !dwarf_strict)
20491 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
20492 add_AT_unsigned (die, DW_AT_call_line, s.line);
20497 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
20498 Add low_pc and high_pc attributes to the DIE for a block STMT. */
20501 add_high_low_attributes (tree stmt, dw_die_ref die)
20503 char label[MAX_ARTIFICIAL_LABEL_BYTES];
20505 if (BLOCK_FRAGMENT_CHAIN (stmt)
20506 && (dwarf_version >= 3 || !dwarf_strict))
20510 if (inlined_function_outer_scope_p (stmt))
20512 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
20513 BLOCK_NUMBER (stmt));
20514 add_AT_lbl_id (die, DW_AT_entry_pc, label);
20517 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
20519 chain = BLOCK_FRAGMENT_CHAIN (stmt);
20522 add_ranges (chain);
20523 chain = BLOCK_FRAGMENT_CHAIN (chain);
20530 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
20531 BLOCK_NUMBER (stmt));
20532 add_AT_lbl_id (die, DW_AT_low_pc, label);
20533 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
20534 BLOCK_NUMBER (stmt));
20535 add_AT_lbl_id (die, DW_AT_high_pc, label);
20539 /* Generate a DIE for a lexical block. */
20542 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
20544 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
20546 if (call_arg_locations)
20548 if (VEC_length (dw_die_ref, block_map) <= BLOCK_NUMBER (stmt))
20549 VEC_safe_grow_cleared (dw_die_ref, heap, block_map,
20550 BLOCK_NUMBER (stmt) + 1);
20551 VEC_replace (dw_die_ref, block_map, BLOCK_NUMBER (stmt), stmt_die);
20554 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
20555 add_high_low_attributes (stmt, stmt_die);
20557 decls_for_scope (stmt, stmt_die, depth);
20560 /* Generate a DIE for an inlined subprogram. */
20563 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
20567 /* The instance of function that is effectively being inlined shall not
20569 gcc_assert (! BLOCK_ABSTRACT (stmt));
20571 decl = block_ultimate_origin (stmt);
20573 /* Emit info for the abstract instance first, if we haven't yet. We
20574 must emit this even if the block is abstract, otherwise when we
20575 emit the block below (or elsewhere), we may end up trying to emit
20576 a die whose origin die hasn't been emitted, and crashing. */
20577 dwarf2out_abstract_function (decl);
20579 if (! BLOCK_ABSTRACT (stmt))
20581 dw_die_ref subr_die
20582 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
20584 if (call_arg_locations)
20586 if (VEC_length (dw_die_ref, block_map) <= BLOCK_NUMBER (stmt))
20587 VEC_safe_grow_cleared (dw_die_ref, heap, block_map,
20588 BLOCK_NUMBER (stmt) + 1);
20589 VEC_replace (dw_die_ref, block_map, BLOCK_NUMBER (stmt), subr_die);
20591 add_abstract_origin_attribute (subr_die, decl);
20592 if (TREE_ASM_WRITTEN (stmt))
20593 add_high_low_attributes (stmt, subr_die);
20594 add_call_src_coords_attributes (stmt, subr_die);
20596 decls_for_scope (stmt, subr_die, depth);
20597 current_function_has_inlines = 1;
20601 /* Generate a DIE for a field in a record, or structure. */
20604 gen_field_die (tree decl, dw_die_ref context_die)
20606 dw_die_ref decl_die;
20608 if (TREE_TYPE (decl) == error_mark_node)
20611 decl_die = new_die (DW_TAG_member, context_die, decl);
20612 add_name_and_src_coords_attributes (decl_die, decl);
20613 add_type_attribute (decl_die, member_declared_type (decl),
20614 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
20617 if (DECL_BIT_FIELD_TYPE (decl))
20619 add_byte_size_attribute (decl_die, decl);
20620 add_bit_size_attribute (decl_die, decl);
20621 add_bit_offset_attribute (decl_die, decl);
20624 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
20625 add_data_member_location_attribute (decl_die, decl);
20627 if (DECL_ARTIFICIAL (decl))
20628 add_AT_flag (decl_die, DW_AT_artificial, 1);
20630 add_accessibility_attribute (decl_die, decl);
20632 /* Equate decl number to die, so that we can look up this decl later on. */
20633 equate_decl_number_to_die (decl, decl_die);
20637 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
20638 Use modified_type_die instead.
20639 We keep this code here just in case these types of DIEs may be needed to
20640 represent certain things in other languages (e.g. Pascal) someday. */
20643 gen_pointer_type_die (tree type, dw_die_ref context_die)
20646 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
20648 equate_type_number_to_die (type, ptr_die);
20649 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
20650 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
20653 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
20654 Use modified_type_die instead.
20655 We keep this code here just in case these types of DIEs may be needed to
20656 represent certain things in other languages (e.g. Pascal) someday. */
20659 gen_reference_type_die (tree type, dw_die_ref context_die)
20661 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die);
20663 if (TYPE_REF_IS_RVALUE (type) && use_debug_types)
20664 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type);
20666 ref_die = new_die (DW_TAG_reference_type, scope_die, type);
20668 equate_type_number_to_die (type, ref_die);
20669 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
20670 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
20674 /* Generate a DIE for a pointer to a member type. */
20677 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
20680 = new_die (DW_TAG_ptr_to_member_type,
20681 scope_die_for (type, context_die), type);
20683 equate_type_number_to_die (type, ptr_die);
20684 add_AT_die_ref (ptr_die, DW_AT_containing_type,
20685 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
20686 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
20689 /* Generate the DIE for the compilation unit. */
20692 gen_compile_unit_die (const char *filename)
20695 char producer[250];
20696 const char *language_string = lang_hooks.name;
20699 die = new_die (DW_TAG_compile_unit, NULL, NULL);
20703 add_name_attribute (die, filename);
20704 /* Don't add cwd for <built-in>. */
20705 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
20706 add_comp_dir_attribute (die);
20709 sprintf (producer, "%s %s", language_string, version_string);
20711 #ifdef MIPS_DEBUGGING_INFO
20712 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
20713 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
20714 not appear in the producer string, the debugger reaches the conclusion
20715 that the object file is stripped and has no debugging information.
20716 To get the MIPS/SGI debugger to believe that there is debugging
20717 information in the object file, we add a -g to the producer string. */
20718 if (debug_info_level > DINFO_LEVEL_TERSE)
20719 strcat (producer, " -g");
20722 add_AT_string (die, DW_AT_producer, producer);
20724 /* If our producer is LTO try to figure out a common language to use
20725 from the global list of translation units. */
20726 if (strcmp (language_string, "GNU GIMPLE") == 0)
20730 const char *common_lang = NULL;
20732 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
20734 if (!TRANSLATION_UNIT_LANGUAGE (t))
20737 common_lang = TRANSLATION_UNIT_LANGUAGE (t);
20738 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
20740 else if (strncmp (common_lang, "GNU C", 5) == 0
20741 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
20742 /* Mixing C and C++ is ok, use C++ in that case. */
20743 common_lang = "GNU C++";
20746 /* Fall back to C. */
20747 common_lang = NULL;
20753 language_string = common_lang;
20756 language = DW_LANG_C89;
20757 if (strcmp (language_string, "GNU C++") == 0)
20758 language = DW_LANG_C_plus_plus;
20759 else if (strcmp (language_string, "GNU F77") == 0)
20760 language = DW_LANG_Fortran77;
20761 else if (strcmp (language_string, "GNU Pascal") == 0)
20762 language = DW_LANG_Pascal83;
20763 else if (dwarf_version >= 3 || !dwarf_strict)
20765 if (strcmp (language_string, "GNU Ada") == 0)
20766 language = DW_LANG_Ada95;
20767 else if (strcmp (language_string, "GNU Fortran") == 0)
20768 language = DW_LANG_Fortran95;
20769 else if (strcmp (language_string, "GNU Java") == 0)
20770 language = DW_LANG_Java;
20771 else if (strcmp (language_string, "GNU Objective-C") == 0)
20772 language = DW_LANG_ObjC;
20773 else if (strcmp (language_string, "GNU Objective-C++") == 0)
20774 language = DW_LANG_ObjC_plus_plus;
20777 add_AT_unsigned (die, DW_AT_language, language);
20781 case DW_LANG_Fortran77:
20782 case DW_LANG_Fortran90:
20783 case DW_LANG_Fortran95:
20784 /* Fortran has case insensitive identifiers and the front-end
20785 lowercases everything. */
20786 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
20789 /* The default DW_ID_case_sensitive doesn't need to be specified. */
20795 /* Generate the DIE for a base class. */
20798 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
20800 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
20802 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
20803 add_data_member_location_attribute (die, binfo);
20805 if (BINFO_VIRTUAL_P (binfo))
20806 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
20808 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
20809 children, otherwise the default is DW_ACCESS_public. In DWARF2
20810 the default has always been DW_ACCESS_private. */
20811 if (access == access_public_node)
20813 if (dwarf_version == 2
20814 || context_die->die_tag == DW_TAG_class_type)
20815 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
20817 else if (access == access_protected_node)
20818 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
20819 else if (dwarf_version > 2
20820 && context_die->die_tag != DW_TAG_class_type)
20821 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
20824 /* Generate a DIE for a class member. */
20827 gen_member_die (tree type, dw_die_ref context_die)
20830 tree binfo = TYPE_BINFO (type);
20833 /* If this is not an incomplete type, output descriptions of each of its
20834 members. Note that as we output the DIEs necessary to represent the
20835 members of this record or union type, we will also be trying to output
20836 DIEs to represent the *types* of those members. However the `type'
20837 function (above) will specifically avoid generating type DIEs for member
20838 types *within* the list of member DIEs for this (containing) type except
20839 for those types (of members) which are explicitly marked as also being
20840 members of this (containing) type themselves. The g++ front- end can
20841 force any given type to be treated as a member of some other (containing)
20842 type by setting the TYPE_CONTEXT of the given (member) type to point to
20843 the TREE node representing the appropriate (containing) type. */
20845 /* First output info about the base classes. */
20848 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
20852 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
20853 gen_inheritance_die (base,
20854 (accesses ? VEC_index (tree, accesses, i)
20855 : access_public_node), context_die);
20858 /* Now output info about the data members and type members. */
20859 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
20861 /* If we thought we were generating minimal debug info for TYPE
20862 and then changed our minds, some of the member declarations
20863 may have already been defined. Don't define them again, but
20864 do put them in the right order. */
20866 child = lookup_decl_die (member);
20868 splice_child_die (context_die, child);
20870 gen_decl_die (member, NULL, context_die);
20873 /* Now output info about the function members (if any). */
20874 for (member = TYPE_METHODS (type); member; member = DECL_CHAIN (member))
20876 /* Don't include clones in the member list. */
20877 if (DECL_ABSTRACT_ORIGIN (member))
20880 child = lookup_decl_die (member);
20882 splice_child_die (context_die, child);
20884 gen_decl_die (member, NULL, context_die);
20888 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
20889 is set, we pretend that the type was never defined, so we only get the
20890 member DIEs needed by later specification DIEs. */
20893 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
20894 enum debug_info_usage usage)
20896 dw_die_ref type_die = lookup_type_die (type);
20897 dw_die_ref scope_die = 0;
20899 int complete = (TYPE_SIZE (type)
20900 && (! TYPE_STUB_DECL (type)
20901 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
20902 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
20903 complete = complete && should_emit_struct_debug (type, usage);
20905 if (type_die && ! complete)
20908 if (TYPE_CONTEXT (type) != NULL_TREE
20909 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
20910 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
20913 scope_die = scope_die_for (type, context_die);
20915 if (! type_die || (nested && is_cu_die (scope_die)))
20916 /* First occurrence of type or toplevel definition of nested class. */
20918 dw_die_ref old_die = type_die;
20920 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
20921 ? record_type_tag (type) : DW_TAG_union_type,
20923 equate_type_number_to_die (type, type_die);
20925 add_AT_specification (type_die, old_die);
20928 add_name_attribute (type_die, type_tag (type));
20929 add_gnat_descriptive_type_attribute (type_die, type, context_die);
20933 remove_AT (type_die, DW_AT_declaration);
20935 /* Generate child dies for template paramaters. */
20936 if (debug_info_level > DINFO_LEVEL_TERSE
20937 && COMPLETE_TYPE_P (type))
20938 schedule_generic_params_dies_gen (type);
20940 /* If this type has been completed, then give it a byte_size attribute and
20941 then give a list of members. */
20942 if (complete && !ns_decl)
20944 /* Prevent infinite recursion in cases where the type of some member of
20945 this type is expressed in terms of this type itself. */
20946 TREE_ASM_WRITTEN (type) = 1;
20947 add_byte_size_attribute (type_die, type);
20948 if (TYPE_STUB_DECL (type) != NULL_TREE)
20950 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
20951 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
20954 /* If the first reference to this type was as the return type of an
20955 inline function, then it may not have a parent. Fix this now. */
20956 if (type_die->die_parent == NULL)
20957 add_child_die (scope_die, type_die);
20959 push_decl_scope (type);
20960 gen_member_die (type, type_die);
20963 /* GNU extension: Record what type our vtable lives in. */
20964 if (TYPE_VFIELD (type))
20966 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
20968 gen_type_die (vtype, context_die);
20969 add_AT_die_ref (type_die, DW_AT_containing_type,
20970 lookup_type_die (vtype));
20975 add_AT_flag (type_die, DW_AT_declaration, 1);
20977 /* We don't need to do this for function-local types. */
20978 if (TYPE_STUB_DECL (type)
20979 && ! decl_function_context (TYPE_STUB_DECL (type)))
20980 VEC_safe_push (tree, gc, incomplete_types, type);
20983 if (get_AT (type_die, DW_AT_name))
20984 add_pubtype (type, type_die);
20987 /* Generate a DIE for a subroutine _type_. */
20990 gen_subroutine_type_die (tree type, dw_die_ref context_die)
20992 tree return_type = TREE_TYPE (type);
20993 dw_die_ref subr_die
20994 = new_die (DW_TAG_subroutine_type,
20995 scope_die_for (type, context_die), type);
20997 equate_type_number_to_die (type, subr_die);
20998 add_prototyped_attribute (subr_die, type);
20999 add_type_attribute (subr_die, return_type, 0, 0, context_die);
21000 gen_formal_types_die (type, subr_die);
21002 if (get_AT (subr_die, DW_AT_name))
21003 add_pubtype (type, subr_die);
21006 /* Generate a DIE for a type definition. */
21009 gen_typedef_die (tree decl, dw_die_ref context_die)
21011 dw_die_ref type_die;
21014 if (TREE_ASM_WRITTEN (decl))
21017 TREE_ASM_WRITTEN (decl) = 1;
21018 type_die = new_die (DW_TAG_typedef, context_die, decl);
21019 origin = decl_ultimate_origin (decl);
21020 if (origin != NULL)
21021 add_abstract_origin_attribute (type_die, origin);
21026 add_name_and_src_coords_attributes (type_die, decl);
21027 if (DECL_ORIGINAL_TYPE (decl))
21029 type = DECL_ORIGINAL_TYPE (decl);
21031 gcc_assert (type != TREE_TYPE (decl));
21032 equate_type_number_to_die (TREE_TYPE (decl), type_die);
21036 type = TREE_TYPE (decl);
21038 if (is_naming_typedef_decl (TYPE_NAME (type)))
21040 /* Here, we are in the case of decl being a typedef naming
21041 an anonymous type, e.g:
21042 typedef struct {...} foo;
21043 In that case TREE_TYPE (decl) is not a typedef variant
21044 type and TYPE_NAME of the anonymous type is set to the
21045 TYPE_DECL of the typedef. This construct is emitted by
21048 TYPE is the anonymous struct named by the typedef
21049 DECL. As we need the DW_AT_type attribute of the
21050 DW_TAG_typedef to point to the DIE of TYPE, let's
21051 generate that DIE right away. add_type_attribute
21052 called below will then pick (via lookup_type_die) that
21053 anonymous struct DIE. */
21054 if (!TREE_ASM_WRITTEN (type))
21055 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
21057 /* This is a GNU Extension. We are adding a
21058 DW_AT_linkage_name attribute to the DIE of the
21059 anonymous struct TYPE. The value of that attribute
21060 is the name of the typedef decl naming the anonymous
21061 struct. This greatly eases the work of consumers of
21062 this debug info. */
21063 add_linkage_attr (lookup_type_die (type), decl);
21067 add_type_attribute (type_die, type, TREE_READONLY (decl),
21068 TREE_THIS_VOLATILE (decl), context_die);
21070 if (is_naming_typedef_decl (decl))
21071 /* We want that all subsequent calls to lookup_type_die with
21072 TYPE in argument yield the DW_TAG_typedef we have just
21074 equate_type_number_to_die (type, type_die);
21076 add_accessibility_attribute (type_die, decl);
21079 if (DECL_ABSTRACT (decl))
21080 equate_decl_number_to_die (decl, type_die);
21082 if (get_AT (type_die, DW_AT_name))
21083 add_pubtype (decl, type_die);
21086 /* Generate a DIE for a struct, class, enum or union type. */
21089 gen_tagged_type_die (tree type,
21090 dw_die_ref context_die,
21091 enum debug_info_usage usage)
21095 if (type == NULL_TREE
21096 || !is_tagged_type (type))
21099 /* If this is a nested type whose containing class hasn't been written
21100 out yet, writing it out will cover this one, too. This does not apply
21101 to instantiations of member class templates; they need to be added to
21102 the containing class as they are generated. FIXME: This hurts the
21103 idea of combining type decls from multiple TUs, since we can't predict
21104 what set of template instantiations we'll get. */
21105 if (TYPE_CONTEXT (type)
21106 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
21107 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
21109 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
21111 if (TREE_ASM_WRITTEN (type))
21114 /* If that failed, attach ourselves to the stub. */
21115 push_decl_scope (TYPE_CONTEXT (type));
21116 context_die = lookup_type_die (TYPE_CONTEXT (type));
21119 else if (TYPE_CONTEXT (type) != NULL_TREE
21120 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
21122 /* If this type is local to a function that hasn't been written
21123 out yet, use a NULL context for now; it will be fixed up in
21124 decls_for_scope. */
21125 context_die = lookup_decl_die (TYPE_CONTEXT (type));
21126 /* A declaration DIE doesn't count; nested types need to go in the
21128 if (context_die && is_declaration_die (context_die))
21129 context_die = NULL;
21134 context_die = declare_in_namespace (type, context_die);
21138 if (TREE_CODE (type) == ENUMERAL_TYPE)
21140 /* This might have been written out by the call to
21141 declare_in_namespace. */
21142 if (!TREE_ASM_WRITTEN (type))
21143 gen_enumeration_type_die (type, context_die);
21146 gen_struct_or_union_type_die (type, context_die, usage);
21151 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
21152 it up if it is ever completed. gen_*_type_die will set it for us
21153 when appropriate. */
21156 /* Generate a type description DIE. */
21159 gen_type_die_with_usage (tree type, dw_die_ref context_die,
21160 enum debug_info_usage usage)
21162 struct array_descr_info info;
21164 if (type == NULL_TREE || type == error_mark_node)
21167 if (TYPE_NAME (type) != NULL_TREE
21168 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
21169 && is_redundant_typedef (TYPE_NAME (type))
21170 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
21171 /* The DECL of this type is a typedef we don't want to emit debug
21172 info for but we want debug info for its underlying typedef.
21173 This can happen for e.g, the injected-class-name of a C++
21175 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
21177 /* If TYPE is a typedef type variant, let's generate debug info
21178 for the parent typedef which TYPE is a type of. */
21179 if (typedef_variant_p (type))
21181 if (TREE_ASM_WRITTEN (type))
21184 /* Prevent broken recursion; we can't hand off to the same type. */
21185 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
21187 /* Use the DIE of the containing namespace as the parent DIE of
21188 the type description DIE we want to generate. */
21189 if (DECL_CONTEXT (TYPE_NAME (type))
21190 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
21191 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
21193 TREE_ASM_WRITTEN (type) = 1;
21195 gen_decl_die (TYPE_NAME (type), NULL, context_die);
21199 /* If type is an anonymous tagged type named by a typedef, let's
21200 generate debug info for the typedef. */
21201 if (is_naming_typedef_decl (TYPE_NAME (type)))
21203 /* Use the DIE of the containing namespace as the parent DIE of
21204 the type description DIE we want to generate. */
21205 if (DECL_CONTEXT (TYPE_NAME (type))
21206 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
21207 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
21209 gen_decl_die (TYPE_NAME (type), NULL, context_die);
21213 /* If this is an array type with hidden descriptor, handle it first. */
21214 if (!TREE_ASM_WRITTEN (type)
21215 && lang_hooks.types.get_array_descr_info
21216 && lang_hooks.types.get_array_descr_info (type, &info)
21217 && (dwarf_version >= 3 || !dwarf_strict))
21219 gen_descr_array_type_die (type, &info, context_die);
21220 TREE_ASM_WRITTEN (type) = 1;
21224 /* We are going to output a DIE to represent the unqualified version
21225 of this type (i.e. without any const or volatile qualifiers) so
21226 get the main variant (i.e. the unqualified version) of this type
21227 now. (Vectors are special because the debugging info is in the
21228 cloned type itself). */
21229 if (TREE_CODE (type) != VECTOR_TYPE)
21230 type = type_main_variant (type);
21232 if (TREE_ASM_WRITTEN (type))
21235 switch (TREE_CODE (type))
21241 case REFERENCE_TYPE:
21242 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
21243 ensures that the gen_type_die recursion will terminate even if the
21244 type is recursive. Recursive types are possible in Ada. */
21245 /* ??? We could perhaps do this for all types before the switch
21247 TREE_ASM_WRITTEN (type) = 1;
21249 /* For these types, all that is required is that we output a DIE (or a
21250 set of DIEs) to represent the "basis" type. */
21251 gen_type_die_with_usage (TREE_TYPE (type), context_die,
21252 DINFO_USAGE_IND_USE);
21256 /* This code is used for C++ pointer-to-data-member types.
21257 Output a description of the relevant class type. */
21258 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
21259 DINFO_USAGE_IND_USE);
21261 /* Output a description of the type of the object pointed to. */
21262 gen_type_die_with_usage (TREE_TYPE (type), context_die,
21263 DINFO_USAGE_IND_USE);
21265 /* Now output a DIE to represent this pointer-to-data-member type
21267 gen_ptr_to_mbr_type_die (type, context_die);
21270 case FUNCTION_TYPE:
21271 /* Force out return type (in case it wasn't forced out already). */
21272 gen_type_die_with_usage (TREE_TYPE (type), context_die,
21273 DINFO_USAGE_DIR_USE);
21274 gen_subroutine_type_die (type, context_die);
21278 /* Force out return type (in case it wasn't forced out already). */
21279 gen_type_die_with_usage (TREE_TYPE (type), context_die,
21280 DINFO_USAGE_DIR_USE);
21281 gen_subroutine_type_die (type, context_die);
21285 gen_array_type_die (type, context_die);
21289 gen_array_type_die (type, context_die);
21292 case ENUMERAL_TYPE:
21295 case QUAL_UNION_TYPE:
21296 gen_tagged_type_die (type, context_die, usage);
21302 case FIXED_POINT_TYPE:
21305 /* No DIEs needed for fundamental types. */
21310 /* Just use DW_TAG_unspecified_type. */
21312 dw_die_ref type_die = lookup_type_die (type);
21313 if (type_die == NULL)
21315 tree name = TYPE_NAME (type);
21316 if (TREE_CODE (name) == TYPE_DECL)
21317 name = DECL_NAME (name);
21318 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (), type);
21319 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
21320 equate_type_number_to_die (type, type_die);
21326 gcc_unreachable ();
21329 TREE_ASM_WRITTEN (type) = 1;
21333 gen_type_die (tree type, dw_die_ref context_die)
21335 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
21338 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
21339 things which are local to the given block. */
21342 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
21344 int must_output_die = 0;
21347 /* Ignore blocks that are NULL. */
21348 if (stmt == NULL_TREE)
21351 inlined_func = inlined_function_outer_scope_p (stmt);
21353 /* If the block is one fragment of a non-contiguous block, do not
21354 process the variables, since they will have been done by the
21355 origin block. Do process subblocks. */
21356 if (BLOCK_FRAGMENT_ORIGIN (stmt))
21360 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
21361 gen_block_die (sub, context_die, depth + 1);
21366 /* Determine if we need to output any Dwarf DIEs at all to represent this
21369 /* The outer scopes for inlinings *must* always be represented. We
21370 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
21371 must_output_die = 1;
21374 /* Determine if this block directly contains any "significant"
21375 local declarations which we will need to output DIEs for. */
21376 if (debug_info_level > DINFO_LEVEL_TERSE)
21377 /* We are not in terse mode so *any* local declaration counts
21378 as being a "significant" one. */
21379 must_output_die = ((BLOCK_VARS (stmt) != NULL
21380 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
21381 && (TREE_USED (stmt)
21382 || TREE_ASM_WRITTEN (stmt)
21383 || BLOCK_ABSTRACT (stmt)));
21384 else if ((TREE_USED (stmt)
21385 || TREE_ASM_WRITTEN (stmt)
21386 || BLOCK_ABSTRACT (stmt))
21387 && !dwarf2out_ignore_block (stmt))
21388 must_output_die = 1;
21391 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
21392 DIE for any block which contains no significant local declarations at
21393 all. Rather, in such cases we just call `decls_for_scope' so that any
21394 needed Dwarf info for any sub-blocks will get properly generated. Note
21395 that in terse mode, our definition of what constitutes a "significant"
21396 local declaration gets restricted to include only inlined function
21397 instances and local (nested) function definitions. */
21398 if (must_output_die)
21402 /* If STMT block is abstract, that means we have been called
21403 indirectly from dwarf2out_abstract_function.
21404 That function rightfully marks the descendent blocks (of
21405 the abstract function it is dealing with) as being abstract,
21406 precisely to prevent us from emitting any
21407 DW_TAG_inlined_subroutine DIE as a descendent
21408 of an abstract function instance. So in that case, we should
21409 not call gen_inlined_subroutine_die.
21411 Later though, when cgraph asks dwarf2out to emit info
21412 for the concrete instance of the function decl into which
21413 the concrete instance of STMT got inlined, the later will lead
21414 to the generation of a DW_TAG_inlined_subroutine DIE. */
21415 if (! BLOCK_ABSTRACT (stmt))
21416 gen_inlined_subroutine_die (stmt, context_die, depth);
21419 gen_lexical_block_die (stmt, context_die, depth);
21422 decls_for_scope (stmt, context_die, depth);
21425 /* Process variable DECL (or variable with origin ORIGIN) within
21426 block STMT and add it to CONTEXT_DIE. */
21428 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
21431 tree decl_or_origin = decl ? decl : origin;
21433 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
21434 die = lookup_decl_die (decl_or_origin);
21435 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
21436 && TYPE_DECL_IS_STUB (decl_or_origin))
21437 die = lookup_type_die (TREE_TYPE (decl_or_origin));
21441 if (die != NULL && die->die_parent == NULL)
21442 add_child_die (context_die, die);
21443 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
21444 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
21445 stmt, context_die);
21447 gen_decl_die (decl, origin, context_die);
21450 /* Generate all of the decls declared within a given scope and (recursively)
21451 all of its sub-blocks. */
21454 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
21460 /* Ignore NULL blocks. */
21461 if (stmt == NULL_TREE)
21464 /* Output the DIEs to represent all of the data objects and typedefs
21465 declared directly within this block but not within any nested
21466 sub-blocks. Also, nested function and tag DIEs have been
21467 generated with a parent of NULL; fix that up now. */
21468 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl))
21469 process_scope_var (stmt, decl, NULL_TREE, context_die);
21470 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
21471 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
21474 /* If we're at -g1, we're not interested in subblocks. */
21475 if (debug_info_level <= DINFO_LEVEL_TERSE)
21478 /* Output the DIEs to represent all sub-blocks (and the items declared
21479 therein) of this block. */
21480 for (subblocks = BLOCK_SUBBLOCKS (stmt);
21482 subblocks = BLOCK_CHAIN (subblocks))
21483 gen_block_die (subblocks, context_die, depth + 1);
21486 /* Is this a typedef we can avoid emitting? */
21489 is_redundant_typedef (const_tree decl)
21491 if (TYPE_DECL_IS_STUB (decl))
21494 if (DECL_ARTIFICIAL (decl)
21495 && DECL_CONTEXT (decl)
21496 && is_tagged_type (DECL_CONTEXT (decl))
21497 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
21498 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
21499 /* Also ignore the artificial member typedef for the class name. */
21505 /* Return TRUE if TYPE is a typedef that names a type for linkage
21506 purposes. This kind of typedefs is produced by the C++ FE for
21509 typedef struct {...} foo;
21511 In that case, there is no typedef variant type produced for foo.
21512 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
21516 is_naming_typedef_decl (const_tree decl)
21518 if (decl == NULL_TREE
21519 || TREE_CODE (decl) != TYPE_DECL
21520 || !is_tagged_type (TREE_TYPE (decl))
21521 || DECL_IS_BUILTIN (decl)
21522 || is_redundant_typedef (decl)
21523 /* It looks like Ada produces TYPE_DECLs that are very similar
21524 to C++ naming typedefs but that have different
21525 semantics. Let's be specific to c++ for now. */
21529 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
21530 && TYPE_NAME (TREE_TYPE (decl)) == decl
21531 && (TYPE_STUB_DECL (TREE_TYPE (decl))
21532 != TYPE_NAME (TREE_TYPE (decl))));
21535 /* Returns the DIE for a context. */
21537 static inline dw_die_ref
21538 get_context_die (tree context)
21542 /* Find die that represents this context. */
21543 if (TYPE_P (context))
21545 context = TYPE_MAIN_VARIANT (context);
21546 return strip_naming_typedef (context, force_type_die (context));
21549 return force_decl_die (context);
21551 return comp_unit_die ();
21554 /* Returns the DIE for decl. A DIE will always be returned. */
21557 force_decl_die (tree decl)
21559 dw_die_ref decl_die;
21560 unsigned saved_external_flag;
21561 tree save_fn = NULL_TREE;
21562 decl_die = lookup_decl_die (decl);
21565 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
21567 decl_die = lookup_decl_die (decl);
21571 switch (TREE_CODE (decl))
21573 case FUNCTION_DECL:
21574 /* Clear current_function_decl, so that gen_subprogram_die thinks
21575 that this is a declaration. At this point, we just want to force
21576 declaration die. */
21577 save_fn = current_function_decl;
21578 current_function_decl = NULL_TREE;
21579 gen_subprogram_die (decl, context_die);
21580 current_function_decl = save_fn;
21584 /* Set external flag to force declaration die. Restore it after
21585 gen_decl_die() call. */
21586 saved_external_flag = DECL_EXTERNAL (decl);
21587 DECL_EXTERNAL (decl) = 1;
21588 gen_decl_die (decl, NULL, context_die);
21589 DECL_EXTERNAL (decl) = saved_external_flag;
21592 case NAMESPACE_DECL:
21593 if (dwarf_version >= 3 || !dwarf_strict)
21594 dwarf2out_decl (decl);
21596 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
21597 decl_die = comp_unit_die ();
21600 case TRANSLATION_UNIT_DECL:
21601 decl_die = comp_unit_die ();
21605 gcc_unreachable ();
21608 /* We should be able to find the DIE now. */
21610 decl_die = lookup_decl_die (decl);
21611 gcc_assert (decl_die);
21617 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
21618 always returned. */
21621 force_type_die (tree type)
21623 dw_die_ref type_die;
21625 type_die = lookup_type_die (type);
21628 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
21630 type_die = modified_type_die (type, TYPE_READONLY (type),
21631 TYPE_VOLATILE (type), context_die);
21632 gcc_assert (type_die);
21637 /* Force out any required namespaces to be able to output DECL,
21638 and return the new context_die for it, if it's changed. */
21641 setup_namespace_context (tree thing, dw_die_ref context_die)
21643 tree context = (DECL_P (thing)
21644 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
21645 if (context && TREE_CODE (context) == NAMESPACE_DECL)
21646 /* Force out the namespace. */
21647 context_die = force_decl_die (context);
21649 return context_die;
21652 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
21653 type) within its namespace, if appropriate.
21655 For compatibility with older debuggers, namespace DIEs only contain
21656 declarations; all definitions are emitted at CU scope. */
21659 declare_in_namespace (tree thing, dw_die_ref context_die)
21661 dw_die_ref ns_context;
21663 if (debug_info_level <= DINFO_LEVEL_TERSE)
21664 return context_die;
21666 /* If this decl is from an inlined function, then don't try to emit it in its
21667 namespace, as we will get confused. It would have already been emitted
21668 when the abstract instance of the inline function was emitted anyways. */
21669 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
21670 return context_die;
21672 ns_context = setup_namespace_context (thing, context_die);
21674 if (ns_context != context_die)
21678 if (DECL_P (thing))
21679 gen_decl_die (thing, NULL, ns_context);
21681 gen_type_die (thing, ns_context);
21683 return context_die;
21686 /* Generate a DIE for a namespace or namespace alias. */
21689 gen_namespace_die (tree decl, dw_die_ref context_die)
21691 dw_die_ref namespace_die;
21693 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
21694 they are an alias of. */
21695 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
21697 /* Output a real namespace or module. */
21698 context_die = setup_namespace_context (decl, comp_unit_die ());
21699 namespace_die = new_die (is_fortran ()
21700 ? DW_TAG_module : DW_TAG_namespace,
21701 context_die, decl);
21702 /* For Fortran modules defined in different CU don't add src coords. */
21703 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
21705 const char *name = dwarf2_name (decl, 0);
21707 add_name_attribute (namespace_die, name);
21710 add_name_and_src_coords_attributes (namespace_die, decl);
21711 if (DECL_EXTERNAL (decl))
21712 add_AT_flag (namespace_die, DW_AT_declaration, 1);
21713 equate_decl_number_to_die (decl, namespace_die);
21717 /* Output a namespace alias. */
21719 /* Force out the namespace we are an alias of, if necessary. */
21720 dw_die_ref origin_die
21721 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
21723 if (DECL_FILE_SCOPE_P (decl)
21724 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
21725 context_die = setup_namespace_context (decl, comp_unit_die ());
21726 /* Now create the namespace alias DIE. */
21727 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
21728 add_name_and_src_coords_attributes (namespace_die, decl);
21729 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
21730 equate_decl_number_to_die (decl, namespace_die);
21734 /* Generate Dwarf debug information for a decl described by DECL.
21735 The return value is currently only meaningful for PARM_DECLs,
21736 for all other decls it returns NULL. */
21739 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
21741 tree decl_or_origin = decl ? decl : origin;
21742 tree class_origin = NULL, ultimate_origin;
21744 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
21747 switch (TREE_CODE (decl_or_origin))
21753 if (!is_fortran () && !is_ada ())
21755 /* The individual enumerators of an enum type get output when we output
21756 the Dwarf representation of the relevant enum type itself. */
21760 /* Emit its type. */
21761 gen_type_die (TREE_TYPE (decl), context_die);
21763 /* And its containing namespace. */
21764 context_die = declare_in_namespace (decl, context_die);
21766 gen_const_die (decl, context_die);
21769 case FUNCTION_DECL:
21770 /* Don't output any DIEs to represent mere function declarations,
21771 unless they are class members or explicit block externs. */
21772 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
21773 && DECL_FILE_SCOPE_P (decl_or_origin)
21774 && (current_function_decl == NULL_TREE
21775 || DECL_ARTIFICIAL (decl_or_origin)))
21780 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
21781 on local redeclarations of global functions. That seems broken. */
21782 if (current_function_decl != decl)
21783 /* This is only a declaration. */;
21786 /* If we're emitting a clone, emit info for the abstract instance. */
21787 if (origin || DECL_ORIGIN (decl) != decl)
21788 dwarf2out_abstract_function (origin
21789 ? DECL_ORIGIN (origin)
21790 : DECL_ABSTRACT_ORIGIN (decl));
21792 /* If we're emitting an out-of-line copy of an inline function,
21793 emit info for the abstract instance and set up to refer to it. */
21794 else if (cgraph_function_possibly_inlined_p (decl)
21795 && ! DECL_ABSTRACT (decl)
21796 && ! class_or_namespace_scope_p (context_die)
21797 /* dwarf2out_abstract_function won't emit a die if this is just
21798 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
21799 that case, because that works only if we have a die. */
21800 && DECL_INITIAL (decl) != NULL_TREE)
21802 dwarf2out_abstract_function (decl);
21803 set_decl_origin_self (decl);
21806 /* Otherwise we're emitting the primary DIE for this decl. */
21807 else if (debug_info_level > DINFO_LEVEL_TERSE)
21809 /* Before we describe the FUNCTION_DECL itself, make sure that we
21810 have its containing type. */
21812 origin = decl_class_context (decl);
21813 if (origin != NULL_TREE)
21814 gen_type_die (origin, context_die);
21816 /* And its return type. */
21817 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
21819 /* And its virtual context. */
21820 if (DECL_VINDEX (decl) != NULL_TREE)
21821 gen_type_die (DECL_CONTEXT (decl), context_die);
21823 /* Make sure we have a member DIE for decl. */
21824 if (origin != NULL_TREE)
21825 gen_type_die_for_member (origin, decl, context_die);
21827 /* And its containing namespace. */
21828 context_die = declare_in_namespace (decl, context_die);
21831 /* Now output a DIE to represent the function itself. */
21833 gen_subprogram_die (decl, context_die);
21837 /* If we are in terse mode, don't generate any DIEs to represent any
21838 actual typedefs. */
21839 if (debug_info_level <= DINFO_LEVEL_TERSE)
21842 /* In the special case of a TYPE_DECL node representing the declaration
21843 of some type tag, if the given TYPE_DECL is marked as having been
21844 instantiated from some other (original) TYPE_DECL node (e.g. one which
21845 was generated within the original definition of an inline function) we
21846 used to generate a special (abbreviated) DW_TAG_structure_type,
21847 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
21848 should be actually referencing those DIEs, as variable DIEs with that
21849 type would be emitted already in the abstract origin, so it was always
21850 removed during unused type prunning. Don't add anything in this
21852 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
21855 if (is_redundant_typedef (decl))
21856 gen_type_die (TREE_TYPE (decl), context_die);
21858 /* Output a DIE to represent the typedef itself. */
21859 gen_typedef_die (decl, context_die);
21863 if (debug_info_level >= DINFO_LEVEL_NORMAL)
21864 gen_label_die (decl, context_die);
21869 /* If we are in terse mode, don't generate any DIEs to represent any
21870 variable declarations or definitions. */
21871 if (debug_info_level <= DINFO_LEVEL_TERSE)
21874 /* Output any DIEs that are needed to specify the type of this data
21876 if (decl_by_reference_p (decl_or_origin))
21877 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
21879 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
21881 /* And its containing type. */
21882 class_origin = decl_class_context (decl_or_origin);
21883 if (class_origin != NULL_TREE)
21884 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
21886 /* And its containing namespace. */
21887 context_die = declare_in_namespace (decl_or_origin, context_die);
21889 /* Now output the DIE to represent the data object itself. This gets
21890 complicated because of the possibility that the VAR_DECL really
21891 represents an inlined instance of a formal parameter for an inline
21893 ultimate_origin = decl_ultimate_origin (decl_or_origin);
21894 if (ultimate_origin != NULL_TREE
21895 && TREE_CODE (ultimate_origin) == PARM_DECL)
21896 gen_formal_parameter_die (decl, origin,
21897 true /* Emit name attribute. */,
21900 gen_variable_die (decl, origin, context_die);
21904 /* Ignore the nameless fields that are used to skip bits but handle C++
21905 anonymous unions and structs. */
21906 if (DECL_NAME (decl) != NULL_TREE
21907 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
21908 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
21910 gen_type_die (member_declared_type (decl), context_die);
21911 gen_field_die (decl, context_die);
21916 if (DECL_BY_REFERENCE (decl_or_origin))
21917 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
21919 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
21920 return gen_formal_parameter_die (decl, origin,
21921 true /* Emit name attribute. */,
21924 case NAMESPACE_DECL:
21925 case IMPORTED_DECL:
21926 if (dwarf_version >= 3 || !dwarf_strict)
21927 gen_namespace_die (decl, context_die);
21931 /* Probably some frontend-internal decl. Assume we don't care. */
21932 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
21939 /* Output debug information for global decl DECL. Called from toplev.c after
21940 compilation proper has finished. */
21943 dwarf2out_global_decl (tree decl)
21945 /* Output DWARF2 information for file-scope tentative data object
21946 declarations, file-scope (extern) function declarations (which
21947 had no corresponding body) and file-scope tagged type declarations
21948 and definitions which have not yet been forced out. */
21949 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
21950 dwarf2out_decl (decl);
21953 /* Output debug information for type decl DECL. Called from toplev.c
21954 and from language front ends (to record built-in types). */
21956 dwarf2out_type_decl (tree decl, int local)
21959 dwarf2out_decl (decl);
21962 /* Output debug information for imported module or decl DECL.
21963 NAME is non-NULL name in the lexical block if the decl has been renamed.
21964 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
21965 that DECL belongs to.
21966 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
21968 dwarf2out_imported_module_or_decl_1 (tree decl,
21970 tree lexical_block,
21971 dw_die_ref lexical_block_die)
21973 expanded_location xloc;
21974 dw_die_ref imported_die = NULL;
21975 dw_die_ref at_import_die;
21977 if (TREE_CODE (decl) == IMPORTED_DECL)
21979 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
21980 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
21984 xloc = expand_location (input_location);
21986 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
21988 at_import_die = force_type_die (TREE_TYPE (decl));
21989 /* For namespace N { typedef void T; } using N::T; base_type_die
21990 returns NULL, but DW_TAG_imported_declaration requires
21991 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
21992 if (!at_import_die)
21994 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
21995 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
21996 at_import_die = lookup_type_die (TREE_TYPE (decl));
21997 gcc_assert (at_import_die);
22002 at_import_die = lookup_decl_die (decl);
22003 if (!at_import_die)
22005 /* If we're trying to avoid duplicate debug info, we may not have
22006 emitted the member decl for this field. Emit it now. */
22007 if (TREE_CODE (decl) == FIELD_DECL)
22009 tree type = DECL_CONTEXT (decl);
22011 if (TYPE_CONTEXT (type)
22012 && TYPE_P (TYPE_CONTEXT (type))
22013 && !should_emit_struct_debug (TYPE_CONTEXT (type),
22014 DINFO_USAGE_DIR_USE))
22016 gen_type_die_for_member (type, decl,
22017 get_context_die (TYPE_CONTEXT (type)));
22019 at_import_die = force_decl_die (decl);
22023 if (TREE_CODE (decl) == NAMESPACE_DECL)
22025 if (dwarf_version >= 3 || !dwarf_strict)
22026 imported_die = new_die (DW_TAG_imported_module,
22033 imported_die = new_die (DW_TAG_imported_declaration,
22037 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
22038 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
22040 add_AT_string (imported_die, DW_AT_name,
22041 IDENTIFIER_POINTER (name));
22042 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
22045 /* Output debug information for imported module or decl DECL.
22046 NAME is non-NULL name in context if the decl has been renamed.
22047 CHILD is true if decl is one of the renamed decls as part of
22048 importing whole module. */
22051 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
22054 /* dw_die_ref at_import_die; */
22055 dw_die_ref scope_die;
22057 if (debug_info_level <= DINFO_LEVEL_TERSE)
22062 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
22063 We need decl DIE for reference and scope die. First, get DIE for the decl
22066 /* Get the scope die for decl context. Use comp_unit_die for global module
22067 or decl. If die is not found for non globals, force new die. */
22069 && TYPE_P (context)
22070 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
22073 if (!(dwarf_version >= 3 || !dwarf_strict))
22076 scope_die = get_context_die (context);
22080 gcc_assert (scope_die->die_child);
22081 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
22082 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
22083 scope_die = scope_die->die_child;
22086 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
22087 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
22091 /* Write the debugging output for DECL. */
22094 dwarf2out_decl (tree decl)
22096 dw_die_ref context_die = comp_unit_die ();
22098 switch (TREE_CODE (decl))
22103 case FUNCTION_DECL:
22104 /* What we would really like to do here is to filter out all mere
22105 file-scope declarations of file-scope functions which are never
22106 referenced later within this translation unit (and keep all of ones
22107 that *are* referenced later on) but we aren't clairvoyant, so we have
22108 no idea which functions will be referenced in the future (i.e. later
22109 on within the current translation unit). So here we just ignore all
22110 file-scope function declarations which are not also definitions. If
22111 and when the debugger needs to know something about these functions,
22112 it will have to hunt around and find the DWARF information associated
22113 with the definition of the function.
22115 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
22116 nodes represent definitions and which ones represent mere
22117 declarations. We have to check DECL_INITIAL instead. That's because
22118 the C front-end supports some weird semantics for "extern inline"
22119 function definitions. These can get inlined within the current
22120 translation unit (and thus, we need to generate Dwarf info for their
22121 abstract instances so that the Dwarf info for the concrete inlined
22122 instances can have something to refer to) but the compiler never
22123 generates any out-of-lines instances of such things (despite the fact
22124 that they *are* definitions).
22126 The important point is that the C front-end marks these "extern
22127 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
22128 them anyway. Note that the C++ front-end also plays some similar games
22129 for inline function definitions appearing within include files which
22130 also contain `#pragma interface' pragmas. */
22131 if (DECL_INITIAL (decl) == NULL_TREE)
22134 /* If we're a nested function, initially use a parent of NULL; if we're
22135 a plain function, this will be fixed up in decls_for_scope. If
22136 we're a method, it will be ignored, since we already have a DIE. */
22137 if (decl_function_context (decl)
22138 /* But if we're in terse mode, we don't care about scope. */
22139 && debug_info_level > DINFO_LEVEL_TERSE)
22140 context_die = NULL;
22144 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
22145 declaration and if the declaration was never even referenced from
22146 within this entire compilation unit. We suppress these DIEs in
22147 order to save space in the .debug section (by eliminating entries
22148 which are probably useless). Note that we must not suppress
22149 block-local extern declarations (whether used or not) because that
22150 would screw-up the debugger's name lookup mechanism and cause it to
22151 miss things which really ought to be in scope at a given point. */
22152 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
22155 /* For local statics lookup proper context die. */
22156 if (TREE_STATIC (decl) && decl_function_context (decl))
22157 context_die = lookup_decl_die (DECL_CONTEXT (decl));
22159 /* If we are in terse mode, don't generate any DIEs to represent any
22160 variable declarations or definitions. */
22161 if (debug_info_level <= DINFO_LEVEL_TERSE)
22166 if (debug_info_level <= DINFO_LEVEL_TERSE)
22168 if (!is_fortran () && !is_ada ())
22170 if (TREE_STATIC (decl) && decl_function_context (decl))
22171 context_die = lookup_decl_die (DECL_CONTEXT (decl));
22174 case NAMESPACE_DECL:
22175 case IMPORTED_DECL:
22176 if (debug_info_level <= DINFO_LEVEL_TERSE)
22178 if (lookup_decl_die (decl) != NULL)
22183 /* Don't emit stubs for types unless they are needed by other DIEs. */
22184 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
22187 /* Don't bother trying to generate any DIEs to represent any of the
22188 normal built-in types for the language we are compiling. */
22189 if (DECL_IS_BUILTIN (decl))
22192 /* If we are in terse mode, don't generate any DIEs for types. */
22193 if (debug_info_level <= DINFO_LEVEL_TERSE)
22196 /* If we're a function-scope tag, initially use a parent of NULL;
22197 this will be fixed up in decls_for_scope. */
22198 if (decl_function_context (decl))
22199 context_die = NULL;
22207 gen_decl_die (decl, NULL, context_die);
22210 /* Write the debugging output for DECL. */
22213 dwarf2out_function_decl (tree decl)
22215 dwarf2out_decl (decl);
22216 call_arg_locations = NULL;
22217 call_arg_loc_last = NULL;
22218 call_site_count = -1;
22219 tail_call_site_count = -1;
22220 VEC_free (dw_die_ref, heap, block_map);
22221 htab_empty (decl_loc_table);
22222 htab_empty (cached_dw_loc_list_table);
22225 /* Output a marker (i.e. a label) for the beginning of the generated code for
22226 a lexical block. */
22229 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
22230 unsigned int blocknum)
22232 switch_to_section (current_function_section ());
22233 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
22236 /* Output a marker (i.e. a label) for the end of the generated code for a
22240 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
22242 switch_to_section (current_function_section ());
22243 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
22246 /* Returns nonzero if it is appropriate not to emit any debugging
22247 information for BLOCK, because it doesn't contain any instructions.
22249 Don't allow this for blocks with nested functions or local classes
22250 as we would end up with orphans, and in the presence of scheduling
22251 we may end up calling them anyway. */
22254 dwarf2out_ignore_block (const_tree block)
22259 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
22260 if (TREE_CODE (decl) == FUNCTION_DECL
22261 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
22263 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
22265 decl = BLOCK_NONLOCALIZED_VAR (block, i);
22266 if (TREE_CODE (decl) == FUNCTION_DECL
22267 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
22274 /* Hash table routines for file_hash. */
22277 file_table_eq (const void *p1_p, const void *p2_p)
22279 const struct dwarf_file_data *const p1 =
22280 (const struct dwarf_file_data *) p1_p;
22281 const char *const p2 = (const char *) p2_p;
22282 return filename_cmp (p1->filename, p2) == 0;
22286 file_table_hash (const void *p_p)
22288 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
22289 return htab_hash_string (p->filename);
22292 /* Lookup FILE_NAME (in the list of filenames that we know about here in
22293 dwarf2out.c) and return its "index". The index of each (known) filename is
22294 just a unique number which is associated with only that one filename. We
22295 need such numbers for the sake of generating labels (in the .debug_sfnames
22296 section) and references to those files numbers (in the .debug_srcinfo
22297 and.debug_macinfo sections). If the filename given as an argument is not
22298 found in our current list, add it to the list and assign it the next
22299 available unique index number. In order to speed up searches, we remember
22300 the index of the filename was looked up last. This handles the majority of
22303 static struct dwarf_file_data *
22304 lookup_filename (const char *file_name)
22307 struct dwarf_file_data * created;
22309 /* Check to see if the file name that was searched on the previous
22310 call matches this file name. If so, return the index. */
22311 if (file_table_last_lookup
22312 && (file_name == file_table_last_lookup->filename
22313 || filename_cmp (file_table_last_lookup->filename, file_name) == 0))
22314 return file_table_last_lookup;
22316 /* Didn't match the previous lookup, search the table. */
22317 slot = htab_find_slot_with_hash (file_table, file_name,
22318 htab_hash_string (file_name), INSERT);
22320 return (struct dwarf_file_data *) *slot;
22322 created = ggc_alloc_dwarf_file_data ();
22323 created->filename = file_name;
22324 created->emitted_number = 0;
22329 /* If the assembler will construct the file table, then translate the compiler
22330 internal file table number into the assembler file table number, and emit
22331 a .file directive if we haven't already emitted one yet. The file table
22332 numbers are different because we prune debug info for unused variables and
22333 types, which may include filenames. */
22336 maybe_emit_file (struct dwarf_file_data * fd)
22338 if (! fd->emitted_number)
22340 if (last_emitted_file)
22341 fd->emitted_number = last_emitted_file->emitted_number + 1;
22343 fd->emitted_number = 1;
22344 last_emitted_file = fd;
22346 if (DWARF2_ASM_LINE_DEBUG_INFO)
22348 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
22349 output_quoted_string (asm_out_file,
22350 remap_debug_filename (fd->filename));
22351 fputc ('\n', asm_out_file);
22355 return fd->emitted_number;
22358 /* Schedule generation of a DW_AT_const_value attribute to DIE.
22359 That generation should happen after function debug info has been
22360 generated. The value of the attribute is the constant value of ARG. */
22363 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
22365 die_arg_entry entry;
22370 if (!tmpl_value_parm_die_table)
22371 tmpl_value_parm_die_table
22372 = VEC_alloc (die_arg_entry, gc, 32);
22376 VEC_safe_push (die_arg_entry, gc,
22377 tmpl_value_parm_die_table,
22381 /* Return TRUE if T is an instance of generic type, FALSE
22385 generic_type_p (tree t)
22387 if (t == NULL_TREE || !TYPE_P (t))
22389 return lang_hooks.get_innermost_generic_parms (t) != NULL_TREE;
22392 /* Schedule the generation of the generic parameter dies for the
22393 instance of generic type T. The proper generation itself is later
22394 done by gen_scheduled_generic_parms_dies. */
22397 schedule_generic_params_dies_gen (tree t)
22399 if (!generic_type_p (t))
22402 if (generic_type_instances == NULL)
22403 generic_type_instances = VEC_alloc (tree, gc, 256);
22405 VEC_safe_push (tree, gc, generic_type_instances, t);
22408 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
22409 by append_entry_to_tmpl_value_parm_die_table. This function must
22410 be called after function DIEs have been generated. */
22413 gen_remaining_tmpl_value_param_die_attribute (void)
22415 if (tmpl_value_parm_die_table)
22420 FOR_EACH_VEC_ELT (die_arg_entry, tmpl_value_parm_die_table, i, e)
22421 tree_add_const_value_attribute (e->die, e->arg);
22425 /* Generate generic parameters DIEs for instances of generic types
22426 that have been previously scheduled by
22427 schedule_generic_params_dies_gen. This function must be called
22428 after all the types of the CU have been laid out. */
22431 gen_scheduled_generic_parms_dies (void)
22436 if (generic_type_instances == NULL)
22439 FOR_EACH_VEC_ELT (tree, generic_type_instances, i, t)
22440 gen_generic_params_dies (t);
22444 /* Replace DW_AT_name for the decl with name. */
22447 dwarf2out_set_name (tree decl, tree name)
22453 die = TYPE_SYMTAB_DIE (decl);
22457 dname = dwarf2_name (name, 0);
22461 attr = get_AT (die, DW_AT_name);
22464 struct indirect_string_node *node;
22466 node = find_AT_string (dname);
22467 /* replace the string. */
22468 attr->dw_attr_val.v.val_str = node;
22472 add_name_attribute (die, dname);
22475 /* Called by the final INSN scan whenever we see a var location. We
22476 use it to drop labels in the right places, and throw the location in
22477 our lookup table. */
22480 dwarf2out_var_location (rtx loc_note)
22482 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
22483 struct var_loc_node *newloc;
22485 static const char *last_label;
22486 static const char *last_postcall_label;
22487 static bool last_in_cold_section_p;
22491 if (!NOTE_P (loc_note))
22493 if (CALL_P (loc_note))
22496 if (SIBLING_CALL_P (loc_note))
22497 tail_call_site_count++;
22502 var_loc_p = NOTE_KIND (loc_note) == NOTE_INSN_VAR_LOCATION;
22503 if (var_loc_p && !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
22506 next_real = next_real_insn (loc_note);
22508 /* If there are no instructions which would be affected by this note,
22509 don't do anything. */
22511 && next_real == NULL_RTX
22512 && !NOTE_DURING_CALL_P (loc_note))
22515 if (next_real == NULL_RTX)
22516 next_real = get_last_insn ();
22518 /* If there were any real insns between note we processed last time
22519 and this note (or if it is the first note), clear
22520 last_{,postcall_}label so that they are not reused this time. */
22521 if (last_var_location_insn == NULL_RTX
22522 || last_var_location_insn != next_real
22523 || last_in_cold_section_p != in_cold_section_p)
22526 last_postcall_label = NULL;
22531 decl = NOTE_VAR_LOCATION_DECL (loc_note);
22532 newloc = add_var_loc_to_decl (decl, loc_note,
22533 NOTE_DURING_CALL_P (loc_note)
22534 ? last_postcall_label : last_label);
22535 if (newloc == NULL)
22544 /* If there were no real insns between note we processed last time
22545 and this note, use the label we emitted last time. Otherwise
22546 create a new label and emit it. */
22547 if (last_label == NULL)
22549 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
22550 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
22552 last_label = ggc_strdup (loclabel);
22557 struct call_arg_loc_node *ca_loc
22558 = ggc_alloc_cleared_call_arg_loc_node ();
22559 rtx prev = prev_real_insn (loc_note), x;
22560 ca_loc->call_arg_loc_note = loc_note;
22561 ca_loc->next = NULL;
22562 ca_loc->label = last_label;
22565 || (NONJUMP_INSN_P (prev)
22566 && GET_CODE (PATTERN (prev)) == SEQUENCE
22567 && CALL_P (XVECEXP (PATTERN (prev), 0, 0)))));
22568 if (!CALL_P (prev))
22569 prev = XVECEXP (PATTERN (prev), 0, 0);
22570 ca_loc->tail_call_p = SIBLING_CALL_P (prev);
22571 x = PATTERN (prev);
22572 if (GET_CODE (x) == PARALLEL)
22573 x = XVECEXP (x, 0, 0);
22574 if (GET_CODE (x) == SET)
22576 if (GET_CODE (x) == CALL && MEM_P (XEXP (x, 0)))
22578 x = XEXP (XEXP (x, 0), 0);
22579 if (GET_CODE (x) == SYMBOL_REF
22580 && SYMBOL_REF_DECL (x)
22581 && TREE_CODE (SYMBOL_REF_DECL (x)) == FUNCTION_DECL)
22582 ca_loc->symbol_ref = x;
22584 ca_loc->block = insn_scope (prev);
22585 if (call_arg_locations)
22586 call_arg_loc_last->next = ca_loc;
22588 call_arg_locations = ca_loc;
22589 call_arg_loc_last = ca_loc;
22591 else if (!NOTE_DURING_CALL_P (loc_note))
22592 newloc->label = last_label;
22595 if (!last_postcall_label)
22597 sprintf (loclabel, "%s-1", last_label);
22598 last_postcall_label = ggc_strdup (loclabel);
22600 newloc->label = last_postcall_label;
22603 last_var_location_insn = next_real;
22604 last_in_cold_section_p = in_cold_section_p;
22607 /* Note in one location list that text section has changed. */
22610 var_location_switch_text_section_1 (void **slot, void *data ATTRIBUTE_UNUSED)
22612 var_loc_list *list = (var_loc_list *) *slot;
22614 list->last_before_switch
22615 = list->last->next ? list->last->next : list->last;
22619 /* Note in all location lists that text section has changed. */
22622 var_location_switch_text_section (void)
22624 if (decl_loc_table == NULL)
22627 htab_traverse (decl_loc_table, var_location_switch_text_section_1, NULL);
22630 /* Create a new line number table. */
22632 static dw_line_info_table *
22633 new_line_info_table (void)
22635 dw_line_info_table *table;
22637 table = ggc_alloc_cleared_dw_line_info_table_struct ();
22638 table->file_num = 1;
22639 table->line_num = 1;
22640 table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
22645 /* Lookup the "current" table into which we emit line info, so
22646 that we don't have to do it for every source line. */
22649 set_cur_line_info_table (section *sec)
22651 dw_line_info_table *table;
22653 if (sec == text_section)
22654 table = text_section_line_info;
22655 else if (sec == cold_text_section)
22657 table = cold_text_section_line_info;
22660 cold_text_section_line_info = table = new_line_info_table ();
22661 table->end_label = cold_end_label;
22666 const char *end_label;
22668 if (flag_reorder_blocks_and_partition)
22670 if (in_cold_section_p)
22671 end_label = crtl->subsections.cold_section_end_label;
22673 end_label = crtl->subsections.hot_section_end_label;
22677 char label[MAX_ARTIFICIAL_LABEL_BYTES];
22678 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
22679 current_function_funcdef_no);
22680 end_label = ggc_strdup (label);
22683 table = new_line_info_table ();
22684 table->end_label = end_label;
22686 VEC_safe_push (dw_line_info_table_p, gc, separate_line_info, table);
22689 cur_line_info_table = table;
22693 /* We need to reset the locations at the beginning of each
22694 function. We can't do this in the end_function hook, because the
22695 declarations that use the locations won't have been output when
22696 that hook is called. Also compute have_multiple_function_sections here. */
22699 dwarf2out_begin_function (tree fun)
22701 section *sec = function_section (fun);
22703 if (sec != text_section)
22704 have_multiple_function_sections = true;
22706 if (flag_reorder_blocks_and_partition && !cold_text_section)
22708 gcc_assert (current_function_decl == fun);
22709 cold_text_section = unlikely_text_section ();
22710 switch_to_section (cold_text_section);
22711 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
22712 switch_to_section (sec);
22715 dwarf2out_note_section_used ();
22716 call_site_count = 0;
22717 tail_call_site_count = 0;
22719 set_cur_line_info_table (sec);
22722 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
22725 push_dw_line_info_entry (dw_line_info_table *table,
22726 enum dw_line_info_opcode opcode, unsigned int val)
22728 dw_line_info_entry e;
22731 VEC_safe_push (dw_line_info_entry, gc, table->entries, &e);
22734 /* Output a label to mark the beginning of a source code line entry
22735 and record information relating to this source line, in
22736 'line_info_table' for later output of the .debug_line section. */
22737 /* ??? The discriminator parameter ought to be unsigned. */
22740 dwarf2out_source_line (unsigned int line, const char *filename,
22741 int discriminator, bool is_stmt)
22743 unsigned int file_num;
22744 dw_line_info_table *table;
22746 if (debug_info_level < DINFO_LEVEL_NORMAL || line == 0)
22749 /* The discriminator column was added in dwarf4. Simplify the below
22750 by simply removing it if we're not supposed to output it. */
22751 if (dwarf_version < 4 && dwarf_strict)
22754 table = cur_line_info_table;
22755 file_num = maybe_emit_file (lookup_filename (filename));
22757 /* ??? TODO: Elide duplicate line number entries. Traditionally,
22758 the debugger has used the second (possibly duplicate) line number
22759 at the beginning of the function to mark the end of the prologue.
22760 We could eliminate any other duplicates within the function. For
22761 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
22762 that second line number entry. */
22763 /* Recall that this end-of-prologue indication is *not* the same thing
22764 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
22765 to which the hook corresponds, follows the last insn that was
22766 emitted by gen_prologue. What we need is to preceed the first insn
22767 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
22768 insn that corresponds to something the user wrote. These may be
22769 very different locations once scheduling is enabled. */
22771 if (0 && file_num == table->file_num
22772 && line == table->line_num
22773 && discriminator == table->discrim_num
22774 && is_stmt == table->is_stmt)
22777 switch_to_section (current_function_section ());
22779 /* If requested, emit something human-readable. */
22780 if (flag_debug_asm)
22781 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line);
22783 if (DWARF2_ASM_LINE_DEBUG_INFO)
22785 /* Emit the .loc directive understood by GNU as. */
22786 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
22787 if (is_stmt != table->is_stmt)
22788 fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
22789 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
22790 fprintf (asm_out_file, " discriminator %d", discriminator);
22791 fputc ('\n', asm_out_file);
22795 unsigned int label_num = ++line_info_label_num;
22797 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num);
22799 push_dw_line_info_entry (table, LI_set_address, label_num);
22800 if (file_num != table->file_num)
22801 push_dw_line_info_entry (table, LI_set_file, file_num);
22802 if (discriminator != table->discrim_num)
22803 push_dw_line_info_entry (table, LI_set_discriminator, discriminator);
22804 if (is_stmt != table->is_stmt)
22805 push_dw_line_info_entry (table, LI_negate_stmt, 0);
22806 push_dw_line_info_entry (table, LI_set_line, line);
22809 table->file_num = file_num;
22810 table->line_num = line;
22811 table->discrim_num = discriminator;
22812 table->is_stmt = is_stmt;
22813 table->in_use = true;
22816 /* Record the beginning of a new source file. */
22819 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
22821 if (flag_eliminate_dwarf2_dups && ! use_debug_types)
22823 /* Record the beginning of the file for break_out_includes. */
22824 dw_die_ref bincl_die;
22826 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die (), NULL);
22827 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
22830 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22833 e.code = DW_MACINFO_start_file;
22835 e.info = xstrdup (filename);
22836 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
22840 /* Record the end of a source file. */
22843 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
22845 if (flag_eliminate_dwarf2_dups && ! use_debug_types)
22846 /* Record the end of the file for break_out_includes. */
22847 new_die (DW_TAG_GNU_EINCL, comp_unit_die (), NULL);
22849 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22852 e.code = DW_MACINFO_end_file;
22855 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
22859 /* Called from debug_define in toplev.c. The `buffer' parameter contains
22860 the tail part of the directive line, i.e. the part which is past the
22861 initial whitespace, #, whitespace, directive-name, whitespace part. */
22864 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
22865 const char *buffer ATTRIBUTE_UNUSED)
22867 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22870 e.code = DW_MACINFO_define;
22872 e.info = xstrdup (buffer);;
22873 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
22877 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
22878 the tail part of the directive line, i.e. the part which is past the
22879 initial whitespace, #, whitespace, directive-name, whitespace part. */
22882 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
22883 const char *buffer ATTRIBUTE_UNUSED)
22885 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22888 e.code = DW_MACINFO_undef;
22890 e.info = xstrdup (buffer);;
22891 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
22896 output_macinfo (void)
22899 unsigned long length = VEC_length (macinfo_entry, macinfo_table);
22900 macinfo_entry *ref;
22905 for (i = 0; VEC_iterate (macinfo_entry, macinfo_table, i, ref); i++)
22909 case DW_MACINFO_start_file:
22911 int file_num = maybe_emit_file (lookup_filename (ref->info));
22912 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
22913 dw2_asm_output_data_uleb128
22914 (ref->lineno, "Included from line number %lu",
22915 (unsigned long)ref->lineno);
22916 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info);
22919 case DW_MACINFO_end_file:
22920 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
22922 case DW_MACINFO_define:
22923 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
22924 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22925 (unsigned long)ref->lineno);
22926 dw2_asm_output_nstring (ref->info, -1, "The macro");
22928 case DW_MACINFO_undef:
22929 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
22930 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
22931 (unsigned long)ref->lineno);
22932 dw2_asm_output_nstring (ref->info, -1, "The macro");
22935 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n",
22936 ASM_COMMENT_START, (unsigned long)ref->code);
22942 /* Set up for Dwarf output at the start of compilation. */
22945 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
22947 /* Allocate the file_table. */
22948 file_table = htab_create_ggc (50, file_table_hash,
22949 file_table_eq, NULL);
22951 /* Allocate the decl_die_table. */
22952 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
22953 decl_die_table_eq, NULL);
22955 /* Allocate the decl_loc_table. */
22956 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
22957 decl_loc_table_eq, NULL);
22959 /* Allocate the cached_dw_loc_list_table. */
22960 cached_dw_loc_list_table
22961 = htab_create_ggc (10, cached_dw_loc_list_table_hash,
22962 cached_dw_loc_list_table_eq, NULL);
22964 /* Allocate the initial hunk of the decl_scope_table. */
22965 decl_scope_table = VEC_alloc (tree, gc, 256);
22967 /* Allocate the initial hunk of the abbrev_die_table. */
22968 abbrev_die_table = ggc_alloc_cleared_vec_dw_die_ref
22969 (ABBREV_DIE_TABLE_INCREMENT);
22970 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
22971 /* Zero-th entry is allocated, but unused. */
22972 abbrev_die_table_in_use = 1;
22974 /* Allocate the pubtypes and pubnames vectors. */
22975 pubname_table = VEC_alloc (pubname_entry, gc, 32);
22976 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
22978 incomplete_types = VEC_alloc (tree, gc, 64);
22980 used_rtx_array = VEC_alloc (rtx, gc, 32);
22982 debug_info_section = get_section (DEBUG_INFO_SECTION,
22983 SECTION_DEBUG, NULL);
22984 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
22985 SECTION_DEBUG, NULL);
22986 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
22987 SECTION_DEBUG, NULL);
22988 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
22989 SECTION_DEBUG, NULL);
22990 debug_line_section = get_section (DEBUG_LINE_SECTION,
22991 SECTION_DEBUG, NULL);
22992 debug_loc_section = get_section (DEBUG_LOC_SECTION,
22993 SECTION_DEBUG, NULL);
22994 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
22995 SECTION_DEBUG, NULL);
22996 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
22997 SECTION_DEBUG, NULL);
22998 debug_str_section = get_section (DEBUG_STR_SECTION,
22999 DEBUG_STR_SECTION_FLAGS, NULL);
23000 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
23001 SECTION_DEBUG, NULL);
23002 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
23003 SECTION_DEBUG, NULL);
23005 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
23006 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
23007 DEBUG_ABBREV_SECTION_LABEL, 0);
23008 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
23009 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
23010 COLD_TEXT_SECTION_LABEL, 0);
23011 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
23013 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
23014 DEBUG_INFO_SECTION_LABEL, 0);
23015 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
23016 DEBUG_LINE_SECTION_LABEL, 0);
23017 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
23018 DEBUG_RANGES_SECTION_LABEL, 0);
23019 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
23020 DEBUG_MACINFO_SECTION_LABEL, 0);
23022 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
23023 macinfo_table = VEC_alloc (macinfo_entry, gc, 64);
23025 switch_to_section (text_section);
23026 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
23028 /* Make sure the line number table for .text always exists. */
23029 text_section_line_info = new_line_info_table ();
23030 text_section_line_info->end_label = text_end_label;
23033 /* Called before cgraph_optimize starts outputtting functions, variables
23034 and toplevel asms into assembly. */
23037 dwarf2out_assembly_start (void)
23039 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
23040 && dwarf2out_do_cfi_asm ()
23041 && (!(flag_unwind_tables || flag_exceptions)
23042 || targetm.except_unwind_info (&global_options) != UI_DWARF2))
23043 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
23046 /* A helper function for dwarf2out_finish called through
23047 htab_traverse. Emit one queued .debug_str string. */
23050 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
23052 struct indirect_string_node *node = (struct indirect_string_node *) *h;
23054 if (node->form == DW_FORM_strp)
23056 switch_to_section (debug_str_section);
23057 ASM_OUTPUT_LABEL (asm_out_file, node->label);
23058 assemble_string (node->str, strlen (node->str) + 1);
23064 #if ENABLE_ASSERT_CHECKING
23065 /* Verify that all marks are clear. */
23068 verify_marks_clear (dw_die_ref die)
23072 gcc_assert (! die->die_mark);
23073 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
23075 #endif /* ENABLE_ASSERT_CHECKING */
23077 /* Clear the marks for a die and its children.
23078 Be cool if the mark isn't set. */
23081 prune_unmark_dies (dw_die_ref die)
23087 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
23090 /* Given DIE that we're marking as used, find any other dies
23091 it references as attributes and mark them as used. */
23094 prune_unused_types_walk_attribs (dw_die_ref die)
23099 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
23101 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
23103 /* A reference to another DIE.
23104 Make sure that it will get emitted.
23105 If it was broken out into a comdat group, don't follow it. */
23106 if (! use_debug_types
23107 || a->dw_attr == DW_AT_specification
23108 || a->dw_attr_val.v.val_die_ref.die->die_id.die_type_node == NULL)
23109 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
23111 /* Set the string's refcount to 0 so that prune_unused_types_mark
23112 accounts properly for it. */
23113 if (AT_class (a) == dw_val_class_str)
23114 a->dw_attr_val.v.val_str->refcount = 0;
23118 /* Mark the generic parameters and arguments children DIEs of DIE. */
23121 prune_unused_types_mark_generic_parms_dies (dw_die_ref die)
23125 if (die == NULL || die->die_child == NULL)
23127 c = die->die_child;
23130 switch (c->die_tag)
23132 case DW_TAG_template_type_param:
23133 case DW_TAG_template_value_param:
23134 case DW_TAG_GNU_template_template_param:
23135 case DW_TAG_GNU_template_parameter_pack:
23136 prune_unused_types_mark (c, 1);
23142 } while (c && c != die->die_child);
23145 /* Mark DIE as being used. If DOKIDS is true, then walk down
23146 to DIE's children. */
23149 prune_unused_types_mark (dw_die_ref die, int dokids)
23153 if (die->die_mark == 0)
23155 /* We haven't done this node yet. Mark it as used. */
23157 /* If this is the DIE of a generic type instantiation,
23158 mark the children DIEs that describe its generic parms and
23160 prune_unused_types_mark_generic_parms_dies (die);
23162 /* We also have to mark its parents as used.
23163 (But we don't want to mark our parents' kids due to this.) */
23164 if (die->die_parent)
23165 prune_unused_types_mark (die->die_parent, 0);
23167 /* Mark any referenced nodes. */
23168 prune_unused_types_walk_attribs (die);
23170 /* If this node is a specification,
23171 also mark the definition, if it exists. */
23172 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
23173 prune_unused_types_mark (die->die_definition, 1);
23176 if (dokids && die->die_mark != 2)
23178 /* We need to walk the children, but haven't done so yet.
23179 Remember that we've walked the kids. */
23182 /* If this is an array type, we need to make sure our
23183 kids get marked, even if they're types. If we're
23184 breaking out types into comdat sections, do this
23185 for all type definitions. */
23186 if (die->die_tag == DW_TAG_array_type
23187 || (use_debug_types
23188 && is_type_die (die) && ! is_declaration_die (die)))
23189 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
23191 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23195 /* For local classes, look if any static member functions were emitted
23196 and if so, mark them. */
23199 prune_unused_types_walk_local_classes (dw_die_ref die)
23203 if (die->die_mark == 2)
23206 switch (die->die_tag)
23208 case DW_TAG_structure_type:
23209 case DW_TAG_union_type:
23210 case DW_TAG_class_type:
23213 case DW_TAG_subprogram:
23214 if (!get_AT_flag (die, DW_AT_declaration)
23215 || die->die_definition != NULL)
23216 prune_unused_types_mark (die, 1);
23223 /* Mark children. */
23224 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
23227 /* Walk the tree DIE and mark types that we actually use. */
23230 prune_unused_types_walk (dw_die_ref die)
23234 /* Don't do anything if this node is already marked and
23235 children have been marked as well. */
23236 if (die->die_mark == 2)
23239 switch (die->die_tag)
23241 case DW_TAG_structure_type:
23242 case DW_TAG_union_type:
23243 case DW_TAG_class_type:
23244 if (die->die_perennial_p)
23247 for (c = die->die_parent; c; c = c->die_parent)
23248 if (c->die_tag == DW_TAG_subprogram)
23251 /* Finding used static member functions inside of classes
23252 is needed just for local classes, because for other classes
23253 static member function DIEs with DW_AT_specification
23254 are emitted outside of the DW_TAG_*_type. If we ever change
23255 it, we'd need to call this even for non-local classes. */
23257 prune_unused_types_walk_local_classes (die);
23259 /* It's a type node --- don't mark it. */
23262 case DW_TAG_const_type:
23263 case DW_TAG_packed_type:
23264 case DW_TAG_pointer_type:
23265 case DW_TAG_reference_type:
23266 case DW_TAG_rvalue_reference_type:
23267 case DW_TAG_volatile_type:
23268 case DW_TAG_typedef:
23269 case DW_TAG_array_type:
23270 case DW_TAG_interface_type:
23271 case DW_TAG_friend:
23272 case DW_TAG_variant_part:
23273 case DW_TAG_enumeration_type:
23274 case DW_TAG_subroutine_type:
23275 case DW_TAG_string_type:
23276 case DW_TAG_set_type:
23277 case DW_TAG_subrange_type:
23278 case DW_TAG_ptr_to_member_type:
23279 case DW_TAG_file_type:
23280 if (die->die_perennial_p)
23283 /* It's a type node --- don't mark it. */
23287 /* Mark everything else. */
23291 if (die->die_mark == 0)
23295 /* Now, mark any dies referenced from here. */
23296 prune_unused_types_walk_attribs (die);
23301 /* Mark children. */
23302 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
23305 /* Increment the string counts on strings referred to from DIE's
23309 prune_unused_types_update_strings (dw_die_ref die)
23314 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
23315 if (AT_class (a) == dw_val_class_str)
23317 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
23319 /* Avoid unnecessarily putting strings that are used less than
23320 twice in the hash table. */
23322 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
23325 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
23326 htab_hash_string (s->str),
23328 gcc_assert (*slot == NULL);
23334 /* Remove from the tree DIE any dies that aren't marked. */
23337 prune_unused_types_prune (dw_die_ref die)
23341 gcc_assert (die->die_mark);
23342 prune_unused_types_update_strings (die);
23344 if (! die->die_child)
23347 c = die->die_child;
23349 dw_die_ref prev = c;
23350 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
23351 if (c == die->die_child)
23353 /* No marked children between 'prev' and the end of the list. */
23355 /* No marked children at all. */
23356 die->die_child = NULL;
23359 prev->die_sib = c->die_sib;
23360 die->die_child = prev;
23365 if (c != prev->die_sib)
23367 prune_unused_types_prune (c);
23368 } while (c != die->die_child);
23371 /* Remove dies representing declarations that we never use. */
23374 prune_unused_types (void)
23377 limbo_die_node *node;
23378 comdat_type_node *ctnode;
23380 dw_die_ref base_type;
23382 #if ENABLE_ASSERT_CHECKING
23383 /* All the marks should already be clear. */
23384 verify_marks_clear (comp_unit_die ());
23385 for (node = limbo_die_list; node; node = node->next)
23386 verify_marks_clear (node->die);
23387 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23388 verify_marks_clear (ctnode->root_die);
23389 #endif /* ENABLE_ASSERT_CHECKING */
23391 /* Mark types that are used in global variables. */
23392 premark_types_used_by_global_vars ();
23394 /* Set the mark on nodes that are actually used. */
23395 prune_unused_types_walk (comp_unit_die ());
23396 for (node = limbo_die_list; node; node = node->next)
23397 prune_unused_types_walk (node->die);
23398 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23400 prune_unused_types_walk (ctnode->root_die);
23401 prune_unused_types_mark (ctnode->type_die, 1);
23404 /* Also set the mark on nodes referenced from the
23406 FOR_EACH_VEC_ELT (pubname_entry, pubname_table, i, pub)
23407 prune_unused_types_mark (pub->die, 1);
23408 for (i = 0; VEC_iterate (dw_die_ref, base_types, i, base_type); i++)
23409 prune_unused_types_mark (base_type, 1);
23411 if (debug_str_hash)
23412 htab_empty (debug_str_hash);
23413 prune_unused_types_prune (comp_unit_die ());
23414 for (node = limbo_die_list; node; node = node->next)
23415 prune_unused_types_prune (node->die);
23416 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23417 prune_unused_types_prune (ctnode->root_die);
23419 /* Leave the marks clear. */
23420 prune_unmark_dies (comp_unit_die ());
23421 for (node = limbo_die_list; node; node = node->next)
23422 prune_unmark_dies (node->die);
23423 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
23424 prune_unmark_dies (ctnode->root_die);
23427 /* Set the parameter to true if there are any relative pathnames in
23430 file_table_relative_p (void ** slot, void *param)
23432 bool *p = (bool *) param;
23433 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
23434 if (!IS_ABSOLUTE_PATH (d->filename))
23442 /* Routines to manipulate hash table of comdat type units. */
23445 htab_ct_hash (const void *of)
23448 const comdat_type_node *const type_node = (const comdat_type_node *) of;
23450 memcpy (&h, type_node->signature, sizeof (h));
23455 htab_ct_eq (const void *of1, const void *of2)
23457 const comdat_type_node *const type_node_1 = (const comdat_type_node *) of1;
23458 const comdat_type_node *const type_node_2 = (const comdat_type_node *) of2;
23460 return (! memcmp (type_node_1->signature, type_node_2->signature,
23461 DWARF_TYPE_SIGNATURE_SIZE));
23464 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
23465 to the location it would have been added, should we know its
23466 DECL_ASSEMBLER_NAME when we added other attributes. This will
23467 probably improve compactness of debug info, removing equivalent
23468 abbrevs, and hide any differences caused by deferring the
23469 computation of the assembler name, triggered by e.g. PCH. */
23472 move_linkage_attr (dw_die_ref die)
23474 unsigned ix = VEC_length (dw_attr_node, die->die_attr);
23475 dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1);
23477 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
23478 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
23482 dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1);
23484 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
23488 if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
23490 VEC_pop (dw_attr_node, die->die_attr);
23491 VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
23495 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
23496 referenced from typed stack ops and count how often they are used. */
23499 mark_base_types (dw_loc_descr_ref loc)
23501 dw_die_ref base_type = NULL;
23503 for (; loc; loc = loc->dw_loc_next)
23505 switch (loc->dw_loc_opc)
23507 case DW_OP_GNU_regval_type:
23508 case DW_OP_GNU_deref_type:
23509 base_type = loc->dw_loc_oprnd2.v.val_die_ref.die;
23511 case DW_OP_GNU_const_type:
23512 case DW_OP_GNU_convert:
23513 case DW_OP_GNU_reinterpret:
23514 base_type = loc->dw_loc_oprnd1.v.val_die_ref.die;
23516 case DW_OP_GNU_entry_value:
23517 mark_base_types (loc->dw_loc_oprnd1.v.val_loc);
23522 gcc_assert (base_type->die_parent == comp_unit_die ());
23523 if (base_type->die_mark)
23524 base_type->die_mark++;
23527 VEC_safe_push (dw_die_ref, heap, base_types, base_type);
23528 base_type->die_mark = 1;
23533 /* Comparison function for sorting marked base types. */
23536 base_type_cmp (const void *x, const void *y)
23538 dw_die_ref dx = *(const dw_die_ref *) x;
23539 dw_die_ref dy = *(const dw_die_ref *) y;
23540 unsigned int byte_size1, byte_size2;
23541 unsigned int encoding1, encoding2;
23542 if (dx->die_mark > dy->die_mark)
23544 if (dx->die_mark < dy->die_mark)
23546 byte_size1 = get_AT_unsigned (dx, DW_AT_byte_size);
23547 byte_size2 = get_AT_unsigned (dy, DW_AT_byte_size);
23548 if (byte_size1 < byte_size2)
23550 if (byte_size1 > byte_size2)
23552 encoding1 = get_AT_unsigned (dx, DW_AT_encoding);
23553 encoding2 = get_AT_unsigned (dy, DW_AT_encoding);
23554 if (encoding1 < encoding2)
23556 if (encoding1 > encoding2)
23561 /* Move base types marked by mark_base_types as early as possible
23562 in the CU, sorted by decreasing usage count both to make the
23563 uleb128 references as small as possible and to make sure they
23564 will have die_offset already computed by calc_die_sizes when
23565 sizes of typed stack loc ops is computed. */
23568 move_marked_base_types (void)
23571 dw_die_ref base_type, die, c;
23573 if (VEC_empty (dw_die_ref, base_types))
23576 /* Sort by decreasing usage count, they will be added again in that
23578 VEC_qsort (dw_die_ref, base_types, base_type_cmp);
23579 die = comp_unit_die ();
23580 c = die->die_child;
23583 dw_die_ref prev = c;
23585 while (c->die_mark)
23587 remove_child_with_prev (c, prev);
23588 /* As base types got marked, there must be at least
23589 one node other than DW_TAG_base_type. */
23590 gcc_assert (c != c->die_sib);
23594 while (c != die->die_child);
23595 gcc_assert (die->die_child);
23596 c = die->die_child;
23597 for (i = 0; VEC_iterate (dw_die_ref, base_types, i, base_type); i++)
23599 base_type->die_mark = 0;
23600 base_type->die_sib = c->die_sib;
23601 c->die_sib = base_type;
23606 /* Helper function for resolve_addr, attempt to resolve
23607 one CONST_STRING, return non-zero if not successful. Similarly verify that
23608 SYMBOL_REFs refer to variables emitted in the current CU. */
23611 resolve_one_addr (rtx *addr, void *data ATTRIBUTE_UNUSED)
23615 if (GET_CODE (rtl) == CONST_STRING)
23617 size_t len = strlen (XSTR (rtl, 0)) + 1;
23618 tree t = build_string (len, XSTR (rtl, 0));
23619 tree tlen = size_int (len - 1);
23621 = build_array_type (char_type_node, build_index_type (tlen));
23622 rtl = lookup_constant_def (t);
23623 if (!rtl || !MEM_P (rtl))
23625 rtl = XEXP (rtl, 0);
23626 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
23631 if (GET_CODE (rtl) == SYMBOL_REF
23632 && SYMBOL_REF_DECL (rtl))
23634 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl))
23636 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl))))
23639 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
23643 if (GET_CODE (rtl) == CONST
23644 && for_each_rtx (&XEXP (rtl, 0), resolve_one_addr, NULL))
23650 /* Helper function for resolve_addr, handle one location
23651 expression, return false if at least one CONST_STRING or SYMBOL_REF in
23652 the location list couldn't be resolved. */
23655 resolve_addr_in_expr (dw_loc_descr_ref loc)
23657 for (; loc; loc = loc->dw_loc_next)
23658 if (((loc->dw_loc_opc == DW_OP_addr || loc->dtprel)
23659 && resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr, NULL))
23660 || (loc->dw_loc_opc == DW_OP_implicit_value
23661 && loc->dw_loc_oprnd2.val_class == dw_val_class_addr
23662 && resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr, NULL)))
23664 else if (loc->dw_loc_opc == DW_OP_GNU_implicit_pointer
23665 && loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
23668 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
23671 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
23672 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
23673 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
23678 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
23679 an address in .rodata section if the string literal is emitted there,
23680 or remove the containing location list or replace DW_AT_const_value
23681 with DW_AT_location and empty location expression, if it isn't found
23682 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
23683 to something that has been emitted in the current CU. */
23686 resolve_addr (dw_die_ref die)
23690 dw_loc_list_ref *curr, *start, loc;
23693 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
23694 switch (AT_class (a))
23696 case dw_val_class_loc_list:
23697 start = curr = AT_loc_list_ptr (a);
23700 /* The same list can be referenced more than once. See if we have
23701 already recorded the result from a previous pass. */
23703 *curr = loc->dw_loc_next;
23704 else if (!loc->resolved_addr)
23706 /* As things stand, we do not expect or allow one die to
23707 reference a suffix of another die's location list chain.
23708 References must be identical or completely separate.
23709 There is therefore no need to cache the result of this
23710 pass on any list other than the first; doing so
23711 would lead to unnecessary writes. */
23714 gcc_assert (!(*curr)->replaced && !(*curr)->resolved_addr);
23715 if (!resolve_addr_in_expr ((*curr)->expr))
23717 dw_loc_list_ref next = (*curr)->dw_loc_next;
23718 if (next && (*curr)->ll_symbol)
23720 gcc_assert (!next->ll_symbol);
23721 next->ll_symbol = (*curr)->ll_symbol;
23727 mark_base_types ((*curr)->expr);
23728 curr = &(*curr)->dw_loc_next;
23732 loc->resolved_addr = 1;
23736 loc->dw_loc_next = *start;
23741 remove_AT (die, a->dw_attr);
23745 case dw_val_class_loc:
23746 if (!resolve_addr_in_expr (AT_loc (a)))
23748 remove_AT (die, a->dw_attr);
23752 mark_base_types (AT_loc (a));
23754 case dw_val_class_addr:
23755 if (a->dw_attr == DW_AT_const_value
23756 && resolve_one_addr (&a->dw_attr_val.v.val_addr, NULL))
23758 remove_AT (die, a->dw_attr);
23761 if (die->die_tag == DW_TAG_GNU_call_site
23762 && a->dw_attr == DW_AT_abstract_origin)
23764 tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr);
23765 dw_die_ref tdie = lookup_decl_die (tdecl);
23767 && DECL_EXTERNAL (tdecl)
23768 && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE)
23770 force_decl_die (tdecl);
23771 tdie = lookup_decl_die (tdecl);
23775 a->dw_attr_val.val_class = dw_val_class_die_ref;
23776 a->dw_attr_val.v.val_die_ref.die = tdie;
23777 a->dw_attr_val.v.val_die_ref.external = 0;
23781 remove_AT (die, a->dw_attr);
23790 FOR_EACH_CHILD (die, c, resolve_addr (c));
23793 /* Helper routines for optimize_location_lists.
23794 This pass tries to share identical local lists in .debug_loc
23797 /* Iteratively hash operands of LOC opcode. */
23799 static inline hashval_t
23800 hash_loc_operands (dw_loc_descr_ref loc, hashval_t hash)
23802 dw_val_ref val1 = &loc->dw_loc_oprnd1;
23803 dw_val_ref val2 = &loc->dw_loc_oprnd2;
23805 switch (loc->dw_loc_opc)
23807 case DW_OP_const4u:
23808 case DW_OP_const8u:
23812 case DW_OP_const1u:
23813 case DW_OP_const1s:
23814 case DW_OP_const2u:
23815 case DW_OP_const2s:
23816 case DW_OP_const4s:
23817 case DW_OP_const8s:
23821 case DW_OP_plus_uconst:
23857 case DW_OP_deref_size:
23858 case DW_OP_xderef_size:
23859 hash = iterative_hash_object (val1->v.val_int, hash);
23866 gcc_assert (val1->val_class == dw_val_class_loc);
23867 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
23868 hash = iterative_hash_object (offset, hash);
23871 case DW_OP_implicit_value:
23872 hash = iterative_hash_object (val1->v.val_unsigned, hash);
23873 switch (val2->val_class)
23875 case dw_val_class_const:
23876 hash = iterative_hash_object (val2->v.val_int, hash);
23878 case dw_val_class_vec:
23880 unsigned int elt_size = val2->v.val_vec.elt_size;
23881 unsigned int len = val2->v.val_vec.length;
23883 hash = iterative_hash_object (elt_size, hash);
23884 hash = iterative_hash_object (len, hash);
23885 hash = iterative_hash (val2->v.val_vec.array,
23886 len * elt_size, hash);
23889 case dw_val_class_const_double:
23890 hash = iterative_hash_object (val2->v.val_double.low, hash);
23891 hash = iterative_hash_object (val2->v.val_double.high, hash);
23893 case dw_val_class_addr:
23894 hash = iterative_hash_rtx (val2->v.val_addr, hash);
23897 gcc_unreachable ();
23901 case DW_OP_bit_piece:
23902 hash = iterative_hash_object (val1->v.val_int, hash);
23903 hash = iterative_hash_object (val2->v.val_int, hash);
23909 unsigned char dtprel = 0xd1;
23910 hash = iterative_hash_object (dtprel, hash);
23912 hash = iterative_hash_rtx (val1->v.val_addr, hash);
23914 case DW_OP_GNU_implicit_pointer:
23915 hash = iterative_hash_object (val2->v.val_int, hash);
23917 case DW_OP_GNU_entry_value:
23918 hash = hash_loc_operands (val1->v.val_loc, hash);
23920 case DW_OP_GNU_regval_type:
23921 case DW_OP_GNU_deref_type:
23923 unsigned int byte_size
23924 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_byte_size);
23925 unsigned int encoding
23926 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_encoding);
23927 hash = iterative_hash_object (val1->v.val_int, hash);
23928 hash = iterative_hash_object (byte_size, hash);
23929 hash = iterative_hash_object (encoding, hash);
23932 case DW_OP_GNU_convert:
23933 case DW_OP_GNU_reinterpret:
23934 case DW_OP_GNU_const_type:
23936 unsigned int byte_size
23937 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_byte_size);
23938 unsigned int encoding
23939 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_encoding);
23940 hash = iterative_hash_object (byte_size, hash);
23941 hash = iterative_hash_object (encoding, hash);
23942 if (loc->dw_loc_opc != DW_OP_GNU_const_type)
23944 hash = iterative_hash_object (val2->val_class, hash);
23945 switch (val2->val_class)
23947 case dw_val_class_const:
23948 hash = iterative_hash_object (val2->v.val_int, hash);
23950 case dw_val_class_vec:
23952 unsigned int elt_size = val2->v.val_vec.elt_size;
23953 unsigned int len = val2->v.val_vec.length;
23955 hash = iterative_hash_object (elt_size, hash);
23956 hash = iterative_hash_object (len, hash);
23957 hash = iterative_hash (val2->v.val_vec.array,
23958 len * elt_size, hash);
23961 case dw_val_class_const_double:
23962 hash = iterative_hash_object (val2->v.val_double.low, hash);
23963 hash = iterative_hash_object (val2->v.val_double.high, hash);
23966 gcc_unreachable ();
23972 /* Other codes have no operands. */
23978 /* Iteratively hash the whole DWARF location expression LOC. */
23980 static inline hashval_t
23981 hash_locs (dw_loc_descr_ref loc, hashval_t hash)
23983 dw_loc_descr_ref l;
23984 bool sizes_computed = false;
23985 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
23986 size_of_locs (loc);
23988 for (l = loc; l != NULL; l = l->dw_loc_next)
23990 enum dwarf_location_atom opc = l->dw_loc_opc;
23991 hash = iterative_hash_object (opc, hash);
23992 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed)
23994 size_of_locs (loc);
23995 sizes_computed = true;
23997 hash = hash_loc_operands (l, hash);
24002 /* Compute hash of the whole location list LIST_HEAD. */
24005 hash_loc_list (dw_loc_list_ref list_head)
24007 dw_loc_list_ref curr = list_head;
24008 hashval_t hash = 0;
24010 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
24012 hash = iterative_hash (curr->begin, strlen (curr->begin) + 1, hash);
24013 hash = iterative_hash (curr->end, strlen (curr->end) + 1, hash);
24015 hash = iterative_hash (curr->section, strlen (curr->section) + 1,
24017 hash = hash_locs (curr->expr, hash);
24019 list_head->hash = hash;
24022 /* Return true if X and Y opcodes have the same operands. */
24025 compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y)
24027 dw_val_ref valx1 = &x->dw_loc_oprnd1;
24028 dw_val_ref valx2 = &x->dw_loc_oprnd2;
24029 dw_val_ref valy1 = &y->dw_loc_oprnd1;
24030 dw_val_ref valy2 = &y->dw_loc_oprnd2;
24032 switch (x->dw_loc_opc)
24034 case DW_OP_const4u:
24035 case DW_OP_const8u:
24039 case DW_OP_const1u:
24040 case DW_OP_const1s:
24041 case DW_OP_const2u:
24042 case DW_OP_const2s:
24043 case DW_OP_const4s:
24044 case DW_OP_const8s:
24048 case DW_OP_plus_uconst:
24084 case DW_OP_deref_size:
24085 case DW_OP_xderef_size:
24086 return valx1->v.val_int == valy1->v.val_int;
24089 gcc_assert (valx1->val_class == dw_val_class_loc
24090 && valy1->val_class == dw_val_class_loc
24091 && x->dw_loc_addr == y->dw_loc_addr);
24092 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr;
24093 case DW_OP_implicit_value:
24094 if (valx1->v.val_unsigned != valy1->v.val_unsigned
24095 || valx2->val_class != valy2->val_class)
24097 switch (valx2->val_class)
24099 case dw_val_class_const:
24100 return valx2->v.val_int == valy2->v.val_int;
24101 case dw_val_class_vec:
24102 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24103 && valx2->v.val_vec.length == valy2->v.val_vec.length
24104 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24105 valx2->v.val_vec.elt_size
24106 * valx2->v.val_vec.length) == 0;
24107 case dw_val_class_const_double:
24108 return valx2->v.val_double.low == valy2->v.val_double.low
24109 && valx2->v.val_double.high == valy2->v.val_double.high;
24110 case dw_val_class_addr:
24111 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr);
24113 gcc_unreachable ();
24116 case DW_OP_bit_piece:
24117 return valx1->v.val_int == valy1->v.val_int
24118 && valx2->v.val_int == valy2->v.val_int;
24121 return rtx_equal_p (valx1->v.val_addr, valy1->v.val_addr);
24122 case DW_OP_GNU_implicit_pointer:
24123 return valx1->val_class == dw_val_class_die_ref
24124 && valx1->val_class == valy1->val_class
24125 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die
24126 && valx2->v.val_int == valy2->v.val_int;
24127 case DW_OP_GNU_entry_value:
24128 return compare_loc_operands (valx1->v.val_loc, valy1->v.val_loc);
24129 case DW_OP_GNU_const_type:
24130 if (valx1->v.val_die_ref.die != valy1->v.val_die_ref.die
24131 || valx2->val_class != valy2->val_class)
24133 switch (valx2->val_class)
24135 case dw_val_class_const:
24136 return valx2->v.val_int == valy2->v.val_int;
24137 case dw_val_class_vec:
24138 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
24139 && valx2->v.val_vec.length == valy2->v.val_vec.length
24140 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
24141 valx2->v.val_vec.elt_size
24142 * valx2->v.val_vec.length) == 0;
24143 case dw_val_class_const_double:
24144 return valx2->v.val_double.low == valy2->v.val_double.low
24145 && valx2->v.val_double.high == valy2->v.val_double.high;
24147 gcc_unreachable ();
24149 case DW_OP_GNU_regval_type:
24150 case DW_OP_GNU_deref_type:
24151 return valx1->v.val_int == valy1->v.val_int
24152 && valx2->v.val_die_ref.die == valy2->v.val_die_ref.die;
24153 case DW_OP_GNU_convert:
24154 case DW_OP_GNU_reinterpret:
24155 return valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
24157 /* Other codes have no operands. */
24162 /* Return true if DWARF location expressions X and Y are the same. */
24165 compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y)
24167 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next)
24168 if (x->dw_loc_opc != y->dw_loc_opc
24169 || x->dtprel != y->dtprel
24170 || !compare_loc_operands (x, y))
24172 return x == NULL && y == NULL;
24175 /* Return precomputed hash of location list X. */
24178 loc_list_hash (const void *x)
24180 return ((const struct dw_loc_list_struct *) x)->hash;
24183 /* Return 1 if location lists X and Y are the same. */
24186 loc_list_eq (const void *x, const void *y)
24188 const struct dw_loc_list_struct *a = (const struct dw_loc_list_struct *) x;
24189 const struct dw_loc_list_struct *b = (const struct dw_loc_list_struct *) y;
24192 if (a->hash != b->hash)
24194 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next)
24195 if (strcmp (a->begin, b->begin) != 0
24196 || strcmp (a->end, b->end) != 0
24197 || (a->section == NULL) != (b->section == NULL)
24198 || (a->section && strcmp (a->section, b->section) != 0)
24199 || !compare_locs (a->expr, b->expr))
24201 return a == NULL && b == NULL;
24204 /* Recursively optimize location lists referenced from DIE
24205 children and share them whenever possible. */
24208 optimize_location_lists_1 (dw_die_ref die, htab_t htab)
24215 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
24216 if (AT_class (a) == dw_val_class_loc_list)
24218 dw_loc_list_ref list = AT_loc_list (a);
24219 /* TODO: perform some optimizations here, before hashing
24220 it and storing into the hash table. */
24221 hash_loc_list (list);
24222 slot = htab_find_slot_with_hash (htab, list, list->hash,
24225 *slot = (void *) list;
24227 a->dw_attr_val.v.val_loc_list = (dw_loc_list_ref) *slot;
24230 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab));
24233 /* Optimize location lists referenced from DIE
24234 children and share them whenever possible. */
24237 optimize_location_lists (dw_die_ref die)
24239 htab_t htab = htab_create (500, loc_list_hash, loc_list_eq, NULL);
24240 optimize_location_lists_1 (die, htab);
24241 htab_delete (htab);
24244 /* Output stuff that dwarf requires at the end of every file,
24245 and generate the DWARF-2 debugging info. */
24248 dwarf2out_finish (const char *filename)
24250 limbo_die_node *node, *next_node;
24251 comdat_type_node *ctnode;
24252 htab_t comdat_type_table;
24255 gen_scheduled_generic_parms_dies ();
24256 gen_remaining_tmpl_value_param_die_attribute ();
24258 /* Add the name for the main input file now. We delayed this from
24259 dwarf2out_init to avoid complications with PCH. */
24260 add_name_attribute (comp_unit_die (), remap_debug_filename (filename));
24261 if (!IS_ABSOLUTE_PATH (filename))
24262 add_comp_dir_attribute (comp_unit_die ());
24263 else if (get_AT (comp_unit_die (), DW_AT_comp_dir) == NULL)
24266 htab_traverse (file_table, file_table_relative_p, &p);
24268 add_comp_dir_attribute (comp_unit_die ());
24271 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
24273 add_location_or_const_value_attribute (
24274 VEC_index (deferred_locations, deferred_locations_list, i)->die,
24275 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
24280 /* Traverse the limbo die list, and add parent/child links. The only
24281 dies without parents that should be here are concrete instances of
24282 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
24283 For concrete instances, we can get the parent die from the abstract
24285 for (node = limbo_die_list; node; node = next_node)
24287 dw_die_ref die = node->die;
24288 next_node = node->next;
24290 if (die->die_parent == NULL)
24292 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
24295 add_child_die (origin->die_parent, die);
24296 else if (is_cu_die (die))
24298 else if (seen_error ())
24299 /* It's OK to be confused by errors in the input. */
24300 add_child_die (comp_unit_die (), die);
24303 /* In certain situations, the lexical block containing a
24304 nested function can be optimized away, which results
24305 in the nested function die being orphaned. Likewise
24306 with the return type of that nested function. Force
24307 this to be a child of the containing function.
24309 It may happen that even the containing function got fully
24310 inlined and optimized out. In that case we are lost and
24311 assign the empty child. This should not be big issue as
24312 the function is likely unreachable too. */
24313 tree context = NULL_TREE;
24315 gcc_assert (node->created_for);
24317 if (DECL_P (node->created_for))
24318 context = DECL_CONTEXT (node->created_for);
24319 else if (TYPE_P (node->created_for))
24320 context = TYPE_CONTEXT (node->created_for);
24322 gcc_assert (context
24323 && (TREE_CODE (context) == FUNCTION_DECL
24324 || TREE_CODE (context) == NAMESPACE_DECL));
24326 origin = lookup_decl_die (context);
24328 add_child_die (origin, die);
24330 add_child_die (comp_unit_die (), die);
24335 limbo_die_list = NULL;
24337 #if ENABLE_ASSERT_CHECKING
24339 dw_die_ref die = comp_unit_die (), c;
24340 FOR_EACH_CHILD (die, c, gcc_assert (! c->die_mark));
24343 resolve_addr (comp_unit_die ());
24344 move_marked_base_types ();
24346 for (node = deferred_asm_name; node; node = node->next)
24348 tree decl = node->created_for;
24349 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
24351 add_linkage_attr (node->die, decl);
24352 move_linkage_attr (node->die);
24356 deferred_asm_name = NULL;
24358 /* Walk through the list of incomplete types again, trying once more to
24359 emit full debugging info for them. */
24360 retry_incomplete_types ();
24362 if (flag_eliminate_unused_debug_types)
24363 prune_unused_types ();
24365 /* Generate separate CUs for each of the include files we've seen.
24366 They will go into limbo_die_list. */
24367 if (flag_eliminate_dwarf2_dups && ! use_debug_types)
24368 break_out_includes (comp_unit_die ());
24370 /* Generate separate COMDAT sections for type DIEs. */
24371 if (use_debug_types)
24373 break_out_comdat_types (comp_unit_die ());
24375 /* Each new type_unit DIE was added to the limbo die list when created.
24376 Since these have all been added to comdat_type_list, clear the
24378 limbo_die_list = NULL;
24380 /* For each new comdat type unit, copy declarations for incomplete
24381 types to make the new unit self-contained (i.e., no direct
24382 references to the main compile unit). */
24383 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24384 copy_decls_for_unworthy_types (ctnode->root_die);
24385 copy_decls_for_unworthy_types (comp_unit_die ());
24387 /* In the process of copying declarations from one unit to another,
24388 we may have left some declarations behind that are no longer
24389 referenced. Prune them. */
24390 prune_unused_types ();
24393 /* Traverse the DIE's and add add sibling attributes to those DIE's
24394 that have children. */
24395 add_sibling_attributes (comp_unit_die ());
24396 for (node = limbo_die_list; node; node = node->next)
24397 add_sibling_attributes (node->die);
24398 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24399 add_sibling_attributes (ctnode->root_die);
24401 /* Output a terminator label for the .text section. */
24402 switch_to_section (text_section);
24403 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
24404 if (cold_text_section)
24406 switch_to_section (cold_text_section);
24407 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
24410 /* We can only use the low/high_pc attributes if all of the code was
24412 if (!have_multiple_function_sections
24413 || (dwarf_version < 3 && dwarf_strict))
24415 /* Don't add if the CU has no associated code. */
24416 if (text_section_used)
24418 add_AT_lbl_id (comp_unit_die (), DW_AT_low_pc, text_section_label);
24419 add_AT_lbl_id (comp_unit_die (), DW_AT_high_pc, text_end_label);
24424 unsigned fde_idx = 0;
24425 bool range_list_added = false;
24427 if (text_section_used)
24428 add_ranges_by_labels (comp_unit_die (), text_section_label,
24429 text_end_label, &range_list_added);
24430 if (cold_text_section_used)
24431 add_ranges_by_labels (comp_unit_die (), cold_text_section_label,
24432 cold_end_label, &range_list_added);
24434 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
24436 dw_fde_ref fde = &fde_table[fde_idx];
24438 if (!fde->in_std_section)
24439 add_ranges_by_labels (comp_unit_die (), fde->dw_fde_begin,
24440 fde->dw_fde_end, &range_list_added);
24441 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
24442 add_ranges_by_labels (comp_unit_die (), fde->dw_fde_second_begin,
24443 fde->dw_fde_second_end, &range_list_added);
24446 if (range_list_added)
24448 /* We need to give .debug_loc and .debug_ranges an appropriate
24449 "base address". Use zero so that these addresses become
24450 absolute. Historically, we've emitted the unexpected
24451 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
24452 Emit both to give time for other tools to adapt. */
24453 add_AT_addr (comp_unit_die (), DW_AT_low_pc, const0_rtx);
24454 if (! dwarf_strict && dwarf_version < 4)
24455 add_AT_addr (comp_unit_die (), DW_AT_entry_pc, const0_rtx);
24461 if (debug_info_level >= DINFO_LEVEL_NORMAL)
24462 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list,
24463 debug_line_section_label);
24465 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
24466 add_AT_macptr (comp_unit_die (), DW_AT_macro_info, macinfo_section_label);
24468 if (have_location_lists)
24469 optimize_location_lists (comp_unit_die ());
24471 /* Output all of the compilation units. We put the main one last so that
24472 the offsets are available to output_pubnames. */
24473 for (node = limbo_die_list; node; node = node->next)
24474 output_comp_unit (node->die, 0);
24476 comdat_type_table = htab_create (100, htab_ct_hash, htab_ct_eq, NULL);
24477 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
24479 void **slot = htab_find_slot (comdat_type_table, ctnode, INSERT);
24481 /* Don't output duplicate types. */
24482 if (*slot != HTAB_EMPTY_ENTRY)
24485 /* Add a pointer to the line table for the main compilation unit
24486 so that the debugger can make sense of DW_AT_decl_file
24488 if (debug_info_level >= DINFO_LEVEL_NORMAL)
24489 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
24490 debug_line_section_label);
24492 output_comdat_type_unit (ctnode);
24495 htab_delete (comdat_type_table);
24497 /* Output the main compilation unit if non-empty or if .debug_macinfo
24498 will be emitted. */
24499 output_comp_unit (comp_unit_die (), debug_info_level >= DINFO_LEVEL_VERBOSE);
24501 /* Output the abbreviation table. */
24502 switch_to_section (debug_abbrev_section);
24503 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
24504 output_abbrev_section ();
24506 /* Output location list section if necessary. */
24507 if (have_location_lists)
24509 /* Output the location lists info. */
24510 switch_to_section (debug_loc_section);
24511 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
24512 DEBUG_LOC_SECTION_LABEL, 0);
24513 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
24514 output_location_lists (comp_unit_die ());
24517 /* Output public names table if necessary. */
24518 if (!VEC_empty (pubname_entry, pubname_table))
24520 gcc_assert (info_section_emitted);
24521 switch_to_section (debug_pubnames_section);
24522 output_pubnames (pubname_table);
24525 /* Output public types table if necessary. */
24526 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
24527 It shouldn't hurt to emit it always, since pure DWARF2 consumers
24528 simply won't look for the section. */
24529 if (!VEC_empty (pubname_entry, pubtype_table))
24531 bool empty = false;
24533 if (flag_eliminate_unused_debug_types)
24535 /* The pubtypes table might be emptied by pruning unused items. */
24539 FOR_EACH_VEC_ELT (pubname_entry, pubtype_table, i, p)
24540 if (p->die->die_offset != 0)
24548 gcc_assert (info_section_emitted);
24549 switch_to_section (debug_pubtypes_section);
24550 output_pubnames (pubtype_table);
24554 /* Output the address range information if a CU (.debug_info section)
24555 was emitted. We output an empty table even if we had no functions
24556 to put in it. This because the consumer has no way to tell the
24557 difference between an empty table that we omitted and failure to
24558 generate a table that would have contained data. */
24559 if (info_section_emitted)
24561 unsigned long aranges_length = size_of_aranges ();
24563 switch_to_section (debug_aranges_section);
24564 output_aranges (aranges_length);
24567 /* Output ranges section if necessary. */
24568 if (ranges_table_in_use)
24570 switch_to_section (debug_ranges_section);
24571 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
24575 /* Output the source line correspondence table. We must do this
24576 even if there is no line information. Otherwise, on an empty
24577 translation unit, we will generate a present, but empty,
24578 .debug_info section. IRIX 6.5 `nm' will then complain when
24579 examining the file. This is done late so that any filenames
24580 used by the debug_info section are marked as 'used'. */
24581 switch_to_section (debug_line_section);
24582 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
24583 if (! DWARF2_ASM_LINE_DEBUG_INFO)
24584 output_line_info ();
24586 /* Have to end the macro section. */
24587 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
24589 switch_to_section (debug_macinfo_section);
24590 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
24591 if (!VEC_empty (macinfo_entry, macinfo_table))
24593 dw2_asm_output_data (1, 0, "End compilation unit");
24596 /* If we emitted any DW_FORM_strp form attribute, output the string
24598 if (debug_str_hash)
24599 htab_traverse (debug_str_hash, output_indirect_string, NULL);
24602 #include "gt-dwarf2out.h"