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
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"
96 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
97 static rtx last_var_location_insn;
99 #ifdef VMS_DEBUGGING_INFO
100 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
102 /* Define this macro to be a nonzero value if the directory specifications
103 which are output in the debug info should end with a separator. */
104 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
105 /* Define this macro to evaluate to a nonzero value if GCC should refrain
106 from generating indirect strings in DWARF2 debug information, for instance
107 if your target is stuck with an old version of GDB that is unable to
108 process them properly or uses VMS Debug. */
109 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
111 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
115 /* ??? Poison these here until it can be done generically. They've been
116 totally replaced in this file; make sure it stays that way. */
117 #undef DWARF2_UNWIND_INFO
118 #undef DWARF2_FRAME_INFO
119 #if (GCC_VERSION >= 3000)
120 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
123 #ifndef INCOMING_RETURN_ADDR_RTX
124 #define INCOMING_RETURN_ADDR_RTX (gcc_unreachable (), NULL_RTX)
127 /* Map register numbers held in the call frame info that gcc has
128 collected using DWARF_FRAME_REGNUM to those that should be output in
129 .debug_frame and .eh_frame. */
130 #ifndef DWARF2_FRAME_REG_OUT
131 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
134 /* Save the result of dwarf2out_do_frame across PCH. */
135 static GTY(()) bool saved_do_cfi_asm = 0;
137 /* Decide whether we want to emit frame unwind information for the current
141 dwarf2out_do_frame (void)
143 /* We want to emit correct CFA location expressions or lists, so we
144 have to return true if we're going to output debug info, even if
145 we're not going to output frame or unwind info. */
146 if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
149 if (saved_do_cfi_asm)
152 if (targetm.debug_unwind_info () == UI_DWARF2)
155 if ((flag_unwind_tables || flag_exceptions)
156 && targetm.except_unwind_info () == UI_DWARF2)
162 /* Decide whether to emit frame unwind via assembler directives. */
165 dwarf2out_do_cfi_asm (void)
169 #ifdef MIPS_DEBUGGING_INFO
172 if (saved_do_cfi_asm)
174 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
176 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
179 /* Make sure the personality encoding is one the assembler can support.
180 In particular, aligned addresses can't be handled. */
181 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
182 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
184 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
185 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
188 /* If we can't get the assembler to emit only .debug_frame, and we don't need
189 dwarf2 unwind info for exceptions, then emit .debug_frame by hand. */
190 if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE
191 && !flag_unwind_tables && !flag_exceptions
192 && targetm.except_unwind_info () != UI_DWARF2)
195 saved_do_cfi_asm = true;
199 /* The size of the target's pointer type. */
201 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
204 /* Array of RTXes referenced by the debugging information, which therefore
205 must be kept around forever. */
206 static GTY(()) VEC(rtx,gc) *used_rtx_array;
208 /* A pointer to the base of a list of incomplete types which might be
209 completed at some later time. incomplete_types_list needs to be a
210 VEC(tree,gc) because we want to tell the garbage collector about
212 static GTY(()) VEC(tree,gc) *incomplete_types;
214 /* A pointer to the base of a table of references to declaration
215 scopes. This table is a display which tracks the nesting
216 of declaration scopes at the current scope and containing
217 scopes. This table is used to find the proper place to
218 define type declaration DIE's. */
219 static GTY(()) VEC(tree,gc) *decl_scope_table;
221 /* Pointers to various DWARF2 sections. */
222 static GTY(()) section *debug_info_section;
223 static GTY(()) section *debug_abbrev_section;
224 static GTY(()) section *debug_aranges_section;
225 static GTY(()) section *debug_macinfo_section;
226 static GTY(()) section *debug_line_section;
227 static GTY(()) section *debug_loc_section;
228 static GTY(()) section *debug_pubnames_section;
229 static GTY(()) section *debug_pubtypes_section;
230 static GTY(()) section *debug_dcall_section;
231 static GTY(()) section *debug_vcall_section;
232 static GTY(()) section *debug_str_section;
233 static GTY(()) section *debug_ranges_section;
234 static GTY(()) section *debug_frame_section;
236 /* Personality decl of current unit. Used only when assembler does not support
238 static GTY(()) rtx current_unit_personality;
240 /* How to start an assembler comment. */
241 #ifndef ASM_COMMENT_START
242 #define ASM_COMMENT_START ";#"
245 typedef struct dw_cfi_struct *dw_cfi_ref;
246 typedef struct dw_fde_struct *dw_fde_ref;
247 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
249 /* Call frames are described using a sequence of Call Frame
250 Information instructions. The register number, offset
251 and address fields are provided as possible operands;
252 their use is selected by the opcode field. */
254 enum dw_cfi_oprnd_type {
256 dw_cfi_oprnd_reg_num,
262 typedef union GTY(()) dw_cfi_oprnd_struct {
263 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
264 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
265 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
266 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
270 typedef struct GTY(()) dw_cfi_struct {
271 dw_cfi_ref dw_cfi_next;
272 enum dwarf_call_frame_info dw_cfi_opc;
273 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
275 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
280 /* This is how we define the location of the CFA. We use to handle it
281 as REG + OFFSET all the time, but now it can be more complex.
282 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
283 Instead of passing around REG and OFFSET, we pass a copy
284 of this structure. */
285 typedef struct GTY(()) cfa_loc {
286 HOST_WIDE_INT offset;
287 HOST_WIDE_INT base_offset;
289 BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
290 BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
293 /* All call frame descriptions (FDE's) in the GCC generated DWARF
294 refer to a single Common Information Entry (CIE), defined at
295 the beginning of the .debug_frame section. This use of a single
296 CIE obviates the need to keep track of multiple CIE's
297 in the DWARF generation routines below. */
299 typedef struct GTY(()) dw_fde_struct {
301 const char *dw_fde_begin;
302 const char *dw_fde_current_label;
303 const char *dw_fde_end;
304 const char *dw_fde_vms_end_prologue;
305 const char *dw_fde_vms_begin_epilogue;
306 const char *dw_fde_hot_section_label;
307 const char *dw_fde_hot_section_end_label;
308 const char *dw_fde_unlikely_section_label;
309 const char *dw_fde_unlikely_section_end_label;
310 dw_cfi_ref dw_fde_cfi;
311 dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections. */
312 HOST_WIDE_INT stack_realignment;
313 unsigned funcdef_number;
314 /* Dynamic realign argument pointer register. */
315 unsigned int drap_reg;
316 /* Virtual dynamic realign argument pointer register. */
317 unsigned int vdrap_reg;
318 /* These 3 flags are copied from rtl_data in function.h. */
319 unsigned all_throwers_are_sibcalls : 1;
320 unsigned uses_eh_lsda : 1;
321 unsigned nothrow : 1;
322 /* Whether we did stack realign in this call frame. */
323 unsigned stack_realign : 1;
324 /* Whether dynamic realign argument pointer register has been saved. */
325 unsigned drap_reg_saved: 1;
326 /* True iff dw_fde_begin label is in text_section or cold_text_section. */
327 unsigned in_std_section : 1;
328 /* True iff dw_fde_unlikely_section_label is in text_section or
329 cold_text_section. */
330 unsigned cold_in_std_section : 1;
331 /* True iff switched sections. */
332 unsigned dw_fde_switched_sections : 1;
333 /* True iff switching from cold to hot section. */
334 unsigned dw_fde_switched_cold_to_hot : 1;
338 /* Maximum size (in bytes) of an artificially generated label. */
339 #define MAX_ARTIFICIAL_LABEL_BYTES 30
341 /* The size of addresses as they appear in the Dwarf 2 data.
342 Some architectures use word addresses to refer to code locations,
343 but Dwarf 2 info always uses byte addresses. On such machines,
344 Dwarf 2 addresses need to be larger than the architecture's
346 #ifndef DWARF2_ADDR_SIZE
347 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
350 /* The size in bytes of a DWARF field indicating an offset or length
351 relative to a debug info section, specified to be 4 bytes in the
352 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
355 #ifndef DWARF_OFFSET_SIZE
356 #define DWARF_OFFSET_SIZE 4
359 /* The size in bytes of a DWARF 4 type signature. */
361 #ifndef DWARF_TYPE_SIGNATURE_SIZE
362 #define DWARF_TYPE_SIGNATURE_SIZE 8
365 /* According to the (draft) DWARF 3 specification, the initial length
366 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
367 bytes are 0xffffffff, followed by the length stored in the next 8
370 However, the SGI/MIPS ABI uses an initial length which is equal to
371 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
373 #ifndef DWARF_INITIAL_LENGTH_SIZE
374 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
377 /* Round SIZE up to the nearest BOUNDARY. */
378 #define DWARF_ROUND(SIZE,BOUNDARY) \
379 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
381 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
382 #ifndef DWARF_CIE_DATA_ALIGNMENT
383 #ifdef STACK_GROWS_DOWNWARD
384 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
386 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
390 /* CIE identifier. */
391 #if HOST_BITS_PER_WIDE_INT >= 64
392 #define DWARF_CIE_ID \
393 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
395 #define DWARF_CIE_ID DW_CIE_ID
398 /* A pointer to the base of a table that contains frame description
399 information for each routine. */
400 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
402 /* Number of elements currently allocated for fde_table. */
403 static GTY(()) unsigned fde_table_allocated;
405 /* Number of elements in fde_table currently in use. */
406 static GTY(()) unsigned fde_table_in_use;
408 /* Size (in elements) of increments by which we may expand the
410 #define FDE_TABLE_INCREMENT 256
412 /* Get the current fde_table entry we should use. */
414 static inline dw_fde_ref
417 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
420 /* A list of call frame insns for the CIE. */
421 static GTY(()) dw_cfi_ref cie_cfi_head;
423 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
424 attribute that accelerates the lookup of the FDE associated
425 with the subprogram. This variable holds the table index of the FDE
426 associated with the current function (body) definition. */
427 static unsigned current_funcdef_fde;
429 struct GTY(()) indirect_string_node {
431 unsigned int refcount;
432 enum dwarf_form form;
436 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
438 /* True if the compilation unit has location entries that reference
440 static GTY(()) bool debug_str_hash_forced = false;
442 static GTY(()) int dw2_string_counter;
443 static GTY(()) unsigned long dwarf2out_cfi_label_num;
445 /* True if the compilation unit places functions in more than one section. */
446 static GTY(()) bool have_multiple_function_sections = false;
448 /* Whether the default text and cold text sections have been used at all. */
450 static GTY(()) bool text_section_used = false;
451 static GTY(()) bool cold_text_section_used = false;
453 /* The default cold text section. */
454 static GTY(()) section *cold_text_section;
456 /* Forward declarations for functions defined in this file. */
458 static char *stripattributes (const char *);
459 static const char *dwarf_cfi_name (unsigned);
460 static dw_cfi_ref new_cfi (void);
461 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
462 static void add_fde_cfi (const char *, dw_cfi_ref);
463 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
464 static void lookup_cfa (dw_cfa_location *);
465 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
466 static void initial_return_save (rtx);
467 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
469 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
470 static void output_cfi_directive (dw_cfi_ref);
471 static void output_call_frame_info (int);
472 static void dwarf2out_note_section_used (void);
473 static bool clobbers_queued_reg_save (const_rtx);
474 static void dwarf2out_frame_debug_expr (rtx, const char *);
476 /* Support for complex CFA locations. */
477 static void output_cfa_loc (dw_cfi_ref);
478 static void output_cfa_loc_raw (dw_cfi_ref);
479 static void get_cfa_from_loc_descr (dw_cfa_location *,
480 struct dw_loc_descr_struct *);
481 static struct dw_loc_descr_struct *build_cfa_loc
482 (dw_cfa_location *, HOST_WIDE_INT);
483 static struct dw_loc_descr_struct *build_cfa_aligned_loc
484 (HOST_WIDE_INT, HOST_WIDE_INT);
485 static void def_cfa_1 (const char *, dw_cfa_location *);
486 static struct dw_loc_descr_struct *mem_loc_descriptor
487 (rtx, enum machine_mode mode, enum var_init_status);
489 /* How to start an assembler comment. */
490 #ifndef ASM_COMMENT_START
491 #define ASM_COMMENT_START ";#"
494 /* Data and reference forms for relocatable data. */
495 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
496 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
498 #ifndef DEBUG_FRAME_SECTION
499 #define DEBUG_FRAME_SECTION ".debug_frame"
502 #ifndef FUNC_BEGIN_LABEL
503 #define FUNC_BEGIN_LABEL "LFB"
506 #ifndef FUNC_END_LABEL
507 #define FUNC_END_LABEL "LFE"
510 #ifndef PROLOGUE_END_LABEL
511 #define PROLOGUE_END_LABEL "LPE"
514 #ifndef EPILOGUE_BEGIN_LABEL
515 #define EPILOGUE_BEGIN_LABEL "LEB"
518 #ifndef FRAME_BEGIN_LABEL
519 #define FRAME_BEGIN_LABEL "Lframe"
521 #define CIE_AFTER_SIZE_LABEL "LSCIE"
522 #define CIE_END_LABEL "LECIE"
523 #define FDE_LABEL "LSFDE"
524 #define FDE_AFTER_SIZE_LABEL "LASFDE"
525 #define FDE_END_LABEL "LEFDE"
526 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
527 #define LINE_NUMBER_END_LABEL "LELT"
528 #define LN_PROLOG_AS_LABEL "LASLTP"
529 #define LN_PROLOG_END_LABEL "LELTP"
530 #define DIE_LABEL_PREFIX "DW"
532 /* The DWARF 2 CFA column which tracks the return address. Normally this
533 is the column for PC, or the first column after all of the hard
535 #ifndef DWARF_FRAME_RETURN_COLUMN
537 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
539 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
543 /* The mapping from gcc register number to DWARF 2 CFA column number. By
544 default, we just provide columns for all registers. */
545 #ifndef DWARF_FRAME_REGNUM
546 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
549 /* Hook used by __throw. */
552 expand_builtin_dwarf_sp_column (void)
554 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
555 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
558 /* Return a pointer to a copy of the section string name S with all
559 attributes stripped off, and an asterisk prepended (for assemble_name). */
562 stripattributes (const char *s)
564 char *stripped = XNEWVEC (char, strlen (s) + 2);
569 while (*s && *s != ',')
576 /* MEM is a memory reference for the register size table, each element of
577 which has mode MODE. Initialize column C as a return address column. */
580 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
582 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
583 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
584 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
587 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
589 static inline HOST_WIDE_INT
590 div_data_align (HOST_WIDE_INT off)
592 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
593 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
597 /* Return true if we need a signed version of a given opcode
598 (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended). */
601 need_data_align_sf_opcode (HOST_WIDE_INT off)
603 return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
606 /* Generate code to initialize the register size table. */
609 expand_builtin_init_dwarf_reg_sizes (tree address)
612 enum machine_mode mode = TYPE_MODE (char_type_node);
613 rtx addr = expand_normal (address);
614 rtx mem = gen_rtx_MEM (BLKmode, addr);
615 bool wrote_return_column = false;
617 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
619 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
621 if (rnum < DWARF_FRAME_REGISTERS)
623 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
624 enum machine_mode save_mode = reg_raw_mode[i];
627 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
628 save_mode = choose_hard_reg_mode (i, 1, true);
629 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
631 if (save_mode == VOIDmode)
633 wrote_return_column = true;
635 size = GET_MODE_SIZE (save_mode);
639 emit_move_insn (adjust_address (mem, mode, offset),
640 gen_int_mode (size, mode));
644 if (!wrote_return_column)
645 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
647 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
648 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
651 targetm.init_dwarf_reg_sizes_extra (address);
654 /* Convert a DWARF call frame info. operation to its string name */
657 dwarf_cfi_name (unsigned int cfi_opc)
661 case DW_CFA_advance_loc:
662 return "DW_CFA_advance_loc";
664 return "DW_CFA_offset";
666 return "DW_CFA_restore";
670 return "DW_CFA_set_loc";
671 case DW_CFA_advance_loc1:
672 return "DW_CFA_advance_loc1";
673 case DW_CFA_advance_loc2:
674 return "DW_CFA_advance_loc2";
675 case DW_CFA_advance_loc4:
676 return "DW_CFA_advance_loc4";
677 case DW_CFA_offset_extended:
678 return "DW_CFA_offset_extended";
679 case DW_CFA_restore_extended:
680 return "DW_CFA_restore_extended";
681 case DW_CFA_undefined:
682 return "DW_CFA_undefined";
683 case DW_CFA_same_value:
684 return "DW_CFA_same_value";
685 case DW_CFA_register:
686 return "DW_CFA_register";
687 case DW_CFA_remember_state:
688 return "DW_CFA_remember_state";
689 case DW_CFA_restore_state:
690 return "DW_CFA_restore_state";
692 return "DW_CFA_def_cfa";
693 case DW_CFA_def_cfa_register:
694 return "DW_CFA_def_cfa_register";
695 case DW_CFA_def_cfa_offset:
696 return "DW_CFA_def_cfa_offset";
699 case DW_CFA_def_cfa_expression:
700 return "DW_CFA_def_cfa_expression";
701 case DW_CFA_expression:
702 return "DW_CFA_expression";
703 case DW_CFA_offset_extended_sf:
704 return "DW_CFA_offset_extended_sf";
705 case DW_CFA_def_cfa_sf:
706 return "DW_CFA_def_cfa_sf";
707 case DW_CFA_def_cfa_offset_sf:
708 return "DW_CFA_def_cfa_offset_sf";
710 /* SGI/MIPS specific */
711 case DW_CFA_MIPS_advance_loc8:
712 return "DW_CFA_MIPS_advance_loc8";
715 case DW_CFA_GNU_window_save:
716 return "DW_CFA_GNU_window_save";
717 case DW_CFA_GNU_args_size:
718 return "DW_CFA_GNU_args_size";
719 case DW_CFA_GNU_negative_offset_extended:
720 return "DW_CFA_GNU_negative_offset_extended";
723 return "DW_CFA_<unknown>";
727 /* Return a pointer to a newly allocated Call Frame Instruction. */
729 static inline dw_cfi_ref
732 dw_cfi_ref cfi = ggc_alloc_dw_cfi_node ();
734 cfi->dw_cfi_next = NULL;
735 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
736 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
741 /* Add a Call Frame Instruction to list of instructions. */
744 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
747 dw_fde_ref fde = current_fde ();
749 /* When DRAP is used, CFA is defined with an expression. Redefine
750 CFA may lead to a different CFA value. */
751 /* ??? Of course, this heuristic fails when we're annotating epilogues,
752 because of course we'll always want to redefine the CFA back to the
753 stack pointer on the way out. Where should we move this check? */
754 if (0 && fde && fde->drap_reg != INVALID_REGNUM)
755 switch (cfi->dw_cfi_opc)
757 case DW_CFA_def_cfa_register:
758 case DW_CFA_def_cfa_offset:
759 case DW_CFA_def_cfa_offset_sf:
761 case DW_CFA_def_cfa_sf:
768 /* Find the end of the chain. */
769 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
775 /* Generate a new label for the CFI info to refer to. FORCE is true
776 if a label needs to be output even when using .cfi_* directives. */
779 dwarf2out_cfi_label (bool force)
781 static char label[20];
783 if (!force && dwarf2out_do_cfi_asm ())
785 /* In this case, we will be emitting the asm directive instead of
786 the label, so just return a placeholder to keep the rest of the
788 strcpy (label, "<do not output>");
792 int num = dwarf2out_cfi_label_num++;
793 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", num);
794 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LCFI", num);
800 /* True if remember_state should be emitted before following CFI directive. */
801 static bool emit_cfa_remember;
803 /* True if any CFI directives were emitted at the current insn. */
804 static bool any_cfis_emitted;
806 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
807 or to the CIE if LABEL is NULL. */
810 add_fde_cfi (const char *label, dw_cfi_ref cfi)
812 dw_cfi_ref *list_head;
814 if (emit_cfa_remember)
816 dw_cfi_ref cfi_remember;
818 /* Emit the state save. */
819 emit_cfa_remember = false;
820 cfi_remember = new_cfi ();
821 cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
822 add_fde_cfi (label, cfi_remember);
825 list_head = &cie_cfi_head;
827 if (dwarf2out_do_cfi_asm ())
831 dw_fde_ref fde = current_fde ();
833 gcc_assert (fde != NULL);
835 /* We still have to add the cfi to the list so that lookup_cfa
836 works later on. When -g2 and above we even need to force
837 emitting of CFI labels and add to list a DW_CFA_set_loc for
838 convert_cfa_to_fb_loc_list purposes. If we're generating
839 DWARF3 output we use DW_OP_call_frame_cfa and so don't use
840 convert_cfa_to_fb_loc_list. */
841 if (dwarf_version == 2
842 && debug_info_level > DINFO_LEVEL_TERSE
843 && (write_symbols == DWARF2_DEBUG
844 || write_symbols == VMS_AND_DWARF2_DEBUG))
846 switch (cfi->dw_cfi_opc)
848 case DW_CFA_def_cfa_offset:
849 case DW_CFA_def_cfa_offset_sf:
850 case DW_CFA_def_cfa_register:
852 case DW_CFA_def_cfa_sf:
853 case DW_CFA_def_cfa_expression:
854 case DW_CFA_restore_state:
855 if (*label == 0 || strcmp (label, "<do not output>") == 0)
856 label = dwarf2out_cfi_label (true);
858 if (fde->dw_fde_current_label == NULL
859 || strcmp (label, fde->dw_fde_current_label) != 0)
863 label = xstrdup (label);
865 /* Set the location counter to the new label. */
867 /* It doesn't metter whether DW_CFA_set_loc
868 or DW_CFA_advance_loc4 is added here, those aren't
869 emitted into assembly, only looked up by
870 convert_cfa_to_fb_loc_list. */
871 xcfi->dw_cfi_opc = DW_CFA_set_loc;
872 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
873 add_cfi (&fde->dw_fde_cfi, xcfi);
874 fde->dw_fde_current_label = label;
882 output_cfi_directive (cfi);
884 list_head = &fde->dw_fde_cfi;
885 any_cfis_emitted = true;
887 /* ??? If this is a CFI for the CIE, we don't emit. This
888 assumes that the standard CIE contents that the assembler
889 uses matches the standard CIE contents that the compiler
890 uses. This is probably a bad assumption. I'm not quite
891 sure how to address this for now. */
895 dw_fde_ref fde = current_fde ();
897 gcc_assert (fde != NULL);
900 label = dwarf2out_cfi_label (false);
902 if (fde->dw_fde_current_label == NULL
903 || strcmp (label, fde->dw_fde_current_label) != 0)
907 label = xstrdup (label);
909 /* Set the location counter to the new label. */
911 /* If we have a current label, advance from there, otherwise
912 set the location directly using set_loc. */
913 xcfi->dw_cfi_opc = fde->dw_fde_current_label
914 ? DW_CFA_advance_loc4
916 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
917 add_cfi (&fde->dw_fde_cfi, xcfi);
919 fde->dw_fde_current_label = label;
922 list_head = &fde->dw_fde_cfi;
923 any_cfis_emitted = true;
926 add_cfi (list_head, cfi);
929 /* Subroutine of lookup_cfa. */
932 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
934 switch (cfi->dw_cfi_opc)
936 case DW_CFA_def_cfa_offset:
937 case DW_CFA_def_cfa_offset_sf:
938 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
940 case DW_CFA_def_cfa_register:
941 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
944 case DW_CFA_def_cfa_sf:
945 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
946 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
948 case DW_CFA_def_cfa_expression:
949 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
952 case DW_CFA_remember_state:
953 gcc_assert (!remember->in_use);
955 remember->in_use = 1;
957 case DW_CFA_restore_state:
958 gcc_assert (remember->in_use);
960 remember->in_use = 0;
968 /* Find the previous value for the CFA. */
971 lookup_cfa (dw_cfa_location *loc)
975 dw_cfa_location remember;
977 memset (loc, 0, sizeof (*loc));
978 loc->reg = INVALID_REGNUM;
981 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
982 lookup_cfa_1 (cfi, loc, &remember);
984 fde = current_fde ();
986 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
987 lookup_cfa_1 (cfi, loc, &remember);
990 /* The current rule for calculating the DWARF2 canonical frame address. */
991 static dw_cfa_location cfa;
993 /* The register used for saving registers to the stack, and its offset
995 static dw_cfa_location cfa_store;
997 /* The current save location around an epilogue. */
998 static dw_cfa_location cfa_remember;
1000 /* The running total of the size of arguments pushed onto the stack. */
1001 static HOST_WIDE_INT args_size;
1003 /* The last args_size we actually output. */
1004 static HOST_WIDE_INT old_args_size;
1006 /* Entry point to update the canonical frame address (CFA).
1007 LABEL is passed to add_fde_cfi. The value of CFA is now to be
1008 calculated from REG+OFFSET. */
1011 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1013 dw_cfa_location loc;
1015 loc.base_offset = 0;
1017 loc.offset = offset;
1018 def_cfa_1 (label, &loc);
1021 /* Determine if two dw_cfa_location structures define the same data. */
1024 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
1026 return (loc1->reg == loc2->reg
1027 && loc1->offset == loc2->offset
1028 && loc1->indirect == loc2->indirect
1029 && (loc1->indirect == 0
1030 || loc1->base_offset == loc2->base_offset));
1033 /* This routine does the actual work. The CFA is now calculated from
1034 the dw_cfa_location structure. */
1037 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1040 dw_cfa_location old_cfa, loc;
1045 if (cfa_store.reg == loc.reg && loc.indirect == 0)
1046 cfa_store.offset = loc.offset;
1048 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1049 lookup_cfa (&old_cfa);
1051 /* If nothing changed, no need to issue any call frame instructions. */
1052 if (cfa_equal_p (&loc, &old_cfa))
1057 if (loc.reg == old_cfa.reg && !loc.indirect && !old_cfa.indirect)
1059 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1060 the CFA register did not change but the offset did. The data
1061 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1062 in the assembler via the .cfi_def_cfa_offset directive. */
1064 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1066 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1067 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1070 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
1071 else if (loc.offset == old_cfa.offset
1072 && old_cfa.reg != INVALID_REGNUM
1074 && !old_cfa.indirect)
1076 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1077 indicating the CFA register has changed to <register> but the
1078 offset has not changed. */
1079 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1080 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1084 else if (loc.indirect == 0)
1086 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1087 indicating the CFA register has changed to <register> with
1088 the specified offset. The data factoring for DW_CFA_def_cfa_sf
1089 happens in output_cfi, or in the assembler via the .cfi_def_cfa
1092 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1094 cfi->dw_cfi_opc = DW_CFA_def_cfa;
1095 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1096 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1100 /* Construct a DW_CFA_def_cfa_expression instruction to
1101 calculate the CFA using a full location expression since no
1102 register-offset pair is available. */
1103 struct dw_loc_descr_struct *loc_list;
1105 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1106 loc_list = build_cfa_loc (&loc, 0);
1107 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1110 add_fde_cfi (label, cfi);
1113 /* Add the CFI for saving a register. REG is the CFA column number.
1114 LABEL is passed to add_fde_cfi.
1115 If SREG is -1, the register is saved at OFFSET from the CFA;
1116 otherwise it is saved in SREG. */
1119 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1121 dw_cfi_ref cfi = new_cfi ();
1122 dw_fde_ref fde = current_fde ();
1124 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1126 /* When stack is aligned, store REG using DW_CFA_expression with
1129 && fde->stack_realign
1130 && sreg == INVALID_REGNUM)
1132 cfi->dw_cfi_opc = DW_CFA_expression;
1133 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1134 cfi->dw_cfi_oprnd2.dw_cfi_loc
1135 = build_cfa_aligned_loc (offset, fde->stack_realignment);
1137 else if (sreg == INVALID_REGNUM)
1139 if (need_data_align_sf_opcode (offset))
1140 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1141 else if (reg & ~0x3f)
1142 cfi->dw_cfi_opc = DW_CFA_offset_extended;
1144 cfi->dw_cfi_opc = DW_CFA_offset;
1145 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1147 else if (sreg == reg)
1148 cfi->dw_cfi_opc = DW_CFA_same_value;
1151 cfi->dw_cfi_opc = DW_CFA_register;
1152 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1155 add_fde_cfi (label, cfi);
1158 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1159 This CFI tells the unwinder that it needs to restore the window registers
1160 from the previous frame's window save area.
1162 ??? Perhaps we should note in the CIE where windows are saved (instead of
1163 assuming 0(cfa)) and what registers are in the window. */
1166 dwarf2out_window_save (const char *label)
1168 dw_cfi_ref cfi = new_cfi ();
1170 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1171 add_fde_cfi (label, cfi);
1174 /* Entry point for saving a register to the stack. REG is the GCC register
1175 number. LABEL and OFFSET are passed to reg_save. */
1178 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1180 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1183 /* Entry point for saving the return address in the stack.
1184 LABEL and OFFSET are passed to reg_save. */
1187 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1189 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1192 /* Entry point for saving the return address in a register.
1193 LABEL and SREG are passed to reg_save. */
1196 dwarf2out_return_reg (const char *label, unsigned int sreg)
1198 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1201 /* Record the initial position of the return address. RTL is
1202 INCOMING_RETURN_ADDR_RTX. */
1205 initial_return_save (rtx rtl)
1207 unsigned int reg = INVALID_REGNUM;
1208 HOST_WIDE_INT offset = 0;
1210 switch (GET_CODE (rtl))
1213 /* RA is in a register. */
1214 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1218 /* RA is on the stack. */
1219 rtl = XEXP (rtl, 0);
1220 switch (GET_CODE (rtl))
1223 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1228 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1229 offset = INTVAL (XEXP (rtl, 1));
1233 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1234 offset = -INTVAL (XEXP (rtl, 1));
1244 /* The return address is at some offset from any value we can
1245 actually load. For instance, on the SPARC it is in %i7+8. Just
1246 ignore the offset for now; it doesn't matter for unwinding frames. */
1247 gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1248 initial_return_save (XEXP (rtl, 0));
1255 if (reg != DWARF_FRAME_RETURN_COLUMN)
1256 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1259 /* Given a SET, calculate the amount of stack adjustment it
1262 static HOST_WIDE_INT
1263 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1264 HOST_WIDE_INT cur_offset)
1266 const_rtx src = SET_SRC (pattern);
1267 const_rtx dest = SET_DEST (pattern);
1268 HOST_WIDE_INT offset = 0;
1271 if (dest == stack_pointer_rtx)
1273 code = GET_CODE (src);
1275 /* Assume (set (reg sp) (reg whatever)) sets args_size
1277 if (code == REG && src != stack_pointer_rtx)
1279 offset = -cur_args_size;
1280 #ifndef STACK_GROWS_DOWNWARD
1283 return offset - cur_offset;
1286 if (! (code == PLUS || code == MINUS)
1287 || XEXP (src, 0) != stack_pointer_rtx
1288 || !CONST_INT_P (XEXP (src, 1)))
1291 /* (set (reg sp) (plus (reg sp) (const_int))) */
1292 offset = INTVAL (XEXP (src, 1));
1298 if (MEM_P (src) && !MEM_P (dest))
1302 /* (set (mem (pre_dec (reg sp))) (foo)) */
1303 src = XEXP (dest, 0);
1304 code = GET_CODE (src);
1310 if (XEXP (src, 0) == stack_pointer_rtx)
1312 rtx val = XEXP (XEXP (src, 1), 1);
1313 /* We handle only adjustments by constant amount. */
1314 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1315 && CONST_INT_P (val));
1316 offset = -INTVAL (val);
1323 if (XEXP (src, 0) == stack_pointer_rtx)
1325 offset = GET_MODE_SIZE (GET_MODE (dest));
1332 if (XEXP (src, 0) == stack_pointer_rtx)
1334 offset = -GET_MODE_SIZE (GET_MODE (dest));
1349 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1350 indexed by INSN_UID. */
1352 static HOST_WIDE_INT *barrier_args_size;
1354 /* Helper function for compute_barrier_args_size. Handle one insn. */
1356 static HOST_WIDE_INT
1357 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1358 VEC (rtx, heap) **next)
1360 HOST_WIDE_INT offset = 0;
1363 if (! RTX_FRAME_RELATED_P (insn))
1365 if (prologue_epilogue_contains (insn))
1367 else if (GET_CODE (PATTERN (insn)) == SET)
1368 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1369 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1370 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1372 /* There may be stack adjustments inside compound insns. Search
1374 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1375 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1376 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1377 cur_args_size, offset);
1382 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1386 expr = XEXP (expr, 0);
1387 if (GET_CODE (expr) == PARALLEL
1388 || GET_CODE (expr) == SEQUENCE)
1389 for (i = 1; i < XVECLEN (expr, 0); i++)
1391 rtx elem = XVECEXP (expr, 0, i);
1393 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1394 offset += stack_adjust_offset (elem, cur_args_size, offset);
1399 #ifndef STACK_GROWS_DOWNWARD
1403 cur_args_size += offset;
1404 if (cur_args_size < 0)
1409 rtx dest = JUMP_LABEL (insn);
1413 if (barrier_args_size [INSN_UID (dest)] < 0)
1415 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1416 VEC_safe_push (rtx, heap, *next, dest);
1421 return cur_args_size;
1424 /* Walk the whole function and compute args_size on BARRIERs. */
1427 compute_barrier_args_size (void)
1429 int max_uid = get_max_uid (), i;
1431 VEC (rtx, heap) *worklist, *next, *tmp;
1433 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1434 for (i = 0; i < max_uid; i++)
1435 barrier_args_size[i] = -1;
1437 worklist = VEC_alloc (rtx, heap, 20);
1438 next = VEC_alloc (rtx, heap, 20);
1439 insn = get_insns ();
1440 barrier_args_size[INSN_UID (insn)] = 0;
1441 VEC_quick_push (rtx, worklist, insn);
1444 while (!VEC_empty (rtx, worklist))
1446 rtx prev, body, first_insn;
1447 HOST_WIDE_INT cur_args_size;
1449 first_insn = insn = VEC_pop (rtx, worklist);
1450 cur_args_size = barrier_args_size[INSN_UID (insn)];
1451 prev = prev_nonnote_insn (insn);
1452 if (prev && BARRIER_P (prev))
1453 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1455 for (; insn; insn = NEXT_INSN (insn))
1457 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1459 if (BARRIER_P (insn))
1464 if (insn == first_insn)
1466 else if (barrier_args_size[INSN_UID (insn)] < 0)
1468 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1473 /* The insns starting with this label have been
1474 already scanned or are in the worklist. */
1479 body = PATTERN (insn);
1480 if (GET_CODE (body) == SEQUENCE)
1482 HOST_WIDE_INT dest_args_size = cur_args_size;
1483 for (i = 1; i < XVECLEN (body, 0); i++)
1484 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1485 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1487 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1488 dest_args_size, &next);
1491 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1492 cur_args_size, &next);
1494 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1495 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1496 dest_args_size, &next);
1499 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1500 cur_args_size, &next);
1504 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1508 if (VEC_empty (rtx, next))
1511 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1515 VEC_truncate (rtx, next, 0);
1518 VEC_free (rtx, heap, worklist);
1519 VEC_free (rtx, heap, next);
1522 /* Add a CFI to update the running total of the size of arguments
1523 pushed onto the stack. */
1526 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1530 if (size == old_args_size)
1533 old_args_size = size;
1536 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1537 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1538 add_fde_cfi (label, cfi);
1541 /* Record a stack adjustment of OFFSET bytes. */
1544 dwarf2out_stack_adjust (HOST_WIDE_INT offset, const char *label)
1546 if (cfa.reg == STACK_POINTER_REGNUM)
1547 cfa.offset += offset;
1549 if (cfa_store.reg == STACK_POINTER_REGNUM)
1550 cfa_store.offset += offset;
1552 if (ACCUMULATE_OUTGOING_ARGS)
1555 #ifndef STACK_GROWS_DOWNWARD
1559 args_size += offset;
1563 def_cfa_1 (label, &cfa);
1564 if (flag_asynchronous_unwind_tables)
1565 dwarf2out_args_size (label, args_size);
1568 /* Check INSN to see if it looks like a push or a stack adjustment, and
1569 make a note of it if it does. EH uses this information to find out
1570 how much extra space it needs to pop off the stack. */
1573 dwarf2out_notice_stack_adjust (rtx insn, bool after_p)
1575 HOST_WIDE_INT offset;
1579 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1580 with this function. Proper support would require all frame-related
1581 insns to be marked, and to be able to handle saving state around
1582 epilogues textually in the middle of the function. */
1583 if (prologue_epilogue_contains (insn))
1586 /* If INSN is an instruction from target of an annulled branch, the
1587 effects are for the target only and so current argument size
1588 shouldn't change at all. */
1590 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1591 && INSN_FROM_TARGET_P (insn))
1594 /* If only calls can throw, and we have a frame pointer,
1595 save up adjustments until we see the CALL_INSN. */
1596 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1598 if (CALL_P (insn) && !after_p)
1600 /* Extract the size of the args from the CALL rtx itself. */
1601 insn = PATTERN (insn);
1602 if (GET_CODE (insn) == PARALLEL)
1603 insn = XVECEXP (insn, 0, 0);
1604 if (GET_CODE (insn) == SET)
1605 insn = SET_SRC (insn);
1606 gcc_assert (GET_CODE (insn) == CALL);
1607 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1612 if (CALL_P (insn) && !after_p)
1614 if (!flag_asynchronous_unwind_tables)
1615 dwarf2out_args_size ("", args_size);
1618 else if (BARRIER_P (insn))
1620 /* Don't call compute_barrier_args_size () if the only
1621 BARRIER is at the end of function. */
1622 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1623 compute_barrier_args_size ();
1624 if (barrier_args_size == NULL)
1628 offset = barrier_args_size[INSN_UID (insn)];
1633 offset -= args_size;
1634 #ifndef STACK_GROWS_DOWNWARD
1638 else if (GET_CODE (PATTERN (insn)) == SET)
1639 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1640 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1641 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1643 /* There may be stack adjustments inside compound insns. Search
1645 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1646 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1647 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1656 label = dwarf2out_cfi_label (false);
1657 dwarf2out_stack_adjust (offset, label);
1660 /* We delay emitting a register save until either (a) we reach the end
1661 of the prologue or (b) the register is clobbered. This clusters
1662 register saves so that there are fewer pc advances. */
1664 struct GTY(()) queued_reg_save {
1665 struct queued_reg_save *next;
1667 HOST_WIDE_INT cfa_offset;
1671 static GTY(()) struct queued_reg_save *queued_reg_saves;
1673 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1674 struct GTY(()) reg_saved_in_data {
1679 /* A list of registers saved in other registers.
1680 The list intentionally has a small maximum capacity of 4; if your
1681 port needs more than that, you might consider implementing a
1682 more efficient data structure. */
1683 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1684 static GTY(()) size_t num_regs_saved_in_regs;
1686 static const char *last_reg_save_label;
1688 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1689 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1692 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1694 struct queued_reg_save *q;
1696 /* Duplicates waste space, but it's also necessary to remove them
1697 for correctness, since the queue gets output in reverse
1699 for (q = queued_reg_saves; q != NULL; q = q->next)
1700 if (REGNO (q->reg) == REGNO (reg))
1705 q = ggc_alloc_queued_reg_save ();
1706 q->next = queued_reg_saves;
1707 queued_reg_saves = q;
1711 q->cfa_offset = offset;
1712 q->saved_reg = sreg;
1714 last_reg_save_label = label;
1717 /* Output all the entries in QUEUED_REG_SAVES. */
1720 dwarf2out_flush_queued_reg_saves (void)
1722 struct queued_reg_save *q;
1724 for (q = queued_reg_saves; q; q = q->next)
1727 unsigned int reg, sreg;
1729 for (i = 0; i < num_regs_saved_in_regs; i++)
1730 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1732 if (q->saved_reg && i == num_regs_saved_in_regs)
1734 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1735 num_regs_saved_in_regs++;
1737 if (i != num_regs_saved_in_regs)
1739 regs_saved_in_regs[i].orig_reg = q->reg;
1740 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1743 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1745 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1747 sreg = INVALID_REGNUM;
1748 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1751 queued_reg_saves = NULL;
1752 last_reg_save_label = NULL;
1755 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1756 location for? Or, does it clobber a register which we've previously
1757 said that some other register is saved in, and for which we now
1758 have a new location for? */
1761 clobbers_queued_reg_save (const_rtx insn)
1763 struct queued_reg_save *q;
1765 for (q = queued_reg_saves; q; q = q->next)
1768 if (modified_in_p (q->reg, insn))
1770 for (i = 0; i < num_regs_saved_in_regs; i++)
1771 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1772 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1779 /* Entry point for saving the first register into the second. */
1782 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1785 unsigned int regno, sregno;
1787 for (i = 0; i < num_regs_saved_in_regs; i++)
1788 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1790 if (i == num_regs_saved_in_regs)
1792 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1793 num_regs_saved_in_regs++;
1795 regs_saved_in_regs[i].orig_reg = reg;
1796 regs_saved_in_regs[i].saved_in_reg = sreg;
1798 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1799 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1800 reg_save (label, regno, sregno, 0);
1803 /* What register, if any, is currently saved in REG? */
1806 reg_saved_in (rtx reg)
1808 unsigned int regn = REGNO (reg);
1810 struct queued_reg_save *q;
1812 for (q = queued_reg_saves; q; q = q->next)
1813 if (q->saved_reg && regn == REGNO (q->saved_reg))
1816 for (i = 0; i < num_regs_saved_in_regs; i++)
1817 if (regs_saved_in_regs[i].saved_in_reg
1818 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1819 return regs_saved_in_regs[i].orig_reg;
1825 /* A temporary register holding an integral value used in adjusting SP
1826 or setting up the store_reg. The "offset" field holds the integer
1827 value, not an offset. */
1828 static dw_cfa_location cfa_temp;
1830 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1833 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1835 memset (&cfa, 0, sizeof (cfa));
1837 switch (GET_CODE (pat))
1840 cfa.reg = REGNO (XEXP (pat, 0));
1841 cfa.offset = INTVAL (XEXP (pat, 1));
1845 cfa.reg = REGNO (pat);
1850 pat = XEXP (pat, 0);
1851 if (GET_CODE (pat) == PLUS)
1853 cfa.base_offset = INTVAL (XEXP (pat, 1));
1854 pat = XEXP (pat, 0);
1856 cfa.reg = REGNO (pat);
1860 /* Recurse and define an expression. */
1864 def_cfa_1 (label, &cfa);
1867 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1870 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1874 gcc_assert (GET_CODE (pat) == SET);
1875 dest = XEXP (pat, 0);
1876 src = XEXP (pat, 1);
1878 switch (GET_CODE (src))
1881 gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1882 cfa.offset -= INTVAL (XEXP (src, 1));
1892 cfa.reg = REGNO (dest);
1893 gcc_assert (cfa.indirect == 0);
1895 def_cfa_1 (label, &cfa);
1898 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1901 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1903 HOST_WIDE_INT offset;
1904 rtx src, addr, span;
1906 src = XEXP (set, 1);
1907 addr = XEXP (set, 0);
1908 gcc_assert (MEM_P (addr));
1909 addr = XEXP (addr, 0);
1911 /* As documented, only consider extremely simple addresses. */
1912 switch (GET_CODE (addr))
1915 gcc_assert (REGNO (addr) == cfa.reg);
1916 offset = -cfa.offset;
1919 gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1920 offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1926 span = targetm.dwarf_register_span (src);
1928 /* ??? We'd like to use queue_reg_save, but we need to come up with
1929 a different flushing heuristic for epilogues. */
1931 reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1934 /* We have a PARALLEL describing where the contents of SRC live.
1935 Queue register saves for each piece of the PARALLEL. */
1938 HOST_WIDE_INT span_offset = offset;
1940 gcc_assert (GET_CODE (span) == PARALLEL);
1942 limit = XVECLEN (span, 0);
1943 for (par_index = 0; par_index < limit; par_index++)
1945 rtx elem = XVECEXP (span, 0, par_index);
1947 reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1948 INVALID_REGNUM, span_offset);
1949 span_offset += GET_MODE_SIZE (GET_MODE (elem));
1954 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
1957 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1960 unsigned sregno, dregno;
1962 src = XEXP (set, 1);
1963 dest = XEXP (set, 0);
1966 sregno = DWARF_FRAME_RETURN_COLUMN;
1968 sregno = DWARF_FRAME_REGNUM (REGNO (src));
1970 dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1972 /* ??? We'd like to use queue_reg_save, but we need to come up with
1973 a different flushing heuristic for epilogues. */
1974 reg_save (label, sregno, dregno, 0);
1977 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_EXPRESSION note. */
1980 dwarf2out_frame_debug_cfa_expression (rtx set, const char *label)
1982 rtx src, dest, span;
1983 dw_cfi_ref cfi = new_cfi ();
1985 dest = SET_DEST (set);
1986 src = SET_SRC (set);
1988 gcc_assert (REG_P (src));
1989 gcc_assert (MEM_P (dest));
1991 span = targetm.dwarf_register_span (src);
1994 cfi->dw_cfi_opc = DW_CFA_expression;
1995 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = DWARF_FRAME_REGNUM (REGNO (src));
1996 cfi->dw_cfi_oprnd2.dw_cfi_loc
1997 = mem_loc_descriptor (XEXP (dest, 0), GET_MODE (dest),
1998 VAR_INIT_STATUS_INITIALIZED);
2000 /* ??? We'd like to use queue_reg_save, were the interface different,
2001 and, as above, we could manage flushing for epilogues. */
2002 add_fde_cfi (label, cfi);
2005 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
2008 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
2010 dw_cfi_ref cfi = new_cfi ();
2011 unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
2013 cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
2014 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
2016 add_fde_cfi (label, cfi);
2019 /* Record call frame debugging information for an expression EXPR,
2020 which either sets SP or FP (adjusting how we calculate the frame
2021 address) or saves a register to the stack or another register.
2022 LABEL indicates the address of EXPR.
2024 This function encodes a state machine mapping rtxes to actions on
2025 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
2026 users need not read the source code.
2028 The High-Level Picture
2030 Changes in the register we use to calculate the CFA: Currently we
2031 assume that if you copy the CFA register into another register, we
2032 should take the other one as the new CFA register; this seems to
2033 work pretty well. If it's wrong for some target, it's simple
2034 enough not to set RTX_FRAME_RELATED_P on the insn in question.
2036 Changes in the register we use for saving registers to the stack:
2037 This is usually SP, but not always. Again, we deduce that if you
2038 copy SP into another register (and SP is not the CFA register),
2039 then the new register is the one we will be using for register
2040 saves. This also seems to work.
2042 Register saves: There's not much guesswork about this one; if
2043 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
2044 register save, and the register used to calculate the destination
2045 had better be the one we think we're using for this purpose.
2046 It's also assumed that a copy from a call-saved register to another
2047 register is saving that register if RTX_FRAME_RELATED_P is set on
2048 that instruction. If the copy is from a call-saved register to
2049 the *same* register, that means that the register is now the same
2050 value as in the caller.
2052 Except: If the register being saved is the CFA register, and the
2053 offset is nonzero, we are saving the CFA, so we assume we have to
2054 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
2055 the intent is to save the value of SP from the previous frame.
2057 In addition, if a register has previously been saved to a different
2060 Invariants / Summaries of Rules
2062 cfa current rule for calculating the CFA. It usually
2063 consists of a register and an offset.
2064 cfa_store register used by prologue code to save things to the stack
2065 cfa_store.offset is the offset from the value of
2066 cfa_store.reg to the actual CFA
2067 cfa_temp register holding an integral value. cfa_temp.offset
2068 stores the value, which will be used to adjust the
2069 stack pointer. cfa_temp is also used like cfa_store,
2070 to track stores to the stack via fp or a temp reg.
2072 Rules 1- 4: Setting a register's value to cfa.reg or an expression
2073 with cfa.reg as the first operand changes the cfa.reg and its
2074 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
2077 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
2078 expression yielding a constant. This sets cfa_temp.reg
2079 and cfa_temp.offset.
2081 Rule 5: Create a new register cfa_store used to save items to the
2084 Rules 10-14: Save a register to the stack. Define offset as the
2085 difference of the original location and cfa_store's
2086 location (or cfa_temp's location if cfa_temp is used).
2088 Rules 16-20: If AND operation happens on sp in prologue, we assume
2089 stack is realigned. We will use a group of DW_OP_XXX
2090 expressions to represent the location of the stored
2091 register instead of CFA+offset.
2095 "{a,b}" indicates a choice of a xor b.
2096 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2099 (set <reg1> <reg2>:cfa.reg)
2100 effects: cfa.reg = <reg1>
2101 cfa.offset unchanged
2102 cfa_temp.reg = <reg1>
2103 cfa_temp.offset = cfa.offset
2106 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2107 {<const_int>,<reg>:cfa_temp.reg}))
2108 effects: cfa.reg = sp if fp used
2109 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2110 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2111 if cfa_store.reg==sp
2114 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2115 effects: cfa.reg = fp
2116 cfa_offset += +/- <const_int>
2119 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2120 constraints: <reg1> != fp
2122 effects: cfa.reg = <reg1>
2123 cfa_temp.reg = <reg1>
2124 cfa_temp.offset = cfa.offset
2127 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2128 constraints: <reg1> != fp
2130 effects: cfa_store.reg = <reg1>
2131 cfa_store.offset = cfa.offset - cfa_temp.offset
2134 (set <reg> <const_int>)
2135 effects: cfa_temp.reg = <reg>
2136 cfa_temp.offset = <const_int>
2139 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2140 effects: cfa_temp.reg = <reg1>
2141 cfa_temp.offset |= <const_int>
2144 (set <reg> (high <exp>))
2148 (set <reg> (lo_sum <exp> <const_int>))
2149 effects: cfa_temp.reg = <reg>
2150 cfa_temp.offset = <const_int>
2153 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2154 effects: cfa_store.offset -= <const_int>
2155 cfa.offset = cfa_store.offset if cfa.reg == sp
2157 cfa.base_offset = -cfa_store.offset
2160 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2161 effects: cfa_store.offset += -/+ mode_size(mem)
2162 cfa.offset = cfa_store.offset if cfa.reg == sp
2164 cfa.base_offset = -cfa_store.offset
2167 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2170 effects: cfa.reg = <reg1>
2171 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2174 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2175 effects: cfa.reg = <reg1>
2176 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2179 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2180 effects: cfa.reg = <reg1>
2181 cfa.base_offset = -cfa_temp.offset
2182 cfa_temp.offset -= mode_size(mem)
2185 (set <reg> {unspec, unspec_volatile})
2186 effects: target-dependent
2189 (set sp (and: sp <const_int>))
2190 constraints: cfa_store.reg == sp
2191 effects: current_fde.stack_realign = 1
2192 cfa_store.offset = 0
2193 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2196 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2197 effects: cfa_store.offset += -/+ mode_size(mem)
2200 (set (mem ({pre_inc, pre_dec} sp)) fp)
2201 constraints: fde->stack_realign == 1
2202 effects: cfa_store.offset = 0
2203 cfa.reg != HARD_FRAME_POINTER_REGNUM
2206 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2207 constraints: fde->stack_realign == 1
2209 && cfa.indirect == 0
2210 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2211 effects: Use DW_CFA_def_cfa_expression to define cfa
2212 cfa.reg == fde->drap_reg */
2215 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2217 rtx src, dest, span;
2218 HOST_WIDE_INT offset;
2221 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2222 the PARALLEL independently. The first element is always processed if
2223 it is a SET. This is for backward compatibility. Other elements
2224 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2225 flag is set in them. */
2226 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2229 int limit = XVECLEN (expr, 0);
2232 /* PARALLELs have strict read-modify-write semantics, so we
2233 ought to evaluate every rvalue before changing any lvalue.
2234 It's cumbersome to do that in general, but there's an
2235 easy approximation that is enough for all current users:
2236 handle register saves before register assignments. */
2237 if (GET_CODE (expr) == PARALLEL)
2238 for (par_index = 0; par_index < limit; par_index++)
2240 elem = XVECEXP (expr, 0, par_index);
2241 if (GET_CODE (elem) == SET
2242 && MEM_P (SET_DEST (elem))
2243 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2244 dwarf2out_frame_debug_expr (elem, label);
2247 for (par_index = 0; par_index < limit; par_index++)
2249 elem = XVECEXP (expr, 0, par_index);
2250 if (GET_CODE (elem) == SET
2251 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2252 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2253 dwarf2out_frame_debug_expr (elem, label);
2254 else if (GET_CODE (elem) == SET
2256 && !RTX_FRAME_RELATED_P (elem))
2258 /* Stack adjustment combining might combine some post-prologue
2259 stack adjustment into a prologue stack adjustment. */
2260 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2263 dwarf2out_stack_adjust (offset, label);
2269 gcc_assert (GET_CODE (expr) == SET);
2271 src = SET_SRC (expr);
2272 dest = SET_DEST (expr);
2276 rtx rsi = reg_saved_in (src);
2281 fde = current_fde ();
2283 switch (GET_CODE (dest))
2286 switch (GET_CODE (src))
2288 /* Setting FP from SP. */
2290 if (cfa.reg == (unsigned) REGNO (src))
2293 /* Update the CFA rule wrt SP or FP. Make sure src is
2294 relative to the current CFA register.
2296 We used to require that dest be either SP or FP, but the
2297 ARM copies SP to a temporary register, and from there to
2298 FP. So we just rely on the backends to only set
2299 RTX_FRAME_RELATED_P on appropriate insns. */
2300 cfa.reg = REGNO (dest);
2301 cfa_temp.reg = cfa.reg;
2302 cfa_temp.offset = cfa.offset;
2306 /* Saving a register in a register. */
2307 gcc_assert (!fixed_regs [REGNO (dest)]
2308 /* For the SPARC and its register window. */
2309 || (DWARF_FRAME_REGNUM (REGNO (src))
2310 == DWARF_FRAME_RETURN_COLUMN));
2312 /* After stack is aligned, we can only save SP in FP
2313 if drap register is used. In this case, we have
2314 to restore stack pointer with the CFA value and we
2315 don't generate this DWARF information. */
2317 && fde->stack_realign
2318 && REGNO (src) == STACK_POINTER_REGNUM)
2319 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2320 && fde->drap_reg != INVALID_REGNUM
2321 && cfa.reg != REGNO (src));
2323 queue_reg_save (label, src, dest, 0);
2330 if (dest == stack_pointer_rtx)
2334 switch (GET_CODE (XEXP (src, 1)))
2337 offset = INTVAL (XEXP (src, 1));
2340 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2342 offset = cfa_temp.offset;
2348 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2350 /* Restoring SP from FP in the epilogue. */
2351 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2352 cfa.reg = STACK_POINTER_REGNUM;
2354 else if (GET_CODE (src) == LO_SUM)
2355 /* Assume we've set the source reg of the LO_SUM from sp. */
2358 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2360 if (GET_CODE (src) != MINUS)
2362 if (cfa.reg == STACK_POINTER_REGNUM)
2363 cfa.offset += offset;
2364 if (cfa_store.reg == STACK_POINTER_REGNUM)
2365 cfa_store.offset += offset;
2367 else if (dest == hard_frame_pointer_rtx)
2370 /* Either setting the FP from an offset of the SP,
2371 or adjusting the FP */
2372 gcc_assert (frame_pointer_needed);
2374 gcc_assert (REG_P (XEXP (src, 0))
2375 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2376 && CONST_INT_P (XEXP (src, 1)));
2377 offset = INTVAL (XEXP (src, 1));
2378 if (GET_CODE (src) != MINUS)
2380 cfa.offset += offset;
2381 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2385 gcc_assert (GET_CODE (src) != MINUS);
2388 if (REG_P (XEXP (src, 0))
2389 && REGNO (XEXP (src, 0)) == cfa.reg
2390 && CONST_INT_P (XEXP (src, 1)))
2392 /* Setting a temporary CFA register that will be copied
2393 into the FP later on. */
2394 offset = - INTVAL (XEXP (src, 1));
2395 cfa.offset += offset;
2396 cfa.reg = REGNO (dest);
2397 /* Or used to save regs to the stack. */
2398 cfa_temp.reg = cfa.reg;
2399 cfa_temp.offset = cfa.offset;
2403 else if (REG_P (XEXP (src, 0))
2404 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2405 && XEXP (src, 1) == stack_pointer_rtx)
2407 /* Setting a scratch register that we will use instead
2408 of SP for saving registers to the stack. */
2409 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2410 cfa_store.reg = REGNO (dest);
2411 cfa_store.offset = cfa.offset - cfa_temp.offset;
2415 else if (GET_CODE (src) == LO_SUM
2416 && CONST_INT_P (XEXP (src, 1)))
2418 cfa_temp.reg = REGNO (dest);
2419 cfa_temp.offset = INTVAL (XEXP (src, 1));
2428 cfa_temp.reg = REGNO (dest);
2429 cfa_temp.offset = INTVAL (src);
2434 gcc_assert (REG_P (XEXP (src, 0))
2435 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2436 && CONST_INT_P (XEXP (src, 1)));
2438 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2439 cfa_temp.reg = REGNO (dest);
2440 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2443 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2444 which will fill in all of the bits. */
2451 case UNSPEC_VOLATILE:
2452 gcc_assert (targetm.dwarf_handle_frame_unspec);
2453 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2458 /* If this AND operation happens on stack pointer in prologue,
2459 we assume the stack is realigned and we extract the
2461 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2463 /* We interpret reg_save differently with stack_realign set.
2464 Thus we must flush whatever we have queued first. */
2465 dwarf2out_flush_queued_reg_saves ();
2467 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2468 fde->stack_realign = 1;
2469 fde->stack_realignment = INTVAL (XEXP (src, 1));
2470 cfa_store.offset = 0;
2472 if (cfa.reg != STACK_POINTER_REGNUM
2473 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2474 fde->drap_reg = cfa.reg;
2482 def_cfa_1 (label, &cfa);
2487 /* Saving a register to the stack. Make sure dest is relative to the
2489 switch (GET_CODE (XEXP (dest, 0)))
2494 /* We can't handle variable size modifications. */
2495 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2497 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2499 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2500 && cfa_store.reg == STACK_POINTER_REGNUM);
2502 cfa_store.offset += offset;
2503 if (cfa.reg == STACK_POINTER_REGNUM)
2504 cfa.offset = cfa_store.offset;
2506 offset = -cfa_store.offset;
2512 offset = GET_MODE_SIZE (GET_MODE (dest));
2513 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2516 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2517 == STACK_POINTER_REGNUM)
2518 && cfa_store.reg == STACK_POINTER_REGNUM);
2520 cfa_store.offset += offset;
2522 /* Rule 18: If stack is aligned, we will use FP as a
2523 reference to represent the address of the stored
2526 && fde->stack_realign
2527 && src == hard_frame_pointer_rtx)
2529 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2530 cfa_store.offset = 0;
2533 if (cfa.reg == STACK_POINTER_REGNUM)
2534 cfa.offset = cfa_store.offset;
2536 offset = -cfa_store.offset;
2540 /* With an offset. */
2547 gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2548 && REG_P (XEXP (XEXP (dest, 0), 0)));
2549 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2550 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2553 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2555 if (cfa.reg == (unsigned) regno)
2556 offset -= cfa.offset;
2557 else if (cfa_store.reg == (unsigned) regno)
2558 offset -= cfa_store.offset;
2561 gcc_assert (cfa_temp.reg == (unsigned) regno);
2562 offset -= cfa_temp.offset;
2568 /* Without an offset. */
2571 int regno = REGNO (XEXP (dest, 0));
2573 if (cfa.reg == (unsigned) regno)
2574 offset = -cfa.offset;
2575 else if (cfa_store.reg == (unsigned) regno)
2576 offset = -cfa_store.offset;
2579 gcc_assert (cfa_temp.reg == (unsigned) regno);
2580 offset = -cfa_temp.offset;
2587 gcc_assert (cfa_temp.reg
2588 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2589 offset = -cfa_temp.offset;
2590 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2598 /* If the source operand of this MEM operation is not a
2599 register, basically the source is return address. Here
2600 we only care how much stack grew and we don't save it. */
2604 if (REGNO (src) != STACK_POINTER_REGNUM
2605 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2606 && (unsigned) REGNO (src) == cfa.reg)
2608 /* We're storing the current CFA reg into the stack. */
2610 if (cfa.offset == 0)
2613 /* If stack is aligned, putting CFA reg into stack means
2614 we can no longer use reg + offset to represent CFA.
2615 Here we use DW_CFA_def_cfa_expression instead. The
2616 result of this expression equals to the original CFA
2619 && fde->stack_realign
2620 && cfa.indirect == 0
2621 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2623 dw_cfa_location cfa_exp;
2625 gcc_assert (fde->drap_reg == cfa.reg);
2627 cfa_exp.indirect = 1;
2628 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2629 cfa_exp.base_offset = offset;
2632 fde->drap_reg_saved = 1;
2634 def_cfa_1 (label, &cfa_exp);
2638 /* If the source register is exactly the CFA, assume
2639 we're saving SP like any other register; this happens
2641 def_cfa_1 (label, &cfa);
2642 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2647 /* Otherwise, we'll need to look in the stack to
2648 calculate the CFA. */
2649 rtx x = XEXP (dest, 0);
2653 gcc_assert (REG_P (x));
2655 cfa.reg = REGNO (x);
2656 cfa.base_offset = offset;
2658 def_cfa_1 (label, &cfa);
2663 def_cfa_1 (label, &cfa);
2665 span = targetm.dwarf_register_span (src);
2668 queue_reg_save (label, src, NULL_RTX, offset);
2671 /* We have a PARALLEL describing where the contents of SRC
2672 live. Queue register saves for each piece of the
2676 HOST_WIDE_INT span_offset = offset;
2678 gcc_assert (GET_CODE (span) == PARALLEL);
2680 limit = XVECLEN (span, 0);
2681 for (par_index = 0; par_index < limit; par_index++)
2683 rtx elem = XVECEXP (span, 0, par_index);
2685 queue_reg_save (label, elem, NULL_RTX, span_offset);
2686 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2697 /* Record call frame debugging information for INSN, which either
2698 sets SP or FP (adjusting how we calculate the frame address) or saves a
2699 register to the stack. If INSN is NULL_RTX, initialize our state.
2701 If AFTER_P is false, we're being called before the insn is emitted,
2702 otherwise after. Call instructions get invoked twice. */
2705 dwarf2out_frame_debug (rtx insn, bool after_p)
2709 bool handled_one = false;
2711 if (insn == NULL_RTX)
2715 /* Flush any queued register saves. */
2716 dwarf2out_flush_queued_reg_saves ();
2718 /* Set up state for generating call frame debug info. */
2721 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2723 cfa.reg = STACK_POINTER_REGNUM;
2726 cfa_temp.offset = 0;
2728 for (i = 0; i < num_regs_saved_in_regs; i++)
2730 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2731 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2733 num_regs_saved_in_regs = 0;
2735 if (barrier_args_size)
2737 XDELETEVEC (barrier_args_size);
2738 barrier_args_size = NULL;
2743 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2744 dwarf2out_flush_queued_reg_saves ();
2746 if (!RTX_FRAME_RELATED_P (insn))
2748 /* ??? This should be done unconditionally since stack adjustments
2749 matter if the stack pointer is not the CFA register anymore but
2750 is still used to save registers. */
2751 if (!ACCUMULATE_OUTGOING_ARGS)
2752 dwarf2out_notice_stack_adjust (insn, after_p);
2756 label = dwarf2out_cfi_label (false);
2757 any_cfis_emitted = false;
2759 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2760 switch (REG_NOTE_KIND (note))
2762 case REG_FRAME_RELATED_EXPR:
2763 insn = XEXP (note, 0);
2766 case REG_CFA_DEF_CFA:
2767 dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2771 case REG_CFA_ADJUST_CFA:
2776 if (GET_CODE (n) == PARALLEL)
2777 n = XVECEXP (n, 0, 0);
2779 dwarf2out_frame_debug_adjust_cfa (n, label);
2783 case REG_CFA_OFFSET:
2786 n = single_set (insn);
2787 dwarf2out_frame_debug_cfa_offset (n, label);
2791 case REG_CFA_REGISTER:
2796 if (GET_CODE (n) == PARALLEL)
2797 n = XVECEXP (n, 0, 0);
2799 dwarf2out_frame_debug_cfa_register (n, label);
2803 case REG_CFA_EXPRESSION:
2806 n = single_set (insn);
2807 dwarf2out_frame_debug_cfa_expression (n, label);
2811 case REG_CFA_RESTORE:
2816 if (GET_CODE (n) == PARALLEL)
2817 n = XVECEXP (n, 0, 0);
2820 dwarf2out_frame_debug_cfa_restore (n, label);
2824 case REG_CFA_SET_VDRAP:
2828 dw_fde_ref fde = current_fde ();
2831 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2833 fde->vdrap_reg = REGNO (n);
2844 if (any_cfis_emitted)
2845 dwarf2out_flush_queued_reg_saves ();
2849 insn = PATTERN (insn);
2851 dwarf2out_frame_debug_expr (insn, label);
2853 /* Check again. A parallel can save and update the same register.
2854 We could probably check just once, here, but this is safer than
2855 removing the check above. */
2856 if (any_cfis_emitted || clobbers_queued_reg_save (insn))
2857 dwarf2out_flush_queued_reg_saves ();
2860 /* Determine if we need to save and restore CFI information around this
2861 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2862 we do need to save/restore, then emit the save now, and insert a
2863 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2866 dwarf2out_cfi_begin_epilogue (rtx insn)
2868 bool saw_frp = false;
2871 /* Scan forward to the return insn, noticing if there are possible
2872 frame related insns. */
2873 for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2878 /* Look for both regular and sibcalls to end the block. */
2879 if (returnjump_p (i))
2881 if (CALL_P (i) && SIBLING_CALL_P (i))
2884 if (GET_CODE (PATTERN (i)) == SEQUENCE)
2887 rtx seq = PATTERN (i);
2889 if (returnjump_p (XVECEXP (seq, 0, 0)))
2891 if (CALL_P (XVECEXP (seq, 0, 0))
2892 && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2895 for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2896 if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2900 if (RTX_FRAME_RELATED_P (i))
2904 /* If the port doesn't emit epilogue unwind info, we don't need a
2905 save/restore pair. */
2909 /* Otherwise, search forward to see if the return insn was the last
2910 basic block of the function. If so, we don't need save/restore. */
2911 gcc_assert (i != NULL);
2912 i = next_real_insn (i);
2916 /* Insert the restore before that next real insn in the stream, and before
2917 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2918 properly nested. This should be after any label or alignment. This
2919 will be pushed into the CFI stream by the function below. */
2922 rtx p = PREV_INSN (i);
2925 if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2929 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2931 emit_cfa_remember = true;
2933 /* And emulate the state save. */
2934 gcc_assert (!cfa_remember.in_use);
2936 cfa_remember.in_use = 1;
2939 /* A "subroutine" of dwarf2out_cfi_begin_epilogue. Emit the restore
2943 dwarf2out_frame_debug_restore_state (void)
2945 dw_cfi_ref cfi = new_cfi ();
2946 const char *label = dwarf2out_cfi_label (false);
2948 cfi->dw_cfi_opc = DW_CFA_restore_state;
2949 add_fde_cfi (label, cfi);
2951 gcc_assert (cfa_remember.in_use);
2953 cfa_remember.in_use = 0;
2956 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2957 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2958 (enum dwarf_call_frame_info cfi);
2960 static enum dw_cfi_oprnd_type
2961 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2966 case DW_CFA_GNU_window_save:
2967 case DW_CFA_remember_state:
2968 case DW_CFA_restore_state:
2969 return dw_cfi_oprnd_unused;
2971 case DW_CFA_set_loc:
2972 case DW_CFA_advance_loc1:
2973 case DW_CFA_advance_loc2:
2974 case DW_CFA_advance_loc4:
2975 case DW_CFA_MIPS_advance_loc8:
2976 return dw_cfi_oprnd_addr;
2979 case DW_CFA_offset_extended:
2980 case DW_CFA_def_cfa:
2981 case DW_CFA_offset_extended_sf:
2982 case DW_CFA_def_cfa_sf:
2983 case DW_CFA_restore:
2984 case DW_CFA_restore_extended:
2985 case DW_CFA_undefined:
2986 case DW_CFA_same_value:
2987 case DW_CFA_def_cfa_register:
2988 case DW_CFA_register:
2989 case DW_CFA_expression:
2990 return dw_cfi_oprnd_reg_num;
2992 case DW_CFA_def_cfa_offset:
2993 case DW_CFA_GNU_args_size:
2994 case DW_CFA_def_cfa_offset_sf:
2995 return dw_cfi_oprnd_offset;
2997 case DW_CFA_def_cfa_expression:
2998 return dw_cfi_oprnd_loc;
3005 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
3006 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
3007 (enum dwarf_call_frame_info cfi);
3009 static enum dw_cfi_oprnd_type
3010 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
3014 case DW_CFA_def_cfa:
3015 case DW_CFA_def_cfa_sf:
3017 case DW_CFA_offset_extended_sf:
3018 case DW_CFA_offset_extended:
3019 return dw_cfi_oprnd_offset;
3021 case DW_CFA_register:
3022 return dw_cfi_oprnd_reg_num;
3024 case DW_CFA_expression:
3025 return dw_cfi_oprnd_loc;
3028 return dw_cfi_oprnd_unused;
3032 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
3033 switch to the data section instead, and write out a synthetic start label
3034 for collect2 the first time around. */
3037 switch_to_eh_frame_section (bool back)
3041 #ifdef EH_FRAME_SECTION_NAME
3042 if (eh_frame_section == 0)
3046 if (EH_TABLES_CAN_BE_READ_ONLY)
3052 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
3054 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
3056 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
3058 flags = ((! flag_pic
3059 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
3060 && (fde_encoding & 0x70) != DW_EH_PE_aligned
3061 && (per_encoding & 0x70) != DW_EH_PE_absptr
3062 && (per_encoding & 0x70) != DW_EH_PE_aligned
3063 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
3064 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
3065 ? 0 : SECTION_WRITE);
3068 flags = SECTION_WRITE;
3069 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
3071 #endif /* EH_FRAME_SECTION_NAME */
3073 if (eh_frame_section)
3074 switch_to_section (eh_frame_section);
3077 /* We have no special eh_frame section. Put the information in
3078 the data section and emit special labels to guide collect2. */
3079 switch_to_section (data_section);
3083 label = get_file_function_name ("F");
3084 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3085 targetm.asm_out.globalize_label (asm_out_file,
3086 IDENTIFIER_POINTER (label));
3087 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
3092 /* Switch [BACK] to the eh or debug frame table section, depending on
3096 switch_to_frame_table_section (int for_eh, bool back)
3099 switch_to_eh_frame_section (back);
3102 if (!debug_frame_section)
3103 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3104 SECTION_DEBUG, NULL);
3105 switch_to_section (debug_frame_section);
3109 /* Output a Call Frame Information opcode and its operand(s). */
3112 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3117 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3118 dw2_asm_output_data (1, (cfi->dw_cfi_opc
3119 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3120 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3121 ((unsigned HOST_WIDE_INT)
3122 cfi->dw_cfi_oprnd1.dw_cfi_offset));
3123 else if (cfi->dw_cfi_opc == DW_CFA_offset)
3125 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3126 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3127 "DW_CFA_offset, column %#lx", r);
3128 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3129 dw2_asm_output_data_uleb128 (off, NULL);
3131 else if (cfi->dw_cfi_opc == DW_CFA_restore)
3133 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3134 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3135 "DW_CFA_restore, column %#lx", r);
3139 dw2_asm_output_data (1, cfi->dw_cfi_opc,
3140 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3142 switch (cfi->dw_cfi_opc)
3144 case DW_CFA_set_loc:
3146 dw2_asm_output_encoded_addr_rtx (
3147 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3148 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3151 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3152 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3153 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3156 case DW_CFA_advance_loc1:
3157 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3158 fde->dw_fde_current_label, NULL);
3159 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3162 case DW_CFA_advance_loc2:
3163 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3164 fde->dw_fde_current_label, NULL);
3165 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3168 case DW_CFA_advance_loc4:
3169 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3170 fde->dw_fde_current_label, NULL);
3171 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3174 case DW_CFA_MIPS_advance_loc8:
3175 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3176 fde->dw_fde_current_label, NULL);
3177 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3180 case DW_CFA_offset_extended:
3181 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3182 dw2_asm_output_data_uleb128 (r, NULL);
3183 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3184 dw2_asm_output_data_uleb128 (off, NULL);
3187 case DW_CFA_def_cfa:
3188 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3189 dw2_asm_output_data_uleb128 (r, NULL);
3190 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3193 case DW_CFA_offset_extended_sf:
3194 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3195 dw2_asm_output_data_uleb128 (r, NULL);
3196 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3197 dw2_asm_output_data_sleb128 (off, NULL);
3200 case DW_CFA_def_cfa_sf:
3201 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3202 dw2_asm_output_data_uleb128 (r, NULL);
3203 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3204 dw2_asm_output_data_sleb128 (off, NULL);
3207 case DW_CFA_restore_extended:
3208 case DW_CFA_undefined:
3209 case DW_CFA_same_value:
3210 case DW_CFA_def_cfa_register:
3211 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3212 dw2_asm_output_data_uleb128 (r, NULL);
3215 case DW_CFA_register:
3216 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3217 dw2_asm_output_data_uleb128 (r, NULL);
3218 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3219 dw2_asm_output_data_uleb128 (r, NULL);
3222 case DW_CFA_def_cfa_offset:
3223 case DW_CFA_GNU_args_size:
3224 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3227 case DW_CFA_def_cfa_offset_sf:
3228 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3229 dw2_asm_output_data_sleb128 (off, NULL);
3232 case DW_CFA_GNU_window_save:
3235 case DW_CFA_def_cfa_expression:
3236 case DW_CFA_expression:
3237 output_cfa_loc (cfi);
3240 case DW_CFA_GNU_negative_offset_extended:
3241 /* Obsoleted by DW_CFA_offset_extended_sf. */
3250 /* Similar, but do it via assembler directives instead. */
3253 output_cfi_directive (dw_cfi_ref cfi)
3255 unsigned long r, r2;
3257 switch (cfi->dw_cfi_opc)
3259 case DW_CFA_advance_loc:
3260 case DW_CFA_advance_loc1:
3261 case DW_CFA_advance_loc2:
3262 case DW_CFA_advance_loc4:
3263 case DW_CFA_MIPS_advance_loc8:
3264 case DW_CFA_set_loc:
3265 /* Should only be created by add_fde_cfi in a code path not
3266 followed when emitting via directives. The assembler is
3267 going to take care of this for us. */
3271 case DW_CFA_offset_extended:
3272 case DW_CFA_offset_extended_sf:
3273 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3274 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3275 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3278 case DW_CFA_restore:
3279 case DW_CFA_restore_extended:
3280 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3281 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3284 case DW_CFA_undefined:
3285 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3286 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3289 case DW_CFA_same_value:
3290 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3291 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3294 case DW_CFA_def_cfa:
3295 case DW_CFA_def_cfa_sf:
3296 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3297 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3298 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3301 case DW_CFA_def_cfa_register:
3302 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3303 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3306 case DW_CFA_register:
3307 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3308 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3309 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3312 case DW_CFA_def_cfa_offset:
3313 case DW_CFA_def_cfa_offset_sf:
3314 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3315 HOST_WIDE_INT_PRINT_DEC"\n",
3316 cfi->dw_cfi_oprnd1.dw_cfi_offset);
3319 case DW_CFA_remember_state:
3320 fprintf (asm_out_file, "\t.cfi_remember_state\n");
3322 case DW_CFA_restore_state:
3323 fprintf (asm_out_file, "\t.cfi_restore_state\n");
3326 case DW_CFA_GNU_args_size:
3327 fprintf (asm_out_file, "\t.cfi_escape %#x,", DW_CFA_GNU_args_size);
3328 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3330 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3331 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3332 fputc ('\n', asm_out_file);
3335 case DW_CFA_GNU_window_save:
3336 fprintf (asm_out_file, "\t.cfi_window_save\n");
3339 case DW_CFA_def_cfa_expression:
3340 case DW_CFA_expression:
3341 fprintf (asm_out_file, "\t.cfi_escape %#x,", cfi->dw_cfi_opc);
3342 output_cfa_loc_raw (cfi);
3343 fputc ('\n', asm_out_file);
3351 DEF_VEC_P (dw_cfi_ref);
3352 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
3354 /* Output CFIs to bring current FDE to the same state as after executing
3355 CFIs in CFI chain. DO_CFI_ASM is true if .cfi_* directives shall
3356 be emitted, false otherwise. If it is false, FDE and FOR_EH are the
3357 other arguments to pass to output_cfi. */
3360 output_cfis (dw_cfi_ref cfi, bool do_cfi_asm, dw_fde_ref fde, bool for_eh)
3362 struct dw_cfi_struct cfi_buf;
3364 dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3365 VEC (dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3366 unsigned int len, idx;
3368 for (;; cfi = cfi->dw_cfi_next)
3369 switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3371 case DW_CFA_advance_loc:
3372 case DW_CFA_advance_loc1:
3373 case DW_CFA_advance_loc2:
3374 case DW_CFA_advance_loc4:
3375 case DW_CFA_MIPS_advance_loc8:
3376 case DW_CFA_set_loc:
3377 /* All advances should be ignored. */
3379 case DW_CFA_remember_state:
3381 dw_cfi_ref args_size = cfi_args_size;
3383 /* Skip everything between .cfi_remember_state and
3384 .cfi_restore_state. */
3385 for (cfi2 = cfi->dw_cfi_next; cfi2; cfi2 = cfi2->dw_cfi_next)
3386 if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3388 else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3391 gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3398 cfi_args_size = args_size;
3402 case DW_CFA_GNU_args_size:
3403 cfi_args_size = cfi;
3405 case DW_CFA_GNU_window_save:
3408 case DW_CFA_offset_extended:
3409 case DW_CFA_offset_extended_sf:
3410 case DW_CFA_restore:
3411 case DW_CFA_restore_extended:
3412 case DW_CFA_undefined:
3413 case DW_CFA_same_value:
3414 case DW_CFA_register:
3415 case DW_CFA_val_offset:
3416 case DW_CFA_val_offset_sf:
3417 case DW_CFA_expression:
3418 case DW_CFA_val_expression:
3419 case DW_CFA_GNU_negative_offset_extended:
3420 if (VEC_length (dw_cfi_ref, regs) <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3421 VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3422 cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3423 VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, cfi);
3425 case DW_CFA_def_cfa:
3426 case DW_CFA_def_cfa_sf:
3427 case DW_CFA_def_cfa_expression:
3429 cfi_cfa_offset = cfi;
3431 case DW_CFA_def_cfa_register:
3434 case DW_CFA_def_cfa_offset:
3435 case DW_CFA_def_cfa_offset_sf:
3436 cfi_cfa_offset = cfi;
3439 gcc_assert (cfi == NULL);
3441 len = VEC_length (dw_cfi_ref, regs);
3442 for (idx = 0; idx < len; idx++)
3444 cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3446 && cfi2->dw_cfi_opc != DW_CFA_restore
3447 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3450 output_cfi_directive (cfi2);
3452 output_cfi (cfi2, fde, for_eh);
3455 if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3457 gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3459 switch (cfi_cfa_offset->dw_cfi_opc)
3461 case DW_CFA_def_cfa_offset:
3462 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3463 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3465 case DW_CFA_def_cfa_offset_sf:
3466 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3467 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3469 case DW_CFA_def_cfa:
3470 case DW_CFA_def_cfa_sf:
3471 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3472 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3479 else if (cfi_cfa_offset)
3480 cfi_cfa = cfi_cfa_offset;
3484 output_cfi_directive (cfi_cfa);
3486 output_cfi (cfi_cfa, fde, for_eh);
3489 cfi_cfa_offset = NULL;
3491 && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3494 output_cfi_directive (cfi_args_size);
3496 output_cfi (cfi_args_size, fde, for_eh);
3498 cfi_args_size = NULL;
3501 VEC_free (dw_cfi_ref, heap, regs);
3504 else if (do_cfi_asm)
3505 output_cfi_directive (cfi);
3507 output_cfi (cfi, fde, for_eh);
3514 /* Output one FDE. */
3517 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3518 char *section_start_label, int fde_encoding, char *augmentation,
3519 bool any_lsda_needed, int lsda_encoding)
3521 const char *begin, *end;
3522 static unsigned int j;
3523 char l1[20], l2[20];
3526 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
3528 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3530 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3531 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3532 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3533 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3534 " indicating 64-bit DWARF extension");
3535 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3537 ASM_OUTPUT_LABEL (asm_out_file, l1);
3540 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3542 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3543 debug_frame_section, "FDE CIE offset");
3545 if (!fde->dw_fde_switched_sections)
3547 begin = fde->dw_fde_begin;
3548 end = fde->dw_fde_end;
3552 /* For the first section, prefer dw_fde_begin over
3553 dw_fde_{hot,cold}_section_label, as the latter
3554 might be separated from the real start of the
3555 function by alignment padding. */
3557 begin = fde->dw_fde_begin;
3558 else if (fde->dw_fde_switched_cold_to_hot)
3559 begin = fde->dw_fde_hot_section_label;
3561 begin = fde->dw_fde_unlikely_section_label;
3562 if (second ^ fde->dw_fde_switched_cold_to_hot)
3563 end = fde->dw_fde_unlikely_section_end_label;
3565 end = fde->dw_fde_hot_section_end_label;
3570 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
3571 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3572 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
3573 "FDE initial location");
3574 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3575 end, begin, "FDE address range");
3579 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
3580 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
3583 if (augmentation[0])
3585 if (any_lsda_needed)
3587 int size = size_of_encoded_value (lsda_encoding);
3589 if (lsda_encoding == DW_EH_PE_aligned)
3591 int offset = ( 4 /* Length */
3592 + 4 /* CIE offset */
3593 + 2 * size_of_encoded_value (fde_encoding)
3594 + 1 /* Augmentation size */ );
3595 int pad = -offset & (PTR_SIZE - 1);
3598 gcc_assert (size_of_uleb128 (size) == 1);
3601 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3603 if (fde->uses_eh_lsda)
3605 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
3606 fde->funcdef_number);
3607 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
3608 gen_rtx_SYMBOL_REF (Pmode, l1),
3610 "Language Specific Data Area");
3614 if (lsda_encoding == DW_EH_PE_aligned)
3615 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3616 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
3617 "Language Specific Data Area (none)");
3621 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3624 /* Loop through the Call Frame Instructions associated with
3626 fde->dw_fde_current_label = begin;
3627 if (!fde->dw_fde_switched_sections)
3628 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3629 output_cfi (cfi, fde, for_eh);
3632 if (fde->dw_fde_switch_cfi)
3633 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3635 output_cfi (cfi, fde, for_eh);
3636 if (cfi == fde->dw_fde_switch_cfi)
3642 dw_cfi_ref cfi_next = fde->dw_fde_cfi;
3644 if (fde->dw_fde_switch_cfi)
3646 cfi_next = fde->dw_fde_switch_cfi->dw_cfi_next;
3647 fde->dw_fde_switch_cfi->dw_cfi_next = NULL;
3648 output_cfis (fde->dw_fde_cfi, false, fde, for_eh);
3649 fde->dw_fde_switch_cfi->dw_cfi_next = cfi_next;
3651 for (cfi = cfi_next; cfi != NULL; cfi = cfi->dw_cfi_next)
3652 output_cfi (cfi, fde, for_eh);
3655 /* If we are to emit a ref/link from function bodies to their frame tables,
3656 do it now. This is typically performed to make sure that tables
3657 associated with functions are dragged with them and not discarded in
3658 garbage collecting links. We need to do this on a per function basis to
3659 cope with -ffunction-sections. */
3661 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3662 /* Switch to the function section, emit the ref to the tables, and
3663 switch *back* into the table section. */
3664 switch_to_section (function_section (fde->decl));
3665 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
3666 switch_to_frame_table_section (for_eh, true);
3669 /* Pad the FDE out to an address sized boundary. */
3670 ASM_OUTPUT_ALIGN (asm_out_file,
3671 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3672 ASM_OUTPUT_LABEL (asm_out_file, l2);
3677 /* Return true if frame description entry FDE is needed for EH. */
3680 fde_needed_for_eh_p (dw_fde_ref fde)
3682 if (flag_asynchronous_unwind_tables)
3685 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
3688 if (fde->uses_eh_lsda)
3691 /* If exceptions are enabled, we have collected nothrow info. */
3692 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
3698 /* Output the call frame information used to record information
3699 that relates to calculating the frame pointer, and records the
3700 location of saved registers. */
3703 output_call_frame_info (int for_eh)
3708 char l1[20], l2[20], section_start_label[20];
3709 bool any_lsda_needed = false;
3710 char augmentation[6];
3711 int augmentation_size;
3712 int fde_encoding = DW_EH_PE_absptr;
3713 int per_encoding = DW_EH_PE_absptr;
3714 int lsda_encoding = DW_EH_PE_absptr;
3716 rtx personality = NULL;
3719 /* Don't emit a CIE if there won't be any FDEs. */
3720 if (fde_table_in_use == 0)
3723 /* Nothing to do if the assembler's doing it all. */
3724 if (dwarf2out_do_cfi_asm ())
3727 /* If we don't have any functions we'll want to unwind out of, don't emit
3728 any EH unwind information. If we make FDEs linkonce, we may have to
3729 emit an empty label for an FDE that wouldn't otherwise be emitted. We
3730 want to avoid having an FDE kept around when the function it refers to
3731 is discarded. Example where this matters: a primary function template
3732 in C++ requires EH information, an explicit specialization doesn't. */
3735 bool any_eh_needed = false;
3737 for (i = 0; i < fde_table_in_use; i++)
3738 if (fde_table[i].uses_eh_lsda)
3739 any_eh_needed = any_lsda_needed = true;
3740 else if (fde_needed_for_eh_p (&fde_table[i]))
3741 any_eh_needed = true;
3742 else if (TARGET_USES_WEAK_UNWIND_INFO)
3743 targetm.asm_out.emit_unwind_label (asm_out_file, fde_table[i].decl,
3750 /* We're going to be generating comments, so turn on app. */
3754 /* Switch to the proper frame section, first time. */
3755 switch_to_frame_table_section (for_eh, false);
3757 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3758 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3760 /* Output the CIE. */
3761 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3762 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3763 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3764 dw2_asm_output_data (4, 0xffffffff,
3765 "Initial length escape value indicating 64-bit DWARF extension");
3766 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3767 "Length of Common Information Entry");
3768 ASM_OUTPUT_LABEL (asm_out_file, l1);
3770 /* Now that the CIE pointer is PC-relative for EH,
3771 use 0 to identify the CIE. */
3772 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3773 (for_eh ? 0 : DWARF_CIE_ID),
3774 "CIE Identifier Tag");
3776 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3777 use CIE version 1, unless that would produce incorrect results
3778 due to overflowing the return register column. */
3779 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3781 if (return_reg >= 256 || dwarf_version > 2)
3783 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
3785 augmentation[0] = 0;
3786 augmentation_size = 0;
3788 personality = current_unit_personality;
3794 z Indicates that a uleb128 is present to size the
3795 augmentation section.
3796 L Indicates the encoding (and thus presence) of
3797 an LSDA pointer in the FDE augmentation.
3798 R Indicates a non-default pointer encoding for
3800 P Indicates the presence of an encoding + language
3801 personality routine in the CIE augmentation. */
3803 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3804 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3805 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3807 p = augmentation + 1;
3811 augmentation_size += 1 + size_of_encoded_value (per_encoding);
3812 assemble_external_libcall (personality);
3814 if (any_lsda_needed)
3817 augmentation_size += 1;
3819 if (fde_encoding != DW_EH_PE_absptr)
3822 augmentation_size += 1;
3824 if (p > augmentation + 1)
3826 augmentation[0] = 'z';
3830 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3831 if (personality && per_encoding == DW_EH_PE_aligned)
3833 int offset = ( 4 /* Length */
3835 + 1 /* CIE version */
3836 + strlen (augmentation) + 1 /* Augmentation */
3837 + size_of_uleb128 (1) /* Code alignment */
3838 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3840 + 1 /* Augmentation size */
3841 + 1 /* Personality encoding */ );
3842 int pad = -offset & (PTR_SIZE - 1);
3844 augmentation_size += pad;
3846 /* Augmentations should be small, so there's scarce need to
3847 iterate for a solution. Die if we exceed one uleb128 byte. */
3848 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3852 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3853 if (dw_cie_version >= 4)
3855 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
3856 dw2_asm_output_data (1, 0, "CIE Segment Size");
3858 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3859 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3860 "CIE Data Alignment Factor");
3862 if (dw_cie_version == 1)
3863 dw2_asm_output_data (1, return_reg, "CIE RA Column");
3865 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3867 if (augmentation[0])
3869 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3872 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3873 eh_data_format_name (per_encoding));
3874 dw2_asm_output_encoded_addr_rtx (per_encoding,
3879 if (any_lsda_needed)
3880 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3881 eh_data_format_name (lsda_encoding));
3883 if (fde_encoding != DW_EH_PE_absptr)
3884 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3885 eh_data_format_name (fde_encoding));
3888 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3889 output_cfi (cfi, NULL, for_eh);
3891 /* Pad the CIE out to an address sized boundary. */
3892 ASM_OUTPUT_ALIGN (asm_out_file,
3893 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3894 ASM_OUTPUT_LABEL (asm_out_file, l2);
3896 /* Loop through all of the FDE's. */
3897 for (i = 0; i < fde_table_in_use; i++)
3900 fde = &fde_table[i];
3902 /* Don't emit EH unwind info for leaf functions that don't need it. */
3903 if (for_eh && !fde_needed_for_eh_p (fde))
3906 for (k = 0; k < (fde->dw_fde_switched_sections ? 2 : 1); k++)
3907 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
3908 augmentation, any_lsda_needed, lsda_encoding);
3911 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3912 dw2_asm_output_data (4, 0, "End of Table");
3913 #ifdef MIPS_DEBUGGING_INFO
3914 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3915 get a value of 0. Putting .align 0 after the label fixes it. */
3916 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3919 /* Turn off app to make assembly quicker. */
3924 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
3927 dwarf2out_do_cfi_startproc (bool second)
3931 rtx personality = get_personality_function (current_function_decl);
3933 fprintf (asm_out_file, "\t.cfi_startproc\n");
3937 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3940 /* ??? The GAS support isn't entirely consistent. We have to
3941 handle indirect support ourselves, but PC-relative is done
3942 in the assembler. Further, the assembler can't handle any
3943 of the weirder relocation types. */
3944 if (enc & DW_EH_PE_indirect)
3945 ref = dw2_force_const_mem (ref, true);
3947 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
3948 output_addr_const (asm_out_file, ref);
3949 fputc ('\n', asm_out_file);
3952 if (crtl->uses_eh_lsda)
3956 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3957 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
3958 current_function_funcdef_no);
3959 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3960 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3962 if (enc & DW_EH_PE_indirect)
3963 ref = dw2_force_const_mem (ref, true);
3965 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
3966 output_addr_const (asm_out_file, ref);
3967 fputc ('\n', asm_out_file);
3971 /* Output a marker (i.e. a label) for the beginning of a function, before
3975 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3976 const char *file ATTRIBUTE_UNUSED)
3978 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3984 current_function_func_begin_label = NULL;
3986 do_frame = dwarf2out_do_frame ();
3988 /* ??? current_function_func_begin_label is also used by except.c for
3989 call-site information. We must emit this label if it might be used. */
3991 && (!flag_exceptions
3992 || targetm.except_unwind_info () != UI_TARGET))
3995 fnsec = function_section (current_function_decl);
3996 switch_to_section (fnsec);
3997 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3998 current_function_funcdef_no);
3999 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
4000 current_function_funcdef_no);
4001 dup_label = xstrdup (label);
4002 current_function_func_begin_label = dup_label;
4004 /* We can elide the fde allocation if we're not emitting debug info. */
4008 /* Expand the fde table if necessary. */
4009 if (fde_table_in_use == fde_table_allocated)
4011 fde_table_allocated += FDE_TABLE_INCREMENT;
4012 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
4013 memset (fde_table + fde_table_in_use, 0,
4014 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
4017 /* Record the FDE associated with this function. */
4018 current_funcdef_fde = fde_table_in_use;
4020 /* Add the new FDE at the end of the fde_table. */
4021 fde = &fde_table[fde_table_in_use++];
4022 fde->decl = current_function_decl;
4023 fde->dw_fde_begin = dup_label;
4024 fde->dw_fde_current_label = dup_label;
4025 fde->dw_fde_hot_section_label = NULL;
4026 fde->dw_fde_hot_section_end_label = NULL;
4027 fde->dw_fde_unlikely_section_label = NULL;
4028 fde->dw_fde_unlikely_section_end_label = NULL;
4029 fde->dw_fde_switched_sections = 0;
4030 fde->dw_fde_switched_cold_to_hot = 0;
4031 fde->dw_fde_end = NULL;
4032 fde->dw_fde_vms_end_prologue = NULL;
4033 fde->dw_fde_vms_begin_epilogue = NULL;
4034 fde->dw_fde_cfi = NULL;
4035 fde->dw_fde_switch_cfi = NULL;
4036 fde->funcdef_number = current_function_funcdef_no;
4037 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
4038 fde->uses_eh_lsda = crtl->uses_eh_lsda;
4039 fde->nothrow = crtl->nothrow;
4040 fde->drap_reg = INVALID_REGNUM;
4041 fde->vdrap_reg = INVALID_REGNUM;
4042 if (flag_reorder_blocks_and_partition)
4044 section *unlikelysec;
4045 if (first_function_block_is_cold)
4046 fde->in_std_section = 1;
4049 = (fnsec == text_section
4050 || (cold_text_section && fnsec == cold_text_section));
4051 unlikelysec = unlikely_text_section ();
4052 fde->cold_in_std_section
4053 = (unlikelysec == text_section
4054 || (cold_text_section && unlikelysec == cold_text_section));
4059 = (fnsec == text_section
4060 || (cold_text_section && fnsec == cold_text_section));
4061 fde->cold_in_std_section = 0;
4064 args_size = old_args_size = 0;
4066 /* We only want to output line number information for the genuine dwarf2
4067 prologue case, not the eh frame case. */
4068 #ifdef DWARF2_DEBUGGING_INFO
4070 dwarf2out_source_line (line, file, 0, true);
4073 if (dwarf2out_do_cfi_asm ())
4074 dwarf2out_do_cfi_startproc (false);
4077 rtx personality = get_personality_function (current_function_decl);
4078 if (!current_unit_personality)
4079 current_unit_personality = personality;
4081 /* We cannot keep a current personality per function as without CFI
4082 asm, at the point where we emit the CFI data, there is no current
4083 function anymore. */
4084 if (personality && current_unit_personality != personality)
4085 sorry ("multiple EH personalities are supported only with assemblers "
4086 "supporting .cfi_personality directive");
4090 /* Output a marker (i.e. a label) for the end of the generated code
4091 for a function prologue. This gets called *after* the prologue code has
4095 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
4096 const char *file ATTRIBUTE_UNUSED)
4099 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4101 /* Output a label to mark the endpoint of the code generated for this
4103 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
4104 current_function_funcdef_no);
4105 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
4106 current_function_funcdef_no);
4107 fde = &fde_table[fde_table_in_use - 1];
4108 fde->dw_fde_vms_end_prologue = xstrdup (label);
4111 /* Output a marker (i.e. a label) for the beginning of the generated code
4112 for a function epilogue. This gets called *before* the prologue code has
4116 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4117 const char *file ATTRIBUTE_UNUSED)
4120 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4122 fde = &fde_table[fde_table_in_use - 1];
4123 if (fde->dw_fde_vms_begin_epilogue)
4126 /* Output a label to mark the endpoint of the code generated for this
4128 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
4129 current_function_funcdef_no);
4130 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
4131 current_function_funcdef_no);
4132 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
4135 /* Output a marker (i.e. a label) for the absolute end of the generated code
4136 for a function definition. This gets called *after* the epilogue code has
4140 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4141 const char *file ATTRIBUTE_UNUSED)
4144 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4146 last_var_location_insn = NULL_RTX;
4148 if (dwarf2out_do_cfi_asm ())
4149 fprintf (asm_out_file, "\t.cfi_endproc\n");
4151 /* Output a label to mark the endpoint of the code generated for this
4153 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
4154 current_function_funcdef_no);
4155 ASM_OUTPUT_LABEL (asm_out_file, label);
4156 fde = current_fde ();
4157 gcc_assert (fde != NULL);
4158 fde->dw_fde_end = xstrdup (label);
4162 dwarf2out_frame_init (void)
4164 /* Allocate the initial hunk of the fde_table. */
4165 fde_table = ggc_alloc_cleared_vec_dw_fde_node (FDE_TABLE_INCREMENT);
4166 fde_table_allocated = FDE_TABLE_INCREMENT;
4167 fde_table_in_use = 0;
4169 /* Generate the CFA instructions common to all FDE's. Do it now for the
4170 sake of lookup_cfa. */
4172 /* On entry, the Canonical Frame Address is at SP. */
4173 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
4175 if (targetm.debug_unwind_info () == UI_DWARF2
4176 || targetm.except_unwind_info () == UI_DWARF2)
4177 initial_return_save (INCOMING_RETURN_ADDR_RTX);
4181 dwarf2out_frame_finish (void)
4183 /* Output call frame information. */
4184 if (targetm.debug_unwind_info () == UI_DWARF2)
4185 output_call_frame_info (0);
4187 /* Output another copy for the unwinder. */
4188 if ((flag_unwind_tables || flag_exceptions)
4189 && targetm.except_unwind_info () == UI_DWARF2)
4190 output_call_frame_info (1);
4193 /* Note that the current function section is being used for code. */
4196 dwarf2out_note_section_used (void)
4198 section *sec = current_function_section ();
4199 if (sec == text_section)
4200 text_section_used = true;
4201 else if (sec == cold_text_section)
4202 cold_text_section_used = true;
4206 dwarf2out_switch_text_section (void)
4208 dw_fde_ref fde = current_fde ();
4210 gcc_assert (cfun && fde && !fde->dw_fde_switched_sections);
4212 fde->dw_fde_switched_sections = 1;
4213 fde->dw_fde_switched_cold_to_hot = !in_cold_section_p;
4215 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
4216 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
4217 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
4218 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
4219 have_multiple_function_sections = true;
4221 /* Reset the current label on switching text sections, so that we
4222 don't attempt to advance_loc4 between labels in different sections. */
4223 fde->dw_fde_current_label = NULL;
4225 /* There is no need to mark used sections when not debugging. */
4226 if (cold_text_section != NULL)
4227 dwarf2out_note_section_used ();
4229 if (dwarf2out_do_cfi_asm ())
4230 fprintf (asm_out_file, "\t.cfi_endproc\n");
4232 /* Now do the real section switch. */
4233 switch_to_section (current_function_section ());
4235 if (dwarf2out_do_cfi_asm ())
4237 dwarf2out_do_cfi_startproc (true);
4238 /* As this is a different FDE, insert all current CFI instructions
4240 output_cfis (fde->dw_fde_cfi, true, fde, true);
4244 dw_cfi_ref cfi = fde->dw_fde_cfi;
4246 cfi = fde->dw_fde_cfi;
4248 while (cfi->dw_cfi_next != NULL)
4249 cfi = cfi->dw_cfi_next;
4250 fde->dw_fde_switch_cfi = cfi;
4254 /* And now, the subset of the debugging information support code necessary
4255 for emitting location expressions. */
4257 /* Data about a single source file. */
4258 struct GTY(()) dwarf_file_data {
4259 const char * filename;
4263 typedef struct dw_val_struct *dw_val_ref;
4264 typedef struct die_struct *dw_die_ref;
4265 typedef const struct die_struct *const_dw_die_ref;
4266 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
4267 typedef struct dw_loc_list_struct *dw_loc_list_ref;
4269 typedef struct GTY(()) deferred_locations_struct
4273 } deferred_locations;
4275 DEF_VEC_O(deferred_locations);
4276 DEF_VEC_ALLOC_O(deferred_locations,gc);
4278 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
4280 DEF_VEC_P(dw_die_ref);
4281 DEF_VEC_ALLOC_P(dw_die_ref,heap);
4283 /* Each DIE may have a series of attribute/value pairs. Values
4284 can take on several forms. The forms that are used in this
4285 implementation are listed below. */
4290 dw_val_class_offset,
4292 dw_val_class_loc_list,
4293 dw_val_class_range_list,
4295 dw_val_class_unsigned_const,
4296 dw_val_class_const_double,
4299 dw_val_class_die_ref,
4300 dw_val_class_fde_ref,
4301 dw_val_class_lbl_id,
4302 dw_val_class_lineptr,
4304 dw_val_class_macptr,
4307 dw_val_class_decl_ref,
4308 dw_val_class_vms_delta
4311 /* Describe a floating point constant value, or a vector constant value. */
4313 typedef struct GTY(()) dw_vec_struct {
4314 unsigned char * GTY((length ("%h.length"))) array;
4320 /* The dw_val_node describes an attribute's value, as it is
4321 represented internally. */
4323 typedef struct GTY(()) dw_val_struct {
4324 enum dw_val_class val_class;
4325 union dw_val_struct_union
4327 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
4328 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
4329 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
4330 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
4331 HOST_WIDE_INT GTY ((default)) val_int;
4332 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
4333 double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
4334 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
4335 struct dw_val_die_union
4339 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
4340 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
4341 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
4342 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
4343 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
4344 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
4345 unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
4346 tree GTY ((tag ("dw_val_class_decl_ref"))) val_decl_ref;
4347 struct dw_val_vms_delta_union
4351 } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
4353 GTY ((desc ("%1.val_class"))) v;
4357 /* Locations in memory are described using a sequence of stack machine
4360 typedef struct GTY(()) dw_loc_descr_struct {
4361 dw_loc_descr_ref dw_loc_next;
4362 ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
4363 /* Used to distinguish DW_OP_addr with a direct symbol relocation
4364 from DW_OP_addr with a dtp-relative symbol relocation. */
4365 unsigned int dtprel : 1;
4367 dw_val_node dw_loc_oprnd1;
4368 dw_val_node dw_loc_oprnd2;
4372 /* Location lists are ranges + location descriptions for that range,
4373 so you can track variables that are in different places over
4374 their entire life. */
4375 typedef struct GTY(()) dw_loc_list_struct {
4376 dw_loc_list_ref dw_loc_next;
4377 const char *begin; /* Label for begin address of range */
4378 const char *end; /* Label for end address of range */
4379 char *ll_symbol; /* Label for beginning of location list.
4380 Only on head of list */
4381 const char *section; /* Section this loclist is relative to */
4382 dw_loc_descr_ref expr;
4387 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4389 /* Convert a DWARF stack opcode into its string name. */
4392 dwarf_stack_op_name (unsigned int op)
4397 return "DW_OP_addr";
4399 return "DW_OP_deref";
4401 return "DW_OP_const1u";
4403 return "DW_OP_const1s";
4405 return "DW_OP_const2u";
4407 return "DW_OP_const2s";
4409 return "DW_OP_const4u";
4411 return "DW_OP_const4s";
4413 return "DW_OP_const8u";
4415 return "DW_OP_const8s";
4417 return "DW_OP_constu";
4419 return "DW_OP_consts";
4423 return "DW_OP_drop";
4425 return "DW_OP_over";
4427 return "DW_OP_pick";
4429 return "DW_OP_swap";
4433 return "DW_OP_xderef";
4441 return "DW_OP_minus";
4453 return "DW_OP_plus";
4454 case DW_OP_plus_uconst:
4455 return "DW_OP_plus_uconst";
4461 return "DW_OP_shra";
4479 return "DW_OP_skip";
4481 return "DW_OP_lit0";
4483 return "DW_OP_lit1";
4485 return "DW_OP_lit2";
4487 return "DW_OP_lit3";
4489 return "DW_OP_lit4";
4491 return "DW_OP_lit5";
4493 return "DW_OP_lit6";
4495 return "DW_OP_lit7";
4497 return "DW_OP_lit8";
4499 return "DW_OP_lit9";
4501 return "DW_OP_lit10";
4503 return "DW_OP_lit11";
4505 return "DW_OP_lit12";
4507 return "DW_OP_lit13";
4509 return "DW_OP_lit14";
4511 return "DW_OP_lit15";
4513 return "DW_OP_lit16";
4515 return "DW_OP_lit17";
4517 return "DW_OP_lit18";
4519 return "DW_OP_lit19";
4521 return "DW_OP_lit20";
4523 return "DW_OP_lit21";
4525 return "DW_OP_lit22";
4527 return "DW_OP_lit23";
4529 return "DW_OP_lit24";
4531 return "DW_OP_lit25";
4533 return "DW_OP_lit26";
4535 return "DW_OP_lit27";
4537 return "DW_OP_lit28";
4539 return "DW_OP_lit29";
4541 return "DW_OP_lit30";
4543 return "DW_OP_lit31";
4545 return "DW_OP_reg0";
4547 return "DW_OP_reg1";
4549 return "DW_OP_reg2";
4551 return "DW_OP_reg3";
4553 return "DW_OP_reg4";
4555 return "DW_OP_reg5";
4557 return "DW_OP_reg6";
4559 return "DW_OP_reg7";
4561 return "DW_OP_reg8";
4563 return "DW_OP_reg9";
4565 return "DW_OP_reg10";
4567 return "DW_OP_reg11";
4569 return "DW_OP_reg12";
4571 return "DW_OP_reg13";
4573 return "DW_OP_reg14";
4575 return "DW_OP_reg15";
4577 return "DW_OP_reg16";
4579 return "DW_OP_reg17";
4581 return "DW_OP_reg18";
4583 return "DW_OP_reg19";
4585 return "DW_OP_reg20";
4587 return "DW_OP_reg21";
4589 return "DW_OP_reg22";
4591 return "DW_OP_reg23";
4593 return "DW_OP_reg24";
4595 return "DW_OP_reg25";
4597 return "DW_OP_reg26";
4599 return "DW_OP_reg27";
4601 return "DW_OP_reg28";
4603 return "DW_OP_reg29";
4605 return "DW_OP_reg30";
4607 return "DW_OP_reg31";
4609 return "DW_OP_breg0";
4611 return "DW_OP_breg1";
4613 return "DW_OP_breg2";
4615 return "DW_OP_breg3";
4617 return "DW_OP_breg4";
4619 return "DW_OP_breg5";
4621 return "DW_OP_breg6";
4623 return "DW_OP_breg7";
4625 return "DW_OP_breg8";
4627 return "DW_OP_breg9";
4629 return "DW_OP_breg10";
4631 return "DW_OP_breg11";
4633 return "DW_OP_breg12";
4635 return "DW_OP_breg13";
4637 return "DW_OP_breg14";
4639 return "DW_OP_breg15";
4641 return "DW_OP_breg16";
4643 return "DW_OP_breg17";
4645 return "DW_OP_breg18";
4647 return "DW_OP_breg19";
4649 return "DW_OP_breg20";
4651 return "DW_OP_breg21";
4653 return "DW_OP_breg22";
4655 return "DW_OP_breg23";
4657 return "DW_OP_breg24";
4659 return "DW_OP_breg25";
4661 return "DW_OP_breg26";
4663 return "DW_OP_breg27";
4665 return "DW_OP_breg28";
4667 return "DW_OP_breg29";
4669 return "DW_OP_breg30";
4671 return "DW_OP_breg31";
4673 return "DW_OP_regx";
4675 return "DW_OP_fbreg";
4677 return "DW_OP_bregx";
4679 return "DW_OP_piece";
4680 case DW_OP_deref_size:
4681 return "DW_OP_deref_size";
4682 case DW_OP_xderef_size:
4683 return "DW_OP_xderef_size";
4687 case DW_OP_push_object_address:
4688 return "DW_OP_push_object_address";
4690 return "DW_OP_call2";
4692 return "DW_OP_call4";
4693 case DW_OP_call_ref:
4694 return "DW_OP_call_ref";
4695 case DW_OP_implicit_value:
4696 return "DW_OP_implicit_value";
4697 case DW_OP_stack_value:
4698 return "DW_OP_stack_value";
4699 case DW_OP_form_tls_address:
4700 return "DW_OP_form_tls_address";
4701 case DW_OP_call_frame_cfa:
4702 return "DW_OP_call_frame_cfa";
4703 case DW_OP_bit_piece:
4704 return "DW_OP_bit_piece";
4706 case DW_OP_GNU_push_tls_address:
4707 return "DW_OP_GNU_push_tls_address";
4708 case DW_OP_GNU_uninit:
4709 return "DW_OP_GNU_uninit";
4710 case DW_OP_GNU_encoded_addr:
4711 return "DW_OP_GNU_encoded_addr";
4712 case DW_OP_GNU_implicit_pointer:
4713 return "DW_OP_GNU_implicit_pointer";
4716 return "OP_<unknown>";
4720 /* Return a pointer to a newly allocated location description. Location
4721 descriptions are simple expression terms that can be strung
4722 together to form more complicated location (address) descriptions. */
4724 static inline dw_loc_descr_ref
4725 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
4726 unsigned HOST_WIDE_INT oprnd2)
4728 dw_loc_descr_ref descr = ggc_alloc_cleared_dw_loc_descr_node ();
4730 descr->dw_loc_opc = op;
4731 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4732 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4733 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4734 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4739 /* Return a pointer to a newly allocated location description for
4742 static inline dw_loc_descr_ref
4743 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
4746 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
4749 return new_loc_descr (DW_OP_bregx, reg, offset);
4752 /* Add a location description term to a location description expression. */
4755 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
4757 dw_loc_descr_ref *d;
4759 /* Find the end of the chain. */
4760 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4766 /* Add a constant OFFSET to a location expression. */
4769 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
4771 dw_loc_descr_ref loc;
4774 gcc_assert (*list_head != NULL);
4779 /* Find the end of the chain. */
4780 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
4784 if (loc->dw_loc_opc == DW_OP_fbreg
4785 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
4786 p = &loc->dw_loc_oprnd1.v.val_int;
4787 else if (loc->dw_loc_opc == DW_OP_bregx)
4788 p = &loc->dw_loc_oprnd2.v.val_int;
4790 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4791 offset. Don't optimize if an signed integer overflow would happen. */
4793 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
4794 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
4797 else if (offset > 0)
4798 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4802 loc->dw_loc_next = int_loc_descriptor (-offset);
4803 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
4807 /* Add a constant OFFSET to a location list. */
4810 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
4813 for (d = list_head; d != NULL; d = d->dw_loc_next)
4814 loc_descr_plus_const (&d->expr, offset);
4817 #define DWARF_REF_SIZE \
4818 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
4820 /* Return the size of a location descriptor. */
4822 static unsigned long
4823 size_of_loc_descr (dw_loc_descr_ref loc)
4825 unsigned long size = 1;
4827 switch (loc->dw_loc_opc)
4830 size += DWARF2_ADDR_SIZE;
4849 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4852 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4857 case DW_OP_plus_uconst:
4858 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4896 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4899 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4902 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4905 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4906 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4909 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4911 case DW_OP_bit_piece:
4912 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4913 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
4915 case DW_OP_deref_size:
4916 case DW_OP_xderef_size:
4925 case DW_OP_call_ref:
4926 size += DWARF_REF_SIZE;
4928 case DW_OP_implicit_value:
4929 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
4930 + loc->dw_loc_oprnd1.v.val_unsigned;
4932 case DW_OP_GNU_implicit_pointer:
4933 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4942 /* Return the size of a series of location descriptors. */
4944 static unsigned long
4945 size_of_locs (dw_loc_descr_ref loc)
4950 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4951 field, to avoid writing to a PCH file. */
4952 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4954 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4956 size += size_of_loc_descr (l);
4961 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4963 l->dw_loc_addr = size;
4964 size += size_of_loc_descr (l);
4970 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4971 static void get_ref_die_offset_label (char *, dw_die_ref);
4973 /* Output location description stack opcode's operands (if any). */
4976 output_loc_operands (dw_loc_descr_ref loc)
4978 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4979 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4981 switch (loc->dw_loc_opc)
4983 #ifdef DWARF2_DEBUGGING_INFO
4986 dw2_asm_output_data (2, val1->v.val_int, NULL);
4991 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
4992 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
4994 fputc ('\n', asm_out_file);
4999 dw2_asm_output_data (4, val1->v.val_int, NULL);
5004 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
5005 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
5007 fputc ('\n', asm_out_file);
5012 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5013 dw2_asm_output_data (8, val1->v.val_int, NULL);
5020 gcc_assert (val1->val_class == dw_val_class_loc);
5021 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5023 dw2_asm_output_data (2, offset, NULL);
5026 case DW_OP_implicit_value:
5027 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5028 switch (val2->val_class)
5030 case dw_val_class_const:
5031 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
5033 case dw_val_class_vec:
5035 unsigned int elt_size = val2->v.val_vec.elt_size;
5036 unsigned int len = val2->v.val_vec.length;
5040 if (elt_size > sizeof (HOST_WIDE_INT))
5045 for (i = 0, p = val2->v.val_vec.array;
5048 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
5049 "fp or vector constant word %u", i);
5052 case dw_val_class_const_double:
5054 unsigned HOST_WIDE_INT first, second;
5056 if (WORDS_BIG_ENDIAN)
5058 first = val2->v.val_double.high;
5059 second = val2->v.val_double.low;
5063 first = val2->v.val_double.low;
5064 second = val2->v.val_double.high;
5066 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
5068 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
5072 case dw_val_class_addr:
5073 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
5074 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
5089 case DW_OP_implicit_value:
5090 /* We currently don't make any attempt to make sure these are
5091 aligned properly like we do for the main unwind info, so
5092 don't support emitting things larger than a byte if we're
5093 only doing unwinding. */
5098 dw2_asm_output_data (1, val1->v.val_int, NULL);
5101 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5104 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5107 dw2_asm_output_data (1, val1->v.val_int, NULL);
5109 case DW_OP_plus_uconst:
5110 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5144 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5147 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5150 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5153 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5154 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
5157 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5159 case DW_OP_bit_piece:
5160 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5161 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
5163 case DW_OP_deref_size:
5164 case DW_OP_xderef_size:
5165 dw2_asm_output_data (1, val1->v.val_int, NULL);
5171 if (targetm.asm_out.output_dwarf_dtprel)
5173 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
5176 fputc ('\n', asm_out_file);
5183 #ifdef DWARF2_DEBUGGING_INFO
5184 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
5191 case DW_OP_GNU_implicit_pointer:
5193 char label[MAX_ARTIFICIAL_LABEL_BYTES
5194 + HOST_BITS_PER_WIDE_INT / 2 + 2];
5195 gcc_assert (val1->val_class == dw_val_class_die_ref);
5196 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
5197 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
5198 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
5203 /* Other codes have no operands. */
5208 /* Output a sequence of location operations. */
5211 output_loc_sequence (dw_loc_descr_ref loc)
5213 for (; loc != NULL; loc = loc->dw_loc_next)
5215 /* Output the opcode. */
5216 dw2_asm_output_data (1, loc->dw_loc_opc,
5217 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
5219 /* Output the operand(s) (if any). */
5220 output_loc_operands (loc);
5224 /* Output location description stack opcode's operands (if any).
5225 The output is single bytes on a line, suitable for .cfi_escape. */
5228 output_loc_operands_raw (dw_loc_descr_ref loc)
5230 dw_val_ref val1 = &loc->dw_loc_oprnd1;
5231 dw_val_ref val2 = &loc->dw_loc_oprnd2;
5233 switch (loc->dw_loc_opc)
5236 case DW_OP_implicit_value:
5237 /* We cannot output addresses in .cfi_escape, only bytes. */
5243 case DW_OP_deref_size:
5244 case DW_OP_xderef_size:
5245 fputc (',', asm_out_file);
5246 dw2_asm_output_data_raw (1, val1->v.val_int);
5251 fputc (',', asm_out_file);
5252 dw2_asm_output_data_raw (2, val1->v.val_int);
5257 fputc (',', asm_out_file);
5258 dw2_asm_output_data_raw (4, val1->v.val_int);
5263 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5264 fputc (',', asm_out_file);
5265 dw2_asm_output_data_raw (8, val1->v.val_int);
5273 gcc_assert (val1->val_class == dw_val_class_loc);
5274 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5276 fputc (',', asm_out_file);
5277 dw2_asm_output_data_raw (2, offset);
5282 case DW_OP_plus_uconst:
5285 fputc (',', asm_out_file);
5286 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5289 case DW_OP_bit_piece:
5290 fputc (',', asm_out_file);
5291 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5292 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
5329 fputc (',', asm_out_file);
5330 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
5334 fputc (',', asm_out_file);
5335 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5336 fputc (',', asm_out_file);
5337 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
5340 case DW_OP_GNU_implicit_pointer:
5345 /* Other codes have no operands. */
5351 output_loc_sequence_raw (dw_loc_descr_ref loc)
5355 /* Output the opcode. */
5356 fprintf (asm_out_file, "%#x", loc->dw_loc_opc);
5357 output_loc_operands_raw (loc);
5359 if (!loc->dw_loc_next)
5361 loc = loc->dw_loc_next;
5363 fputc (',', asm_out_file);
5367 /* This routine will generate the correct assembly data for a location
5368 description based on a cfi entry with a complex address. */
5371 output_cfa_loc (dw_cfi_ref cfi)
5373 dw_loc_descr_ref loc;
5376 if (cfi->dw_cfi_opc == DW_CFA_expression)
5378 dw2_asm_output_data (1, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, NULL);
5379 loc = cfi->dw_cfi_oprnd2.dw_cfi_loc;
5382 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5384 /* Output the size of the block. */
5385 size = size_of_locs (loc);
5386 dw2_asm_output_data_uleb128 (size, NULL);
5388 /* Now output the operations themselves. */
5389 output_loc_sequence (loc);
5392 /* Similar, but used for .cfi_escape. */
5395 output_cfa_loc_raw (dw_cfi_ref cfi)
5397 dw_loc_descr_ref loc;
5400 if (cfi->dw_cfi_opc == DW_CFA_expression)
5402 fprintf (asm_out_file, "%#x,", cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
5403 loc = cfi->dw_cfi_oprnd2.dw_cfi_loc;
5406 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5408 /* Output the size of the block. */
5409 size = size_of_locs (loc);
5410 dw2_asm_output_data_uleb128_raw (size);
5411 fputc (',', asm_out_file);
5413 /* Now output the operations themselves. */
5414 output_loc_sequence_raw (loc);
5417 /* This function builds a dwarf location descriptor sequence from a
5418 dw_cfa_location, adding the given OFFSET to the result of the
5421 static struct dw_loc_descr_struct *
5422 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
5424 struct dw_loc_descr_struct *head, *tmp;
5426 offset += cfa->offset;
5430 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
5431 head->dw_loc_oprnd1.val_class = dw_val_class_const;
5432 tmp = new_loc_descr (DW_OP_deref, 0, 0);
5433 add_loc_descr (&head, tmp);
5436 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
5437 add_loc_descr (&head, tmp);
5441 head = new_reg_loc_descr (cfa->reg, offset);
5446 /* This function builds a dwarf location descriptor sequence for
5447 the address at OFFSET from the CFA when stack is aligned to
5450 static struct dw_loc_descr_struct *
5451 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
5453 struct dw_loc_descr_struct *head;
5454 unsigned int dwarf_fp
5455 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
5457 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
5458 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
5460 head = new_reg_loc_descr (dwarf_fp, 0);
5461 add_loc_descr (&head, int_loc_descriptor (alignment));
5462 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
5463 loc_descr_plus_const (&head, offset);
5466 head = new_reg_loc_descr (dwarf_fp, offset);
5470 /* This function fills in aa dw_cfa_location structure from a dwarf location
5471 descriptor sequence. */
5474 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
5476 struct dw_loc_descr_struct *ptr;
5478 cfa->base_offset = 0;
5482 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
5484 enum dwarf_location_atom op = ptr->dw_loc_opc;
5520 cfa->reg = op - DW_OP_reg0;
5523 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5557 cfa->reg = op - DW_OP_breg0;
5558 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
5561 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5562 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
5567 case DW_OP_plus_uconst:
5568 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
5571 internal_error ("DW_LOC_OP %s not implemented",
5572 dwarf_stack_op_name (ptr->dw_loc_opc));
5577 /* And now, the support for symbolic debugging information. */
5579 /* .debug_str support. */
5580 static int output_indirect_string (void **, void *);
5582 static void dwarf2out_init (const char *);
5583 static void dwarf2out_finish (const char *);
5584 static void dwarf2out_assembly_start (void);
5585 static void dwarf2out_define (unsigned int, const char *);
5586 static void dwarf2out_undef (unsigned int, const char *);
5587 static void dwarf2out_start_source_file (unsigned, const char *);
5588 static void dwarf2out_end_source_file (unsigned);
5589 static void dwarf2out_function_decl (tree);
5590 static void dwarf2out_begin_block (unsigned, unsigned);
5591 static void dwarf2out_end_block (unsigned, unsigned);
5592 static bool dwarf2out_ignore_block (const_tree);
5593 static void dwarf2out_global_decl (tree);
5594 static void dwarf2out_type_decl (tree, int);
5595 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
5596 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
5598 static void dwarf2out_abstract_function (tree);
5599 static void dwarf2out_var_location (rtx);
5600 static void dwarf2out_direct_call (tree);
5601 static void dwarf2out_virtual_call_token (tree, int);
5602 static void dwarf2out_copy_call_info (rtx, rtx);
5603 static void dwarf2out_virtual_call (int);
5604 static void dwarf2out_begin_function (tree);
5605 static void dwarf2out_set_name (tree, tree);
5607 /* The debug hooks structure. */
5609 const struct gcc_debug_hooks dwarf2_debug_hooks =
5613 dwarf2out_assembly_start,
5616 dwarf2out_start_source_file,
5617 dwarf2out_end_source_file,
5618 dwarf2out_begin_block,
5619 dwarf2out_end_block,
5620 dwarf2out_ignore_block,
5621 dwarf2out_source_line,
5622 dwarf2out_begin_prologue,
5623 #if VMS_DEBUGGING_INFO
5624 dwarf2out_vms_end_prologue,
5625 dwarf2out_vms_begin_epilogue,
5627 debug_nothing_int_charstar,
5628 debug_nothing_int_charstar,
5630 dwarf2out_end_epilogue,
5631 dwarf2out_begin_function,
5632 debug_nothing_int, /* end_function */
5633 dwarf2out_function_decl, /* function_decl */
5634 dwarf2out_global_decl,
5635 dwarf2out_type_decl, /* type_decl */
5636 dwarf2out_imported_module_or_decl,
5637 debug_nothing_tree, /* deferred_inline_function */
5638 /* The DWARF 2 backend tries to reduce debugging bloat by not
5639 emitting the abstract description of inline functions until
5640 something tries to reference them. */
5641 dwarf2out_abstract_function, /* outlining_inline_function */
5642 debug_nothing_rtx, /* label */
5643 debug_nothing_int, /* handle_pch */
5644 dwarf2out_var_location,
5645 dwarf2out_switch_text_section,
5646 dwarf2out_direct_call,
5647 dwarf2out_virtual_call_token,
5648 dwarf2out_copy_call_info,
5649 dwarf2out_virtual_call,
5651 1, /* start_end_main_source_file */
5652 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */
5655 /* NOTE: In the comments in this file, many references are made to
5656 "Debugging Information Entries". This term is abbreviated as `DIE'
5657 throughout the remainder of this file. */
5659 /* An internal representation of the DWARF output is built, and then
5660 walked to generate the DWARF debugging info. The walk of the internal
5661 representation is done after the entire program has been compiled.
5662 The types below are used to describe the internal representation. */
5664 /* Various DIE's use offsets relative to the beginning of the
5665 .debug_info section to refer to each other. */
5667 typedef long int dw_offset;
5669 /* Define typedefs here to avoid circular dependencies. */
5671 typedef struct dw_attr_struct *dw_attr_ref;
5672 typedef struct dw_line_info_struct *dw_line_info_ref;
5673 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
5674 typedef struct pubname_struct *pubname_ref;
5675 typedef struct dw_ranges_struct *dw_ranges_ref;
5676 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
5677 typedef struct comdat_type_struct *comdat_type_node_ref;
5679 /* Each entry in the line_info_table maintains the file and
5680 line number associated with the label generated for that
5681 entry. The label gives the PC value associated with
5682 the line number entry. */
5684 typedef struct GTY(()) dw_line_info_struct {
5685 unsigned long dw_file_num;
5686 unsigned long dw_line_num;
5690 /* Line information for functions in separate sections; each one gets its
5692 typedef struct GTY(()) dw_separate_line_info_struct {
5693 unsigned long dw_file_num;
5694 unsigned long dw_line_num;
5695 unsigned long function;
5697 dw_separate_line_info_entry;
5699 /* Each DIE attribute has a field specifying the attribute kind,
5700 a link to the next attribute in the chain, and an attribute value.
5701 Attributes are typically linked below the DIE they modify. */
5703 typedef struct GTY(()) dw_attr_struct {
5704 enum dwarf_attribute dw_attr;
5705 dw_val_node dw_attr_val;
5709 DEF_VEC_O(dw_attr_node);
5710 DEF_VEC_ALLOC_O(dw_attr_node,gc);
5712 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
5713 The children of each node form a circular list linked by
5714 die_sib. die_child points to the node *before* the "first" child node. */
5716 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
5717 union die_symbol_or_type_node
5719 char * GTY ((tag ("0"))) die_symbol;
5720 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
5722 GTY ((desc ("dwarf_version >= 4"))) die_id;
5723 VEC(dw_attr_node,gc) * die_attr;
5724 dw_die_ref die_parent;
5725 dw_die_ref die_child;
5727 dw_die_ref die_definition; /* ref from a specification to its definition */
5728 dw_offset die_offset;
5729 unsigned long die_abbrev;
5731 /* Die is used and must not be pruned as unused. */
5732 int die_perennial_p;
5733 unsigned int decl_id;
5734 enum dwarf_tag die_tag;
5738 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
5739 #define FOR_EACH_CHILD(die, c, expr) do { \
5740 c = die->die_child; \
5744 } while (c != die->die_child); \
5747 /* The pubname structure */
5749 typedef struct GTY(()) pubname_struct {
5755 DEF_VEC_O(pubname_entry);
5756 DEF_VEC_ALLOC_O(pubname_entry, gc);
5758 struct GTY(()) dw_ranges_struct {
5759 /* If this is positive, it's a block number, otherwise it's a
5760 bitwise-negated index into dw_ranges_by_label. */
5764 /* A structure to hold a macinfo entry. */
5766 typedef struct GTY(()) macinfo_struct {
5767 unsigned HOST_WIDE_INT code;
5768 unsigned HOST_WIDE_INT lineno;
5773 DEF_VEC_O(macinfo_entry);
5774 DEF_VEC_ALLOC_O(macinfo_entry, gc);
5776 struct GTY(()) dw_ranges_by_label_struct {
5781 /* The comdat type node structure. */
5782 typedef struct GTY(()) comdat_type_struct
5784 dw_die_ref root_die;
5785 dw_die_ref type_die;
5786 char signature[DWARF_TYPE_SIGNATURE_SIZE];
5787 struct comdat_type_struct *next;
5791 /* The limbo die list structure. */
5792 typedef struct GTY(()) limbo_die_struct {
5795 struct limbo_die_struct *next;
5799 typedef struct GTY(()) skeleton_chain_struct
5803 struct skeleton_chain_struct *parent;
5805 skeleton_chain_node;
5807 /* How to start an assembler comment. */
5808 #ifndef ASM_COMMENT_START
5809 #define ASM_COMMENT_START ";#"
5812 /* Define a macro which returns nonzero for a TYPE_DECL which was
5813 implicitly generated for a tagged type.
5815 Note that unlike the gcc front end (which generates a NULL named
5816 TYPE_DECL node for each complete tagged type, each array type, and
5817 each function type node created) the g++ front end generates a
5818 _named_ TYPE_DECL node for each tagged type node created.
5819 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
5820 generate a DW_TAG_typedef DIE for them. */
5822 #define TYPE_DECL_IS_STUB(decl) \
5823 (DECL_NAME (decl) == NULL_TREE \
5824 || (DECL_ARTIFICIAL (decl) \
5825 && is_tagged_type (TREE_TYPE (decl)) \
5826 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
5827 /* This is necessary for stub decls that \
5828 appear in nested inline functions. */ \
5829 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
5830 && (decl_ultimate_origin (decl) \
5831 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
5833 /* Information concerning the compilation unit's programming
5834 language, and compiler version. */
5836 /* Fixed size portion of the DWARF compilation unit header. */
5837 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
5838 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
5840 /* Fixed size portion of the DWARF comdat type unit header. */
5841 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
5842 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
5843 + DWARF_OFFSET_SIZE)
5845 /* Fixed size portion of public names info. */
5846 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
5848 /* Fixed size portion of the address range info. */
5849 #define DWARF_ARANGES_HEADER_SIZE \
5850 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5851 DWARF2_ADDR_SIZE * 2) \
5852 - DWARF_INITIAL_LENGTH_SIZE)
5854 /* Size of padding portion in the address range info. It must be
5855 aligned to twice the pointer size. */
5856 #define DWARF_ARANGES_PAD_SIZE \
5857 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5858 DWARF2_ADDR_SIZE * 2) \
5859 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
5861 /* Use assembler line directives if available. */
5862 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
5863 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
5864 #define DWARF2_ASM_LINE_DEBUG_INFO 1
5866 #define DWARF2_ASM_LINE_DEBUG_INFO 0
5870 /* Minimum line offset in a special line info. opcode.
5871 This value was chosen to give a reasonable range of values. */
5872 #define DWARF_LINE_BASE -10
5874 /* First special line opcode - leave room for the standard opcodes. */
5875 #define DWARF_LINE_OPCODE_BASE 10
5877 /* Range of line offsets in a special line info. opcode. */
5878 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
5880 /* Flag that indicates the initial value of the is_stmt_start flag.
5881 In the present implementation, we do not mark any lines as
5882 the beginning of a source statement, because that information
5883 is not made available by the GCC front-end. */
5884 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
5886 /* Maximum number of operations per instruction bundle. */
5887 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
5888 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
5891 /* This location is used by calc_die_sizes() to keep track
5892 the offset of each DIE within the .debug_info section. */
5893 static unsigned long next_die_offset;
5895 /* Record the root of the DIE's built for the current compilation unit. */
5896 static GTY(()) dw_die_ref single_comp_unit_die;
5898 /* A list of type DIEs that have been separated into comdat sections. */
5899 static GTY(()) comdat_type_node *comdat_type_list;
5901 /* A list of DIEs with a NULL parent waiting to be relocated. */
5902 static GTY(()) limbo_die_node *limbo_die_list;
5904 /* A list of DIEs for which we may have to generate
5905 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
5906 static GTY(()) limbo_die_node *deferred_asm_name;
5908 /* Filenames referenced by this compilation unit. */
5909 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
5911 /* A hash table of references to DIE's that describe declarations.
5912 The key is a DECL_UID() which is a unique number identifying each decl. */
5913 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
5915 /* A hash table of references to DIE's that describe COMMON blocks.
5916 The key is DECL_UID() ^ die_parent. */
5917 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
5919 typedef struct GTY(()) die_arg_entry_struct {
5924 DEF_VEC_O(die_arg_entry);
5925 DEF_VEC_ALLOC_O(die_arg_entry,gc);
5927 /* Node of the variable location list. */
5928 struct GTY ((chain_next ("%h.next"))) var_loc_node {
5929 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
5930 EXPR_LIST chain. For small bitsizes, bitsize is encoded
5931 in mode of the EXPR_LIST node and first EXPR_LIST operand
5932 is either NOTE_INSN_VAR_LOCATION for a piece with a known
5933 location or NULL for padding. For larger bitsizes,
5934 mode is 0 and first operand is a CONCAT with bitsize
5935 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
5936 NULL as second operand. */
5938 const char * GTY (()) label;
5939 struct var_loc_node * GTY (()) next;
5942 /* Variable location list. */
5943 struct GTY (()) var_loc_list_def {
5944 struct var_loc_node * GTY (()) first;
5946 /* Pointer to the last but one or last element of the
5947 chained list. If the list is empty, both first and
5948 last are NULL, if the list contains just one node
5949 or the last node certainly is not redundant, it points
5950 to the last node, otherwise points to the last but one.
5951 Do not mark it for GC because it is marked through the chain. */
5952 struct var_loc_node * GTY ((skip ("%h"))) last;
5954 /* DECL_UID of the variable decl. */
5955 unsigned int decl_id;
5957 typedef struct var_loc_list_def var_loc_list;
5960 /* Table of decl location linked lists. */
5961 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
5963 /* A pointer to the base of a list of references to DIE's that
5964 are uniquely identified by their tag, presence/absence of
5965 children DIE's, and list of attribute/value pairs. */
5966 static GTY((length ("abbrev_die_table_allocated")))
5967 dw_die_ref *abbrev_die_table;
5969 /* Number of elements currently allocated for abbrev_die_table. */
5970 static GTY(()) unsigned abbrev_die_table_allocated;
5972 /* Number of elements in type_die_table currently in use. */
5973 static GTY(()) unsigned abbrev_die_table_in_use;
5975 /* Size (in elements) of increments by which we may expand the
5976 abbrev_die_table. */
5977 #define ABBREV_DIE_TABLE_INCREMENT 256
5979 /* A pointer to the base of a table that contains line information
5980 for each source code line in .text in the compilation unit. */
5981 static GTY((length ("line_info_table_allocated")))
5982 dw_line_info_ref line_info_table;
5984 /* Number of elements currently allocated for line_info_table. */
5985 static GTY(()) unsigned line_info_table_allocated;
5987 /* Number of elements in line_info_table currently in use. */
5988 static GTY(()) unsigned line_info_table_in_use;
5990 /* A pointer to the base of a table that contains line information
5991 for each source code line outside of .text in the compilation unit. */
5992 static GTY ((length ("separate_line_info_table_allocated")))
5993 dw_separate_line_info_ref separate_line_info_table;
5995 /* Number of elements currently allocated for separate_line_info_table. */
5996 static GTY(()) unsigned separate_line_info_table_allocated;
5998 /* Number of elements in separate_line_info_table currently in use. */
5999 static GTY(()) unsigned separate_line_info_table_in_use;
6001 /* Size (in elements) of increments by which we may expand the
6003 #define LINE_INFO_TABLE_INCREMENT 1024
6005 /* A flag to tell pubnames/types export if there is an info section to
6007 static bool info_section_emitted;
6009 /* A pointer to the base of a table that contains a list of publicly
6010 accessible names. */
6011 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
6013 /* A pointer to the base of a table that contains a list of publicly
6014 accessible types. */
6015 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
6017 /* A pointer to the base of a table that contains a list of macro
6018 defines/undefines (and file start/end markers). */
6019 static GTY (()) VEC (macinfo_entry, gc) * macinfo_table;
6021 /* Array of dies for which we should generate .debug_arange info. */
6022 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
6024 /* Number of elements currently allocated for arange_table. */
6025 static GTY(()) unsigned arange_table_allocated;
6027 /* Number of elements in arange_table currently in use. */
6028 static GTY(()) unsigned arange_table_in_use;
6030 /* Size (in elements) of increments by which we may expand the
6032 #define ARANGE_TABLE_INCREMENT 64
6034 /* Array of dies for which we should generate .debug_ranges info. */
6035 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
6037 /* Number of elements currently allocated for ranges_table. */
6038 static GTY(()) unsigned ranges_table_allocated;
6040 /* Number of elements in ranges_table currently in use. */
6041 static GTY(()) unsigned ranges_table_in_use;
6043 /* Array of pairs of labels referenced in ranges_table. */
6044 static GTY ((length ("ranges_by_label_allocated")))
6045 dw_ranges_by_label_ref ranges_by_label;
6047 /* Number of elements currently allocated for ranges_by_label. */
6048 static GTY(()) unsigned ranges_by_label_allocated;
6050 /* Number of elements in ranges_by_label currently in use. */
6051 static GTY(()) unsigned ranges_by_label_in_use;
6053 /* Size (in elements) of increments by which we may expand the
6055 #define RANGES_TABLE_INCREMENT 64
6057 /* Whether we have location lists that need outputting */
6058 static GTY(()) bool have_location_lists;
6060 /* Unique label counter. */
6061 static GTY(()) unsigned int loclabel_num;
6063 /* Unique label counter for point-of-call tables. */
6064 static GTY(()) unsigned int poc_label_num;
6066 /* The direct call table structure. */
6068 typedef struct GTY(()) dcall_struct {
6069 unsigned int poc_label_num;
6071 dw_die_ref targ_die;
6075 DEF_VEC_O(dcall_entry);
6076 DEF_VEC_ALLOC_O(dcall_entry, gc);
6078 /* The virtual call table structure. */
6080 typedef struct GTY(()) vcall_struct {
6081 unsigned int poc_label_num;
6082 unsigned int vtable_slot;
6086 DEF_VEC_O(vcall_entry);
6087 DEF_VEC_ALLOC_O(vcall_entry, gc);
6089 /* Pointers to the direct and virtual call tables. */
6090 static GTY (()) VEC (dcall_entry, gc) * dcall_table = NULL;
6091 static GTY (()) VEC (vcall_entry, gc) * vcall_table = NULL;
6093 /* A hash table to map INSN_UIDs to vtable slot indexes. */
6095 struct GTY (()) vcall_insn {
6097 unsigned int vtable_slot;
6100 static GTY ((param_is (struct vcall_insn))) htab_t vcall_insn_table;
6102 /* Record whether the function being analyzed contains inlined functions. */
6103 static int current_function_has_inlines;
6105 /* The last file entry emitted by maybe_emit_file(). */
6106 static GTY(()) struct dwarf_file_data * last_emitted_file;
6108 /* Number of internal labels generated by gen_internal_sym(). */
6109 static GTY(()) int label_num;
6111 /* Cached result of previous call to lookup_filename. */
6112 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
6114 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
6116 /* Offset from the "steady-state frame pointer" to the frame base,
6117 within the current function. */
6118 static HOST_WIDE_INT frame_pointer_fb_offset;
6120 /* Forward declarations for functions defined in this file. */
6122 static int is_pseudo_reg (const_rtx);
6123 static tree type_main_variant (tree);
6124 static int is_tagged_type (const_tree);
6125 static const char *dwarf_tag_name (unsigned);
6126 static const char *dwarf_attr_name (unsigned);
6127 static const char *dwarf_form_name (unsigned);
6128 static tree decl_ultimate_origin (const_tree);
6129 static tree decl_class_context (tree);
6130 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
6131 static inline enum dw_val_class AT_class (dw_attr_ref);
6132 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
6133 static inline unsigned AT_flag (dw_attr_ref);
6134 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
6135 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
6136 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
6137 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
6138 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
6139 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
6140 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
6141 unsigned int, unsigned char *);
6142 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
6143 static hashval_t debug_str_do_hash (const void *);
6144 static int debug_str_eq (const void *, const void *);
6145 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
6146 static inline const char *AT_string (dw_attr_ref);
6147 static enum dwarf_form AT_string_form (dw_attr_ref);
6148 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
6149 static void add_AT_specification (dw_die_ref, dw_die_ref);
6150 static inline dw_die_ref AT_ref (dw_attr_ref);
6151 static inline int AT_ref_external (dw_attr_ref);
6152 static inline void set_AT_ref_external (dw_attr_ref, int);
6153 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
6154 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
6155 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
6156 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
6158 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
6159 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
6160 static inline rtx AT_addr (dw_attr_ref);
6161 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
6162 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
6163 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
6164 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
6165 unsigned HOST_WIDE_INT);
6166 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
6168 static inline const char *AT_lbl (dw_attr_ref);
6169 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
6170 static const char *get_AT_low_pc (dw_die_ref);
6171 static const char *get_AT_hi_pc (dw_die_ref);
6172 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
6173 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
6174 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
6175 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
6176 static bool is_cxx (void);
6177 static bool is_fortran (void);
6178 static bool is_ada (void);
6179 static void remove_AT (dw_die_ref, enum dwarf_attribute);
6180 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
6181 static void add_child_die (dw_die_ref, dw_die_ref);
6182 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
6183 static dw_die_ref lookup_type_die (tree);
6184 static void equate_type_number_to_die (tree, dw_die_ref);
6185 static hashval_t decl_die_table_hash (const void *);
6186 static int decl_die_table_eq (const void *, const void *);
6187 static dw_die_ref lookup_decl_die (tree);
6188 static hashval_t common_block_die_table_hash (const void *);
6189 static int common_block_die_table_eq (const void *, const void *);
6190 static hashval_t decl_loc_table_hash (const void *);
6191 static int decl_loc_table_eq (const void *, const void *);
6192 static var_loc_list *lookup_decl_loc (const_tree);
6193 static void equate_decl_number_to_die (tree, dw_die_ref);
6194 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
6195 static void print_spaces (FILE *);
6196 static void print_die (dw_die_ref, FILE *);
6197 static void print_dwarf_line_table (FILE *);
6198 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
6199 static dw_die_ref pop_compile_unit (dw_die_ref);
6200 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
6201 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
6202 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
6203 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
6204 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
6205 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
6206 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
6207 struct md5_ctx *, int *);
6208 struct checksum_attributes;
6209 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
6210 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
6211 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
6212 static void generate_type_signature (dw_die_ref, comdat_type_node *);
6213 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
6214 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
6215 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
6216 static int same_die_p (dw_die_ref, dw_die_ref, int *);
6217 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
6218 static void compute_section_prefix (dw_die_ref);
6219 static int is_type_die (dw_die_ref);
6220 static int is_comdat_die (dw_die_ref);
6221 static int is_symbol_die (dw_die_ref);
6222 static void assign_symbol_names (dw_die_ref);
6223 static void break_out_includes (dw_die_ref);
6224 static int is_declaration_die (dw_die_ref);
6225 static int should_move_die_to_comdat (dw_die_ref);
6226 static dw_die_ref clone_as_declaration (dw_die_ref);
6227 static dw_die_ref clone_die (dw_die_ref);
6228 static dw_die_ref clone_tree (dw_die_ref);
6229 static void copy_declaration_context (dw_die_ref, dw_die_ref);
6230 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
6231 static void generate_skeleton_bottom_up (skeleton_chain_node *);
6232 static dw_die_ref generate_skeleton (dw_die_ref);
6233 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
6235 static void break_out_comdat_types (dw_die_ref);
6236 static dw_die_ref copy_ancestor_tree (dw_die_ref, dw_die_ref, htab_t);
6237 static void copy_decls_walk (dw_die_ref, dw_die_ref, htab_t);
6238 static void copy_decls_for_unworthy_types (dw_die_ref);
6240 static hashval_t htab_cu_hash (const void *);
6241 static int htab_cu_eq (const void *, const void *);
6242 static void htab_cu_del (void *);
6243 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
6244 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
6245 static void add_sibling_attributes (dw_die_ref);
6246 static void build_abbrev_table (dw_die_ref);
6247 static void output_location_lists (dw_die_ref);
6248 static int constant_size (unsigned HOST_WIDE_INT);
6249 static unsigned long size_of_die (dw_die_ref);
6250 static void calc_die_sizes (dw_die_ref);
6251 static void mark_dies (dw_die_ref);
6252 static void unmark_dies (dw_die_ref);
6253 static void unmark_all_dies (dw_die_ref);
6254 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
6255 static unsigned long size_of_aranges (void);
6256 static enum dwarf_form value_format (dw_attr_ref);
6257 static void output_value_format (dw_attr_ref);
6258 static void output_abbrev_section (void);
6259 static void output_die_symbol (dw_die_ref);
6260 static void output_die (dw_die_ref);
6261 static void output_compilation_unit_header (void);
6262 static void output_comp_unit (dw_die_ref, int);
6263 static void output_comdat_type_unit (comdat_type_node *);
6264 static const char *dwarf2_name (tree, int);
6265 static void add_pubname (tree, dw_die_ref);
6266 static void add_pubname_string (const char *, dw_die_ref);
6267 static void add_pubtype (tree, dw_die_ref);
6268 static void output_pubnames (VEC (pubname_entry,gc) *);
6269 static void add_arange (tree, dw_die_ref);
6270 static void output_aranges (void);
6271 static unsigned int add_ranges_num (int);
6272 static unsigned int add_ranges (const_tree);
6273 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
6275 static void output_ranges (void);
6276 static void output_line_info (void);
6277 static void output_file_names (void);
6278 static dw_die_ref base_type_die (tree);
6279 static int is_base_type (tree);
6280 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
6281 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
6282 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
6283 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
6284 static int type_is_enum (const_tree);
6285 static unsigned int dbx_reg_number (const_rtx);
6286 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
6287 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
6288 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
6289 enum var_init_status);
6290 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
6291 enum var_init_status);
6292 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
6293 enum var_init_status);
6294 static int is_based_loc (const_rtx);
6295 static int resolve_one_addr (rtx *, void *);
6296 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
6297 enum var_init_status);
6298 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
6299 enum var_init_status);
6300 static dw_loc_list_ref loc_list_from_tree (tree, int);
6301 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
6302 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
6303 static tree field_type (const_tree);
6304 static unsigned int simple_type_align_in_bits (const_tree);
6305 static unsigned int simple_decl_align_in_bits (const_tree);
6306 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
6307 static HOST_WIDE_INT field_byte_offset (const_tree);
6308 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
6310 static void add_data_member_location_attribute (dw_die_ref, tree);
6311 static bool add_const_value_attribute (dw_die_ref, rtx);
6312 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
6313 static void insert_double (double_int, unsigned char *);
6314 static void insert_float (const_rtx, unsigned char *);
6315 static rtx rtl_for_decl_location (tree);
6316 static bool add_location_or_const_value_attribute (dw_die_ref, tree,
6317 enum dwarf_attribute);
6318 static bool tree_add_const_value_attribute (dw_die_ref, tree);
6319 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
6320 static void add_name_attribute (dw_die_ref, const char *);
6321 static void add_comp_dir_attribute (dw_die_ref);
6322 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
6323 static void add_subscript_info (dw_die_ref, tree, bool);
6324 static void add_byte_size_attribute (dw_die_ref, tree);
6325 static void add_bit_offset_attribute (dw_die_ref, tree);
6326 static void add_bit_size_attribute (dw_die_ref, tree);
6327 static void add_prototyped_attribute (dw_die_ref, tree);
6328 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
6329 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
6330 static void add_src_coords_attributes (dw_die_ref, tree);
6331 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
6332 static void push_decl_scope (tree);
6333 static void pop_decl_scope (void);
6334 static dw_die_ref scope_die_for (tree, dw_die_ref);
6335 static inline int local_scope_p (dw_die_ref);
6336 static inline int class_scope_p (dw_die_ref);
6337 static inline int class_or_namespace_scope_p (dw_die_ref);
6338 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
6339 static void add_calling_convention_attribute (dw_die_ref, tree);
6340 static const char *type_tag (const_tree);
6341 static tree member_declared_type (const_tree);
6343 static const char *decl_start_label (tree);
6345 static void gen_array_type_die (tree, dw_die_ref);
6346 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
6348 static void gen_entry_point_die (tree, dw_die_ref);
6350 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
6351 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
6352 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
6353 static void gen_unspecified_parameters_die (tree, dw_die_ref);
6354 static void gen_formal_types_die (tree, dw_die_ref);
6355 static void gen_subprogram_die (tree, dw_die_ref);
6356 static void gen_variable_die (tree, tree, dw_die_ref);
6357 static void gen_const_die (tree, dw_die_ref);
6358 static void gen_label_die (tree, dw_die_ref);
6359 static void gen_lexical_block_die (tree, dw_die_ref, int);
6360 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
6361 static void gen_field_die (tree, dw_die_ref);
6362 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
6363 static dw_die_ref gen_compile_unit_die (const char *);
6364 static void gen_inheritance_die (tree, tree, dw_die_ref);
6365 static void gen_member_die (tree, dw_die_ref);
6366 static void gen_struct_or_union_type_die (tree, dw_die_ref,
6367 enum debug_info_usage);
6368 static void gen_subroutine_type_die (tree, dw_die_ref);
6369 static void gen_typedef_die (tree, dw_die_ref);
6370 static void gen_type_die (tree, dw_die_ref);
6371 static void gen_block_die (tree, dw_die_ref, int);
6372 static void decls_for_scope (tree, dw_die_ref, int);
6373 static int is_redundant_typedef (const_tree);
6374 static bool is_naming_typedef_decl (const_tree);
6375 static inline dw_die_ref get_context_die (tree);
6376 static void gen_namespace_die (tree, dw_die_ref);
6377 static dw_die_ref gen_decl_die (tree, tree, dw_die_ref);
6378 static dw_die_ref force_decl_die (tree);
6379 static dw_die_ref force_type_die (tree);
6380 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
6381 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
6382 static struct dwarf_file_data * lookup_filename (const char *);
6383 static void retry_incomplete_types (void);
6384 static void gen_type_die_for_member (tree, tree, dw_die_ref);
6385 static void gen_generic_params_dies (tree);
6386 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
6387 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
6388 static void splice_child_die (dw_die_ref, dw_die_ref);
6389 static int file_info_cmp (const void *, const void *);
6390 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
6391 const char *, const char *);
6392 static void output_loc_list (dw_loc_list_ref);
6393 static char *gen_internal_sym (const char *);
6395 static void prune_unmark_dies (dw_die_ref);
6396 static void prune_unused_types_mark (dw_die_ref, int);
6397 static void prune_unused_types_walk (dw_die_ref);
6398 static void prune_unused_types_walk_attribs (dw_die_ref);
6399 static void prune_unused_types_prune (dw_die_ref);
6400 static void prune_unused_types (void);
6401 static int maybe_emit_file (struct dwarf_file_data *fd);
6402 static inline const char *AT_vms_delta1 (dw_attr_ref);
6403 static inline const char *AT_vms_delta2 (dw_attr_ref);
6404 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
6405 const char *, const char *);
6406 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
6407 static void gen_remaining_tmpl_value_param_die_attribute (void);
6409 /* Section names used to hold DWARF debugging information. */
6410 #ifndef DEBUG_INFO_SECTION
6411 #define DEBUG_INFO_SECTION ".debug_info"
6413 #ifndef DEBUG_ABBREV_SECTION
6414 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
6416 #ifndef DEBUG_ARANGES_SECTION
6417 #define DEBUG_ARANGES_SECTION ".debug_aranges"
6419 #ifndef DEBUG_MACINFO_SECTION
6420 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
6422 #ifndef DEBUG_LINE_SECTION
6423 #define DEBUG_LINE_SECTION ".debug_line"
6425 #ifndef DEBUG_LOC_SECTION
6426 #define DEBUG_LOC_SECTION ".debug_loc"
6428 #ifndef DEBUG_PUBNAMES_SECTION
6429 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
6431 #ifndef DEBUG_PUBTYPES_SECTION
6432 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
6434 #ifndef DEBUG_DCALL_SECTION
6435 #define DEBUG_DCALL_SECTION ".debug_dcall"
6437 #ifndef DEBUG_VCALL_SECTION
6438 #define DEBUG_VCALL_SECTION ".debug_vcall"
6440 #ifndef DEBUG_STR_SECTION
6441 #define DEBUG_STR_SECTION ".debug_str"
6443 #ifndef DEBUG_RANGES_SECTION
6444 #define DEBUG_RANGES_SECTION ".debug_ranges"
6447 /* Standard ELF section names for compiled code and data. */
6448 #ifndef TEXT_SECTION_NAME
6449 #define TEXT_SECTION_NAME ".text"
6452 /* Section flags for .debug_str section. */
6453 #define DEBUG_STR_SECTION_FLAGS \
6454 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
6455 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
6458 /* Labels we insert at beginning sections we can reference instead of
6459 the section names themselves. */
6461 #ifndef TEXT_SECTION_LABEL
6462 #define TEXT_SECTION_LABEL "Ltext"
6464 #ifndef COLD_TEXT_SECTION_LABEL
6465 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
6467 #ifndef DEBUG_LINE_SECTION_LABEL
6468 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
6470 #ifndef DEBUG_INFO_SECTION_LABEL
6471 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
6473 #ifndef DEBUG_ABBREV_SECTION_LABEL
6474 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
6476 #ifndef DEBUG_LOC_SECTION_LABEL
6477 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
6479 #ifndef DEBUG_RANGES_SECTION_LABEL
6480 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
6482 #ifndef DEBUG_MACINFO_SECTION_LABEL
6483 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
6487 /* Definitions of defaults for formats and names of various special
6488 (artificial) labels which may be generated within this file (when the -g
6489 options is used and DWARF2_DEBUGGING_INFO is in effect.
6490 If necessary, these may be overridden from within the tm.h file, but
6491 typically, overriding these defaults is unnecessary. */
6493 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6494 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6495 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6496 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6497 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6498 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6499 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6500 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6501 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6502 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
6504 #ifndef TEXT_END_LABEL
6505 #define TEXT_END_LABEL "Letext"
6507 #ifndef COLD_END_LABEL
6508 #define COLD_END_LABEL "Letext_cold"
6510 #ifndef BLOCK_BEGIN_LABEL
6511 #define BLOCK_BEGIN_LABEL "LBB"
6513 #ifndef BLOCK_END_LABEL
6514 #define BLOCK_END_LABEL "LBE"
6516 #ifndef LINE_CODE_LABEL
6517 #define LINE_CODE_LABEL "LM"
6519 #ifndef SEPARATE_LINE_CODE_LABEL
6520 #define SEPARATE_LINE_CODE_LABEL "LSM"
6524 /* Return the root of the DIE's built for the current compilation unit. */
6526 comp_unit_die (void)
6528 if (!single_comp_unit_die)
6529 single_comp_unit_die = gen_compile_unit_die (NULL);
6530 return single_comp_unit_die;
6533 /* We allow a language front-end to designate a function that is to be
6534 called to "demangle" any name before it is put into a DIE. */
6536 static const char *(*demangle_name_func) (const char *);
6539 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
6541 demangle_name_func = func;
6544 /* Test if rtl node points to a pseudo register. */
6547 is_pseudo_reg (const_rtx rtl)
6549 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
6550 || (GET_CODE (rtl) == SUBREG
6551 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
6554 /* Return a reference to a type, with its const and volatile qualifiers
6558 type_main_variant (tree type)
6560 type = TYPE_MAIN_VARIANT (type);
6562 /* ??? There really should be only one main variant among any group of
6563 variants of a given type (and all of the MAIN_VARIANT values for all
6564 members of the group should point to that one type) but sometimes the C
6565 front-end messes this up for array types, so we work around that bug
6567 if (TREE_CODE (type) == ARRAY_TYPE)
6568 while (type != TYPE_MAIN_VARIANT (type))
6569 type = TYPE_MAIN_VARIANT (type);
6574 /* Return nonzero if the given type node represents a tagged type. */
6577 is_tagged_type (const_tree type)
6579 enum tree_code code = TREE_CODE (type);
6581 return (code == RECORD_TYPE || code == UNION_TYPE
6582 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
6585 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
6588 get_ref_die_offset_label (char *label, dw_die_ref ref)
6590 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
6593 /* Convert a DIE tag into its string name. */
6596 dwarf_tag_name (unsigned int tag)
6600 case DW_TAG_padding:
6601 return "DW_TAG_padding";
6602 case DW_TAG_array_type:
6603 return "DW_TAG_array_type";
6604 case DW_TAG_class_type:
6605 return "DW_TAG_class_type";
6606 case DW_TAG_entry_point:
6607 return "DW_TAG_entry_point";
6608 case DW_TAG_enumeration_type:
6609 return "DW_TAG_enumeration_type";
6610 case DW_TAG_formal_parameter:
6611 return "DW_TAG_formal_parameter";
6612 case DW_TAG_imported_declaration:
6613 return "DW_TAG_imported_declaration";
6615 return "DW_TAG_label";
6616 case DW_TAG_lexical_block:
6617 return "DW_TAG_lexical_block";
6619 return "DW_TAG_member";
6620 case DW_TAG_pointer_type:
6621 return "DW_TAG_pointer_type";
6622 case DW_TAG_reference_type:
6623 return "DW_TAG_reference_type";
6624 case DW_TAG_compile_unit:
6625 return "DW_TAG_compile_unit";
6626 case DW_TAG_string_type:
6627 return "DW_TAG_string_type";
6628 case DW_TAG_structure_type:
6629 return "DW_TAG_structure_type";
6630 case DW_TAG_subroutine_type:
6631 return "DW_TAG_subroutine_type";
6632 case DW_TAG_typedef:
6633 return "DW_TAG_typedef";
6634 case DW_TAG_union_type:
6635 return "DW_TAG_union_type";
6636 case DW_TAG_unspecified_parameters:
6637 return "DW_TAG_unspecified_parameters";
6638 case DW_TAG_variant:
6639 return "DW_TAG_variant";
6640 case DW_TAG_common_block:
6641 return "DW_TAG_common_block";
6642 case DW_TAG_common_inclusion:
6643 return "DW_TAG_common_inclusion";
6644 case DW_TAG_inheritance:
6645 return "DW_TAG_inheritance";
6646 case DW_TAG_inlined_subroutine:
6647 return "DW_TAG_inlined_subroutine";
6649 return "DW_TAG_module";
6650 case DW_TAG_ptr_to_member_type:
6651 return "DW_TAG_ptr_to_member_type";
6652 case DW_TAG_set_type:
6653 return "DW_TAG_set_type";
6654 case DW_TAG_subrange_type:
6655 return "DW_TAG_subrange_type";
6656 case DW_TAG_with_stmt:
6657 return "DW_TAG_with_stmt";
6658 case DW_TAG_access_declaration:
6659 return "DW_TAG_access_declaration";
6660 case DW_TAG_base_type:
6661 return "DW_TAG_base_type";
6662 case DW_TAG_catch_block:
6663 return "DW_TAG_catch_block";
6664 case DW_TAG_const_type:
6665 return "DW_TAG_const_type";
6666 case DW_TAG_constant:
6667 return "DW_TAG_constant";
6668 case DW_TAG_enumerator:
6669 return "DW_TAG_enumerator";
6670 case DW_TAG_file_type:
6671 return "DW_TAG_file_type";
6673 return "DW_TAG_friend";
6674 case DW_TAG_namelist:
6675 return "DW_TAG_namelist";
6676 case DW_TAG_namelist_item:
6677 return "DW_TAG_namelist_item";
6678 case DW_TAG_packed_type:
6679 return "DW_TAG_packed_type";
6680 case DW_TAG_subprogram:
6681 return "DW_TAG_subprogram";
6682 case DW_TAG_template_type_param:
6683 return "DW_TAG_template_type_param";
6684 case DW_TAG_template_value_param:
6685 return "DW_TAG_template_value_param";
6686 case DW_TAG_thrown_type:
6687 return "DW_TAG_thrown_type";
6688 case DW_TAG_try_block:
6689 return "DW_TAG_try_block";
6690 case DW_TAG_variant_part:
6691 return "DW_TAG_variant_part";
6692 case DW_TAG_variable:
6693 return "DW_TAG_variable";
6694 case DW_TAG_volatile_type:
6695 return "DW_TAG_volatile_type";
6696 case DW_TAG_dwarf_procedure:
6697 return "DW_TAG_dwarf_procedure";
6698 case DW_TAG_restrict_type:
6699 return "DW_TAG_restrict_type";
6700 case DW_TAG_interface_type:
6701 return "DW_TAG_interface_type";
6702 case DW_TAG_namespace:
6703 return "DW_TAG_namespace";
6704 case DW_TAG_imported_module:
6705 return "DW_TAG_imported_module";
6706 case DW_TAG_unspecified_type:
6707 return "DW_TAG_unspecified_type";
6708 case DW_TAG_partial_unit:
6709 return "DW_TAG_partial_unit";
6710 case DW_TAG_imported_unit:
6711 return "DW_TAG_imported_unit";
6712 case DW_TAG_condition:
6713 return "DW_TAG_condition";
6714 case DW_TAG_shared_type:
6715 return "DW_TAG_shared_type";
6716 case DW_TAG_type_unit:
6717 return "DW_TAG_type_unit";
6718 case DW_TAG_rvalue_reference_type:
6719 return "DW_TAG_rvalue_reference_type";
6720 case DW_TAG_template_alias:
6721 return "DW_TAG_template_alias";
6722 case DW_TAG_GNU_template_parameter_pack:
6723 return "DW_TAG_GNU_template_parameter_pack";
6724 case DW_TAG_GNU_formal_parameter_pack:
6725 return "DW_TAG_GNU_formal_parameter_pack";
6726 case DW_TAG_MIPS_loop:
6727 return "DW_TAG_MIPS_loop";
6728 case DW_TAG_format_label:
6729 return "DW_TAG_format_label";
6730 case DW_TAG_function_template:
6731 return "DW_TAG_function_template";
6732 case DW_TAG_class_template:
6733 return "DW_TAG_class_template";
6734 case DW_TAG_GNU_BINCL:
6735 return "DW_TAG_GNU_BINCL";
6736 case DW_TAG_GNU_EINCL:
6737 return "DW_TAG_GNU_EINCL";
6738 case DW_TAG_GNU_template_template_param:
6739 return "DW_TAG_GNU_template_template_param";
6741 return "DW_TAG_<unknown>";
6745 /* Convert a DWARF attribute code into its string name. */
6748 dwarf_attr_name (unsigned int attr)
6753 return "DW_AT_sibling";
6754 case DW_AT_location:
6755 return "DW_AT_location";
6757 return "DW_AT_name";
6758 case DW_AT_ordering:
6759 return "DW_AT_ordering";
6760 case DW_AT_subscr_data:
6761 return "DW_AT_subscr_data";
6762 case DW_AT_byte_size:
6763 return "DW_AT_byte_size";
6764 case DW_AT_bit_offset:
6765 return "DW_AT_bit_offset";
6766 case DW_AT_bit_size:
6767 return "DW_AT_bit_size";
6768 case DW_AT_element_list:
6769 return "DW_AT_element_list";
6770 case DW_AT_stmt_list:
6771 return "DW_AT_stmt_list";
6773 return "DW_AT_low_pc";
6775 return "DW_AT_high_pc";
6776 case DW_AT_language:
6777 return "DW_AT_language";
6779 return "DW_AT_member";
6781 return "DW_AT_discr";
6782 case DW_AT_discr_value:
6783 return "DW_AT_discr_value";
6784 case DW_AT_visibility:
6785 return "DW_AT_visibility";
6787 return "DW_AT_import";
6788 case DW_AT_string_length:
6789 return "DW_AT_string_length";
6790 case DW_AT_common_reference:
6791 return "DW_AT_common_reference";
6792 case DW_AT_comp_dir:
6793 return "DW_AT_comp_dir";
6794 case DW_AT_const_value:
6795 return "DW_AT_const_value";
6796 case DW_AT_containing_type:
6797 return "DW_AT_containing_type";
6798 case DW_AT_default_value:
6799 return "DW_AT_default_value";
6801 return "DW_AT_inline";
6802 case DW_AT_is_optional:
6803 return "DW_AT_is_optional";
6804 case DW_AT_lower_bound:
6805 return "DW_AT_lower_bound";
6806 case DW_AT_producer:
6807 return "DW_AT_producer";
6808 case DW_AT_prototyped:
6809 return "DW_AT_prototyped";
6810 case DW_AT_return_addr:
6811 return "DW_AT_return_addr";
6812 case DW_AT_start_scope:
6813 return "DW_AT_start_scope";
6814 case DW_AT_bit_stride:
6815 return "DW_AT_bit_stride";
6816 case DW_AT_upper_bound:
6817 return "DW_AT_upper_bound";
6818 case DW_AT_abstract_origin:
6819 return "DW_AT_abstract_origin";
6820 case DW_AT_accessibility:
6821 return "DW_AT_accessibility";
6822 case DW_AT_address_class:
6823 return "DW_AT_address_class";
6824 case DW_AT_artificial:
6825 return "DW_AT_artificial";
6826 case DW_AT_base_types:
6827 return "DW_AT_base_types";
6828 case DW_AT_calling_convention:
6829 return "DW_AT_calling_convention";
6831 return "DW_AT_count";
6832 case DW_AT_data_member_location:
6833 return "DW_AT_data_member_location";
6834 case DW_AT_decl_column:
6835 return "DW_AT_decl_column";
6836 case DW_AT_decl_file:
6837 return "DW_AT_decl_file";
6838 case DW_AT_decl_line:
6839 return "DW_AT_decl_line";
6840 case DW_AT_declaration:
6841 return "DW_AT_declaration";
6842 case DW_AT_discr_list:
6843 return "DW_AT_discr_list";
6844 case DW_AT_encoding:
6845 return "DW_AT_encoding";
6846 case DW_AT_external:
6847 return "DW_AT_external";
6848 case DW_AT_explicit:
6849 return "DW_AT_explicit";
6850 case DW_AT_frame_base:
6851 return "DW_AT_frame_base";
6853 return "DW_AT_friend";
6854 case DW_AT_identifier_case:
6855 return "DW_AT_identifier_case";
6856 case DW_AT_macro_info:
6857 return "DW_AT_macro_info";
6858 case DW_AT_namelist_items:
6859 return "DW_AT_namelist_items";
6860 case DW_AT_priority:
6861 return "DW_AT_priority";
6863 return "DW_AT_segment";
6864 case DW_AT_specification:
6865 return "DW_AT_specification";
6866 case DW_AT_static_link:
6867 return "DW_AT_static_link";
6869 return "DW_AT_type";
6870 case DW_AT_use_location:
6871 return "DW_AT_use_location";
6872 case DW_AT_variable_parameter:
6873 return "DW_AT_variable_parameter";
6874 case DW_AT_virtuality:
6875 return "DW_AT_virtuality";
6876 case DW_AT_vtable_elem_location:
6877 return "DW_AT_vtable_elem_location";
6879 case DW_AT_allocated:
6880 return "DW_AT_allocated";
6881 case DW_AT_associated:
6882 return "DW_AT_associated";
6883 case DW_AT_data_location:
6884 return "DW_AT_data_location";
6885 case DW_AT_byte_stride:
6886 return "DW_AT_byte_stride";
6887 case DW_AT_entry_pc:
6888 return "DW_AT_entry_pc";
6889 case DW_AT_use_UTF8:
6890 return "DW_AT_use_UTF8";
6891 case DW_AT_extension:
6892 return "DW_AT_extension";
6894 return "DW_AT_ranges";
6895 case DW_AT_trampoline:
6896 return "DW_AT_trampoline";
6897 case DW_AT_call_column:
6898 return "DW_AT_call_column";
6899 case DW_AT_call_file:
6900 return "DW_AT_call_file";
6901 case DW_AT_call_line:
6902 return "DW_AT_call_line";
6903 case DW_AT_object_pointer:
6904 return "DW_AT_object_pointer";
6906 case DW_AT_signature:
6907 return "DW_AT_signature";
6908 case DW_AT_main_subprogram:
6909 return "DW_AT_main_subprogram";
6910 case DW_AT_data_bit_offset:
6911 return "DW_AT_data_bit_offset";
6912 case DW_AT_const_expr:
6913 return "DW_AT_const_expr";
6914 case DW_AT_enum_class:
6915 return "DW_AT_enum_class";
6916 case DW_AT_linkage_name:
6917 return "DW_AT_linkage_name";
6919 case DW_AT_MIPS_fde:
6920 return "DW_AT_MIPS_fde";
6921 case DW_AT_MIPS_loop_begin:
6922 return "DW_AT_MIPS_loop_begin";
6923 case DW_AT_MIPS_tail_loop_begin:
6924 return "DW_AT_MIPS_tail_loop_begin";
6925 case DW_AT_MIPS_epilog_begin:
6926 return "DW_AT_MIPS_epilog_begin";
6927 #if VMS_DEBUGGING_INFO
6928 case DW_AT_HP_prologue:
6929 return "DW_AT_HP_prologue";
6931 case DW_AT_MIPS_loop_unroll_factor:
6932 return "DW_AT_MIPS_loop_unroll_factor";
6934 case DW_AT_MIPS_software_pipeline_depth:
6935 return "DW_AT_MIPS_software_pipeline_depth";
6936 case DW_AT_MIPS_linkage_name:
6937 return "DW_AT_MIPS_linkage_name";
6938 #if VMS_DEBUGGING_INFO
6939 case DW_AT_HP_epilogue:
6940 return "DW_AT_HP_epilogue";
6942 case DW_AT_MIPS_stride:
6943 return "DW_AT_MIPS_stride";
6945 case DW_AT_MIPS_abstract_name:
6946 return "DW_AT_MIPS_abstract_name";
6947 case DW_AT_MIPS_clone_origin:
6948 return "DW_AT_MIPS_clone_origin";
6949 case DW_AT_MIPS_has_inlines:
6950 return "DW_AT_MIPS_has_inlines";
6952 case DW_AT_sf_names:
6953 return "DW_AT_sf_names";
6954 case DW_AT_src_info:
6955 return "DW_AT_src_info";
6956 case DW_AT_mac_info:
6957 return "DW_AT_mac_info";
6958 case DW_AT_src_coords:
6959 return "DW_AT_src_coords";
6960 case DW_AT_body_begin:
6961 return "DW_AT_body_begin";
6962 case DW_AT_body_end:
6963 return "DW_AT_body_end";
6964 case DW_AT_GNU_vector:
6965 return "DW_AT_GNU_vector";
6966 case DW_AT_GNU_guarded_by:
6967 return "DW_AT_GNU_guarded_by";
6968 case DW_AT_GNU_pt_guarded_by:
6969 return "DW_AT_GNU_pt_guarded_by";
6970 case DW_AT_GNU_guarded:
6971 return "DW_AT_GNU_guarded";
6972 case DW_AT_GNU_pt_guarded:
6973 return "DW_AT_GNU_pt_guarded";
6974 case DW_AT_GNU_locks_excluded:
6975 return "DW_AT_GNU_locks_excluded";
6976 case DW_AT_GNU_exclusive_locks_required:
6977 return "DW_AT_GNU_exclusive_locks_required";
6978 case DW_AT_GNU_shared_locks_required:
6979 return "DW_AT_GNU_shared_locks_required";
6980 case DW_AT_GNU_odr_signature:
6981 return "DW_AT_GNU_odr_signature";
6982 case DW_AT_GNU_template_name:
6983 return "DW_AT_GNU_template_name";
6985 case DW_AT_VMS_rtnbeg_pd_address:
6986 return "DW_AT_VMS_rtnbeg_pd_address";
6989 return "DW_AT_<unknown>";
6993 /* Convert a DWARF value form code into its string name. */
6996 dwarf_form_name (unsigned int form)
7001 return "DW_FORM_addr";
7002 case DW_FORM_block2:
7003 return "DW_FORM_block2";
7004 case DW_FORM_block4:
7005 return "DW_FORM_block4";
7007 return "DW_FORM_data2";
7009 return "DW_FORM_data4";
7011 return "DW_FORM_data8";
7012 case DW_FORM_string:
7013 return "DW_FORM_string";
7015 return "DW_FORM_block";
7016 case DW_FORM_block1:
7017 return "DW_FORM_block1";
7019 return "DW_FORM_data1";
7021 return "DW_FORM_flag";
7023 return "DW_FORM_sdata";
7025 return "DW_FORM_strp";
7027 return "DW_FORM_udata";
7028 case DW_FORM_ref_addr:
7029 return "DW_FORM_ref_addr";
7031 return "DW_FORM_ref1";
7033 return "DW_FORM_ref2";
7035 return "DW_FORM_ref4";
7037 return "DW_FORM_ref8";
7038 case DW_FORM_ref_udata:
7039 return "DW_FORM_ref_udata";
7040 case DW_FORM_indirect:
7041 return "DW_FORM_indirect";
7042 case DW_FORM_sec_offset:
7043 return "DW_FORM_sec_offset";
7044 case DW_FORM_exprloc:
7045 return "DW_FORM_exprloc";
7046 case DW_FORM_flag_present:
7047 return "DW_FORM_flag_present";
7048 case DW_FORM_ref_sig8:
7049 return "DW_FORM_ref_sig8";
7051 return "DW_FORM_<unknown>";
7055 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
7056 instance of an inlined instance of a decl which is local to an inline
7057 function, so we have to trace all of the way back through the origin chain
7058 to find out what sort of node actually served as the original seed for the
7062 decl_ultimate_origin (const_tree decl)
7064 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
7067 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
7068 nodes in the function to point to themselves; ignore that if
7069 we're trying to output the abstract instance of this function. */
7070 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
7073 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
7074 most distant ancestor, this should never happen. */
7075 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
7077 return DECL_ABSTRACT_ORIGIN (decl);
7080 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
7081 of a virtual function may refer to a base class, so we check the 'this'
7085 decl_class_context (tree decl)
7087 tree context = NULL_TREE;
7089 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
7090 context = DECL_CONTEXT (decl);
7092 context = TYPE_MAIN_VARIANT
7093 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
7095 if (context && !TYPE_P (context))
7096 context = NULL_TREE;
7101 /* Add an attribute/value pair to a DIE. */
7104 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
7106 /* Maybe this should be an assert? */
7110 if (die->die_attr == NULL)
7111 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
7112 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
7115 static inline enum dw_val_class
7116 AT_class (dw_attr_ref a)
7118 return a->dw_attr_val.val_class;
7121 /* Add a flag value attribute to a DIE. */
7124 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
7128 attr.dw_attr = attr_kind;
7129 attr.dw_attr_val.val_class = dw_val_class_flag;
7130 attr.dw_attr_val.v.val_flag = flag;
7131 add_dwarf_attr (die, &attr);
7134 static inline unsigned
7135 AT_flag (dw_attr_ref a)
7137 gcc_assert (a && AT_class (a) == dw_val_class_flag);
7138 return a->dw_attr_val.v.val_flag;
7141 /* Add a signed integer attribute value to a DIE. */
7144 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
7148 attr.dw_attr = attr_kind;
7149 attr.dw_attr_val.val_class = dw_val_class_const;
7150 attr.dw_attr_val.v.val_int = int_val;
7151 add_dwarf_attr (die, &attr);
7154 static inline HOST_WIDE_INT
7155 AT_int (dw_attr_ref a)
7157 gcc_assert (a && AT_class (a) == dw_val_class_const);
7158 return a->dw_attr_val.v.val_int;
7161 /* Add an unsigned integer attribute value to a DIE. */
7164 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
7165 unsigned HOST_WIDE_INT unsigned_val)
7169 attr.dw_attr = attr_kind;
7170 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
7171 attr.dw_attr_val.v.val_unsigned = unsigned_val;
7172 add_dwarf_attr (die, &attr);
7175 static inline unsigned HOST_WIDE_INT
7176 AT_unsigned (dw_attr_ref a)
7178 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
7179 return a->dw_attr_val.v.val_unsigned;
7182 /* Add an unsigned double integer attribute value to a DIE. */
7185 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
7186 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
7190 attr.dw_attr = attr_kind;
7191 attr.dw_attr_val.val_class = dw_val_class_const_double;
7192 attr.dw_attr_val.v.val_double.high = high;
7193 attr.dw_attr_val.v.val_double.low = low;
7194 add_dwarf_attr (die, &attr);
7197 /* Add a floating point attribute value to a DIE and return it. */
7200 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
7201 unsigned int length, unsigned int elt_size, unsigned char *array)
7205 attr.dw_attr = attr_kind;
7206 attr.dw_attr_val.val_class = dw_val_class_vec;
7207 attr.dw_attr_val.v.val_vec.length = length;
7208 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
7209 attr.dw_attr_val.v.val_vec.array = array;
7210 add_dwarf_attr (die, &attr);
7213 /* Add an 8-byte data attribute value to a DIE. */
7216 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
7217 unsigned char data8[8])
7221 attr.dw_attr = attr_kind;
7222 attr.dw_attr_val.val_class = dw_val_class_data8;
7223 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
7224 add_dwarf_attr (die, &attr);
7227 /* Hash and equality functions for debug_str_hash. */
7230 debug_str_do_hash (const void *x)
7232 return htab_hash_string (((const struct indirect_string_node *)x)->str);
7236 debug_str_eq (const void *x1, const void *x2)
7238 return strcmp ((((const struct indirect_string_node *)x1)->str),
7239 (const char *)x2) == 0;
7242 /* Add STR to the indirect string hash table. */
7244 static struct indirect_string_node *
7245 find_AT_string (const char *str)
7247 struct indirect_string_node *node;
7250 if (! debug_str_hash)
7251 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
7252 debug_str_eq, NULL);
7254 slot = htab_find_slot_with_hash (debug_str_hash, str,
7255 htab_hash_string (str), INSERT);
7258 node = ggc_alloc_cleared_indirect_string_node ();
7259 node->str = ggc_strdup (str);
7263 node = (struct indirect_string_node *) *slot;
7269 /* Add a string attribute value to a DIE. */
7272 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
7275 struct indirect_string_node *node;
7277 node = find_AT_string (str);
7279 attr.dw_attr = attr_kind;
7280 attr.dw_attr_val.val_class = dw_val_class_str;
7281 attr.dw_attr_val.v.val_str = node;
7282 add_dwarf_attr (die, &attr);
7285 /* Create a label for an indirect string node, ensuring it is going to
7286 be output, unless its reference count goes down to zero. */
7289 gen_label_for_indirect_string (struct indirect_string_node *node)
7296 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
7297 ++dw2_string_counter;
7298 node->label = xstrdup (label);
7301 /* Create a SYMBOL_REF rtx whose value is the initial address of a
7302 debug string STR. */
7305 get_debug_string_label (const char *str)
7307 struct indirect_string_node *node = find_AT_string (str);
7309 debug_str_hash_forced = true;
7311 gen_label_for_indirect_string (node);
7313 return gen_rtx_SYMBOL_REF (Pmode, node->label);
7316 static inline const char *
7317 AT_string (dw_attr_ref a)
7319 gcc_assert (a && AT_class (a) == dw_val_class_str);
7320 return a->dw_attr_val.v.val_str->str;
7323 /* Find out whether a string should be output inline in DIE
7324 or out-of-line in .debug_str section. */
7326 static enum dwarf_form
7327 AT_string_form (dw_attr_ref a)
7329 struct indirect_string_node *node;
7332 gcc_assert (a && AT_class (a) == dw_val_class_str);
7334 node = a->dw_attr_val.v.val_str;
7338 len = strlen (node->str) + 1;
7340 /* If the string is shorter or equal to the size of the reference, it is
7341 always better to put it inline. */
7342 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
7343 return node->form = DW_FORM_string;
7345 /* If we cannot expect the linker to merge strings in .debug_str
7346 section, only put it into .debug_str if it is worth even in this
7348 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
7349 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
7350 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
7351 return node->form = DW_FORM_string;
7353 gen_label_for_indirect_string (node);
7355 return node->form = DW_FORM_strp;
7358 /* Add a DIE reference attribute value to a DIE. */
7361 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
7365 attr.dw_attr = attr_kind;
7366 attr.dw_attr_val.val_class = dw_val_class_die_ref;
7367 attr.dw_attr_val.v.val_die_ref.die = targ_die;
7368 attr.dw_attr_val.v.val_die_ref.external = 0;
7369 add_dwarf_attr (die, &attr);
7372 /* Add an AT_specification attribute to a DIE, and also make the back
7373 pointer from the specification to the definition. */
7376 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
7378 add_AT_die_ref (die, DW_AT_specification, targ_die);
7379 gcc_assert (!targ_die->die_definition);
7380 targ_die->die_definition = die;
7383 static inline dw_die_ref
7384 AT_ref (dw_attr_ref a)
7386 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7387 return a->dw_attr_val.v.val_die_ref.die;
7391 AT_ref_external (dw_attr_ref a)
7393 if (a && AT_class (a) == dw_val_class_die_ref)
7394 return a->dw_attr_val.v.val_die_ref.external;
7400 set_AT_ref_external (dw_attr_ref a, int i)
7402 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7403 a->dw_attr_val.v.val_die_ref.external = i;
7406 /* Add an FDE reference attribute value to a DIE. */
7409 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
7413 attr.dw_attr = attr_kind;
7414 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
7415 attr.dw_attr_val.v.val_fde_index = targ_fde;
7416 add_dwarf_attr (die, &attr);
7419 /* Add a location description attribute value to a DIE. */
7422 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
7426 attr.dw_attr = attr_kind;
7427 attr.dw_attr_val.val_class = dw_val_class_loc;
7428 attr.dw_attr_val.v.val_loc = loc;
7429 add_dwarf_attr (die, &attr);
7432 static inline dw_loc_descr_ref
7433 AT_loc (dw_attr_ref a)
7435 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7436 return a->dw_attr_val.v.val_loc;
7440 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
7444 attr.dw_attr = attr_kind;
7445 attr.dw_attr_val.val_class = dw_val_class_loc_list;
7446 attr.dw_attr_val.v.val_loc_list = loc_list;
7447 add_dwarf_attr (die, &attr);
7448 have_location_lists = true;
7451 static inline dw_loc_list_ref
7452 AT_loc_list (dw_attr_ref a)
7454 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7455 return a->dw_attr_val.v.val_loc_list;
7458 static inline dw_loc_list_ref *
7459 AT_loc_list_ptr (dw_attr_ref a)
7461 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7462 return &a->dw_attr_val.v.val_loc_list;
7465 /* Add an address constant attribute value to a DIE. */
7468 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
7472 attr.dw_attr = attr_kind;
7473 attr.dw_attr_val.val_class = dw_val_class_addr;
7474 attr.dw_attr_val.v.val_addr = addr;
7475 add_dwarf_attr (die, &attr);
7478 /* Get the RTX from to an address DIE attribute. */
7481 AT_addr (dw_attr_ref a)
7483 gcc_assert (a && AT_class (a) == dw_val_class_addr);
7484 return a->dw_attr_val.v.val_addr;
7487 /* Add a file attribute value to a DIE. */
7490 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
7491 struct dwarf_file_data *fd)
7495 attr.dw_attr = attr_kind;
7496 attr.dw_attr_val.val_class = dw_val_class_file;
7497 attr.dw_attr_val.v.val_file = fd;
7498 add_dwarf_attr (die, &attr);
7501 /* Get the dwarf_file_data from a file DIE attribute. */
7503 static inline struct dwarf_file_data *
7504 AT_file (dw_attr_ref a)
7506 gcc_assert (a && AT_class (a) == dw_val_class_file);
7507 return a->dw_attr_val.v.val_file;
7510 /* Add a vms delta attribute value to a DIE. */
7513 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
7514 const char *lbl1, const char *lbl2)
7518 attr.dw_attr = attr_kind;
7519 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
7520 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
7521 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
7522 add_dwarf_attr (die, &attr);
7525 /* Add a label identifier attribute value to a DIE. */
7528 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
7532 attr.dw_attr = attr_kind;
7533 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
7534 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
7535 add_dwarf_attr (die, &attr);
7538 /* Add a section offset attribute value to a DIE, an offset into the
7539 debug_line section. */
7542 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7547 attr.dw_attr = attr_kind;
7548 attr.dw_attr_val.val_class = dw_val_class_lineptr;
7549 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7550 add_dwarf_attr (die, &attr);
7553 /* Add a section offset attribute value to a DIE, an offset into the
7554 debug_macinfo section. */
7557 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7562 attr.dw_attr = attr_kind;
7563 attr.dw_attr_val.val_class = dw_val_class_macptr;
7564 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7565 add_dwarf_attr (die, &attr);
7568 /* Add an offset attribute value to a DIE. */
7571 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
7572 unsigned HOST_WIDE_INT offset)
7576 attr.dw_attr = attr_kind;
7577 attr.dw_attr_val.val_class = dw_val_class_offset;
7578 attr.dw_attr_val.v.val_offset = offset;
7579 add_dwarf_attr (die, &attr);
7582 /* Add an range_list attribute value to a DIE. */
7585 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
7586 long unsigned int offset)
7590 attr.dw_attr = attr_kind;
7591 attr.dw_attr_val.val_class = dw_val_class_range_list;
7592 attr.dw_attr_val.v.val_offset = offset;
7593 add_dwarf_attr (die, &attr);
7596 /* Return the start label of a delta attribute. */
7598 static inline const char *
7599 AT_vms_delta1 (dw_attr_ref a)
7601 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
7602 return a->dw_attr_val.v.val_vms_delta.lbl1;
7605 /* Return the end label of a delta attribute. */
7607 static inline const char *
7608 AT_vms_delta2 (dw_attr_ref a)
7610 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
7611 return a->dw_attr_val.v.val_vms_delta.lbl2;
7614 static inline const char *
7615 AT_lbl (dw_attr_ref a)
7617 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
7618 || AT_class (a) == dw_val_class_lineptr
7619 || AT_class (a) == dw_val_class_macptr));
7620 return a->dw_attr_val.v.val_lbl_id;
7623 /* Get the attribute of type attr_kind. */
7626 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7630 dw_die_ref spec = NULL;
7635 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7636 if (a->dw_attr == attr_kind)
7638 else if (a->dw_attr == DW_AT_specification
7639 || a->dw_attr == DW_AT_abstract_origin)
7643 return get_AT (spec, attr_kind);
7648 /* Return the "low pc" attribute value, typically associated with a subprogram
7649 DIE. Return null if the "low pc" attribute is either not present, or if it
7650 cannot be represented as an assembler label identifier. */
7652 static inline const char *
7653 get_AT_low_pc (dw_die_ref die)
7655 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
7657 return a ? AT_lbl (a) : NULL;
7660 /* Return the "high pc" attribute value, typically associated with a subprogram
7661 DIE. Return null if the "high pc" attribute is either not present, or if it
7662 cannot be represented as an assembler label identifier. */
7664 static inline const char *
7665 get_AT_hi_pc (dw_die_ref die)
7667 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
7669 return a ? AT_lbl (a) : NULL;
7672 /* Return the value of the string attribute designated by ATTR_KIND, or
7673 NULL if it is not present. */
7675 static inline const char *
7676 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
7678 dw_attr_ref a = get_AT (die, attr_kind);
7680 return a ? AT_string (a) : NULL;
7683 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
7684 if it is not present. */
7687 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
7689 dw_attr_ref a = get_AT (die, attr_kind);
7691 return a ? AT_flag (a) : 0;
7694 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
7695 if it is not present. */
7697 static inline unsigned
7698 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
7700 dw_attr_ref a = get_AT (die, attr_kind);
7702 return a ? AT_unsigned (a) : 0;
7705 static inline dw_die_ref
7706 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
7708 dw_attr_ref a = get_AT (die, attr_kind);
7710 return a ? AT_ref (a) : NULL;
7713 static inline struct dwarf_file_data *
7714 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
7716 dw_attr_ref a = get_AT (die, attr_kind);
7718 return a ? AT_file (a) : NULL;
7721 /* Return TRUE if the language is C++. */
7726 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
7728 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
7731 /* Return TRUE if the language is Fortran. */
7736 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
7738 return (lang == DW_LANG_Fortran77
7739 || lang == DW_LANG_Fortran90
7740 || lang == DW_LANG_Fortran95);
7743 /* Return TRUE if the language is Ada. */
7748 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
7750 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
7753 /* Remove the specified attribute if present. */
7756 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7764 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
7765 if (a->dw_attr == attr_kind)
7767 if (AT_class (a) == dw_val_class_str)
7768 if (a->dw_attr_val.v.val_str->refcount)
7769 a->dw_attr_val.v.val_str->refcount--;
7771 /* VEC_ordered_remove should help reduce the number of abbrevs
7773 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
7778 /* Remove CHILD from its parent. PREV must have the property that
7779 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
7782 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
7784 gcc_assert (child->die_parent == prev->die_parent);
7785 gcc_assert (prev->die_sib == child);
7788 gcc_assert (child->die_parent->die_child == child);
7792 prev->die_sib = child->die_sib;
7793 if (child->die_parent->die_child == child)
7794 child->die_parent->die_child = prev;
7797 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
7798 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
7801 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
7803 dw_die_ref parent = old_child->die_parent;
7805 gcc_assert (parent == prev->die_parent);
7806 gcc_assert (prev->die_sib == old_child);
7808 new_child->die_parent = parent;
7809 if (prev == old_child)
7811 gcc_assert (parent->die_child == old_child);
7812 new_child->die_sib = new_child;
7816 prev->die_sib = new_child;
7817 new_child->die_sib = old_child->die_sib;
7819 if (old_child->die_parent->die_child == old_child)
7820 old_child->die_parent->die_child = new_child;
7823 /* Move all children from OLD_PARENT to NEW_PARENT. */
7826 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
7829 new_parent->die_child = old_parent->die_child;
7830 old_parent->die_child = NULL;
7831 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
7834 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
7838 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
7844 dw_die_ref prev = c;
7846 while (c->die_tag == tag)
7848 remove_child_with_prev (c, prev);
7849 /* Might have removed every child. */
7850 if (c == c->die_sib)
7854 } while (c != die->die_child);
7857 /* Add a CHILD_DIE as the last child of DIE. */
7860 add_child_die (dw_die_ref die, dw_die_ref child_die)
7862 /* FIXME this should probably be an assert. */
7863 if (! die || ! child_die)
7865 gcc_assert (die != child_die);
7867 child_die->die_parent = die;
7870 child_die->die_sib = die->die_child->die_sib;
7871 die->die_child->die_sib = child_die;
7874 child_die->die_sib = child_die;
7875 die->die_child = child_die;
7878 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
7879 is the specification, to the end of PARENT's list of children.
7880 This is done by removing and re-adding it. */
7883 splice_child_die (dw_die_ref parent, dw_die_ref child)
7887 /* We want the declaration DIE from inside the class, not the
7888 specification DIE at toplevel. */
7889 if (child->die_parent != parent)
7891 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
7897 gcc_assert (child->die_parent == parent
7898 || (child->die_parent
7899 == get_AT_ref (parent, DW_AT_specification)));
7901 for (p = child->die_parent->die_child; ; p = p->die_sib)
7902 if (p->die_sib == child)
7904 remove_child_with_prev (child, p);
7908 add_child_die (parent, child);
7911 /* Return a pointer to a newly created DIE node. */
7913 static inline dw_die_ref
7914 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
7916 dw_die_ref die = ggc_alloc_cleared_die_node ();
7918 die->die_tag = tag_value;
7920 if (parent_die != NULL)
7921 add_child_die (parent_die, die);
7924 limbo_die_node *limbo_node;
7926 limbo_node = ggc_alloc_cleared_limbo_die_node ();
7927 limbo_node->die = die;
7928 limbo_node->created_for = t;
7929 limbo_node->next = limbo_die_list;
7930 limbo_die_list = limbo_node;
7936 /* Return the DIE associated with the given type specifier. */
7938 static inline dw_die_ref
7939 lookup_type_die (tree type)
7941 return TYPE_SYMTAB_DIE (type);
7944 /* Equate a DIE to a given type specifier. */
7947 equate_type_number_to_die (tree type, dw_die_ref type_die)
7949 TYPE_SYMTAB_DIE (type) = type_die;
7952 /* Returns a hash value for X (which really is a die_struct). */
7955 decl_die_table_hash (const void *x)
7957 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
7960 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
7963 decl_die_table_eq (const void *x, const void *y)
7965 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
7968 /* Return the DIE associated with a given declaration. */
7970 static inline dw_die_ref
7971 lookup_decl_die (tree decl)
7973 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
7976 /* Returns a hash value for X (which really is a var_loc_list). */
7979 decl_loc_table_hash (const void *x)
7981 return (hashval_t) ((const var_loc_list *) x)->decl_id;
7984 /* Return nonzero if decl_id of var_loc_list X is the same as
7988 decl_loc_table_eq (const void *x, const void *y)
7990 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
7993 /* Return the var_loc list associated with a given declaration. */
7995 static inline var_loc_list *
7996 lookup_decl_loc (const_tree decl)
7998 if (!decl_loc_table)
8000 return (var_loc_list *)
8001 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
8004 /* Equate a DIE to a particular declaration. */
8007 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
8009 unsigned int decl_id = DECL_UID (decl);
8012 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
8014 decl_die->decl_id = decl_id;
8017 /* Return how many bits covers PIECE EXPR_LIST. */
8020 decl_piece_bitsize (rtx piece)
8022 int ret = (int) GET_MODE (piece);
8025 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
8026 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
8027 return INTVAL (XEXP (XEXP (piece, 0), 0));
8030 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
8033 decl_piece_varloc_ptr (rtx piece)
8035 if ((int) GET_MODE (piece))
8036 return &XEXP (piece, 0);
8038 return &XEXP (XEXP (piece, 0), 1);
8041 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
8042 Next is the chain of following piece nodes. */
8045 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
8047 if (bitsize <= (int) MAX_MACHINE_MODE)
8048 return alloc_EXPR_LIST (bitsize, loc_note, next);
8050 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
8055 /* Return rtx that should be stored into loc field for
8056 LOC_NOTE and BITPOS/BITSIZE. */
8059 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
8060 HOST_WIDE_INT bitsize)
8064 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
8066 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
8071 /* This function either modifies location piece list *DEST in
8072 place (if SRC and INNER is NULL), or copies location piece list
8073 *SRC to *DEST while modifying it. Location BITPOS is modified
8074 to contain LOC_NOTE, any pieces overlapping it are removed resp.
8075 not copied and if needed some padding around it is added.
8076 When modifying in place, DEST should point to EXPR_LIST where
8077 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
8078 to the start of the whole list and INNER points to the EXPR_LIST
8079 where earlier pieces cover PIECE_BITPOS bits. */
8082 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
8083 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
8084 HOST_WIDE_INT bitsize, rtx loc_note)
8087 bool copy = inner != NULL;
8091 /* First copy all nodes preceeding the current bitpos. */
8092 while (src != inner)
8094 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
8095 decl_piece_bitsize (*src), NULL_RTX);
8096 dest = &XEXP (*dest, 1);
8097 src = &XEXP (*src, 1);
8100 /* Add padding if needed. */
8101 if (bitpos != piece_bitpos)
8103 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
8104 copy ? NULL_RTX : *dest);
8105 dest = &XEXP (*dest, 1);
8107 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
8110 /* A piece with correct bitpos and bitsize already exist,
8111 just update the location for it and return. */
8112 *decl_piece_varloc_ptr (*dest) = loc_note;
8115 /* Add the piece that changed. */
8116 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
8117 dest = &XEXP (*dest, 1);
8118 /* Skip over pieces that overlap it. */
8119 diff = bitpos - piece_bitpos + bitsize;
8122 while (diff > 0 && *src)
8125 diff -= decl_piece_bitsize (piece);
8127 src = &XEXP (piece, 1);
8130 *src = XEXP (piece, 1);
8131 free_EXPR_LIST_node (piece);
8134 /* Add padding if needed. */
8135 if (diff < 0 && *src)
8139 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
8140 dest = &XEXP (*dest, 1);
8144 /* Finally copy all nodes following it. */
8147 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
8148 decl_piece_bitsize (*src), NULL_RTX);
8149 dest = &XEXP (*dest, 1);
8150 src = &XEXP (*src, 1);
8154 /* Add a variable location node to the linked list for DECL. */
8156 static struct var_loc_node *
8157 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label)
8159 unsigned int decl_id;
8162 struct var_loc_node *loc = NULL;
8163 HOST_WIDE_INT bitsize = -1, bitpos = -1;
8165 if (DECL_DEBUG_EXPR_IS_FROM (decl))
8167 tree realdecl = DECL_DEBUG_EXPR (decl);
8168 if (realdecl && handled_component_p (realdecl))
8170 HOST_WIDE_INT maxsize;
8173 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize);
8174 if (!DECL_P (innerdecl)
8175 || DECL_IGNORED_P (innerdecl)
8176 || TREE_STATIC (innerdecl)
8178 || bitpos + bitsize > 256
8179 || bitsize != maxsize)
8185 decl_id = DECL_UID (decl);
8186 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
8189 temp = ggc_alloc_cleared_var_loc_list ();
8190 temp->decl_id = decl_id;
8194 temp = (var_loc_list *) *slot;
8198 struct var_loc_node *last = temp->last, *unused = NULL;
8199 rtx *piece_loc = NULL, last_loc_note;
8200 int piece_bitpos = 0;
8204 gcc_assert (last->next == NULL);
8206 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
8208 piece_loc = &last->loc;
8211 int cur_bitsize = decl_piece_bitsize (*piece_loc);
8212 if (piece_bitpos + cur_bitsize > bitpos)
8214 piece_bitpos += cur_bitsize;
8215 piece_loc = &XEXP (*piece_loc, 1);
8219 /* TEMP->LAST here is either pointer to the last but one or
8220 last element in the chained list, LAST is pointer to the
8222 if (label && strcmp (last->label, label) == 0)
8224 /* For SRA optimized variables if there weren't any real
8225 insns since last note, just modify the last node. */
8226 if (piece_loc != NULL)
8228 adjust_piece_list (piece_loc, NULL, NULL,
8229 bitpos, piece_bitpos, bitsize, loc_note);
8232 /* If the last note doesn't cover any instructions, remove it. */
8233 if (temp->last != last)
8235 temp->last->next = NULL;
8238 gcc_assert (strcmp (last->label, label) != 0);
8242 gcc_assert (temp->first == temp->last);
8243 memset (temp->last, '\0', sizeof (*temp->last));
8244 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
8248 if (bitsize == -1 && NOTE_P (last->loc))
8249 last_loc_note = last->loc;
8250 else if (piece_loc != NULL
8251 && *piece_loc != NULL_RTX
8252 && piece_bitpos == bitpos
8253 && decl_piece_bitsize (*piece_loc) == bitsize)
8254 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
8256 last_loc_note = NULL_RTX;
8257 /* If the current location is the same as the end of the list,
8258 and either both or neither of the locations is uninitialized,
8259 we have nothing to do. */
8260 if (last_loc_note == NULL_RTX
8261 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
8262 NOTE_VAR_LOCATION_LOC (loc_note)))
8263 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
8264 != NOTE_VAR_LOCATION_STATUS (loc_note))
8265 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
8266 == VAR_INIT_STATUS_UNINITIALIZED)
8267 || (NOTE_VAR_LOCATION_STATUS (loc_note)
8268 == VAR_INIT_STATUS_UNINITIALIZED))))
8270 /* Add LOC to the end of list and update LAST. If the last
8271 element of the list has been removed above, reuse its
8272 memory for the new node, otherwise allocate a new one. */
8276 memset (loc, '\0', sizeof (*loc));
8279 loc = ggc_alloc_cleared_var_loc_node ();
8280 if (bitsize == -1 || piece_loc == NULL)
8281 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
8283 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
8284 bitpos, piece_bitpos, bitsize, loc_note);
8286 /* Ensure TEMP->LAST will point either to the new last but one
8287 element of the chain, or to the last element in it. */
8288 if (last != temp->last)
8296 loc = ggc_alloc_cleared_var_loc_node ();
8299 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
8304 /* Keep track of the number of spaces used to indent the
8305 output of the debugging routines that print the structure of
8306 the DIE internal representation. */
8307 static int print_indent;
8309 /* Indent the line the number of spaces given by print_indent. */
8312 print_spaces (FILE *outfile)
8314 fprintf (outfile, "%*s", print_indent, "");
8317 /* Print a type signature in hex. */
8320 print_signature (FILE *outfile, char *sig)
8324 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8325 fprintf (outfile, "%02x", sig[i] & 0xff);
8328 /* Print the information associated with a given DIE, and its children.
8329 This routine is a debugging aid only. */
8332 print_die (dw_die_ref die, FILE *outfile)
8338 print_spaces (outfile);
8339 fprintf (outfile, "DIE %4ld: %s\n",
8340 die->die_offset, dwarf_tag_name (die->die_tag));
8341 print_spaces (outfile);
8342 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
8343 fprintf (outfile, " offset: %ld\n", die->die_offset);
8344 if (dwarf_version >= 4 && die->die_id.die_type_node)
8346 print_spaces (outfile);
8347 fprintf (outfile, " signature: ");
8348 print_signature (outfile, die->die_id.die_type_node->signature);
8349 fprintf (outfile, "\n");
8352 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
8354 print_spaces (outfile);
8355 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
8357 switch (AT_class (a))
8359 case dw_val_class_addr:
8360 fprintf (outfile, "address");
8362 case dw_val_class_offset:
8363 fprintf (outfile, "offset");
8365 case dw_val_class_loc:
8366 fprintf (outfile, "location descriptor");
8368 case dw_val_class_loc_list:
8369 fprintf (outfile, "location list -> label:%s",
8370 AT_loc_list (a)->ll_symbol);
8372 case dw_val_class_range_list:
8373 fprintf (outfile, "range list");
8375 case dw_val_class_const:
8376 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
8378 case dw_val_class_unsigned_const:
8379 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
8381 case dw_val_class_const_double:
8382 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
8383 HOST_WIDE_INT_PRINT_UNSIGNED")",
8384 a->dw_attr_val.v.val_double.high,
8385 a->dw_attr_val.v.val_double.low);
8387 case dw_val_class_vec:
8388 fprintf (outfile, "floating-point or vector constant");
8390 case dw_val_class_flag:
8391 fprintf (outfile, "%u", AT_flag (a));
8393 case dw_val_class_die_ref:
8394 if (AT_ref (a) != NULL)
8396 if (dwarf_version >= 4 && AT_ref (a)->die_id.die_type_node)
8398 fprintf (outfile, "die -> signature: ");
8399 print_signature (outfile,
8400 AT_ref (a)->die_id.die_type_node->signature);
8402 else if (dwarf_version < 4 && AT_ref (a)->die_id.die_symbol)
8403 fprintf (outfile, "die -> label: %s",
8404 AT_ref (a)->die_id.die_symbol);
8406 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
8409 fprintf (outfile, "die -> <null>");
8411 case dw_val_class_vms_delta:
8412 fprintf (outfile, "delta: @slotcount(%s-%s)",
8413 AT_vms_delta2 (a), AT_vms_delta1 (a));
8415 case dw_val_class_lbl_id:
8416 case dw_val_class_lineptr:
8417 case dw_val_class_macptr:
8418 fprintf (outfile, "label: %s", AT_lbl (a));
8420 case dw_val_class_str:
8421 if (AT_string (a) != NULL)
8422 fprintf (outfile, "\"%s\"", AT_string (a));
8424 fprintf (outfile, "<null>");
8426 case dw_val_class_file:
8427 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
8428 AT_file (a)->emitted_number);
8430 case dw_val_class_data8:
8434 for (i = 0; i < 8; i++)
8435 fprintf (outfile, "%02x", a->dw_attr_val.v.val_data8[i]);
8442 fprintf (outfile, "\n");
8445 if (die->die_child != NULL)
8448 FOR_EACH_CHILD (die, c, print_die (c, outfile));
8451 if (print_indent == 0)
8452 fprintf (outfile, "\n");
8455 /* Print the contents of the source code line number correspondence table.
8456 This routine is a debugging aid only. */
8459 print_dwarf_line_table (FILE *outfile)
8462 dw_line_info_ref line_info;
8464 fprintf (outfile, "\n\nDWARF source line information\n");
8465 for (i = 1; i < line_info_table_in_use; i++)
8467 line_info = &line_info_table[i];
8468 fprintf (outfile, "%5d: %4ld %6ld\n", i,
8469 line_info->dw_file_num,
8470 line_info->dw_line_num);
8473 fprintf (outfile, "\n\n");
8476 /* Print the information collected for a given DIE. */
8479 debug_dwarf_die (dw_die_ref die)
8481 print_die (die, stderr);
8484 /* Print all DWARF information collected for the compilation unit.
8485 This routine is a debugging aid only. */
8491 print_die (comp_unit_die (), stderr);
8492 if (! DWARF2_ASM_LINE_DEBUG_INFO)
8493 print_dwarf_line_table (stderr);
8496 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
8497 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
8498 DIE that marks the start of the DIEs for this include file. */
8501 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
8503 const char *filename = get_AT_string (bincl_die, DW_AT_name);
8504 dw_die_ref new_unit = gen_compile_unit_die (filename);
8506 new_unit->die_sib = old_unit;
8510 /* Close an include-file CU and reopen the enclosing one. */
8513 pop_compile_unit (dw_die_ref old_unit)
8515 dw_die_ref new_unit = old_unit->die_sib;
8517 old_unit->die_sib = NULL;
8521 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8522 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
8524 /* Calculate the checksum of a location expression. */
8527 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
8531 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
8533 CHECKSUM (loc->dw_loc_oprnd1);
8534 CHECKSUM (loc->dw_loc_oprnd2);
8537 /* Calculate the checksum of an attribute. */
8540 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
8542 dw_loc_descr_ref loc;
8545 CHECKSUM (at->dw_attr);
8547 /* We don't care that this was compiled with a different compiler
8548 snapshot; if the output is the same, that's what matters. */
8549 if (at->dw_attr == DW_AT_producer)
8552 switch (AT_class (at))
8554 case dw_val_class_const:
8555 CHECKSUM (at->dw_attr_val.v.val_int);
8557 case dw_val_class_unsigned_const:
8558 CHECKSUM (at->dw_attr_val.v.val_unsigned);
8560 case dw_val_class_const_double:
8561 CHECKSUM (at->dw_attr_val.v.val_double);
8563 case dw_val_class_vec:
8564 CHECKSUM (at->dw_attr_val.v.val_vec);
8566 case dw_val_class_flag:
8567 CHECKSUM (at->dw_attr_val.v.val_flag);
8569 case dw_val_class_str:
8570 CHECKSUM_STRING (AT_string (at));
8573 case dw_val_class_addr:
8575 gcc_assert (GET_CODE (r) == SYMBOL_REF);
8576 CHECKSUM_STRING (XSTR (r, 0));
8579 case dw_val_class_offset:
8580 CHECKSUM (at->dw_attr_val.v.val_offset);
8583 case dw_val_class_loc:
8584 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
8585 loc_checksum (loc, ctx);
8588 case dw_val_class_die_ref:
8589 die_checksum (AT_ref (at), ctx, mark);
8592 case dw_val_class_fde_ref:
8593 case dw_val_class_vms_delta:
8594 case dw_val_class_lbl_id:
8595 case dw_val_class_lineptr:
8596 case dw_val_class_macptr:
8599 case dw_val_class_file:
8600 CHECKSUM_STRING (AT_file (at)->filename);
8603 case dw_val_class_data8:
8604 CHECKSUM (at->dw_attr_val.v.val_data8);
8612 /* Calculate the checksum of a DIE. */
8615 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
8621 /* To avoid infinite recursion. */
8624 CHECKSUM (die->die_mark);
8627 die->die_mark = ++(*mark);
8629 CHECKSUM (die->die_tag);
8631 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
8632 attr_checksum (a, ctx, mark);
8634 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
8638 #undef CHECKSUM_STRING
8640 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
8641 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8642 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
8643 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
8644 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
8645 #define CHECKSUM_ATTR(FOO) \
8646 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
8648 /* Calculate the checksum of a number in signed LEB128 format. */
8651 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
8658 byte = (value & 0x7f);
8660 more = !((value == 0 && (byte & 0x40) == 0)
8661 || (value == -1 && (byte & 0x40) != 0));
8670 /* Calculate the checksum of a number in unsigned LEB128 format. */
8673 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
8677 unsigned char byte = (value & 0x7f);
8680 /* More bytes to follow. */
8688 /* Checksum the context of the DIE. This adds the names of any
8689 surrounding namespaces or structures to the checksum. */
8692 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
8696 int tag = die->die_tag;
8698 if (tag != DW_TAG_namespace
8699 && tag != DW_TAG_structure_type
8700 && tag != DW_TAG_class_type)
8703 name = get_AT_string (die, DW_AT_name);
8705 spec = get_AT_ref (die, DW_AT_specification);
8709 if (die->die_parent != NULL)
8710 checksum_die_context (die->die_parent, ctx);
8712 CHECKSUM_ULEB128 ('C');
8713 CHECKSUM_ULEB128 (tag);
8715 CHECKSUM_STRING (name);
8718 /* Calculate the checksum of a location expression. */
8721 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
8723 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
8724 were emitted as a DW_FORM_sdata instead of a location expression. */
8725 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
8727 CHECKSUM_ULEB128 (DW_FORM_sdata);
8728 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
8732 /* Otherwise, just checksum the raw location expression. */
8735 CHECKSUM_ULEB128 (loc->dw_loc_opc);
8736 CHECKSUM (loc->dw_loc_oprnd1);
8737 CHECKSUM (loc->dw_loc_oprnd2);
8738 loc = loc->dw_loc_next;
8742 /* Calculate the checksum of an attribute. */
8745 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
8746 struct md5_ctx *ctx, int *mark)
8748 dw_loc_descr_ref loc;
8751 if (AT_class (at) == dw_val_class_die_ref)
8753 dw_die_ref target_die = AT_ref (at);
8755 /* For pointer and reference types, we checksum only the (qualified)
8756 name of the target type (if there is a name). For friend entries,
8757 we checksum only the (qualified) name of the target type or function.
8758 This allows the checksum to remain the same whether the target type
8759 is complete or not. */
8760 if ((at->dw_attr == DW_AT_type
8761 && (tag == DW_TAG_pointer_type
8762 || tag == DW_TAG_reference_type
8763 || tag == DW_TAG_rvalue_reference_type
8764 || tag == DW_TAG_ptr_to_member_type))
8765 || (at->dw_attr == DW_AT_friend
8766 && tag == DW_TAG_friend))
8768 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
8770 if (name_attr != NULL)
8772 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
8776 CHECKSUM_ULEB128 ('N');
8777 CHECKSUM_ULEB128 (at->dw_attr);
8778 if (decl->die_parent != NULL)
8779 checksum_die_context (decl->die_parent, ctx);
8780 CHECKSUM_ULEB128 ('E');
8781 CHECKSUM_STRING (AT_string (name_attr));
8786 /* For all other references to another DIE, we check to see if the
8787 target DIE has already been visited. If it has, we emit a
8788 backward reference; if not, we descend recursively. */
8789 if (target_die->die_mark > 0)
8791 CHECKSUM_ULEB128 ('R');
8792 CHECKSUM_ULEB128 (at->dw_attr);
8793 CHECKSUM_ULEB128 (target_die->die_mark);
8797 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
8801 target_die->die_mark = ++(*mark);
8802 CHECKSUM_ULEB128 ('T');
8803 CHECKSUM_ULEB128 (at->dw_attr);
8804 if (decl->die_parent != NULL)
8805 checksum_die_context (decl->die_parent, ctx);
8806 die_checksum_ordered (target_die, ctx, mark);
8811 CHECKSUM_ULEB128 ('A');
8812 CHECKSUM_ULEB128 (at->dw_attr);
8814 switch (AT_class (at))
8816 case dw_val_class_const:
8817 CHECKSUM_ULEB128 (DW_FORM_sdata);
8818 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
8821 case dw_val_class_unsigned_const:
8822 CHECKSUM_ULEB128 (DW_FORM_sdata);
8823 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
8826 case dw_val_class_const_double:
8827 CHECKSUM_ULEB128 (DW_FORM_block);
8828 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
8829 CHECKSUM (at->dw_attr_val.v.val_double);
8832 case dw_val_class_vec:
8833 CHECKSUM_ULEB128 (DW_FORM_block);
8834 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_vec));
8835 CHECKSUM (at->dw_attr_val.v.val_vec);
8838 case dw_val_class_flag:
8839 CHECKSUM_ULEB128 (DW_FORM_flag);
8840 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
8843 case dw_val_class_str:
8844 CHECKSUM_ULEB128 (DW_FORM_string);
8845 CHECKSUM_STRING (AT_string (at));
8848 case dw_val_class_addr:
8850 gcc_assert (GET_CODE (r) == SYMBOL_REF);
8851 CHECKSUM_ULEB128 (DW_FORM_string);
8852 CHECKSUM_STRING (XSTR (r, 0));
8855 case dw_val_class_offset:
8856 CHECKSUM_ULEB128 (DW_FORM_sdata);
8857 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
8860 case dw_val_class_loc:
8861 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
8862 loc_checksum_ordered (loc, ctx);
8865 case dw_val_class_fde_ref:
8866 case dw_val_class_lbl_id:
8867 case dw_val_class_lineptr:
8868 case dw_val_class_macptr:
8871 case dw_val_class_file:
8872 CHECKSUM_ULEB128 (DW_FORM_string);
8873 CHECKSUM_STRING (AT_file (at)->filename);
8876 case dw_val_class_data8:
8877 CHECKSUM (at->dw_attr_val.v.val_data8);
8885 struct checksum_attributes
8887 dw_attr_ref at_name;
8888 dw_attr_ref at_type;
8889 dw_attr_ref at_friend;
8890 dw_attr_ref at_accessibility;
8891 dw_attr_ref at_address_class;
8892 dw_attr_ref at_allocated;
8893 dw_attr_ref at_artificial;
8894 dw_attr_ref at_associated;
8895 dw_attr_ref at_binary_scale;
8896 dw_attr_ref at_bit_offset;
8897 dw_attr_ref at_bit_size;
8898 dw_attr_ref at_bit_stride;
8899 dw_attr_ref at_byte_size;
8900 dw_attr_ref at_byte_stride;
8901 dw_attr_ref at_const_value;
8902 dw_attr_ref at_containing_type;
8903 dw_attr_ref at_count;
8904 dw_attr_ref at_data_location;
8905 dw_attr_ref at_data_member_location;
8906 dw_attr_ref at_decimal_scale;
8907 dw_attr_ref at_decimal_sign;
8908 dw_attr_ref at_default_value;
8909 dw_attr_ref at_digit_count;
8910 dw_attr_ref at_discr;
8911 dw_attr_ref at_discr_list;
8912 dw_attr_ref at_discr_value;
8913 dw_attr_ref at_encoding;
8914 dw_attr_ref at_endianity;
8915 dw_attr_ref at_explicit;
8916 dw_attr_ref at_is_optional;
8917 dw_attr_ref at_location;
8918 dw_attr_ref at_lower_bound;
8919 dw_attr_ref at_mutable;
8920 dw_attr_ref at_ordering;
8921 dw_attr_ref at_picture_string;
8922 dw_attr_ref at_prototyped;
8923 dw_attr_ref at_small;
8924 dw_attr_ref at_segment;
8925 dw_attr_ref at_string_length;
8926 dw_attr_ref at_threads_scaled;
8927 dw_attr_ref at_upper_bound;
8928 dw_attr_ref at_use_location;
8929 dw_attr_ref at_use_UTF8;
8930 dw_attr_ref at_variable_parameter;
8931 dw_attr_ref at_virtuality;
8932 dw_attr_ref at_visibility;
8933 dw_attr_ref at_vtable_elem_location;
8936 /* Collect the attributes that we will want to use for the checksum. */
8939 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
8944 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
8955 attrs->at_friend = a;
8957 case DW_AT_accessibility:
8958 attrs->at_accessibility = a;
8960 case DW_AT_address_class:
8961 attrs->at_address_class = a;
8963 case DW_AT_allocated:
8964 attrs->at_allocated = a;
8966 case DW_AT_artificial:
8967 attrs->at_artificial = a;
8969 case DW_AT_associated:
8970 attrs->at_associated = a;
8972 case DW_AT_binary_scale:
8973 attrs->at_binary_scale = a;
8975 case DW_AT_bit_offset:
8976 attrs->at_bit_offset = a;
8978 case DW_AT_bit_size:
8979 attrs->at_bit_size = a;
8981 case DW_AT_bit_stride:
8982 attrs->at_bit_stride = a;
8984 case DW_AT_byte_size:
8985 attrs->at_byte_size = a;
8987 case DW_AT_byte_stride:
8988 attrs->at_byte_stride = a;
8990 case DW_AT_const_value:
8991 attrs->at_const_value = a;
8993 case DW_AT_containing_type:
8994 attrs->at_containing_type = a;
8997 attrs->at_count = a;
8999 case DW_AT_data_location:
9000 attrs->at_data_location = a;
9002 case DW_AT_data_member_location:
9003 attrs->at_data_member_location = a;
9005 case DW_AT_decimal_scale:
9006 attrs->at_decimal_scale = a;
9008 case DW_AT_decimal_sign:
9009 attrs->at_decimal_sign = a;
9011 case DW_AT_default_value:
9012 attrs->at_default_value = a;
9014 case DW_AT_digit_count:
9015 attrs->at_digit_count = a;
9018 attrs->at_discr = a;
9020 case DW_AT_discr_list:
9021 attrs->at_discr_list = a;
9023 case DW_AT_discr_value:
9024 attrs->at_discr_value = a;
9026 case DW_AT_encoding:
9027 attrs->at_encoding = a;
9029 case DW_AT_endianity:
9030 attrs->at_endianity = a;
9032 case DW_AT_explicit:
9033 attrs->at_explicit = a;
9035 case DW_AT_is_optional:
9036 attrs->at_is_optional = a;
9038 case DW_AT_location:
9039 attrs->at_location = a;
9041 case DW_AT_lower_bound:
9042 attrs->at_lower_bound = a;
9045 attrs->at_mutable = a;
9047 case DW_AT_ordering:
9048 attrs->at_ordering = a;
9050 case DW_AT_picture_string:
9051 attrs->at_picture_string = a;
9053 case DW_AT_prototyped:
9054 attrs->at_prototyped = a;
9057 attrs->at_small = a;
9060 attrs->at_segment = a;
9062 case DW_AT_string_length:
9063 attrs->at_string_length = a;
9065 case DW_AT_threads_scaled:
9066 attrs->at_threads_scaled = a;
9068 case DW_AT_upper_bound:
9069 attrs->at_upper_bound = a;
9071 case DW_AT_use_location:
9072 attrs->at_use_location = a;
9074 case DW_AT_use_UTF8:
9075 attrs->at_use_UTF8 = a;
9077 case DW_AT_variable_parameter:
9078 attrs->at_variable_parameter = a;
9080 case DW_AT_virtuality:
9081 attrs->at_virtuality = a;
9083 case DW_AT_visibility:
9084 attrs->at_visibility = a;
9086 case DW_AT_vtable_elem_location:
9087 attrs->at_vtable_elem_location = a;
9095 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
9098 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
9102 struct checksum_attributes attrs;
9104 CHECKSUM_ULEB128 ('D');
9105 CHECKSUM_ULEB128 (die->die_tag);
9107 memset (&attrs, 0, sizeof (attrs));
9109 decl = get_AT_ref (die, DW_AT_specification);
9111 collect_checksum_attributes (&attrs, decl);
9112 collect_checksum_attributes (&attrs, die);
9114 CHECKSUM_ATTR (attrs.at_name);
9115 CHECKSUM_ATTR (attrs.at_accessibility);
9116 CHECKSUM_ATTR (attrs.at_address_class);
9117 CHECKSUM_ATTR (attrs.at_allocated);
9118 CHECKSUM_ATTR (attrs.at_artificial);
9119 CHECKSUM_ATTR (attrs.at_associated);
9120 CHECKSUM_ATTR (attrs.at_binary_scale);
9121 CHECKSUM_ATTR (attrs.at_bit_offset);
9122 CHECKSUM_ATTR (attrs.at_bit_size);
9123 CHECKSUM_ATTR (attrs.at_bit_stride);
9124 CHECKSUM_ATTR (attrs.at_byte_size);
9125 CHECKSUM_ATTR (attrs.at_byte_stride);
9126 CHECKSUM_ATTR (attrs.at_const_value);
9127 CHECKSUM_ATTR (attrs.at_containing_type);
9128 CHECKSUM_ATTR (attrs.at_count);
9129 CHECKSUM_ATTR (attrs.at_data_location);
9130 CHECKSUM_ATTR (attrs.at_data_member_location);
9131 CHECKSUM_ATTR (attrs.at_decimal_scale);
9132 CHECKSUM_ATTR (attrs.at_decimal_sign);
9133 CHECKSUM_ATTR (attrs.at_default_value);
9134 CHECKSUM_ATTR (attrs.at_digit_count);
9135 CHECKSUM_ATTR (attrs.at_discr);
9136 CHECKSUM_ATTR (attrs.at_discr_list);
9137 CHECKSUM_ATTR (attrs.at_discr_value);
9138 CHECKSUM_ATTR (attrs.at_encoding);
9139 CHECKSUM_ATTR (attrs.at_endianity);
9140 CHECKSUM_ATTR (attrs.at_explicit);
9141 CHECKSUM_ATTR (attrs.at_is_optional);
9142 CHECKSUM_ATTR (attrs.at_location);
9143 CHECKSUM_ATTR (attrs.at_lower_bound);
9144 CHECKSUM_ATTR (attrs.at_mutable);
9145 CHECKSUM_ATTR (attrs.at_ordering);
9146 CHECKSUM_ATTR (attrs.at_picture_string);
9147 CHECKSUM_ATTR (attrs.at_prototyped);
9148 CHECKSUM_ATTR (attrs.at_small);
9149 CHECKSUM_ATTR (attrs.at_segment);
9150 CHECKSUM_ATTR (attrs.at_string_length);
9151 CHECKSUM_ATTR (attrs.at_threads_scaled);
9152 CHECKSUM_ATTR (attrs.at_upper_bound);
9153 CHECKSUM_ATTR (attrs.at_use_location);
9154 CHECKSUM_ATTR (attrs.at_use_UTF8);
9155 CHECKSUM_ATTR (attrs.at_variable_parameter);
9156 CHECKSUM_ATTR (attrs.at_virtuality);
9157 CHECKSUM_ATTR (attrs.at_visibility);
9158 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
9159 CHECKSUM_ATTR (attrs.at_type);
9160 CHECKSUM_ATTR (attrs.at_friend);
9162 /* Checksum the child DIEs, except for nested types and member functions. */
9165 dw_attr_ref name_attr;
9168 name_attr = get_AT (c, DW_AT_name);
9169 if ((is_type_die (c) || c->die_tag == DW_TAG_subprogram)
9170 && name_attr != NULL)
9172 CHECKSUM_ULEB128 ('S');
9173 CHECKSUM_ULEB128 (c->die_tag);
9174 CHECKSUM_STRING (AT_string (name_attr));
9178 /* Mark this DIE so it gets processed when unmarking. */
9179 if (c->die_mark == 0)
9181 die_checksum_ordered (c, ctx, mark);
9183 } while (c != die->die_child);
9185 CHECKSUM_ULEB128 (0);
9189 #undef CHECKSUM_STRING
9190 #undef CHECKSUM_ATTR
9191 #undef CHECKSUM_LEB128
9192 #undef CHECKSUM_ULEB128
9194 /* Generate the type signature for DIE. This is computed by generating an
9195 MD5 checksum over the DIE's tag, its relevant attributes, and its
9196 children. Attributes that are references to other DIEs are processed
9197 by recursion, using the MARK field to prevent infinite recursion.
9198 If the DIE is nested inside a namespace or another type, we also
9199 need to include that context in the signature. The lower 64 bits
9200 of the resulting MD5 checksum comprise the signature. */
9203 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
9207 unsigned char checksum[16];
9211 name = get_AT_string (die, DW_AT_name);
9212 decl = get_AT_ref (die, DW_AT_specification);
9214 /* First, compute a signature for just the type name (and its surrounding
9215 context, if any. This is stored in the type unit DIE for link-time
9216 ODR (one-definition rule) checking. */
9218 if (is_cxx() && name != NULL)
9220 md5_init_ctx (&ctx);
9222 /* Checksum the names of surrounding namespaces and structures. */
9223 if (decl != NULL && decl->die_parent != NULL)
9224 checksum_die_context (decl->die_parent, &ctx);
9226 md5_process_bytes (&die->die_tag, sizeof (die->die_tag), &ctx);
9227 md5_process_bytes (name, strlen (name) + 1, &ctx);
9228 md5_finish_ctx (&ctx, checksum);
9230 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
9233 /* Next, compute the complete type signature. */
9235 md5_init_ctx (&ctx);
9237 die->die_mark = mark;
9239 /* Checksum the names of surrounding namespaces and structures. */
9240 if (decl != NULL && decl->die_parent != NULL)
9241 checksum_die_context (decl->die_parent, &ctx);
9243 /* Checksum the DIE and its children. */
9244 die_checksum_ordered (die, &ctx, &mark);
9245 unmark_all_dies (die);
9246 md5_finish_ctx (&ctx, checksum);
9248 /* Store the signature in the type node and link the type DIE and the
9249 type node together. */
9250 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
9251 DWARF_TYPE_SIGNATURE_SIZE);
9252 die->die_id.die_type_node = type_node;
9253 type_node->type_die = die;
9255 /* If the DIE is a specification, link its declaration to the type node
9258 decl->die_id.die_type_node = type_node;
9261 /* Do the location expressions look same? */
9263 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
9265 return loc1->dw_loc_opc == loc2->dw_loc_opc
9266 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
9267 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
9270 /* Do the values look the same? */
9272 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
9274 dw_loc_descr_ref loc1, loc2;
9277 if (v1->val_class != v2->val_class)
9280 switch (v1->val_class)
9282 case dw_val_class_const:
9283 return v1->v.val_int == v2->v.val_int;
9284 case dw_val_class_unsigned_const:
9285 return v1->v.val_unsigned == v2->v.val_unsigned;
9286 case dw_val_class_const_double:
9287 return v1->v.val_double.high == v2->v.val_double.high
9288 && v1->v.val_double.low == v2->v.val_double.low;
9289 case dw_val_class_vec:
9290 if (v1->v.val_vec.length != v2->v.val_vec.length
9291 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
9293 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
9294 v1->v.val_vec.length * v1->v.val_vec.elt_size))
9297 case dw_val_class_flag:
9298 return v1->v.val_flag == v2->v.val_flag;
9299 case dw_val_class_str:
9300 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
9302 case dw_val_class_addr:
9303 r1 = v1->v.val_addr;
9304 r2 = v2->v.val_addr;
9305 if (GET_CODE (r1) != GET_CODE (r2))
9307 return !rtx_equal_p (r1, r2);
9309 case dw_val_class_offset:
9310 return v1->v.val_offset == v2->v.val_offset;
9312 case dw_val_class_loc:
9313 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
9315 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
9316 if (!same_loc_p (loc1, loc2, mark))
9318 return !loc1 && !loc2;
9320 case dw_val_class_die_ref:
9321 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
9323 case dw_val_class_fde_ref:
9324 case dw_val_class_vms_delta:
9325 case dw_val_class_lbl_id:
9326 case dw_val_class_lineptr:
9327 case dw_val_class_macptr:
9330 case dw_val_class_file:
9331 return v1->v.val_file == v2->v.val_file;
9333 case dw_val_class_data8:
9334 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
9341 /* Do the attributes look the same? */
9344 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
9346 if (at1->dw_attr != at2->dw_attr)
9349 /* We don't care that this was compiled with a different compiler
9350 snapshot; if the output is the same, that's what matters. */
9351 if (at1->dw_attr == DW_AT_producer)
9354 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
9357 /* Do the dies look the same? */
9360 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
9366 /* To avoid infinite recursion. */
9368 return die1->die_mark == die2->die_mark;
9369 die1->die_mark = die2->die_mark = ++(*mark);
9371 if (die1->die_tag != die2->die_tag)
9374 if (VEC_length (dw_attr_node, die1->die_attr)
9375 != VEC_length (dw_attr_node, die2->die_attr))
9378 FOR_EACH_VEC_ELT (dw_attr_node, die1->die_attr, ix, a1)
9379 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
9382 c1 = die1->die_child;
9383 c2 = die2->die_child;
9392 if (!same_die_p (c1, c2, mark))
9396 if (c1 == die1->die_child)
9398 if (c2 == die2->die_child)
9408 /* Do the dies look the same? Wrapper around same_die_p. */
9411 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
9414 int ret = same_die_p (die1, die2, &mark);
9416 unmark_all_dies (die1);
9417 unmark_all_dies (die2);
9422 /* The prefix to attach to symbols on DIEs in the current comdat debug
9424 static char *comdat_symbol_id;
9426 /* The index of the current symbol within the current comdat CU. */
9427 static unsigned int comdat_symbol_number;
9429 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
9430 children, and set comdat_symbol_id accordingly. */
9433 compute_section_prefix (dw_die_ref unit_die)
9435 const char *die_name = get_AT_string (unit_die, DW_AT_name);
9436 const char *base = die_name ? lbasename (die_name) : "anonymous";
9437 char *name = XALLOCAVEC (char, strlen (base) + 64);
9440 unsigned char checksum[16];
9443 /* Compute the checksum of the DIE, then append part of it as hex digits to
9444 the name filename of the unit. */
9446 md5_init_ctx (&ctx);
9448 die_checksum (unit_die, &ctx, &mark);
9449 unmark_all_dies (unit_die);
9450 md5_finish_ctx (&ctx, checksum);
9452 sprintf (name, "%s.", base);
9453 clean_symbol_name (name);
9455 p = name + strlen (name);
9456 for (i = 0; i < 4; i++)
9458 sprintf (p, "%.2x", checksum[i]);
9462 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
9463 comdat_symbol_number = 0;
9466 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
9469 is_type_die (dw_die_ref die)
9471 switch (die->die_tag)
9473 case DW_TAG_array_type:
9474 case DW_TAG_class_type:
9475 case DW_TAG_interface_type:
9476 case DW_TAG_enumeration_type:
9477 case DW_TAG_pointer_type:
9478 case DW_TAG_reference_type:
9479 case DW_TAG_rvalue_reference_type:
9480 case DW_TAG_string_type:
9481 case DW_TAG_structure_type:
9482 case DW_TAG_subroutine_type:
9483 case DW_TAG_union_type:
9484 case DW_TAG_ptr_to_member_type:
9485 case DW_TAG_set_type:
9486 case DW_TAG_subrange_type:
9487 case DW_TAG_base_type:
9488 case DW_TAG_const_type:
9489 case DW_TAG_file_type:
9490 case DW_TAG_packed_type:
9491 case DW_TAG_volatile_type:
9492 case DW_TAG_typedef:
9499 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
9500 Basically, we want to choose the bits that are likely to be shared between
9501 compilations (types) and leave out the bits that are specific to individual
9502 compilations (functions). */
9505 is_comdat_die (dw_die_ref c)
9507 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
9508 we do for stabs. The advantage is a greater likelihood of sharing between
9509 objects that don't include headers in the same order (and therefore would
9510 put the base types in a different comdat). jason 8/28/00 */
9512 if (c->die_tag == DW_TAG_base_type)
9515 if (c->die_tag == DW_TAG_pointer_type
9516 || c->die_tag == DW_TAG_reference_type
9517 || c->die_tag == DW_TAG_rvalue_reference_type
9518 || c->die_tag == DW_TAG_const_type
9519 || c->die_tag == DW_TAG_volatile_type)
9521 dw_die_ref t = get_AT_ref (c, DW_AT_type);
9523 return t ? is_comdat_die (t) : 0;
9526 return is_type_die (c);
9529 /* Returns 1 iff C is the sort of DIE that might be referred to from another
9530 compilation unit. */
9533 is_symbol_die (dw_die_ref c)
9535 return (is_type_die (c)
9536 || is_declaration_die (c)
9537 || c->die_tag == DW_TAG_namespace
9538 || c->die_tag == DW_TAG_module);
9541 /* Returns true iff C is a compile-unit DIE. */
9544 is_cu_die (dw_die_ref c)
9546 return c && c->die_tag == DW_TAG_compile_unit;
9550 gen_internal_sym (const char *prefix)
9554 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
9555 return xstrdup (buf);
9558 /* Assign symbols to all worthy DIEs under DIE. */
9561 assign_symbol_names (dw_die_ref die)
9565 if (is_symbol_die (die))
9567 if (comdat_symbol_id)
9569 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
9571 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
9572 comdat_symbol_id, comdat_symbol_number++);
9573 die->die_id.die_symbol = xstrdup (p);
9576 die->die_id.die_symbol = gen_internal_sym ("LDIE");
9579 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
9582 struct cu_hash_table_entry
9585 unsigned min_comdat_num, max_comdat_num;
9586 struct cu_hash_table_entry *next;
9589 /* Routines to manipulate hash table of CUs. */
9591 htab_cu_hash (const void *of)
9593 const struct cu_hash_table_entry *const entry =
9594 (const struct cu_hash_table_entry *) of;
9596 return htab_hash_string (entry->cu->die_id.die_symbol);
9600 htab_cu_eq (const void *of1, const void *of2)
9602 const struct cu_hash_table_entry *const entry1 =
9603 (const struct cu_hash_table_entry *) of1;
9604 const struct die_struct *const entry2 = (const struct die_struct *) of2;
9606 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
9610 htab_cu_del (void *what)
9612 struct cu_hash_table_entry *next,
9613 *entry = (struct cu_hash_table_entry *) what;
9623 /* Check whether we have already seen this CU and set up SYM_NUM
9626 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
9628 struct cu_hash_table_entry dummy;
9629 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
9631 dummy.max_comdat_num = 0;
9633 slot = (struct cu_hash_table_entry **)
9634 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
9638 for (; entry; last = entry, entry = entry->next)
9640 if (same_die_p_wrap (cu, entry->cu))
9646 *sym_num = entry->min_comdat_num;
9650 entry = XCNEW (struct cu_hash_table_entry);
9652 entry->min_comdat_num = *sym_num = last->max_comdat_num;
9653 entry->next = *slot;
9659 /* Record SYM_NUM to record of CU in HTABLE. */
9661 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
9663 struct cu_hash_table_entry **slot, *entry;
9665 slot = (struct cu_hash_table_entry **)
9666 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
9670 entry->max_comdat_num = sym_num;
9673 /* Traverse the DIE (which is always comp_unit_die), and set up
9674 additional compilation units for each of the include files we see
9675 bracketed by BINCL/EINCL. */
9678 break_out_includes (dw_die_ref die)
9681 dw_die_ref unit = NULL;
9682 limbo_die_node *node, **pnode;
9683 htab_t cu_hash_table;
9687 dw_die_ref prev = c;
9689 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
9690 || (unit && is_comdat_die (c)))
9692 dw_die_ref next = c->die_sib;
9694 /* This DIE is for a secondary CU; remove it from the main one. */
9695 remove_child_with_prev (c, prev);
9697 if (c->die_tag == DW_TAG_GNU_BINCL)
9698 unit = push_new_compile_unit (unit, c);
9699 else if (c->die_tag == DW_TAG_GNU_EINCL)
9700 unit = pop_compile_unit (unit);
9702 add_child_die (unit, c);
9704 if (c == die->die_child)
9707 } while (c != die->die_child);
9710 /* We can only use this in debugging, since the frontend doesn't check
9711 to make sure that we leave every include file we enter. */
9715 assign_symbol_names (die);
9716 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
9717 for (node = limbo_die_list, pnode = &limbo_die_list;
9723 compute_section_prefix (node->die);
9724 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
9725 &comdat_symbol_number);
9726 assign_symbol_names (node->die);
9728 *pnode = node->next;
9731 pnode = &node->next;
9732 record_comdat_symbol_number (node->die, cu_hash_table,
9733 comdat_symbol_number);
9736 htab_delete (cu_hash_table);
9739 /* Return non-zero if this DIE is a declaration. */
9742 is_declaration_die (dw_die_ref die)
9747 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
9748 if (a->dw_attr == DW_AT_declaration)
9754 /* Return non-zero if this DIE is nested inside a subprogram. */
9757 is_nested_in_subprogram (dw_die_ref die)
9759 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
9763 return local_scope_p (decl);
9766 /* Return non-zero if this is a type DIE that should be moved to a
9767 COMDAT .debug_types section. */
9770 should_move_die_to_comdat (dw_die_ref die)
9772 switch (die->die_tag)
9774 case DW_TAG_class_type:
9775 case DW_TAG_structure_type:
9776 case DW_TAG_enumeration_type:
9777 case DW_TAG_union_type:
9778 /* Don't move declarations, inlined instances, or types nested in a
9780 if (is_declaration_die (die)
9781 || get_AT (die, DW_AT_abstract_origin)
9782 || is_nested_in_subprogram (die))
9785 case DW_TAG_array_type:
9786 case DW_TAG_interface_type:
9787 case DW_TAG_pointer_type:
9788 case DW_TAG_reference_type:
9789 case DW_TAG_rvalue_reference_type:
9790 case DW_TAG_string_type:
9791 case DW_TAG_subroutine_type:
9792 case DW_TAG_ptr_to_member_type:
9793 case DW_TAG_set_type:
9794 case DW_TAG_subrange_type:
9795 case DW_TAG_base_type:
9796 case DW_TAG_const_type:
9797 case DW_TAG_file_type:
9798 case DW_TAG_packed_type:
9799 case DW_TAG_volatile_type:
9800 case DW_TAG_typedef:
9806 /* Make a clone of DIE. */
9809 clone_die (dw_die_ref die)
9815 clone = ggc_alloc_cleared_die_node ();
9816 clone->die_tag = die->die_tag;
9818 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
9819 add_dwarf_attr (clone, a);
9824 /* Make a clone of the tree rooted at DIE. */
9827 clone_tree (dw_die_ref die)
9830 dw_die_ref clone = clone_die (die);
9832 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree(c)));
9837 /* Make a clone of DIE as a declaration. */
9840 clone_as_declaration (dw_die_ref die)
9847 /* If the DIE is already a declaration, just clone it. */
9848 if (is_declaration_die (die))
9849 return clone_die (die);
9851 /* If the DIE is a specification, just clone its declaration DIE. */
9852 decl = get_AT_ref (die, DW_AT_specification);
9854 return clone_die (decl);
9856 clone = ggc_alloc_cleared_die_node ();
9857 clone->die_tag = die->die_tag;
9859 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
9861 /* We don't want to copy over all attributes.
9862 For example we don't want DW_AT_byte_size because otherwise we will no
9863 longer have a declaration and GDB will treat it as a definition. */
9867 case DW_AT_artificial:
9868 case DW_AT_containing_type:
9869 case DW_AT_external:
9872 case DW_AT_virtuality:
9873 case DW_AT_linkage_name:
9874 case DW_AT_MIPS_linkage_name:
9875 add_dwarf_attr (clone, a);
9877 case DW_AT_byte_size:
9883 if (die->die_id.die_type_node)
9884 add_AT_die_ref (clone, DW_AT_signature, die);
9886 add_AT_flag (clone, DW_AT_declaration, 1);
9890 /* Copy the declaration context to the new compile unit DIE. This includes
9891 any surrounding namespace or type declarations. If the DIE has an
9892 AT_specification attribute, it also includes attributes and children
9893 attached to the specification. */
9896 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
9899 dw_die_ref new_decl;
9901 decl = get_AT_ref (die, DW_AT_specification);
9910 /* Copy the type node pointer from the new DIE to the original
9911 declaration DIE so we can forward references later. */
9912 decl->die_id.die_type_node = die->die_id.die_type_node;
9914 remove_AT (die, DW_AT_specification);
9916 FOR_EACH_VEC_ELT (dw_attr_node, decl->die_attr, ix, a)
9918 if (a->dw_attr != DW_AT_name
9919 && a->dw_attr != DW_AT_declaration
9920 && a->dw_attr != DW_AT_external)
9921 add_dwarf_attr (die, a);
9924 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree(c)));
9927 if (decl->die_parent != NULL
9928 && decl->die_parent->die_tag != DW_TAG_compile_unit
9929 && decl->die_parent->die_tag != DW_TAG_type_unit)
9931 new_decl = copy_ancestor_tree (unit, decl, NULL);
9932 if (new_decl != NULL)
9934 remove_AT (new_decl, DW_AT_signature);
9935 add_AT_specification (die, new_decl);
9940 /* Generate the skeleton ancestor tree for the given NODE, then clone
9941 the DIE and add the clone into the tree. */
9944 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
9946 if (node->new_die != NULL)
9949 node->new_die = clone_as_declaration (node->old_die);
9951 if (node->parent != NULL)
9953 generate_skeleton_ancestor_tree (node->parent);
9954 add_child_die (node->parent->new_die, node->new_die);
9958 /* Generate a skeleton tree of DIEs containing any declarations that are
9959 found in the original tree. We traverse the tree looking for declaration
9960 DIEs, and construct the skeleton from the bottom up whenever we find one. */
9963 generate_skeleton_bottom_up (skeleton_chain_node *parent)
9965 skeleton_chain_node node;
9968 dw_die_ref prev = NULL;
9969 dw_die_ref next = NULL;
9971 node.parent = parent;
9973 first = c = parent->old_die->die_child;
9977 if (prev == NULL || prev->die_sib == c)
9980 next = (c == first ? NULL : c->die_sib);
9982 node.new_die = NULL;
9983 if (is_declaration_die (c))
9985 /* Clone the existing DIE, move the original to the skeleton
9986 tree (which is in the main CU), and put the clone, with
9987 all the original's children, where the original came from. */
9988 dw_die_ref clone = clone_die (c);
9989 move_all_children (c, clone);
9991 replace_child (c, clone, prev);
9992 generate_skeleton_ancestor_tree (parent);
9993 add_child_die (parent->new_die, c);
9997 generate_skeleton_bottom_up (&node);
9998 } while (next != NULL);
10001 /* Wrapper function for generate_skeleton_bottom_up. */
10004 generate_skeleton (dw_die_ref die)
10006 skeleton_chain_node node;
10008 node.old_die = die;
10009 node.new_die = NULL;
10010 node.parent = NULL;
10012 /* If this type definition is nested inside another type,
10013 always leave at least a declaration in its place. */
10014 if (die->die_parent != NULL && is_type_die (die->die_parent))
10015 node.new_die = clone_as_declaration (die);
10017 generate_skeleton_bottom_up (&node);
10018 return node.new_die;
10021 /* Remove the DIE from its parent, possibly replacing it with a cloned
10022 declaration. The original DIE will be moved to a new compile unit
10023 so that existing references to it follow it to the new location. If
10024 any of the original DIE's descendants is a declaration, we need to
10025 replace the original DIE with a skeleton tree and move the
10026 declarations back into the skeleton tree. */
10029 remove_child_or_replace_with_skeleton (dw_die_ref child, dw_die_ref prev)
10031 dw_die_ref skeleton;
10033 skeleton = generate_skeleton (child);
10034 if (skeleton == NULL)
10035 remove_child_with_prev (child, prev);
10038 skeleton->die_id.die_type_node = child->die_id.die_type_node;
10039 replace_child (child, skeleton, prev);
10045 /* Traverse the DIE and set up additional .debug_types sections for each
10046 type worthy of being placed in a COMDAT section. */
10049 break_out_comdat_types (dw_die_ref die)
10053 dw_die_ref prev = NULL;
10054 dw_die_ref next = NULL;
10055 dw_die_ref unit = NULL;
10057 first = c = die->die_child;
10061 if (prev == NULL || prev->die_sib == c)
10064 next = (c == first ? NULL : c->die_sib);
10065 if (should_move_die_to_comdat (c))
10067 dw_die_ref replacement;
10068 comdat_type_node_ref type_node;
10070 /* Create a new type unit DIE as the root for the new tree, and
10071 add it to the list of comdat types. */
10072 unit = new_die (DW_TAG_type_unit, NULL, NULL);
10073 add_AT_unsigned (unit, DW_AT_language,
10074 get_AT_unsigned (comp_unit_die (), DW_AT_language));
10075 type_node = ggc_alloc_cleared_comdat_type_node ();
10076 type_node->root_die = unit;
10077 type_node->next = comdat_type_list;
10078 comdat_type_list = type_node;
10080 /* Generate the type signature. */
10081 generate_type_signature (c, type_node);
10083 /* Copy the declaration context, attributes, and children of the
10084 declaration into the new compile unit DIE. */
10085 copy_declaration_context (unit, c);
10087 /* Remove this DIE from the main CU. */
10088 replacement = remove_child_or_replace_with_skeleton (c, prev);
10090 /* Break out nested types into their own type units. */
10091 break_out_comdat_types (c);
10093 /* Add the DIE to the new compunit. */
10094 add_child_die (unit, c);
10096 if (replacement != NULL)
10099 else if (c->die_tag == DW_TAG_namespace
10100 || c->die_tag == DW_TAG_class_type
10101 || c->die_tag == DW_TAG_structure_type
10102 || c->die_tag == DW_TAG_union_type)
10104 /* Look for nested types that can be broken out. */
10105 break_out_comdat_types (c);
10107 } while (next != NULL);
10110 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
10112 struct decl_table_entry
10118 /* Routines to manipulate hash table of copied declarations. */
10121 htab_decl_hash (const void *of)
10123 const struct decl_table_entry *const entry =
10124 (const struct decl_table_entry *) of;
10126 return htab_hash_pointer (entry->orig);
10130 htab_decl_eq (const void *of1, const void *of2)
10132 const struct decl_table_entry *const entry1 =
10133 (const struct decl_table_entry *) of1;
10134 const struct die_struct *const entry2 = (const struct die_struct *) of2;
10136 return entry1->orig == entry2;
10140 htab_decl_del (void *what)
10142 struct decl_table_entry *entry = (struct decl_table_entry *) what;
10147 /* Copy DIE and its ancestors, up to, but not including, the compile unit
10148 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
10149 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
10150 to check if the ancestor has already been copied into UNIT. */
10153 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
10155 dw_die_ref parent = die->die_parent;
10156 dw_die_ref new_parent = unit;
10158 void **slot = NULL;
10159 struct decl_table_entry *entry = NULL;
10163 /* Check if the entry has already been copied to UNIT. */
10164 slot = htab_find_slot_with_hash (decl_table, die,
10165 htab_hash_pointer (die), INSERT);
10166 if (*slot != HTAB_EMPTY_ENTRY)
10168 entry = (struct decl_table_entry *) *slot;
10169 return entry->copy;
10172 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
10173 entry = XCNEW (struct decl_table_entry);
10175 entry->copy = NULL;
10179 if (parent != NULL)
10181 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
10184 if (parent->die_tag != DW_TAG_compile_unit
10185 && parent->die_tag != DW_TAG_type_unit)
10186 new_parent = copy_ancestor_tree (unit, parent, decl_table);
10189 copy = clone_as_declaration (die);
10190 add_child_die (new_parent, copy);
10192 if (decl_table != NULL)
10194 /* Record the pointer to the copy. */
10195 entry->copy = copy;
10201 /* Walk the DIE and its children, looking for references to incomplete
10202 or trivial types that are unmarked (i.e., that are not in the current
10206 copy_decls_walk (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
10212 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10214 if (AT_class (a) == dw_val_class_die_ref)
10216 dw_die_ref targ = AT_ref (a);
10217 comdat_type_node_ref type_node = targ->die_id.die_type_node;
10219 struct decl_table_entry *entry;
10221 if (targ->die_mark != 0 || type_node != NULL)
10224 slot = htab_find_slot_with_hash (decl_table, targ,
10225 htab_hash_pointer (targ), INSERT);
10227 if (*slot != HTAB_EMPTY_ENTRY)
10229 /* TARG has already been copied, so we just need to
10230 modify the reference to point to the copy. */
10231 entry = (struct decl_table_entry *) *slot;
10232 a->dw_attr_val.v.val_die_ref.die = entry->copy;
10236 dw_die_ref parent = unit;
10237 dw_die_ref copy = clone_tree (targ);
10239 /* Make sure the cloned tree is marked as part of the
10243 /* Record in DECL_TABLE that TARG has been copied.
10244 Need to do this now, before the recursive call,
10245 because DECL_TABLE may be expanded and SLOT
10246 would no longer be a valid pointer. */
10247 entry = XCNEW (struct decl_table_entry);
10248 entry->orig = targ;
10249 entry->copy = copy;
10252 /* If TARG has surrounding context, copy its ancestor tree
10253 into the new type unit. */
10254 if (targ->die_parent != NULL
10255 && targ->die_parent->die_tag != DW_TAG_compile_unit
10256 && targ->die_parent->die_tag != DW_TAG_type_unit)
10257 parent = copy_ancestor_tree (unit, targ->die_parent,
10260 add_child_die (parent, copy);
10261 a->dw_attr_val.v.val_die_ref.die = copy;
10263 /* Make sure the newly-copied DIE is walked. If it was
10264 installed in a previously-added context, it won't
10265 get visited otherwise. */
10266 if (parent != unit)
10268 /* Find the highest point of the newly-added tree,
10269 mark each node along the way, and walk from there. */
10270 parent->die_mark = 1;
10271 while (parent->die_parent
10272 && parent->die_parent->die_mark == 0)
10274 parent = parent->die_parent;
10275 parent->die_mark = 1;
10277 copy_decls_walk (unit, parent, decl_table);
10283 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
10286 /* Copy declarations for "unworthy" types into the new comdat section.
10287 Incomplete types, modified types, and certain other types aren't broken
10288 out into comdat sections of their own, so they don't have a signature,
10289 and we need to copy the declaration into the same section so that we
10290 don't have an external reference. */
10293 copy_decls_for_unworthy_types (dw_die_ref unit)
10298 decl_table = htab_create (10, htab_decl_hash, htab_decl_eq, htab_decl_del);
10299 copy_decls_walk (unit, unit, decl_table);
10300 htab_delete (decl_table);
10301 unmark_dies (unit);
10304 /* Traverse the DIE and add a sibling attribute if it may have the
10305 effect of speeding up access to siblings. To save some space,
10306 avoid generating sibling attributes for DIE's without children. */
10309 add_sibling_attributes (dw_die_ref die)
10313 if (! die->die_child)
10316 if (die->die_parent && die != die->die_parent->die_child)
10317 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
10319 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
10322 /* Output all location lists for the DIE and its children. */
10325 output_location_lists (dw_die_ref die)
10331 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10332 if (AT_class (a) == dw_val_class_loc_list)
10333 output_loc_list (AT_loc_list (a));
10335 FOR_EACH_CHILD (die, c, output_location_lists (c));
10338 /* The format of each DIE (and its attribute value pairs) is encoded in an
10339 abbreviation table. This routine builds the abbreviation table and assigns
10340 a unique abbreviation id for each abbreviation entry. The children of each
10341 die are visited recursively. */
10344 build_abbrev_table (dw_die_ref die)
10346 unsigned long abbrev_id;
10347 unsigned int n_alloc;
10352 /* Scan the DIE references, and mark as external any that refer to
10353 DIEs from other CUs (i.e. those which are not marked). */
10354 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10355 if (AT_class (a) == dw_val_class_die_ref
10356 && AT_ref (a)->die_mark == 0)
10358 gcc_assert (dwarf_version >= 4 || AT_ref (a)->die_id.die_symbol);
10359 set_AT_ref_external (a, 1);
10362 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
10364 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
10365 dw_attr_ref die_a, abbrev_a;
10369 if (abbrev->die_tag != die->die_tag)
10371 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
10374 if (VEC_length (dw_attr_node, abbrev->die_attr)
10375 != VEC_length (dw_attr_node, die->die_attr))
10378 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, die_a)
10380 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
10381 if ((abbrev_a->dw_attr != die_a->dw_attr)
10382 || (value_format (abbrev_a) != value_format (die_a)))
10392 if (abbrev_id >= abbrev_die_table_in_use)
10394 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
10396 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
10397 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
10400 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
10401 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
10402 abbrev_die_table_allocated = n_alloc;
10405 ++abbrev_die_table_in_use;
10406 abbrev_die_table[abbrev_id] = die;
10409 die->die_abbrev = abbrev_id;
10410 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
10413 /* Return the power-of-two number of bytes necessary to represent VALUE. */
10416 constant_size (unsigned HOST_WIDE_INT value)
10423 log = floor_log2 (value);
10426 log = 1 << (floor_log2 (log) + 1);
10431 /* Return the size of a DIE as it is represented in the
10432 .debug_info section. */
10434 static unsigned long
10435 size_of_die (dw_die_ref die)
10437 unsigned long size = 0;
10441 size += size_of_uleb128 (die->die_abbrev);
10442 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10444 switch (AT_class (a))
10446 case dw_val_class_addr:
10447 size += DWARF2_ADDR_SIZE;
10449 case dw_val_class_offset:
10450 size += DWARF_OFFSET_SIZE;
10452 case dw_val_class_loc:
10454 unsigned long lsize = size_of_locs (AT_loc (a));
10456 /* Block length. */
10457 if (dwarf_version >= 4)
10458 size += size_of_uleb128 (lsize);
10460 size += constant_size (lsize);
10464 case dw_val_class_loc_list:
10465 size += DWARF_OFFSET_SIZE;
10467 case dw_val_class_range_list:
10468 size += DWARF_OFFSET_SIZE;
10470 case dw_val_class_const:
10471 size += size_of_sleb128 (AT_int (a));
10473 case dw_val_class_unsigned_const:
10474 size += constant_size (AT_unsigned (a));
10476 case dw_val_class_const_double:
10477 size += 2 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
10478 if (HOST_BITS_PER_WIDE_INT >= 64)
10479 size++; /* block */
10481 case dw_val_class_vec:
10482 size += constant_size (a->dw_attr_val.v.val_vec.length
10483 * a->dw_attr_val.v.val_vec.elt_size)
10484 + a->dw_attr_val.v.val_vec.length
10485 * a->dw_attr_val.v.val_vec.elt_size; /* block */
10487 case dw_val_class_flag:
10488 if (dwarf_version >= 4)
10489 /* Currently all add_AT_flag calls pass in 1 as last argument,
10490 so DW_FORM_flag_present can be used. If that ever changes,
10491 we'll need to use DW_FORM_flag and have some optimization
10492 in build_abbrev_table that will change those to
10493 DW_FORM_flag_present if it is set to 1 in all DIEs using
10494 the same abbrev entry. */
10495 gcc_assert (a->dw_attr_val.v.val_flag == 1);
10499 case dw_val_class_die_ref:
10500 if (AT_ref_external (a))
10502 /* In DWARF4, we use DW_FORM_sig8; for earlier versions
10503 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
10504 is sized by target address length, whereas in DWARF3
10505 it's always sized as an offset. */
10506 if (dwarf_version >= 4)
10507 size += DWARF_TYPE_SIGNATURE_SIZE;
10508 else if (dwarf_version == 2)
10509 size += DWARF2_ADDR_SIZE;
10511 size += DWARF_OFFSET_SIZE;
10514 size += DWARF_OFFSET_SIZE;
10516 case dw_val_class_fde_ref:
10517 size += DWARF_OFFSET_SIZE;
10519 case dw_val_class_lbl_id:
10520 size += DWARF2_ADDR_SIZE;
10522 case dw_val_class_lineptr:
10523 case dw_val_class_macptr:
10524 size += DWARF_OFFSET_SIZE;
10526 case dw_val_class_str:
10527 if (AT_string_form (a) == DW_FORM_strp)
10528 size += DWARF_OFFSET_SIZE;
10530 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
10532 case dw_val_class_file:
10533 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
10535 case dw_val_class_data8:
10538 case dw_val_class_vms_delta:
10539 size += DWARF_OFFSET_SIZE;
10542 gcc_unreachable ();
10549 /* Size the debugging information associated with a given DIE. Visits the
10550 DIE's children recursively. Updates the global variable next_die_offset, on
10551 each time through. Uses the current value of next_die_offset to update the
10552 die_offset field in each DIE. */
10555 calc_die_sizes (dw_die_ref die)
10559 die->die_offset = next_die_offset;
10560 next_die_offset += size_of_die (die);
10562 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
10564 if (die->die_child != NULL)
10565 /* Count the null byte used to terminate sibling lists. */
10566 next_die_offset += 1;
10569 /* Set the marks for a die and its children. We do this so
10570 that we know whether or not a reference needs to use FORM_ref_addr; only
10571 DIEs in the same CU will be marked. We used to clear out the offset
10572 and use that as the flag, but ran into ordering problems. */
10575 mark_dies (dw_die_ref die)
10579 gcc_assert (!die->die_mark);
10582 FOR_EACH_CHILD (die, c, mark_dies (c));
10585 /* Clear the marks for a die and its children. */
10588 unmark_dies (dw_die_ref die)
10592 if (dwarf_version < 4)
10593 gcc_assert (die->die_mark);
10596 FOR_EACH_CHILD (die, c, unmark_dies (c));
10599 /* Clear the marks for a die, its children and referred dies. */
10602 unmark_all_dies (dw_die_ref die)
10608 if (!die->die_mark)
10612 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
10614 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10615 if (AT_class (a) == dw_val_class_die_ref)
10616 unmark_all_dies (AT_ref (a));
10619 /* Return the size of the .debug_pubnames or .debug_pubtypes table
10620 generated for the compilation unit. */
10622 static unsigned long
10623 size_of_pubnames (VEC (pubname_entry, gc) * names)
10625 unsigned long size;
10629 size = DWARF_PUBNAMES_HEADER_SIZE;
10630 FOR_EACH_VEC_ELT (pubname_entry, names, i, p)
10631 if (names != pubtype_table
10632 || p->die->die_offset != 0
10633 || !flag_eliminate_unused_debug_types)
10634 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
10636 size += DWARF_OFFSET_SIZE;
10640 /* Return the size of the information in the .debug_aranges section. */
10642 static unsigned long
10643 size_of_aranges (void)
10645 unsigned long size;
10647 size = DWARF_ARANGES_HEADER_SIZE;
10649 /* Count the address/length pair for this compilation unit. */
10650 if (text_section_used)
10651 size += 2 * DWARF2_ADDR_SIZE;
10652 if (cold_text_section_used)
10653 size += 2 * DWARF2_ADDR_SIZE;
10654 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
10656 /* Count the two zero words used to terminated the address range table. */
10657 size += 2 * DWARF2_ADDR_SIZE;
10661 /* Select the encoding of an attribute value. */
10663 static enum dwarf_form
10664 value_format (dw_attr_ref a)
10666 switch (a->dw_attr_val.val_class)
10668 case dw_val_class_addr:
10669 /* Only very few attributes allow DW_FORM_addr. */
10670 switch (a->dw_attr)
10673 case DW_AT_high_pc:
10674 case DW_AT_entry_pc:
10675 case DW_AT_trampoline:
10676 return DW_FORM_addr;
10680 switch (DWARF2_ADDR_SIZE)
10683 return DW_FORM_data1;
10685 return DW_FORM_data2;
10687 return DW_FORM_data4;
10689 return DW_FORM_data8;
10691 gcc_unreachable ();
10693 case dw_val_class_range_list:
10694 case dw_val_class_loc_list:
10695 if (dwarf_version >= 4)
10696 return DW_FORM_sec_offset;
10698 case dw_val_class_vms_delta:
10699 case dw_val_class_offset:
10700 switch (DWARF_OFFSET_SIZE)
10703 return DW_FORM_data4;
10705 return DW_FORM_data8;
10707 gcc_unreachable ();
10709 case dw_val_class_loc:
10710 if (dwarf_version >= 4)
10711 return DW_FORM_exprloc;
10712 switch (constant_size (size_of_locs (AT_loc (a))))
10715 return DW_FORM_block1;
10717 return DW_FORM_block2;
10719 gcc_unreachable ();
10721 case dw_val_class_const:
10722 return DW_FORM_sdata;
10723 case dw_val_class_unsigned_const:
10724 switch (constant_size (AT_unsigned (a)))
10727 return DW_FORM_data1;
10729 return DW_FORM_data2;
10731 return DW_FORM_data4;
10733 return DW_FORM_data8;
10735 gcc_unreachable ();
10737 case dw_val_class_const_double:
10738 switch (HOST_BITS_PER_WIDE_INT)
10741 return DW_FORM_data2;
10743 return DW_FORM_data4;
10745 return DW_FORM_data8;
10748 return DW_FORM_block1;
10750 case dw_val_class_vec:
10751 switch (constant_size (a->dw_attr_val.v.val_vec.length
10752 * a->dw_attr_val.v.val_vec.elt_size))
10755 return DW_FORM_block1;
10757 return DW_FORM_block2;
10759 return DW_FORM_block4;
10761 gcc_unreachable ();
10763 case dw_val_class_flag:
10764 if (dwarf_version >= 4)
10766 /* Currently all add_AT_flag calls pass in 1 as last argument,
10767 so DW_FORM_flag_present can be used. If that ever changes,
10768 we'll need to use DW_FORM_flag and have some optimization
10769 in build_abbrev_table that will change those to
10770 DW_FORM_flag_present if it is set to 1 in all DIEs using
10771 the same abbrev entry. */
10772 gcc_assert (a->dw_attr_val.v.val_flag == 1);
10773 return DW_FORM_flag_present;
10775 return DW_FORM_flag;
10776 case dw_val_class_die_ref:
10777 if (AT_ref_external (a))
10778 return dwarf_version >= 4 ? DW_FORM_sig8 : DW_FORM_ref_addr;
10780 return DW_FORM_ref;
10781 case dw_val_class_fde_ref:
10782 return DW_FORM_data;
10783 case dw_val_class_lbl_id:
10784 return DW_FORM_addr;
10785 case dw_val_class_lineptr:
10786 case dw_val_class_macptr:
10787 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
10788 case dw_val_class_str:
10789 return AT_string_form (a);
10790 case dw_val_class_file:
10791 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
10794 return DW_FORM_data1;
10796 return DW_FORM_data2;
10798 return DW_FORM_data4;
10800 gcc_unreachable ();
10803 case dw_val_class_data8:
10804 return DW_FORM_data8;
10807 gcc_unreachable ();
10811 /* Output the encoding of an attribute value. */
10814 output_value_format (dw_attr_ref a)
10816 enum dwarf_form form = value_format (a);
10818 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
10821 /* Output the .debug_abbrev section which defines the DIE abbreviation
10825 output_abbrev_section (void)
10827 unsigned long abbrev_id;
10829 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
10831 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
10833 dw_attr_ref a_attr;
10835 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
10836 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
10837 dwarf_tag_name (abbrev->die_tag));
10839 if (abbrev->die_child != NULL)
10840 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
10842 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
10844 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
10847 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
10848 dwarf_attr_name (a_attr->dw_attr));
10849 output_value_format (a_attr);
10852 dw2_asm_output_data (1, 0, NULL);
10853 dw2_asm_output_data (1, 0, NULL);
10856 /* Terminate the table. */
10857 dw2_asm_output_data (1, 0, NULL);
10860 /* Output a symbol we can use to refer to this DIE from another CU. */
10863 output_die_symbol (dw_die_ref die)
10865 char *sym = die->die_id.die_symbol;
10870 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
10871 /* We make these global, not weak; if the target doesn't support
10872 .linkonce, it doesn't support combining the sections, so debugging
10874 targetm.asm_out.globalize_label (asm_out_file, sym);
10876 ASM_OUTPUT_LABEL (asm_out_file, sym);
10879 /* Return a new location list, given the begin and end range, and the
10882 static inline dw_loc_list_ref
10883 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
10884 const char *section)
10886 dw_loc_list_ref retlist = ggc_alloc_cleared_dw_loc_list_node ();
10888 retlist->begin = begin;
10889 retlist->end = end;
10890 retlist->expr = expr;
10891 retlist->section = section;
10896 /* Generate a new internal symbol for this location list node, if it
10897 hasn't got one yet. */
10900 gen_llsym (dw_loc_list_ref list)
10902 gcc_assert (!list->ll_symbol);
10903 list->ll_symbol = gen_internal_sym ("LLST");
10906 /* Output the location list given to us. */
10909 output_loc_list (dw_loc_list_ref list_head)
10911 dw_loc_list_ref curr = list_head;
10913 if (list_head->emitted)
10915 list_head->emitted = true;
10917 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
10919 /* Walk the location list, and output each range + expression. */
10920 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
10922 unsigned long size;
10923 /* Don't output an entry that starts and ends at the same address. */
10924 if (strcmp (curr->begin, curr->end) == 0)
10926 if (!have_multiple_function_sections)
10928 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
10929 "Location list begin address (%s)",
10930 list_head->ll_symbol);
10931 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
10932 "Location list end address (%s)",
10933 list_head->ll_symbol);
10937 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
10938 "Location list begin address (%s)",
10939 list_head->ll_symbol);
10940 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
10941 "Location list end address (%s)",
10942 list_head->ll_symbol);
10944 size = size_of_locs (curr->expr);
10946 /* Output the block length for this list of location operations. */
10947 gcc_assert (size <= 0xffff);
10948 dw2_asm_output_data (2, size, "%s", "Location expression size");
10950 output_loc_sequence (curr->expr);
10953 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10954 "Location list terminator begin (%s)",
10955 list_head->ll_symbol);
10956 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10957 "Location list terminator end (%s)",
10958 list_head->ll_symbol);
10961 /* Output a type signature. */
10964 output_signature (const char *sig, const char *name)
10968 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
10969 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
10972 /* Output the DIE and its attributes. Called recursively to generate
10973 the definitions of each child DIE. */
10976 output_die (dw_die_ref die)
10980 unsigned long size;
10983 /* If someone in another CU might refer to us, set up a symbol for
10984 them to point to. */
10985 if (dwarf_version < 4 && die->die_id.die_symbol)
10986 output_die_symbol (die);
10988 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
10989 (unsigned long)die->die_offset,
10990 dwarf_tag_name (die->die_tag));
10992 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
10994 const char *name = dwarf_attr_name (a->dw_attr);
10996 switch (AT_class (a))
10998 case dw_val_class_addr:
10999 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
11002 case dw_val_class_offset:
11003 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
11007 case dw_val_class_range_list:
11009 char *p = strchr (ranges_section_label, '\0');
11011 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
11012 a->dw_attr_val.v.val_offset);
11013 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
11014 debug_ranges_section, "%s", name);
11019 case dw_val_class_loc:
11020 size = size_of_locs (AT_loc (a));
11022 /* Output the block length for this list of location operations. */
11023 if (dwarf_version >= 4)
11024 dw2_asm_output_data_uleb128 (size, "%s", name);
11026 dw2_asm_output_data (constant_size (size), size, "%s", name);
11028 output_loc_sequence (AT_loc (a));
11031 case dw_val_class_const:
11032 /* ??? It would be slightly more efficient to use a scheme like is
11033 used for unsigned constants below, but gdb 4.x does not sign
11034 extend. Gdb 5.x does sign extend. */
11035 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
11038 case dw_val_class_unsigned_const:
11039 dw2_asm_output_data (constant_size (AT_unsigned (a)),
11040 AT_unsigned (a), "%s", name);
11043 case dw_val_class_const_double:
11045 unsigned HOST_WIDE_INT first, second;
11047 if (HOST_BITS_PER_WIDE_INT >= 64)
11048 dw2_asm_output_data (1,
11049 2 * HOST_BITS_PER_WIDE_INT
11050 / HOST_BITS_PER_CHAR,
11053 if (WORDS_BIG_ENDIAN)
11055 first = a->dw_attr_val.v.val_double.high;
11056 second = a->dw_attr_val.v.val_double.low;
11060 first = a->dw_attr_val.v.val_double.low;
11061 second = a->dw_attr_val.v.val_double.high;
11064 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
11066 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
11071 case dw_val_class_vec:
11073 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
11074 unsigned int len = a->dw_attr_val.v.val_vec.length;
11078 dw2_asm_output_data (constant_size (len * elt_size),
11079 len * elt_size, "%s", name);
11080 if (elt_size > sizeof (HOST_WIDE_INT))
11085 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
11087 i++, p += elt_size)
11088 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
11089 "fp or vector constant word %u", i);
11093 case dw_val_class_flag:
11094 if (dwarf_version >= 4)
11096 /* Currently all add_AT_flag calls pass in 1 as last argument,
11097 so DW_FORM_flag_present can be used. If that ever changes,
11098 we'll need to use DW_FORM_flag and have some optimization
11099 in build_abbrev_table that will change those to
11100 DW_FORM_flag_present if it is set to 1 in all DIEs using
11101 the same abbrev entry. */
11102 gcc_assert (AT_flag (a) == 1);
11103 if (flag_debug_asm)
11104 fprintf (asm_out_file, "\t\t\t%s %s\n",
11105 ASM_COMMENT_START, name);
11108 dw2_asm_output_data (1, AT_flag (a), "%s", name);
11111 case dw_val_class_loc_list:
11113 char *sym = AT_loc_list (a)->ll_symbol;
11116 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
11121 case dw_val_class_die_ref:
11122 if (AT_ref_external (a))
11124 if (dwarf_version >= 4)
11126 comdat_type_node_ref type_node =
11127 AT_ref (a)->die_id.die_type_node;
11129 gcc_assert (type_node);
11130 output_signature (type_node->signature, name);
11134 char *sym = AT_ref (a)->die_id.die_symbol;
11138 /* In DWARF2, DW_FORM_ref_addr is sized by target address
11139 length, whereas in DWARF3 it's always sized as an
11141 if (dwarf_version == 2)
11142 size = DWARF2_ADDR_SIZE;
11144 size = DWARF_OFFSET_SIZE;
11145 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
11151 gcc_assert (AT_ref (a)->die_offset);
11152 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
11157 case dw_val_class_fde_ref:
11161 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
11162 a->dw_attr_val.v.val_fde_index * 2);
11163 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
11168 case dw_val_class_vms_delta:
11169 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
11170 AT_vms_delta2 (a), AT_vms_delta1 (a),
11174 case dw_val_class_lbl_id:
11175 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
11178 case dw_val_class_lineptr:
11179 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
11180 debug_line_section, "%s", name);
11183 case dw_val_class_macptr:
11184 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
11185 debug_macinfo_section, "%s", name);
11188 case dw_val_class_str:
11189 if (AT_string_form (a) == DW_FORM_strp)
11190 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
11191 a->dw_attr_val.v.val_str->label,
11193 "%s: \"%s\"", name, AT_string (a));
11195 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
11198 case dw_val_class_file:
11200 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
11202 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
11203 a->dw_attr_val.v.val_file->filename);
11207 case dw_val_class_data8:
11211 for (i = 0; i < 8; i++)
11212 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
11213 i == 0 ? "%s" : NULL, name);
11218 gcc_unreachable ();
11222 FOR_EACH_CHILD (die, c, output_die (c));
11224 /* Add null byte to terminate sibling list. */
11225 if (die->die_child != NULL)
11226 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
11227 (unsigned long) die->die_offset);
11230 /* Output the compilation unit that appears at the beginning of the
11231 .debug_info section, and precedes the DIE descriptions. */
11234 output_compilation_unit_header (void)
11236 int ver = dwarf_version;
11238 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11239 dw2_asm_output_data (4, 0xffffffff,
11240 "Initial length escape value indicating 64-bit DWARF extension");
11241 dw2_asm_output_data (DWARF_OFFSET_SIZE,
11242 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
11243 "Length of Compilation Unit Info");
11244 dw2_asm_output_data (2, ver, "DWARF version number");
11245 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
11246 debug_abbrev_section,
11247 "Offset Into Abbrev. Section");
11248 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11251 /* Output the compilation unit DIE and its children. */
11254 output_comp_unit (dw_die_ref die, int output_if_empty)
11256 const char *secname;
11257 char *oldsym, *tmp;
11259 /* Unless we are outputting main CU, we may throw away empty ones. */
11260 if (!output_if_empty && die->die_child == NULL)
11263 /* Even if there are no children of this DIE, we must output the information
11264 about the compilation unit. Otherwise, on an empty translation unit, we
11265 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11266 will then complain when examining the file. First mark all the DIEs in
11267 this CU so we know which get local refs. */
11270 build_abbrev_table (die);
11272 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11273 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
11274 calc_die_sizes (die);
11276 oldsym = die->die_id.die_symbol;
11279 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
11281 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
11283 die->die_id.die_symbol = NULL;
11284 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11288 switch_to_section (debug_info_section);
11289 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
11290 info_section_emitted = true;
11293 /* Output debugging information. */
11294 output_compilation_unit_header ();
11297 /* Leave the marks on the main CU, so we can check them in
11298 output_pubnames. */
11302 die->die_id.die_symbol = oldsym;
11306 /* Output a comdat type unit DIE and its children. */
11309 output_comdat_type_unit (comdat_type_node *node)
11311 const char *secname;
11314 #if defined (OBJECT_FORMAT_ELF)
11318 /* First mark all the DIEs in this CU so we know which get local refs. */
11319 mark_dies (node->root_die);
11321 build_abbrev_table (node->root_die);
11323 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11324 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
11325 calc_die_sizes (node->root_die);
11327 #if defined (OBJECT_FORMAT_ELF)
11328 secname = ".debug_types";
11329 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11330 sprintf (tmp, "wt.");
11331 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11332 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
11333 comdat_key = get_identifier (tmp);
11334 targetm.asm_out.named_section (secname,
11335 SECTION_DEBUG | SECTION_LINKONCE,
11338 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11339 sprintf (tmp, ".gnu.linkonce.wt.");
11340 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11341 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
11343 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11346 /* Output debugging information. */
11347 output_compilation_unit_header ();
11348 output_signature (node->signature, "Type Signature");
11349 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
11350 "Offset to Type DIE");
11351 output_die (node->root_die);
11353 unmark_dies (node->root_die);
11356 /* Return the DWARF2/3 pubname associated with a decl. */
11358 static const char *
11359 dwarf2_name (tree decl, int scope)
11361 if (DECL_NAMELESS (decl))
11363 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
11366 /* Add a new entry to .debug_pubnames if appropriate. */
11369 add_pubname_string (const char *str, dw_die_ref die)
11371 if (targetm.want_debug_pub_sections)
11376 e.name = xstrdup (str);
11377 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
11382 add_pubname (tree decl, dw_die_ref die)
11384 if (targetm.want_debug_pub_sections && TREE_PUBLIC (decl))
11386 const char *name = dwarf2_name (decl, 1);
11388 add_pubname_string (name, die);
11392 /* Add a new entry to .debug_pubtypes if appropriate. */
11395 add_pubtype (tree decl, dw_die_ref die)
11399 if (!targetm.want_debug_pub_sections)
11403 if ((TREE_PUBLIC (decl)
11404 || is_cu_die (die->die_parent))
11405 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
11410 if (TYPE_NAME (decl))
11412 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
11413 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
11414 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
11415 && DECL_NAME (TYPE_NAME (decl)))
11416 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
11418 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
11423 e.name = dwarf2_name (decl, 1);
11425 e.name = xstrdup (e.name);
11428 /* If we don't have a name for the type, there's no point in adding
11429 it to the table. */
11430 if (e.name && e.name[0] != '\0')
11431 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
11435 /* Output the public names table used to speed up access to externally
11436 visible names; or the public types table used to find type definitions. */
11439 output_pubnames (VEC (pubname_entry, gc) * names)
11442 unsigned long pubnames_length = size_of_pubnames (names);
11445 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11446 dw2_asm_output_data (4, 0xffffffff,
11447 "Initial length escape value indicating 64-bit DWARF extension");
11448 if (names == pubname_table)
11449 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
11450 "Length of Public Names Info");
11452 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
11453 "Length of Public Type Names Info");
11454 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
11455 dw2_asm_output_data (2, 2, "DWARF Version");
11456 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11457 debug_info_section,
11458 "Offset of Compilation Unit Info");
11459 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
11460 "Compilation Unit Length");
11462 FOR_EACH_VEC_ELT (pubname_entry, names, i, pub)
11464 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11465 if (names == pubname_table)
11466 gcc_assert (pub->die->die_mark);
11468 if (names != pubtype_table
11469 || pub->die->die_offset != 0
11470 || !flag_eliminate_unused_debug_types)
11472 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
11475 dw2_asm_output_nstring (pub->name, -1, "external name");
11479 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
11482 /* Add a new entry to .debug_aranges if appropriate. */
11485 add_arange (tree decl, dw_die_ref die)
11487 if (! DECL_SECTION_NAME (decl))
11490 if (arange_table_in_use == arange_table_allocated)
11492 arange_table_allocated += ARANGE_TABLE_INCREMENT;
11493 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
11494 arange_table_allocated);
11495 memset (arange_table + arange_table_in_use, 0,
11496 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
11499 arange_table[arange_table_in_use++] = die;
11502 /* Output the information that goes into the .debug_aranges table.
11503 Namely, define the beginning and ending address range of the
11504 text section generated for this compilation unit. */
11507 output_aranges (void)
11510 unsigned long aranges_length = size_of_aranges ();
11512 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11513 dw2_asm_output_data (4, 0xffffffff,
11514 "Initial length escape value indicating 64-bit DWARF extension");
11515 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
11516 "Length of Address Ranges Info");
11517 /* Version number for aranges is still 2, even in DWARF3. */
11518 dw2_asm_output_data (2, 2, "DWARF Version");
11519 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11520 debug_info_section,
11521 "Offset of Compilation Unit Info");
11522 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
11523 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11525 /* We need to align to twice the pointer size here. */
11526 if (DWARF_ARANGES_PAD_SIZE)
11528 /* Pad using a 2 byte words so that padding is correct for any
11530 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11531 2 * DWARF2_ADDR_SIZE);
11532 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
11533 dw2_asm_output_data (2, 0, NULL);
11536 /* It is necessary not to output these entries if the sections were
11537 not used; if the sections were not used, the length will be 0 and
11538 the address may end up as 0 if the section is discarded by ld
11539 --gc-sections, leaving an invalid (0, 0) entry that can be
11540 confused with the terminator. */
11541 if (text_section_used)
11543 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
11544 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
11545 text_section_label, "Length");
11547 if (cold_text_section_used)
11549 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
11551 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
11552 cold_text_section_label, "Length");
11555 for (i = 0; i < arange_table_in_use; i++)
11557 dw_die_ref die = arange_table[i];
11559 /* We shouldn't see aranges for DIEs outside of the main CU. */
11560 gcc_assert (die->die_mark);
11562 if (die->die_tag == DW_TAG_subprogram)
11564 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
11566 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
11567 get_AT_low_pc (die), "Length");
11571 /* A static variable; extract the symbol from DW_AT_location.
11572 Note that this code isn't currently hit, as we only emit
11573 aranges for functions (jason 9/23/99). */
11574 dw_attr_ref a = get_AT (die, DW_AT_location);
11575 dw_loc_descr_ref loc;
11577 gcc_assert (a && AT_class (a) == dw_val_class_loc);
11580 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
11582 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
11583 loc->dw_loc_oprnd1.v.val_addr, "Address");
11584 dw2_asm_output_data (DWARF2_ADDR_SIZE,
11585 get_AT_unsigned (die, DW_AT_byte_size),
11590 /* Output the terminator words. */
11591 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11592 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11595 /* Add a new entry to .debug_ranges. Return the offset at which it
11598 static unsigned int
11599 add_ranges_num (int num)
11601 unsigned int in_use = ranges_table_in_use;
11603 if (in_use == ranges_table_allocated)
11605 ranges_table_allocated += RANGES_TABLE_INCREMENT;
11606 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
11607 ranges_table_allocated);
11608 memset (ranges_table + ranges_table_in_use, 0,
11609 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
11612 ranges_table[in_use].num = num;
11613 ranges_table_in_use = in_use + 1;
11615 return in_use * 2 * DWARF2_ADDR_SIZE;
11618 /* Add a new entry to .debug_ranges corresponding to a block, or a
11619 range terminator if BLOCK is NULL. */
11621 static unsigned int
11622 add_ranges (const_tree block)
11624 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
11627 /* Add a new entry to .debug_ranges corresponding to a pair of
11631 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
11634 unsigned int in_use = ranges_by_label_in_use;
11635 unsigned int offset;
11637 if (in_use == ranges_by_label_allocated)
11639 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
11640 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
11642 ranges_by_label_allocated);
11643 memset (ranges_by_label + ranges_by_label_in_use, 0,
11644 RANGES_TABLE_INCREMENT
11645 * sizeof (struct dw_ranges_by_label_struct));
11648 ranges_by_label[in_use].begin = begin;
11649 ranges_by_label[in_use].end = end;
11650 ranges_by_label_in_use = in_use + 1;
11652 offset = add_ranges_num (-(int)in_use - 1);
11655 add_AT_range_list (die, DW_AT_ranges, offset);
11661 output_ranges (void)
11664 static const char *const start_fmt = "Offset %#x";
11665 const char *fmt = start_fmt;
11667 for (i = 0; i < ranges_table_in_use; i++)
11669 int block_num = ranges_table[i].num;
11673 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
11674 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
11676 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
11677 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
11679 /* If all code is in the text section, then the compilation
11680 unit base address defaults to DW_AT_low_pc, which is the
11681 base of the text section. */
11682 if (!have_multiple_function_sections)
11684 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
11685 text_section_label,
11686 fmt, i * 2 * DWARF2_ADDR_SIZE);
11687 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
11688 text_section_label, NULL);
11691 /* Otherwise, the compilation unit base address is zero,
11692 which allows us to use absolute addresses, and not worry
11693 about whether the target supports cross-section
11697 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11698 fmt, i * 2 * DWARF2_ADDR_SIZE);
11699 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
11705 /* Negative block_num stands for an index into ranges_by_label. */
11706 else if (block_num < 0)
11708 int lab_idx = - block_num - 1;
11710 if (!have_multiple_function_sections)
11712 gcc_unreachable ();
11714 /* If we ever use add_ranges_by_labels () for a single
11715 function section, all we have to do is to take out
11716 the #if 0 above. */
11717 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11718 ranges_by_label[lab_idx].begin,
11719 text_section_label,
11720 fmt, i * 2 * DWARF2_ADDR_SIZE);
11721 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11722 ranges_by_label[lab_idx].end,
11723 text_section_label, NULL);
11728 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11729 ranges_by_label[lab_idx].begin,
11730 fmt, i * 2 * DWARF2_ADDR_SIZE);
11731 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11732 ranges_by_label[lab_idx].end,
11738 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11739 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11745 /* Data structure containing information about input files. */
11748 const char *path; /* Complete file name. */
11749 const char *fname; /* File name part. */
11750 int length; /* Length of entire string. */
11751 struct dwarf_file_data * file_idx; /* Index in input file table. */
11752 int dir_idx; /* Index in directory table. */
11755 /* Data structure containing information about directories with source
11759 const char *path; /* Path including directory name. */
11760 int length; /* Path length. */
11761 int prefix; /* Index of directory entry which is a prefix. */
11762 int count; /* Number of files in this directory. */
11763 int dir_idx; /* Index of directory used as base. */
11766 /* Callback function for file_info comparison. We sort by looking at
11767 the directories in the path. */
11770 file_info_cmp (const void *p1, const void *p2)
11772 const struct file_info *const s1 = (const struct file_info *) p1;
11773 const struct file_info *const s2 = (const struct file_info *) p2;
11774 const unsigned char *cp1;
11775 const unsigned char *cp2;
11777 /* Take care of file names without directories. We need to make sure that
11778 we return consistent values to qsort since some will get confused if
11779 we return the same value when identical operands are passed in opposite
11780 orders. So if neither has a directory, return 0 and otherwise return
11781 1 or -1 depending on which one has the directory. */
11782 if ((s1->path == s1->fname || s2->path == s2->fname))
11783 return (s2->path == s2->fname) - (s1->path == s1->fname);
11785 cp1 = (const unsigned char *) s1->path;
11786 cp2 = (const unsigned char *) s2->path;
11792 /* Reached the end of the first path? If so, handle like above. */
11793 if ((cp1 == (const unsigned char *) s1->fname)
11794 || (cp2 == (const unsigned char *) s2->fname))
11795 return ((cp2 == (const unsigned char *) s2->fname)
11796 - (cp1 == (const unsigned char *) s1->fname));
11798 /* Character of current path component the same? */
11799 else if (*cp1 != *cp2)
11800 return *cp1 - *cp2;
11804 struct file_name_acquire_data
11806 struct file_info *files;
11811 /* Traversal function for the hash table. */
11814 file_name_acquire (void ** slot, void *data)
11816 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
11817 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
11818 struct file_info *fi;
11821 gcc_assert (fnad->max_files >= d->emitted_number);
11823 if (! d->emitted_number)
11826 gcc_assert (fnad->max_files != fnad->used_files);
11828 fi = fnad->files + fnad->used_files++;
11830 /* Skip all leading "./". */
11832 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
11835 /* Create a new array entry. */
11837 fi->length = strlen (f);
11840 /* Search for the file name part. */
11841 f = strrchr (f, DIR_SEPARATOR);
11842 #if defined (DIR_SEPARATOR_2)
11844 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
11848 if (f == NULL || f < g)
11854 fi->fname = f == NULL ? fi->path : f + 1;
11858 /* Output the directory table and the file name table. We try to minimize
11859 the total amount of memory needed. A heuristic is used to avoid large
11860 slowdowns with many input files. */
11863 output_file_names (void)
11865 struct file_name_acquire_data fnad;
11867 struct file_info *files;
11868 struct dir_info *dirs;
11876 if (!last_emitted_file)
11878 dw2_asm_output_data (1, 0, "End directory table");
11879 dw2_asm_output_data (1, 0, "End file name table");
11883 numfiles = last_emitted_file->emitted_number;
11885 /* Allocate the various arrays we need. */
11886 files = XALLOCAVEC (struct file_info, numfiles);
11887 dirs = XALLOCAVEC (struct dir_info, numfiles);
11889 fnad.files = files;
11890 fnad.used_files = 0;
11891 fnad.max_files = numfiles;
11892 htab_traverse (file_table, file_name_acquire, &fnad);
11893 gcc_assert (fnad.used_files == fnad.max_files);
11895 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
11897 /* Find all the different directories used. */
11898 dirs[0].path = files[0].path;
11899 dirs[0].length = files[0].fname - files[0].path;
11900 dirs[0].prefix = -1;
11902 dirs[0].dir_idx = 0;
11903 files[0].dir_idx = 0;
11906 for (i = 1; i < numfiles; i++)
11907 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
11908 && memcmp (dirs[ndirs - 1].path, files[i].path,
11909 dirs[ndirs - 1].length) == 0)
11911 /* Same directory as last entry. */
11912 files[i].dir_idx = ndirs - 1;
11913 ++dirs[ndirs - 1].count;
11919 /* This is a new directory. */
11920 dirs[ndirs].path = files[i].path;
11921 dirs[ndirs].length = files[i].fname - files[i].path;
11922 dirs[ndirs].count = 1;
11923 dirs[ndirs].dir_idx = ndirs;
11924 files[i].dir_idx = ndirs;
11926 /* Search for a prefix. */
11927 dirs[ndirs].prefix = -1;
11928 for (j = 0; j < ndirs; j++)
11929 if (dirs[j].length < dirs[ndirs].length
11930 && dirs[j].length > 1
11931 && (dirs[ndirs].prefix == -1
11932 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
11933 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
11934 dirs[ndirs].prefix = j;
11939 /* Now to the actual work. We have to find a subset of the directories which
11940 allow expressing the file name using references to the directory table
11941 with the least amount of characters. We do not do an exhaustive search
11942 where we would have to check out every combination of every single
11943 possible prefix. Instead we use a heuristic which provides nearly optimal
11944 results in most cases and never is much off. */
11945 saved = XALLOCAVEC (int, ndirs);
11946 savehere = XALLOCAVEC (int, ndirs);
11948 memset (saved, '\0', ndirs * sizeof (saved[0]));
11949 for (i = 0; i < ndirs; i++)
11954 /* We can always save some space for the current directory. But this
11955 does not mean it will be enough to justify adding the directory. */
11956 savehere[i] = dirs[i].length;
11957 total = (savehere[i] - saved[i]) * dirs[i].count;
11959 for (j = i + 1; j < ndirs; j++)
11962 if (saved[j] < dirs[i].length)
11964 /* Determine whether the dirs[i] path is a prefix of the
11968 k = dirs[j].prefix;
11969 while (k != -1 && k != (int) i)
11970 k = dirs[k].prefix;
11974 /* Yes it is. We can possibly save some memory by
11975 writing the filenames in dirs[j] relative to
11977 savehere[j] = dirs[i].length;
11978 total += (savehere[j] - saved[j]) * dirs[j].count;
11983 /* Check whether we can save enough to justify adding the dirs[i]
11985 if (total > dirs[i].length + 1)
11987 /* It's worthwhile adding. */
11988 for (j = i; j < ndirs; j++)
11989 if (savehere[j] > 0)
11991 /* Remember how much we saved for this directory so far. */
11992 saved[j] = savehere[j];
11994 /* Remember the prefix directory. */
11995 dirs[j].dir_idx = i;
12000 /* Emit the directory name table. */
12001 idx_offset = dirs[0].length > 0 ? 1 : 0;
12002 for (i = 1 - idx_offset; i < ndirs; i++)
12003 dw2_asm_output_nstring (dirs[i].path,
12005 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
12006 "Directory Entry: %#x", i + idx_offset);
12008 dw2_asm_output_data (1, 0, "End directory table");
12010 /* We have to emit them in the order of emitted_number since that's
12011 used in the debug info generation. To do this efficiently we
12012 generate a back-mapping of the indices first. */
12013 backmap = XALLOCAVEC (int, numfiles);
12014 for (i = 0; i < numfiles; i++)
12015 backmap[files[i].file_idx->emitted_number - 1] = i;
12017 /* Now write all the file names. */
12018 for (i = 0; i < numfiles; i++)
12020 int file_idx = backmap[i];
12021 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
12023 #ifdef VMS_DEBUGGING_INFO
12024 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12026 /* Setting these fields can lead to debugger miscomparisons,
12027 but VMS Debug requires them to be set correctly. */
12032 int maxfilelen = strlen (files[file_idx].path)
12033 + dirs[dir_idx].length
12034 + MAX_VMS_VERSION_LEN + 1;
12035 char *filebuf = XALLOCAVEC (char, maxfilelen);
12037 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
12038 snprintf (filebuf, maxfilelen, "%s;%d",
12039 files[file_idx].path + dirs[dir_idx].length, ver);
12041 dw2_asm_output_nstring
12042 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1);
12044 /* Include directory index. */
12045 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
12047 /* Modification time. */
12048 dw2_asm_output_data_uleb128
12049 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
12053 /* File length in bytes. */
12054 dw2_asm_output_data_uleb128
12055 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
12059 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
12060 "File Entry: %#x", (unsigned) i + 1);
12062 /* Include directory index. */
12063 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
12065 /* Modification time. */
12066 dw2_asm_output_data_uleb128 (0, NULL);
12068 /* File length in bytes. */
12069 dw2_asm_output_data_uleb128 (0, NULL);
12070 #endif /* VMS_DEBUGGING_INFO */
12073 dw2_asm_output_data (1, 0, "End file name table");
12077 /* Output the source line number correspondence information. This
12078 information goes into the .debug_line section. */
12081 output_line_info (void)
12083 char l1[20], l2[20], p1[20], p2[20];
12084 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
12085 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
12087 unsigned n_op_args;
12088 unsigned long lt_index;
12089 unsigned long current_line;
12092 unsigned long current_file;
12093 unsigned long function;
12094 int ver = dwarf_version;
12096 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
12097 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
12098 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
12099 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
12101 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
12102 dw2_asm_output_data (4, 0xffffffff,
12103 "Initial length escape value indicating 64-bit DWARF extension");
12104 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
12105 "Length of Source Line Info");
12106 ASM_OUTPUT_LABEL (asm_out_file, l1);
12108 dw2_asm_output_data (2, ver, "DWARF Version");
12109 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
12110 ASM_OUTPUT_LABEL (asm_out_file, p1);
12112 /* Define the architecture-dependent minimum instruction length (in
12113 bytes). In this implementation of DWARF, this field is used for
12114 information purposes only. Since GCC generates assembly language,
12115 we have no a priori knowledge of how many instruction bytes are
12116 generated for each source line, and therefore can use only the
12117 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
12118 commands. Accordingly, we fix this as `1', which is "correct
12119 enough" for all architectures, and don't let the target override. */
12120 dw2_asm_output_data (1, 1,
12121 "Minimum Instruction Length");
12124 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
12125 "Maximum Operations Per Instruction");
12126 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
12127 "Default is_stmt_start flag");
12128 dw2_asm_output_data (1, DWARF_LINE_BASE,
12129 "Line Base Value (Special Opcodes)");
12130 dw2_asm_output_data (1, DWARF_LINE_RANGE,
12131 "Line Range Value (Special Opcodes)");
12132 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
12133 "Special Opcode Base");
12135 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
12139 case DW_LNS_advance_pc:
12140 case DW_LNS_advance_line:
12141 case DW_LNS_set_file:
12142 case DW_LNS_set_column:
12143 case DW_LNS_fixed_advance_pc:
12151 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
12155 /* Write out the information about the files we use. */
12156 output_file_names ();
12157 ASM_OUTPUT_LABEL (asm_out_file, p2);
12159 /* We used to set the address register to the first location in the text
12160 section here, but that didn't accomplish anything since we already
12161 have a line note for the opening brace of the first function. */
12163 /* Generate the line number to PC correspondence table, encoded as
12164 a series of state machine operations. */
12168 if (cfun && in_cold_section_p)
12169 strcpy (prev_line_label, crtl->subsections.cold_section_label);
12171 strcpy (prev_line_label, text_section_label);
12172 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
12174 dw_line_info_ref line_info = &line_info_table[lt_index];
12177 /* Disable this optimization for now; GDB wants to see two line notes
12178 at the beginning of a function so it can find the end of the
12181 /* Don't emit anything for redundant notes. Just updating the
12182 address doesn't accomplish anything, because we already assume
12183 that anything after the last address is this line. */
12184 if (line_info->dw_line_num == current_line
12185 && line_info->dw_file_num == current_file)
12189 /* Emit debug info for the address of the current line.
12191 Unfortunately, we have little choice here currently, and must always
12192 use the most general form. GCC does not know the address delta
12193 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
12194 attributes which will give an upper bound on the address range. We
12195 could perhaps use length attributes to determine when it is safe to
12196 use DW_LNS_fixed_advance_pc. */
12198 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
12201 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
12202 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12203 "DW_LNS_fixed_advance_pc");
12204 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
12208 /* This can handle any delta. This takes
12209 4+DWARF2_ADDR_SIZE bytes. */
12210 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12211 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12212 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12213 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12216 strcpy (prev_line_label, line_label);
12218 /* Emit debug info for the source file of the current line, if
12219 different from the previous line. */
12220 if (line_info->dw_file_num != current_file)
12222 current_file = line_info->dw_file_num;
12223 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
12224 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
12227 /* Emit debug info for the current line number, choosing the encoding
12228 that uses the least amount of space. */
12229 if (line_info->dw_line_num != current_line)
12231 line_offset = line_info->dw_line_num - current_line;
12232 line_delta = line_offset - DWARF_LINE_BASE;
12233 current_line = line_info->dw_line_num;
12234 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
12235 /* This can handle deltas from -10 to 234, using the current
12236 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
12238 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
12239 "line %lu", current_line);
12242 /* This can handle any delta. This takes at least 4 bytes,
12243 depending on the value being encoded. */
12244 dw2_asm_output_data (1, DW_LNS_advance_line,
12245 "advance to line %lu", current_line);
12246 dw2_asm_output_data_sleb128 (line_offset, NULL);
12247 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12251 /* We still need to start a new row, so output a copy insn. */
12252 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12255 /* Emit debug info for the address of the end of the function. */
12258 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12259 "DW_LNS_fixed_advance_pc");
12260 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
12264 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12265 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12266 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12267 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
12270 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
12271 dw2_asm_output_data_uleb128 (1, NULL);
12272 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
12277 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
12279 dw_separate_line_info_ref line_info
12280 = &separate_line_info_table[lt_index];
12283 /* Don't emit anything for redundant notes. */
12284 if (line_info->dw_line_num == current_line
12285 && line_info->dw_file_num == current_file
12286 && line_info->function == function)
12290 /* Emit debug info for the address of the current line. If this is
12291 a new function, or the first line of a function, then we need
12292 to handle it differently. */
12293 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
12295 if (function != line_info->function)
12297 function = line_info->function;
12299 /* Set the address register to the first line in the function. */
12300 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12301 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12302 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12303 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12307 /* ??? See the DW_LNS_advance_pc comment above. */
12310 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12311 "DW_LNS_fixed_advance_pc");
12312 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
12316 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12317 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12318 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12319 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12323 strcpy (prev_line_label, line_label);
12325 /* Emit debug info for the source file of the current line, if
12326 different from the previous line. */
12327 if (line_info->dw_file_num != current_file)
12329 current_file = line_info->dw_file_num;
12330 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
12331 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
12334 /* Emit debug info for the current line number, choosing the encoding
12335 that uses the least amount of space. */
12336 if (line_info->dw_line_num != current_line)
12338 line_offset = line_info->dw_line_num - current_line;
12339 line_delta = line_offset - DWARF_LINE_BASE;
12340 current_line = line_info->dw_line_num;
12341 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
12342 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
12343 "line %lu", current_line);
12346 dw2_asm_output_data (1, DW_LNS_advance_line,
12347 "advance to line %lu", current_line);
12348 dw2_asm_output_data_sleb128 (line_offset, NULL);
12349 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12353 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12361 /* If we're done with a function, end its sequence. */
12362 if (lt_index == separate_line_info_table_in_use
12363 || separate_line_info_table[lt_index].function != function)
12368 /* Emit debug info for the address of the end of the function. */
12369 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
12372 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12373 "DW_LNS_fixed_advance_pc");
12374 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
12378 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12379 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12380 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12381 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12384 /* Output the marker for the end of this sequence. */
12385 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
12386 dw2_asm_output_data_uleb128 (1, NULL);
12387 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
12391 /* Output the marker for the end of the line number info. */
12392 ASM_OUTPUT_LABEL (asm_out_file, l2);
12395 /* Return the size of the .debug_dcall table for the compilation unit. */
12397 static unsigned long
12398 size_of_dcall_table (void)
12400 unsigned long size;
12403 tree last_poc_decl = NULL;
12405 /* Header: version + debug info section pointer + pointer size. */
12406 size = 2 + DWARF_OFFSET_SIZE + 1;
12408 /* Each entry: code label + DIE offset. */
12409 FOR_EACH_VEC_ELT (dcall_entry, dcall_table, i, p)
12411 gcc_assert (p->targ_die != NULL);
12412 /* Insert a "from" entry when the point-of-call DIE offset changes. */
12413 if (p->poc_decl != last_poc_decl)
12415 dw_die_ref poc_die = lookup_decl_die (p->poc_decl);
12416 gcc_assert (poc_die);
12417 last_poc_decl = p->poc_decl;
12419 size += (DWARF_OFFSET_SIZE
12420 + size_of_uleb128 (poc_die->die_offset));
12422 size += DWARF_OFFSET_SIZE + size_of_uleb128 (p->targ_die->die_offset);
12428 /* Output the direct call table used to disambiguate PC values when
12429 identical function have been merged. */
12432 output_dcall_table (void)
12435 unsigned long dcall_length = size_of_dcall_table ();
12437 char poc_label[MAX_ARTIFICIAL_LABEL_BYTES];
12438 tree last_poc_decl = NULL;
12440 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
12441 dw2_asm_output_data (4, 0xffffffff,
12442 "Initial length escape value indicating 64-bit DWARF extension");
12443 dw2_asm_output_data (DWARF_OFFSET_SIZE, dcall_length,
12444 "Length of Direct Call Table");
12445 dw2_asm_output_data (2, 4, "Version number");
12446 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
12447 debug_info_section,
12448 "Offset of Compilation Unit Info");
12449 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
12451 FOR_EACH_VEC_ELT (dcall_entry, dcall_table, i, p)
12453 /* Insert a "from" entry when the point-of-call DIE offset changes. */
12454 if (p->poc_decl != last_poc_decl)
12456 dw_die_ref poc_die = lookup_decl_die (p->poc_decl);
12457 last_poc_decl = p->poc_decl;
12460 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, "New caller");
12461 dw2_asm_output_data_uleb128 (poc_die->die_offset,
12462 "Caller DIE offset");
12465 ASM_GENERATE_INTERNAL_LABEL (poc_label, "LPOC", p->poc_label_num);
12466 dw2_asm_output_addr (DWARF_OFFSET_SIZE, poc_label, "Point of call");
12467 dw2_asm_output_data_uleb128 (p->targ_die->die_offset,
12468 "Callee DIE offset");
12472 /* Return the size of the .debug_vcall table for the compilation unit. */
12474 static unsigned long
12475 size_of_vcall_table (void)
12477 unsigned long size;
12481 /* Header: version + pointer size. */
12484 /* Each entry: code label + vtable slot index. */
12485 FOR_EACH_VEC_ELT (vcall_entry, vcall_table, i, p)
12486 size += DWARF_OFFSET_SIZE + size_of_uleb128 (p->vtable_slot);
12491 /* Output the virtual call table used to disambiguate PC values when
12492 identical function have been merged. */
12495 output_vcall_table (void)
12498 unsigned long vcall_length = size_of_vcall_table ();
12500 char poc_label[MAX_ARTIFICIAL_LABEL_BYTES];
12502 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
12503 dw2_asm_output_data (4, 0xffffffff,
12504 "Initial length escape value indicating 64-bit DWARF extension");
12505 dw2_asm_output_data (DWARF_OFFSET_SIZE, vcall_length,
12506 "Length of Virtual Call Table");
12507 dw2_asm_output_data (2, 4, "Version number");
12508 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
12510 FOR_EACH_VEC_ELT (vcall_entry, vcall_table, i, p)
12512 ASM_GENERATE_INTERNAL_LABEL (poc_label, "LPOC", p->poc_label_num);
12513 dw2_asm_output_addr (DWARF_OFFSET_SIZE, poc_label, "Point of call");
12514 dw2_asm_output_data_uleb128 (p->vtable_slot, "Vtable slot");
12518 /* Given a pointer to a tree node for some base type, return a pointer to
12519 a DIE that describes the given type.
12521 This routine must only be called for GCC type nodes that correspond to
12522 Dwarf base (fundamental) types. */
12525 base_type_die (tree type)
12527 dw_die_ref base_type_result;
12528 enum dwarf_type encoding;
12530 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
12533 /* If this is a subtype that should not be emitted as a subrange type,
12534 use the base type. See subrange_type_for_debug_p. */
12535 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
12536 type = TREE_TYPE (type);
12538 switch (TREE_CODE (type))
12541 if ((dwarf_version >= 4 || !dwarf_strict)
12542 && TYPE_NAME (type)
12543 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12544 && DECL_IS_BUILTIN (TYPE_NAME (type))
12545 && DECL_NAME (TYPE_NAME (type)))
12547 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
12548 if (strcmp (name, "char16_t") == 0
12549 || strcmp (name, "char32_t") == 0)
12551 encoding = DW_ATE_UTF;
12555 if (TYPE_STRING_FLAG (type))
12557 if (TYPE_UNSIGNED (type))
12558 encoding = DW_ATE_unsigned_char;
12560 encoding = DW_ATE_signed_char;
12562 else if (TYPE_UNSIGNED (type))
12563 encoding = DW_ATE_unsigned;
12565 encoding = DW_ATE_signed;
12569 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
12571 if (dwarf_version >= 3 || !dwarf_strict)
12572 encoding = DW_ATE_decimal_float;
12574 encoding = DW_ATE_lo_user;
12577 encoding = DW_ATE_float;
12580 case FIXED_POINT_TYPE:
12581 if (!(dwarf_version >= 3 || !dwarf_strict))
12582 encoding = DW_ATE_lo_user;
12583 else if (TYPE_UNSIGNED (type))
12584 encoding = DW_ATE_unsigned_fixed;
12586 encoding = DW_ATE_signed_fixed;
12589 /* Dwarf2 doesn't know anything about complex ints, so use
12590 a user defined type for it. */
12592 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
12593 encoding = DW_ATE_complex_float;
12595 encoding = DW_ATE_lo_user;
12599 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12600 encoding = DW_ATE_boolean;
12604 /* No other TREE_CODEs are Dwarf fundamental types. */
12605 gcc_unreachable ();
12608 base_type_result = new_die (DW_TAG_base_type, comp_unit_die (), type);
12610 add_AT_unsigned (base_type_result, DW_AT_byte_size,
12611 int_size_in_bytes (type));
12612 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
12614 return base_type_result;
12617 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12618 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12621 is_base_type (tree type)
12623 switch (TREE_CODE (type))
12629 case FIXED_POINT_TYPE:
12637 case QUAL_UNION_TYPE:
12638 case ENUMERAL_TYPE:
12639 case FUNCTION_TYPE:
12642 case REFERENCE_TYPE:
12650 gcc_unreachable ();
12656 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12657 node, return the size in bits for the type if it is a constant, or else
12658 return the alignment for the type if the type's size is not constant, or
12659 else return BITS_PER_WORD if the type actually turns out to be an
12660 ERROR_MARK node. */
12662 static inline unsigned HOST_WIDE_INT
12663 simple_type_size_in_bits (const_tree type)
12665 if (TREE_CODE (type) == ERROR_MARK)
12666 return BITS_PER_WORD;
12667 else if (TYPE_SIZE (type) == NULL_TREE)
12669 else if (host_integerp (TYPE_SIZE (type), 1))
12670 return tree_low_cst (TYPE_SIZE (type), 1);
12672 return TYPE_ALIGN (type);
12675 /* Similarly, but return a double_int instead of UHWI. */
12677 static inline double_int
12678 double_int_type_size_in_bits (const_tree type)
12680 if (TREE_CODE (type) == ERROR_MARK)
12681 return uhwi_to_double_int (BITS_PER_WORD);
12682 else if (TYPE_SIZE (type) == NULL_TREE)
12683 return double_int_zero;
12684 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
12685 return tree_to_double_int (TYPE_SIZE (type));
12687 return uhwi_to_double_int (TYPE_ALIGN (type));
12690 /* Given a pointer to a tree node for a subrange type, return a pointer
12691 to a DIE that describes the given type. */
12694 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
12696 dw_die_ref subrange_die;
12697 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
12699 if (context_die == NULL)
12700 context_die = comp_unit_die ();
12702 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
12704 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
12706 /* The size of the subrange type and its base type do not match,
12707 so we need to generate a size attribute for the subrange type. */
12708 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
12712 add_bound_info (subrange_die, DW_AT_lower_bound, low);
12714 add_bound_info (subrange_die, DW_AT_upper_bound, high);
12716 return subrange_die;
12719 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
12720 entry that chains various modifiers in front of the given type. */
12723 modified_type_die (tree type, int is_const_type, int is_volatile_type,
12724 dw_die_ref context_die)
12726 enum tree_code code = TREE_CODE (type);
12727 dw_die_ref mod_type_die;
12728 dw_die_ref sub_die = NULL;
12729 tree item_type = NULL;
12730 tree qualified_type;
12731 tree name, low, high;
12733 if (code == ERROR_MARK)
12736 /* See if we already have the appropriately qualified variant of
12739 = get_qualified_type (type,
12740 ((is_const_type ? TYPE_QUAL_CONST : 0)
12741 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
12743 if (qualified_type == sizetype
12744 && TYPE_NAME (qualified_type)
12745 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
12747 tree t = TREE_TYPE (TYPE_NAME (qualified_type));
12749 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE
12750 && TYPE_PRECISION (t)
12751 == TYPE_PRECISION (qualified_type)
12752 && TYPE_UNSIGNED (t)
12753 == TYPE_UNSIGNED (qualified_type));
12754 qualified_type = t;
12757 /* If we do, then we can just use its DIE, if it exists. */
12758 if (qualified_type)
12760 mod_type_die = lookup_type_die (qualified_type);
12762 return mod_type_die;
12765 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
12767 /* Handle C typedef types. */
12768 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)
12769 && !DECL_ARTIFICIAL (name))
12771 tree dtype = TREE_TYPE (name);
12773 if (qualified_type == dtype)
12775 /* For a named type, use the typedef. */
12776 gen_type_die (qualified_type, context_die);
12777 return lookup_type_die (qualified_type);
12779 else if (is_const_type < TYPE_READONLY (dtype)
12780 || is_volatile_type < TYPE_VOLATILE (dtype)
12781 || (is_const_type <= TYPE_READONLY (dtype)
12782 && is_volatile_type <= TYPE_VOLATILE (dtype)
12783 && DECL_ORIGINAL_TYPE (name) != type))
12784 /* cv-unqualified version of named type. Just use the unnamed
12785 type to which it refers. */
12786 return modified_type_die (DECL_ORIGINAL_TYPE (name),
12787 is_const_type, is_volatile_type,
12789 /* Else cv-qualified version of named type; fall through. */
12794 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die (), type);
12795 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
12797 else if (is_volatile_type)
12799 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die (), type);
12800 sub_die = modified_type_die (type, 0, 0, context_die);
12802 else if (code == POINTER_TYPE)
12804 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die (), type);
12805 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
12806 simple_type_size_in_bits (type) / BITS_PER_UNIT);
12807 item_type = TREE_TYPE (type);
12808 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
12809 add_AT_unsigned (mod_type_die, DW_AT_address_class,
12810 TYPE_ADDR_SPACE (item_type));
12812 else if (code == REFERENCE_TYPE)
12814 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
12815 mod_type_die = new_die (DW_TAG_rvalue_reference_type, comp_unit_die (),
12818 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die (), type);
12819 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
12820 simple_type_size_in_bits (type) / BITS_PER_UNIT);
12821 item_type = TREE_TYPE (type);
12822 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
12823 add_AT_unsigned (mod_type_die, DW_AT_address_class,
12824 TYPE_ADDR_SPACE (item_type));
12826 else if (code == INTEGER_TYPE
12827 && TREE_TYPE (type) != NULL_TREE
12828 && subrange_type_for_debug_p (type, &low, &high))
12830 mod_type_die = subrange_type_die (type, low, high, context_die);
12831 item_type = TREE_TYPE (type);
12833 else if (is_base_type (type))
12834 mod_type_die = base_type_die (type);
12837 gen_type_die (type, context_die);
12839 /* We have to get the type_main_variant here (and pass that to the
12840 `lookup_type_die' routine) because the ..._TYPE node we have
12841 might simply be a *copy* of some original type node (where the
12842 copy was created to help us keep track of typedef names) and
12843 that copy might have a different TYPE_UID from the original
12845 if (TREE_CODE (type) != VECTOR_TYPE)
12846 return lookup_type_die (type_main_variant (type));
12848 /* Vectors have the debugging information in the type,
12849 not the main variant. */
12850 return lookup_type_die (type);
12853 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
12854 don't output a DW_TAG_typedef, since there isn't one in the
12855 user's program; just attach a DW_AT_name to the type.
12856 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
12857 if the base type already has the same name. */
12859 && ((TREE_CODE (name) != TYPE_DECL
12860 && (qualified_type == TYPE_MAIN_VARIANT (type)
12861 || (!is_const_type && !is_volatile_type)))
12862 || (TREE_CODE (name) == TYPE_DECL
12863 && TREE_TYPE (name) == qualified_type
12864 && DECL_NAME (name))))
12866 if (TREE_CODE (name) == TYPE_DECL)
12867 /* Could just call add_name_and_src_coords_attributes here,
12868 but since this is a builtin type it doesn't have any
12869 useful source coordinates anyway. */
12870 name = DECL_NAME (name);
12871 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
12873 /* This probably indicates a bug. */
12874 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
12875 add_name_attribute (mod_type_die, "__unknown__");
12877 if (qualified_type)
12878 equate_type_number_to_die (qualified_type, mod_type_die);
12881 /* We must do this after the equate_type_number_to_die call, in case
12882 this is a recursive type. This ensures that the modified_type_die
12883 recursion will terminate even if the type is recursive. Recursive
12884 types are possible in Ada. */
12885 sub_die = modified_type_die (item_type,
12886 TYPE_READONLY (item_type),
12887 TYPE_VOLATILE (item_type),
12890 if (sub_die != NULL)
12891 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
12893 return mod_type_die;
12896 /* Generate DIEs for the generic parameters of T.
12897 T must be either a generic type or a generic function.
12898 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
12901 gen_generic_params_dies (tree t)
12905 dw_die_ref die = NULL;
12907 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
12911 die = lookup_type_die (t);
12912 else if (DECL_P (t))
12913 die = lookup_decl_die (t);
12917 parms = lang_hooks.get_innermost_generic_parms (t);
12919 /* T has no generic parameter. It means T is neither a generic type
12920 or function. End of story. */
12923 parms_num = TREE_VEC_LENGTH (parms);
12924 args = lang_hooks.get_innermost_generic_args (t);
12925 for (i = 0; i < parms_num; i++)
12927 tree parm, arg, arg_pack_elems;
12929 parm = TREE_VEC_ELT (parms, i);
12930 arg = TREE_VEC_ELT (args, i);
12931 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
12932 gcc_assert (parm && TREE_VALUE (parm) && arg);
12934 if (parm && TREE_VALUE (parm) && arg)
12936 /* If PARM represents a template parameter pack,
12937 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
12938 by DW_TAG_template_*_parameter DIEs for the argument
12939 pack elements of ARG. Note that ARG would then be
12940 an argument pack. */
12941 if (arg_pack_elems)
12942 template_parameter_pack_die (TREE_VALUE (parm),
12946 generic_parameter_die (TREE_VALUE (parm), arg,
12947 true /* Emit DW_AT_name */, die);
12952 /* Create and return a DIE for PARM which should be
12953 the representation of a generic type parameter.
12954 For instance, in the C++ front end, PARM would be a template parameter.
12955 ARG is the argument to PARM.
12956 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
12958 PARENT_DIE is the parent DIE which the new created DIE should be added to,
12959 as a child node. */
12962 generic_parameter_die (tree parm, tree arg,
12964 dw_die_ref parent_die)
12966 dw_die_ref tmpl_die = NULL;
12967 const char *name = NULL;
12969 if (!parm || !DECL_NAME (parm) || !arg)
12972 /* We support non-type generic parameters and arguments,
12973 type generic parameters and arguments, as well as
12974 generic generic parameters (a.k.a. template template parameters in C++)
12976 if (TREE_CODE (parm) == PARM_DECL)
12977 /* PARM is a nontype generic parameter */
12978 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
12979 else if (TREE_CODE (parm) == TYPE_DECL)
12980 /* PARM is a type generic parameter. */
12981 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
12982 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
12983 /* PARM is a generic generic parameter.
12984 Its DIE is a GNU extension. It shall have a
12985 DW_AT_name attribute to represent the name of the template template
12986 parameter, and a DW_AT_GNU_template_name attribute to represent the
12987 name of the template template argument. */
12988 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
12991 gcc_unreachable ();
12997 /* If PARM is a generic parameter pack, it means we are
12998 emitting debug info for a template argument pack element.
12999 In other terms, ARG is a template argument pack element.
13000 In that case, we don't emit any DW_AT_name attribute for
13004 name = IDENTIFIER_POINTER (DECL_NAME (parm));
13006 add_AT_string (tmpl_die, DW_AT_name, name);
13009 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
13011 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
13012 TMPL_DIE should have a child DW_AT_type attribute that is set
13013 to the type of the argument to PARM, which is ARG.
13014 If PARM is a type generic parameter, TMPL_DIE should have a
13015 child DW_AT_type that is set to ARG. */
13016 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
13017 add_type_attribute (tmpl_die, tmpl_type, 0,
13018 TREE_THIS_VOLATILE (tmpl_type),
13023 /* So TMPL_DIE is a DIE representing a
13024 a generic generic template parameter, a.k.a template template
13025 parameter in C++ and arg is a template. */
13027 /* The DW_AT_GNU_template_name attribute of the DIE must be set
13028 to the name of the argument. */
13029 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
13031 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
13034 if (TREE_CODE (parm) == PARM_DECL)
13035 /* So PARM is a non-type generic parameter.
13036 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13037 attribute of TMPL_DIE which value represents the value
13039 We must be careful here:
13040 The value of ARG might reference some function decls.
13041 We might currently be emitting debug info for a generic
13042 type and types are emitted before function decls, we don't
13043 know if the function decls referenced by ARG will actually be
13044 emitted after cgraph computations.
13045 So must defer the generation of the DW_AT_const_value to
13046 after cgraph is ready. */
13047 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
13053 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13054 PARM_PACK must be a template parameter pack. The returned DIE
13055 will be child DIE of PARENT_DIE. */
13058 template_parameter_pack_die (tree parm_pack,
13059 tree parm_pack_args,
13060 dw_die_ref parent_die)
13065 gcc_assert (parent_die && parm_pack);
13067 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
13068 add_name_and_src_coords_attributes (die, parm_pack);
13069 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
13070 generic_parameter_die (parm_pack,
13071 TREE_VEC_ELT (parm_pack_args, j),
13072 false /* Don't emit DW_AT_name */,
13077 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
13078 an enumerated type. */
13081 type_is_enum (const_tree type)
13083 return TREE_CODE (type) == ENUMERAL_TYPE;
13086 /* Return the DBX register number described by a given RTL node. */
13088 static unsigned int
13089 dbx_reg_number (const_rtx rtl)
13091 unsigned regno = REGNO (rtl);
13093 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
13095 #ifdef LEAF_REG_REMAP
13096 if (current_function_uses_only_leaf_regs)
13098 int leaf_reg = LEAF_REG_REMAP (regno);
13099 if (leaf_reg != -1)
13100 regno = (unsigned) leaf_reg;
13104 return DBX_REGISTER_NUMBER (regno);
13107 /* Optionally add a DW_OP_piece term to a location description expression.
13108 DW_OP_piece is only added if the location description expression already
13109 doesn't end with DW_OP_piece. */
13112 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
13114 dw_loc_descr_ref loc;
13116 if (*list_head != NULL)
13118 /* Find the end of the chain. */
13119 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
13122 if (loc->dw_loc_opc != DW_OP_piece)
13123 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
13127 /* Return a location descriptor that designates a machine register or
13128 zero if there is none. */
13130 static dw_loc_descr_ref
13131 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
13135 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
13138 /* We only use "frame base" when we're sure we're talking about the
13139 post-prologue local stack frame. We do this by *not* running
13140 register elimination until this point, and recognizing the special
13141 argument pointer and soft frame pointer rtx's.
13142 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13143 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
13144 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
13146 dw_loc_descr_ref result = NULL;
13148 if (dwarf_version >= 4 || !dwarf_strict)
13150 result = mem_loc_descriptor (rtl, VOIDmode, initialized);
13152 add_loc_descr (&result,
13153 new_loc_descr (DW_OP_stack_value, 0, 0));
13158 regs = targetm.dwarf_register_span (rtl);
13160 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
13161 return multiple_reg_loc_descriptor (rtl, regs, initialized);
13163 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
13166 /* Return a location descriptor that designates a machine register for
13167 a given hard register number. */
13169 static dw_loc_descr_ref
13170 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
13172 dw_loc_descr_ref reg_loc_descr;
13176 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
13178 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
13180 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13181 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13183 return reg_loc_descr;
13186 /* Given an RTL of a register, return a location descriptor that
13187 designates a value that spans more than one register. */
13189 static dw_loc_descr_ref
13190 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
13191 enum var_init_status initialized)
13193 int nregs, size, i;
13195 dw_loc_descr_ref loc_result = NULL;
13198 #ifdef LEAF_REG_REMAP
13199 if (current_function_uses_only_leaf_regs)
13201 int leaf_reg = LEAF_REG_REMAP (reg);
13202 if (leaf_reg != -1)
13203 reg = (unsigned) leaf_reg;
13206 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
13207 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
13209 /* Simple, contiguous registers. */
13210 if (regs == NULL_RTX)
13212 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
13217 dw_loc_descr_ref t;
13219 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
13220 VAR_INIT_STATUS_INITIALIZED);
13221 add_loc_descr (&loc_result, t);
13222 add_loc_descr_op_piece (&loc_result, size);
13228 /* Now onto stupid register sets in non contiguous locations. */
13230 gcc_assert (GET_CODE (regs) == PARALLEL);
13232 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
13235 for (i = 0; i < XVECLEN (regs, 0); ++i)
13237 dw_loc_descr_ref t;
13239 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
13240 VAR_INIT_STATUS_INITIALIZED);
13241 add_loc_descr (&loc_result, t);
13242 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
13243 add_loc_descr_op_piece (&loc_result, size);
13246 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13247 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13251 /* Return a location descriptor that designates a constant. */
13253 static dw_loc_descr_ref
13254 int_loc_descriptor (HOST_WIDE_INT i)
13256 enum dwarf_location_atom op;
13258 /* Pick the smallest representation of a constant, rather than just
13259 defaulting to the LEB encoding. */
13263 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
13264 else if (i <= 0xff)
13265 op = DW_OP_const1u;
13266 else if (i <= 0xffff)
13267 op = DW_OP_const2u;
13268 else if (HOST_BITS_PER_WIDE_INT == 32
13269 || i <= 0xffffffff)
13270 op = DW_OP_const4u;
13277 op = DW_OP_const1s;
13278 else if (i >= -0x8000)
13279 op = DW_OP_const2s;
13280 else if (HOST_BITS_PER_WIDE_INT == 32
13281 || i >= -0x80000000)
13282 op = DW_OP_const4s;
13287 return new_loc_descr (op, i, 0);
13290 /* Return loc description representing "address" of integer value.
13291 This can appear only as toplevel expression. */
13293 static dw_loc_descr_ref
13294 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
13297 dw_loc_descr_ref loc_result = NULL;
13299 if (!(dwarf_version >= 4 || !dwarf_strict))
13306 else if (i <= 0xff)
13308 else if (i <= 0xffff)
13310 else if (HOST_BITS_PER_WIDE_INT == 32
13311 || i <= 0xffffffff)
13314 litsize = 1 + size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
13320 else if (i >= -0x8000)
13322 else if (HOST_BITS_PER_WIDE_INT == 32
13323 || i >= -0x80000000)
13326 litsize = 1 + size_of_sleb128 (i);
13328 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
13329 is more compact. For DW_OP_stack_value we need:
13330 litsize + 1 (DW_OP_stack_value)
13331 and for DW_OP_implicit_value:
13332 1 (DW_OP_implicit_value) + 1 (length) + size. */
13333 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
13335 loc_result = int_loc_descriptor (i);
13336 add_loc_descr (&loc_result,
13337 new_loc_descr (DW_OP_stack_value, 0, 0));
13341 loc_result = new_loc_descr (DW_OP_implicit_value,
13343 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
13344 loc_result->dw_loc_oprnd2.v.val_int = i;
13348 /* Return a location descriptor that designates a base+offset location. */
13350 static dw_loc_descr_ref
13351 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
13352 enum var_init_status initialized)
13354 unsigned int regno;
13355 dw_loc_descr_ref result;
13356 dw_fde_ref fde = current_fde ();
13358 /* We only use "frame base" when we're sure we're talking about the
13359 post-prologue local stack frame. We do this by *not* running
13360 register elimination until this point, and recognizing the special
13361 argument pointer and soft frame pointer rtx's. */
13362 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
13364 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
13368 if (GET_CODE (elim) == PLUS)
13370 offset += INTVAL (XEXP (elim, 1));
13371 elim = XEXP (elim, 0);
13373 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
13374 && (elim == hard_frame_pointer_rtx
13375 || elim == stack_pointer_rtx))
13376 || elim == (frame_pointer_needed
13377 ? hard_frame_pointer_rtx
13378 : stack_pointer_rtx));
13380 /* If drap register is used to align stack, use frame
13381 pointer + offset to access stack variables. If stack
13382 is aligned without drap, use stack pointer + offset to
13383 access stack variables. */
13384 if (crtl->stack_realign_tried
13385 && reg == frame_pointer_rtx)
13388 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
13389 ? HARD_FRAME_POINTER_REGNUM
13390 : STACK_POINTER_REGNUM);
13391 return new_reg_loc_descr (base_reg, offset);
13394 offset += frame_pointer_fb_offset;
13395 return new_loc_descr (DW_OP_fbreg, offset, 0);
13400 && (fde->drap_reg == REGNO (reg)
13401 || fde->vdrap_reg == REGNO (reg)))
13403 /* Use cfa+offset to represent the location of arguments passed
13404 on the stack when drap is used to align stack.
13405 Only do this when not optimizing, for optimized code var-tracking
13406 is supposed to track where the arguments live and the register
13407 used as vdrap or drap in some spot might be used for something
13408 else in other part of the routine. */
13409 return new_loc_descr (DW_OP_fbreg, offset, 0);
13412 regno = dbx_reg_number (reg);
13414 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
13417 result = new_loc_descr (DW_OP_bregx, regno, offset);
13419 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13420 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13425 /* Return true if this RTL expression describes a base+offset calculation. */
13428 is_based_loc (const_rtx rtl)
13430 return (GET_CODE (rtl) == PLUS
13431 && ((REG_P (XEXP (rtl, 0))
13432 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
13433 && CONST_INT_P (XEXP (rtl, 1)))));
13436 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
13439 static dw_loc_descr_ref
13440 tls_mem_loc_descriptor (rtx mem)
13443 dw_loc_descr_ref loc_result;
13445 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
13448 base = get_base_address (MEM_EXPR (mem));
13450 || TREE_CODE (base) != VAR_DECL
13451 || !DECL_THREAD_LOCAL_P (base))
13454 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1);
13455 if (loc_result == NULL)
13458 if (INTVAL (MEM_OFFSET (mem)))
13459 loc_descr_plus_const (&loc_result, INTVAL (MEM_OFFSET (mem)));
13464 /* Output debug info about reason why we failed to expand expression as dwarf
13468 expansion_failed (tree expr, rtx rtl, char const *reason)
13470 if (dump_file && (dump_flags & TDF_DETAILS))
13472 fprintf (dump_file, "Failed to expand as dwarf: ");
13474 print_generic_expr (dump_file, expr, dump_flags);
13477 fprintf (dump_file, "\n");
13478 print_rtl (dump_file, rtl);
13480 fprintf (dump_file, "\nReason: %s\n", reason);
13484 /* Helper function for const_ok_for_output, called either directly
13485 or via for_each_rtx. */
13488 const_ok_for_output_1 (rtx *rtlp, void *data ATTRIBUTE_UNUSED)
13492 if (GET_CODE (rtl) == UNSPEC)
13494 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
13495 we can't express it in the debug info. */
13496 #ifdef ENABLE_CHECKING
13497 inform (current_function_decl
13498 ? DECL_SOURCE_LOCATION (current_function_decl)
13499 : UNKNOWN_LOCATION,
13500 "non-delegitimized UNSPEC %d found in variable location",
13503 expansion_failed (NULL_TREE, rtl,
13504 "UNSPEC hasn't been delegitimized.\n");
13508 if (GET_CODE (rtl) != SYMBOL_REF)
13511 if (CONSTANT_POOL_ADDRESS_P (rtl))
13514 get_pool_constant_mark (rtl, &marked);
13515 /* If all references to this pool constant were optimized away,
13516 it was not output and thus we can't represent it. */
13519 expansion_failed (NULL_TREE, rtl,
13520 "Constant was removed from constant pool.\n");
13525 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
13528 /* Avoid references to external symbols in debug info, on several targets
13529 the linker might even refuse to link when linking a shared library,
13530 and in many other cases the relocations for .debug_info/.debug_loc are
13531 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
13532 to be defined within the same shared library or executable are fine. */
13533 if (SYMBOL_REF_EXTERNAL_P (rtl))
13535 tree decl = SYMBOL_REF_DECL (rtl);
13537 if (decl == NULL || !targetm.binds_local_p (decl))
13539 expansion_failed (NULL_TREE, rtl,
13540 "Symbol not defined in current TU.\n");
13548 /* Return true if constant RTL can be emitted in DW_OP_addr or
13549 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
13550 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
13553 const_ok_for_output (rtx rtl)
13555 if (GET_CODE (rtl) == SYMBOL_REF)
13556 return const_ok_for_output_1 (&rtl, NULL) == 0;
13558 if (GET_CODE (rtl) == CONST)
13559 return for_each_rtx (&XEXP (rtl, 0), const_ok_for_output_1, NULL) == 0;
13564 /* The following routine converts the RTL for a variable or parameter
13565 (resident in memory) into an equivalent Dwarf representation of a
13566 mechanism for getting the address of that same variable onto the top of a
13567 hypothetical "address evaluation" stack.
13569 When creating memory location descriptors, we are effectively transforming
13570 the RTL for a memory-resident object into its Dwarf postfix expression
13571 equivalent. This routine recursively descends an RTL tree, turning
13572 it into Dwarf postfix code as it goes.
13574 MODE is the mode of the memory reference, needed to handle some
13575 autoincrement addressing modes.
13577 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
13578 location list for RTL.
13580 Return 0 if we can't represent the location. */
13582 static dw_loc_descr_ref
13583 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
13584 enum var_init_status initialized)
13586 dw_loc_descr_ref mem_loc_result = NULL;
13587 enum dwarf_location_atom op;
13588 dw_loc_descr_ref op0, op1;
13590 /* Note that for a dynamically sized array, the location we will generate a
13591 description of here will be the lowest numbered location which is
13592 actually within the array. That's *not* necessarily the same as the
13593 zeroth element of the array. */
13595 rtl = targetm.delegitimize_address (rtl);
13597 switch (GET_CODE (rtl))
13602 return mem_loc_descriptor (XEXP (rtl, 0), mode, initialized);
13605 /* The case of a subreg may arise when we have a local (register)
13606 variable or a formal (register) parameter which doesn't quite fill
13607 up an entire register. For now, just assume that it is
13608 legitimate to make the Dwarf info refer to the whole register which
13609 contains the given subreg. */
13610 if (!subreg_lowpart_p (rtl))
13612 rtl = SUBREG_REG (rtl);
13613 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
13615 if (GET_MODE_CLASS (GET_MODE (rtl)) != MODE_INT)
13617 mem_loc_result = mem_loc_descriptor (rtl, mode, initialized);
13621 /* Whenever a register number forms a part of the description of the
13622 method for calculating the (dynamic) address of a memory resident
13623 object, DWARF rules require the register number be referred to as
13624 a "base register". This distinction is not based in any way upon
13625 what category of register the hardware believes the given register
13626 belongs to. This is strictly DWARF terminology we're dealing with
13627 here. Note that in cases where the location of a memory-resident
13628 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
13629 OP_CONST (0)) the actual DWARF location descriptor that we generate
13630 may just be OP_BASEREG (basereg). This may look deceptively like
13631 the object in question was allocated to a register (rather than in
13632 memory) so DWARF consumers need to be aware of the subtle
13633 distinction between OP_REG and OP_BASEREG. */
13634 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
13635 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
13636 else if (stack_realign_drap
13638 && crtl->args.internal_arg_pointer == rtl
13639 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
13641 /* If RTL is internal_arg_pointer, which has been optimized
13642 out, use DRAP instead. */
13643 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
13644 VAR_INIT_STATUS_INITIALIZED);
13650 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13651 VAR_INIT_STATUS_INITIALIZED);
13656 int shift = DWARF2_ADDR_SIZE
13657 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
13658 shift *= BITS_PER_UNIT;
13659 if (GET_CODE (rtl) == SIGN_EXTEND)
13663 mem_loc_result = op0;
13664 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
13665 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
13666 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
13667 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13672 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
13673 VAR_INIT_STATUS_INITIALIZED);
13674 if (mem_loc_result == NULL)
13675 mem_loc_result = tls_mem_loc_descriptor (rtl);
13676 if (mem_loc_result != 0)
13678 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
13680 expansion_failed (NULL_TREE, rtl, "DWARF address size mismatch");
13683 else if (GET_MODE_SIZE (GET_MODE (rtl)) == DWARF2_ADDR_SIZE)
13684 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
13686 add_loc_descr (&mem_loc_result,
13687 new_loc_descr (DW_OP_deref_size,
13688 GET_MODE_SIZE (GET_MODE (rtl)), 0));
13692 rtx new_rtl = avoid_constant_pool_reference (rtl);
13693 if (new_rtl != rtl)
13694 return mem_loc_descriptor (new_rtl, mode, initialized);
13699 rtl = XEXP (rtl, 1);
13701 /* ... fall through ... */
13704 /* Some ports can transform a symbol ref into a label ref, because
13705 the symbol ref is too far away and has to be dumped into a constant
13709 if (GET_CODE (rtl) == SYMBOL_REF
13710 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
13712 dw_loc_descr_ref temp;
13714 /* If this is not defined, we have no way to emit the data. */
13715 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
13718 /* We used to emit DW_OP_addr here, but that's wrong, since
13719 DW_OP_addr should be relocated by the debug info consumer,
13720 while DW_OP_GNU_push_tls_address operand should not. */
13721 temp = new_loc_descr (DWARF2_ADDR_SIZE == 4
13722 ? DW_OP_const4u : DW_OP_const8u, 0, 0);
13723 temp->dw_loc_oprnd1.val_class = dw_val_class_addr;
13724 temp->dw_loc_oprnd1.v.val_addr = rtl;
13725 temp->dtprel = true;
13727 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
13728 add_loc_descr (&mem_loc_result, temp);
13733 if (!const_ok_for_output (rtl))
13737 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
13738 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
13739 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
13740 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
13746 case DEBUG_IMPLICIT_PTR:
13747 expansion_failed (NULL_TREE, rtl,
13748 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
13752 /* Extract the PLUS expression nested inside and fall into
13753 PLUS code below. */
13754 rtl = XEXP (rtl, 1);
13759 /* Turn these into a PLUS expression and fall into the PLUS code
13761 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
13762 GEN_INT (GET_CODE (rtl) == PRE_INC
13763 ? GET_MODE_UNIT_SIZE (mode)
13764 : -GET_MODE_UNIT_SIZE (mode)));
13766 /* ... fall through ... */
13770 if (is_based_loc (rtl))
13771 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
13772 INTVAL (XEXP (rtl, 1)),
13773 VAR_INIT_STATUS_INITIALIZED);
13776 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
13777 VAR_INIT_STATUS_INITIALIZED);
13778 if (mem_loc_result == 0)
13781 if (CONST_INT_P (XEXP (rtl, 1)))
13782 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
13785 dw_loc_descr_ref mem_loc_result2
13786 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13787 VAR_INIT_STATUS_INITIALIZED);
13788 if (mem_loc_result2 == 0)
13790 add_loc_descr (&mem_loc_result, mem_loc_result2);
13791 add_loc_descr (&mem_loc_result,
13792 new_loc_descr (DW_OP_plus, 0, 0));
13797 /* If a pseudo-reg is optimized away, it is possible for it to
13798 be replaced with a MEM containing a multiply or shift. */
13840 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13841 VAR_INIT_STATUS_INITIALIZED);
13842 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13843 VAR_INIT_STATUS_INITIALIZED);
13845 if (op0 == 0 || op1 == 0)
13848 mem_loc_result = op0;
13849 add_loc_descr (&mem_loc_result, op1);
13850 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13854 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13855 VAR_INIT_STATUS_INITIALIZED);
13856 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13857 VAR_INIT_STATUS_INITIALIZED);
13859 if (op0 == 0 || op1 == 0)
13862 mem_loc_result = op0;
13863 add_loc_descr (&mem_loc_result, op1);
13864 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13865 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13866 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
13867 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13868 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
13884 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13885 VAR_INIT_STATUS_INITIALIZED);
13890 mem_loc_result = op0;
13891 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13895 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13923 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
13924 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 1))) > DWARF2_ADDR_SIZE)
13928 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
13930 if (op_mode == VOIDmode)
13931 op_mode = GET_MODE (XEXP (rtl, 1));
13932 if (op_mode != VOIDmode && GET_MODE_CLASS (op_mode) != MODE_INT)
13935 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13936 VAR_INIT_STATUS_INITIALIZED);
13937 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13938 VAR_INIT_STATUS_INITIALIZED);
13940 if (op0 == 0 || op1 == 0)
13943 if (op_mode != VOIDmode
13944 && GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
13946 int shift = DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode);
13947 shift *= BITS_PER_UNIT;
13948 /* For eq/ne, if the operands are known to be zero-extended,
13949 there is no need to do the fancy shifting up. */
13950 if (op == DW_OP_eq || op == DW_OP_ne)
13952 dw_loc_descr_ref last0, last1;
13954 last0->dw_loc_next != NULL;
13955 last0 = last0->dw_loc_next)
13958 last1->dw_loc_next != NULL;
13959 last1 = last1->dw_loc_next)
13961 /* deref_size zero extends, and for constants we can check
13962 whether they are zero extended or not. */
13963 if (((last0->dw_loc_opc == DW_OP_deref_size
13964 && last0->dw_loc_oprnd1.v.val_int
13965 <= GET_MODE_SIZE (op_mode))
13966 || (CONST_INT_P (XEXP (rtl, 0))
13967 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
13968 == (INTVAL (XEXP (rtl, 0))
13969 & GET_MODE_MASK (op_mode))))
13970 && ((last1->dw_loc_opc == DW_OP_deref_size
13971 && last1->dw_loc_oprnd1.v.val_int
13972 <= GET_MODE_SIZE (op_mode))
13973 || (CONST_INT_P (XEXP (rtl, 1))
13974 && (unsigned HOST_WIDE_INT)
13975 INTVAL (XEXP (rtl, 1))
13976 == (INTVAL (XEXP (rtl, 1))
13977 & GET_MODE_MASK (op_mode)))))
13980 add_loc_descr (&op0, int_loc_descriptor (shift));
13981 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
13982 if (CONST_INT_P (XEXP (rtl, 1)))
13983 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
13986 add_loc_descr (&op1, int_loc_descriptor (shift));
13987 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
13993 mem_loc_result = op0;
13994 add_loc_descr (&mem_loc_result, op1);
13995 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13996 if (STORE_FLAG_VALUE != 1)
13998 add_loc_descr (&mem_loc_result,
13999 int_loc_descriptor (STORE_FLAG_VALUE));
14000 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
14021 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
14022 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 1))) > DWARF2_ADDR_SIZE)
14026 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
14028 if (op_mode == VOIDmode)
14029 op_mode = GET_MODE (XEXP (rtl, 1));
14030 if (op_mode != VOIDmode && GET_MODE_CLASS (op_mode) != MODE_INT)
14033 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
14034 VAR_INIT_STATUS_INITIALIZED);
14035 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
14036 VAR_INIT_STATUS_INITIALIZED);
14038 if (op0 == 0 || op1 == 0)
14041 if (op_mode != VOIDmode
14042 && GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
14044 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
14045 dw_loc_descr_ref last0, last1;
14047 last0->dw_loc_next != NULL;
14048 last0 = last0->dw_loc_next)
14051 last1->dw_loc_next != NULL;
14052 last1 = last1->dw_loc_next)
14054 if (CONST_INT_P (XEXP (rtl, 0)))
14055 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
14056 /* deref_size zero extends, so no need to mask it again. */
14057 else if (last0->dw_loc_opc != DW_OP_deref_size
14058 || last0->dw_loc_oprnd1.v.val_int
14059 > GET_MODE_SIZE (op_mode))
14061 add_loc_descr (&op0, int_loc_descriptor (mask));
14062 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14064 if (CONST_INT_P (XEXP (rtl, 1)))
14065 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
14066 /* deref_size zero extends, so no need to mask it again. */
14067 else if (last1->dw_loc_opc != DW_OP_deref_size
14068 || last1->dw_loc_oprnd1.v.val_int
14069 > GET_MODE_SIZE (op_mode))
14071 add_loc_descr (&op1, int_loc_descriptor (mask));
14072 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
14077 HOST_WIDE_INT bias = 1;
14078 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
14079 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14080 if (CONST_INT_P (XEXP (rtl, 1)))
14081 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
14082 + INTVAL (XEXP (rtl, 1)));
14084 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
14094 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
14095 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
14096 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
14099 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
14100 VAR_INIT_STATUS_INITIALIZED);
14101 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
14102 VAR_INIT_STATUS_INITIALIZED);
14104 if (op0 == 0 || op1 == 0)
14107 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
14108 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
14109 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
14110 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
14112 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
14114 HOST_WIDE_INT mask = GET_MODE_MASK (GET_MODE (XEXP (rtl, 0)));
14115 add_loc_descr (&op0, int_loc_descriptor (mask));
14116 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14117 add_loc_descr (&op1, int_loc_descriptor (mask));
14118 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
14122 HOST_WIDE_INT bias = 1;
14123 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
14124 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14125 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14128 else if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
14130 int shift = DWARF2_ADDR_SIZE
14131 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
14132 shift *= BITS_PER_UNIT;
14133 add_loc_descr (&op0, int_loc_descriptor (shift));
14134 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
14135 add_loc_descr (&op1, int_loc_descriptor (shift));
14136 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
14139 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
14143 mem_loc_result = op0;
14144 add_loc_descr (&mem_loc_result, op1);
14145 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14147 dw_loc_descr_ref bra_node, drop_node;
14149 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14150 add_loc_descr (&mem_loc_result, bra_node);
14151 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
14152 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
14153 add_loc_descr (&mem_loc_result, drop_node);
14154 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14155 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
14161 if (CONST_INT_P (XEXP (rtl, 1))
14162 && CONST_INT_P (XEXP (rtl, 2))
14163 && ((unsigned) INTVAL (XEXP (rtl, 1))
14164 + (unsigned) INTVAL (XEXP (rtl, 2))
14165 <= GET_MODE_BITSIZE (GET_MODE (rtl)))
14166 && GET_MODE_BITSIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
14167 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
14170 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
14171 VAR_INIT_STATUS_INITIALIZED);
14174 if (GET_CODE (rtl) == SIGN_EXTRACT)
14178 mem_loc_result = op0;
14179 size = INTVAL (XEXP (rtl, 1));
14180 shift = INTVAL (XEXP (rtl, 2));
14181 if (BITS_BIG_ENDIAN)
14182 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
14184 if (shift + size != (int) DWARF2_ADDR_SIZE)
14186 add_loc_descr (&mem_loc_result,
14187 int_loc_descriptor (DWARF2_ADDR_SIZE
14189 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
14191 if (size != (int) DWARF2_ADDR_SIZE)
14193 add_loc_descr (&mem_loc_result,
14194 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
14195 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14202 dw_loc_descr_ref op2, bra_node, drop_node;
14203 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
14204 VAR_INIT_STATUS_INITIALIZED);
14205 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
14206 VAR_INIT_STATUS_INITIALIZED);
14207 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode,
14208 VAR_INIT_STATUS_INITIALIZED);
14209 if (op0 == NULL || op1 == NULL || op2 == NULL)
14212 mem_loc_result = op1;
14213 add_loc_descr (&mem_loc_result, op2);
14214 add_loc_descr (&mem_loc_result, op0);
14215 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14216 add_loc_descr (&mem_loc_result, bra_node);
14217 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
14218 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
14219 add_loc_descr (&mem_loc_result, drop_node);
14220 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14221 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
14229 /* In theory, we could implement the above. */
14230 /* DWARF cannot represent the unsigned compare operations
14257 case FLOAT_TRUNCATE:
14259 case UNSIGNED_FLOAT:
14262 case FRACT_CONVERT:
14263 case UNSIGNED_FRACT_CONVERT:
14265 case UNSIGNED_SAT_FRACT:
14277 case VEC_DUPLICATE:
14280 /* If delegitimize_address couldn't do anything with the UNSPEC, we
14281 can't express it in the debug info. This can happen e.g. with some
14286 resolve_one_addr (&rtl, NULL);
14290 #ifdef ENABLE_CHECKING
14291 print_rtl (stderr, rtl);
14292 gcc_unreachable ();
14298 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
14299 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14301 return mem_loc_result;
14304 /* Return a descriptor that describes the concatenation of two locations.
14305 This is typically a complex variable. */
14307 static dw_loc_descr_ref
14308 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
14310 dw_loc_descr_ref cc_loc_result = NULL;
14311 dw_loc_descr_ref x0_ref
14312 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14313 dw_loc_descr_ref x1_ref
14314 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14316 if (x0_ref == 0 || x1_ref == 0)
14319 cc_loc_result = x0_ref;
14320 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
14322 add_loc_descr (&cc_loc_result, x1_ref);
14323 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
14325 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
14326 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14328 return cc_loc_result;
14331 /* Return a descriptor that describes the concatenation of N
14334 static dw_loc_descr_ref
14335 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
14338 dw_loc_descr_ref cc_loc_result = NULL;
14339 unsigned int n = XVECLEN (concatn, 0);
14341 for (i = 0; i < n; ++i)
14343 dw_loc_descr_ref ref;
14344 rtx x = XVECEXP (concatn, 0, i);
14346 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14350 add_loc_descr (&cc_loc_result, ref);
14351 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
14354 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
14355 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14357 return cc_loc_result;
14360 /* Helper function for loc_descriptor. Return DW_OP_GNU_implicit_pointer
14361 for DEBUG_IMPLICIT_PTR RTL. */
14363 static dw_loc_descr_ref
14364 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
14366 dw_loc_descr_ref ret;
14371 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
14372 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
14373 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
14374 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
14375 ret = new_loc_descr (DW_OP_GNU_implicit_pointer, 0, offset);
14376 ret->dw_loc_oprnd2.val_class = dw_val_class_const;
14379 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14380 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
14381 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
14385 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
14386 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl);
14391 /* Output a proper Dwarf location descriptor for a variable or parameter
14392 which is either allocated in a register or in a memory location. For a
14393 register, we just generate an OP_REG and the register number. For a
14394 memory location we provide a Dwarf postfix expression describing how to
14395 generate the (dynamic) address of the object onto the address stack.
14397 MODE is mode of the decl if this loc_descriptor is going to be used in
14398 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
14399 allowed, VOIDmode otherwise.
14401 If we don't know how to describe it, return 0. */
14403 static dw_loc_descr_ref
14404 loc_descriptor (rtx rtl, enum machine_mode mode,
14405 enum var_init_status initialized)
14407 dw_loc_descr_ref loc_result = NULL;
14409 switch (GET_CODE (rtl))
14412 /* The case of a subreg may arise when we have a local (register)
14413 variable or a formal (register) parameter which doesn't quite fill
14414 up an entire register. For now, just assume that it is
14415 legitimate to make the Dwarf info refer to the whole register which
14416 contains the given subreg. */
14417 loc_result = loc_descriptor (SUBREG_REG (rtl), mode, initialized);
14421 loc_result = reg_loc_descriptor (rtl, initialized);
14425 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
14427 if (loc_result == NULL)
14428 loc_result = tls_mem_loc_descriptor (rtl);
14429 if (loc_result == NULL)
14431 rtx new_rtl = avoid_constant_pool_reference (rtl);
14432 if (new_rtl != rtl)
14433 loc_result = loc_descriptor (new_rtl, mode, initialized);
14438 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
14443 loc_result = concatn_loc_descriptor (rtl, initialized);
14448 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
14450 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
14451 if (GET_CODE (loc) == EXPR_LIST)
14452 loc = XEXP (loc, 0);
14453 loc_result = loc_descriptor (loc, mode, initialized);
14457 rtl = XEXP (rtl, 1);
14462 rtvec par_elems = XVEC (rtl, 0);
14463 int num_elem = GET_NUM_ELEM (par_elems);
14464 enum machine_mode mode;
14467 /* Create the first one, so we have something to add to. */
14468 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
14469 VOIDmode, initialized);
14470 if (loc_result == NULL)
14472 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
14473 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
14474 for (i = 1; i < num_elem; i++)
14476 dw_loc_descr_ref temp;
14478 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
14479 VOIDmode, initialized);
14482 add_loc_descr (&loc_result, temp);
14483 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
14484 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
14490 if (mode != VOIDmode && mode != BLKmode)
14491 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
14496 if (mode == VOIDmode)
14497 mode = GET_MODE (rtl);
14499 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
14501 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
14503 /* Note that a CONST_DOUBLE rtx could represent either an integer
14504 or a floating-point constant. A CONST_DOUBLE is used whenever
14505 the constant requires more than one word in order to be
14506 adequately represented. We output CONST_DOUBLEs as blocks. */
14507 loc_result = new_loc_descr (DW_OP_implicit_value,
14508 GET_MODE_SIZE (mode), 0);
14509 if (SCALAR_FLOAT_MODE_P (mode))
14511 unsigned int length = GET_MODE_SIZE (mode);
14512 unsigned char *array
14513 = (unsigned char*) ggc_alloc_atomic (length);
14515 insert_float (rtl, array);
14516 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
14517 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
14518 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
14519 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
14523 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
14524 loc_result->dw_loc_oprnd2.v.val_double
14525 = rtx_to_double_int (rtl);
14531 if (mode == VOIDmode)
14532 mode = GET_MODE (rtl);
14534 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
14536 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
14537 unsigned int length = CONST_VECTOR_NUNITS (rtl);
14538 unsigned char *array = (unsigned char *)
14539 ggc_alloc_atomic (length * elt_size);
14543 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
14544 switch (GET_MODE_CLASS (mode))
14546 case MODE_VECTOR_INT:
14547 for (i = 0, p = array; i < length; i++, p += elt_size)
14549 rtx elt = CONST_VECTOR_ELT (rtl, i);
14550 double_int val = rtx_to_double_int (elt);
14552 if (elt_size <= sizeof (HOST_WIDE_INT))
14553 insert_int (double_int_to_shwi (val), elt_size, p);
14556 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
14557 insert_double (val, p);
14562 case MODE_VECTOR_FLOAT:
14563 for (i = 0, p = array; i < length; i++, p += elt_size)
14565 rtx elt = CONST_VECTOR_ELT (rtl, i);
14566 insert_float (elt, p);
14571 gcc_unreachable ();
14574 loc_result = new_loc_descr (DW_OP_implicit_value,
14575 length * elt_size, 0);
14576 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
14577 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
14578 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
14579 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
14584 if (mode == VOIDmode
14585 || GET_CODE (XEXP (rtl, 0)) == CONST_INT
14586 || GET_CODE (XEXP (rtl, 0)) == CONST_DOUBLE
14587 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
14589 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
14594 if (!const_ok_for_output (rtl))
14597 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
14598 && (dwarf_version >= 4 || !dwarf_strict))
14600 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
14601 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
14602 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
14603 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
14604 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
14608 case DEBUG_IMPLICIT_PTR:
14609 loc_result = implicit_ptr_descriptor (rtl, 0);
14613 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR
14614 && CONST_INT_P (XEXP (rtl, 1)))
14617 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1)));
14622 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
14623 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
14624 && (dwarf_version >= 4 || !dwarf_strict))
14626 /* Value expression. */
14627 loc_result = mem_loc_descriptor (rtl, VOIDmode, initialized);
14629 add_loc_descr (&loc_result,
14630 new_loc_descr (DW_OP_stack_value, 0, 0));
14638 /* We need to figure out what section we should use as the base for the
14639 address ranges where a given location is valid.
14640 1. If this particular DECL has a section associated with it, use that.
14641 2. If this function has a section associated with it, use that.
14642 3. Otherwise, use the text section.
14643 XXX: If you split a variable across multiple sections, we won't notice. */
14645 static const char *
14646 secname_for_decl (const_tree decl)
14648 const char *secname;
14650 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
14652 tree sectree = DECL_SECTION_NAME (decl);
14653 secname = TREE_STRING_POINTER (sectree);
14655 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
14657 tree sectree = DECL_SECTION_NAME (current_function_decl);
14658 secname = TREE_STRING_POINTER (sectree);
14660 else if (cfun && in_cold_section_p)
14661 secname = crtl->subsections.cold_section_label;
14663 secname = text_section_label;
14668 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
14671 decl_by_reference_p (tree decl)
14673 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
14674 || TREE_CODE (decl) == VAR_DECL)
14675 && DECL_BY_REFERENCE (decl));
14678 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14681 static dw_loc_descr_ref
14682 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
14683 enum var_init_status initialized)
14685 int have_address = 0;
14686 dw_loc_descr_ref descr;
14687 enum machine_mode mode;
14689 if (want_address != 2)
14691 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
14693 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
14695 varloc = PAT_VAR_LOCATION_LOC (varloc);
14696 if (GET_CODE (varloc) == EXPR_LIST)
14697 varloc = XEXP (varloc, 0);
14698 mode = GET_MODE (varloc);
14699 if (MEM_P (varloc))
14701 rtx addr = XEXP (varloc, 0);
14702 descr = mem_loc_descriptor (addr, mode, initialized);
14707 rtx x = avoid_constant_pool_reference (varloc);
14709 descr = mem_loc_descriptor (x, mode, initialized);
14713 descr = mem_loc_descriptor (varloc, mode, initialized);
14720 if (GET_CODE (varloc) == VAR_LOCATION)
14721 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
14723 mode = DECL_MODE (loc);
14724 descr = loc_descriptor (varloc, mode, initialized);
14731 if (want_address == 2 && !have_address
14732 && (dwarf_version >= 4 || !dwarf_strict))
14734 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
14736 expansion_failed (loc, NULL_RTX,
14737 "DWARF address size mismatch");
14740 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
14743 /* Show if we can't fill the request for an address. */
14744 if (want_address && !have_address)
14746 expansion_failed (loc, NULL_RTX,
14747 "Want address and only have value");
14751 /* If we've got an address and don't want one, dereference. */
14752 if (!want_address && have_address)
14754 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
14755 enum dwarf_location_atom op;
14757 if (size > DWARF2_ADDR_SIZE || size == -1)
14759 expansion_failed (loc, NULL_RTX,
14760 "DWARF address size mismatch");
14763 else if (size == DWARF2_ADDR_SIZE)
14766 op = DW_OP_deref_size;
14768 add_loc_descr (&descr, new_loc_descr (op, size, 0));
14774 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
14775 if it is not possible. */
14777 static dw_loc_descr_ref
14778 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
14780 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
14781 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
14782 else if (dwarf_version >= 3 || !dwarf_strict)
14783 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
14788 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14789 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
14791 static dw_loc_descr_ref
14792 dw_sra_loc_expr (tree decl, rtx loc)
14795 unsigned int padsize = 0;
14796 dw_loc_descr_ref descr, *descr_tail;
14797 unsigned HOST_WIDE_INT decl_size;
14799 enum var_init_status initialized;
14801 if (DECL_SIZE (decl) == NULL
14802 || !host_integerp (DECL_SIZE (decl), 1))
14805 decl_size = tree_low_cst (DECL_SIZE (decl), 1);
14807 descr_tail = &descr;
14809 for (p = loc; p; p = XEXP (p, 1))
14811 unsigned int bitsize = decl_piece_bitsize (p);
14812 rtx loc_note = *decl_piece_varloc_ptr (p);
14813 dw_loc_descr_ref cur_descr;
14814 dw_loc_descr_ref *tail, last = NULL;
14815 unsigned int opsize = 0;
14817 if (loc_note == NULL_RTX
14818 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
14820 padsize += bitsize;
14823 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
14824 varloc = NOTE_VAR_LOCATION (loc_note);
14825 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
14826 if (cur_descr == NULL)
14828 padsize += bitsize;
14832 /* Check that cur_descr either doesn't use
14833 DW_OP_*piece operations, or their sum is equal
14834 to bitsize. Otherwise we can't embed it. */
14835 for (tail = &cur_descr; *tail != NULL;
14836 tail = &(*tail)->dw_loc_next)
14837 if ((*tail)->dw_loc_opc == DW_OP_piece)
14839 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
14843 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
14845 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
14849 if (last != NULL && opsize != bitsize)
14851 padsize += bitsize;
14855 /* If there is a hole, add DW_OP_*piece after empty DWARF
14856 expression, which means that those bits are optimized out. */
14859 if (padsize > decl_size)
14861 decl_size -= padsize;
14862 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
14863 if (*descr_tail == NULL)
14865 descr_tail = &(*descr_tail)->dw_loc_next;
14868 *descr_tail = cur_descr;
14870 if (bitsize > decl_size)
14872 decl_size -= bitsize;
14875 HOST_WIDE_INT offset = 0;
14876 if (GET_CODE (varloc) == VAR_LOCATION
14877 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
14879 varloc = PAT_VAR_LOCATION_LOC (varloc);
14880 if (GET_CODE (varloc) == EXPR_LIST)
14881 varloc = XEXP (varloc, 0);
14885 if (GET_CODE (varloc) == CONST
14886 || GET_CODE (varloc) == SIGN_EXTEND
14887 || GET_CODE (varloc) == ZERO_EXTEND)
14888 varloc = XEXP (varloc, 0);
14889 else if (GET_CODE (varloc) == SUBREG)
14890 varloc = SUBREG_REG (varloc);
14895 /* DW_OP_bit_size offset should be zero for register
14896 or implicit location descriptions and empty location
14897 descriptions, but for memory addresses needs big endian
14899 if (MEM_P (varloc))
14901 unsigned HOST_WIDE_INT memsize
14902 = INTVAL (MEM_SIZE (varloc)) * BITS_PER_UNIT;
14903 if (memsize != bitsize)
14905 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
14906 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
14908 if (memsize < bitsize)
14910 if (BITS_BIG_ENDIAN)
14911 offset = memsize - bitsize;
14915 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
14916 if (*descr_tail == NULL)
14918 descr_tail = &(*descr_tail)->dw_loc_next;
14922 /* If there were any non-empty expressions, add padding till the end of
14924 if (descr != NULL && decl_size != 0)
14926 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
14927 if (*descr_tail == NULL)
14933 /* Return the dwarf representation of the location list LOC_LIST of
14934 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14937 static dw_loc_list_ref
14938 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
14940 const char *endname, *secname;
14942 enum var_init_status initialized;
14943 struct var_loc_node *node;
14944 dw_loc_descr_ref descr;
14945 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
14946 dw_loc_list_ref list = NULL;
14947 dw_loc_list_ref *listp = &list;
14949 /* Now that we know what section we are using for a base,
14950 actually construct the list of locations.
14951 The first location information is what is passed to the
14952 function that creates the location list, and the remaining
14953 locations just get added on to that list.
14954 Note that we only know the start address for a location
14955 (IE location changes), so to build the range, we use
14956 the range [current location start, next location start].
14957 This means we have to special case the last node, and generate
14958 a range of [last location start, end of function label]. */
14960 secname = secname_for_decl (decl);
14962 for (node = loc_list->first; node; node = node->next)
14963 if (GET_CODE (node->loc) == EXPR_LIST
14964 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
14966 if (GET_CODE (node->loc) == EXPR_LIST)
14968 /* This requires DW_OP_{,bit_}piece, which is not usable
14969 inside DWARF expressions. */
14970 if (want_address != 2)
14972 descr = dw_sra_loc_expr (decl, node->loc);
14978 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14979 varloc = NOTE_VAR_LOCATION (node->loc);
14980 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
14984 /* The variable has a location between NODE->LABEL and
14985 NODE->NEXT->LABEL. */
14987 endname = node->next->label;
14988 /* If the variable has a location at the last label
14989 it keeps its location until the end of function. */
14990 else if (!current_function_decl)
14991 endname = text_end_label;
14994 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
14995 current_function_funcdef_no);
14996 endname = ggc_strdup (label_id);
14999 *listp = new_loc_list (descr, node->label, endname, secname);
15000 listp = &(*listp)->dw_loc_next;
15004 /* Try to avoid the overhead of a location list emitting a location
15005 expression instead, but only if we didn't have more than one
15006 location entry in the first place. If some entries were not
15007 representable, we don't want to pretend a single entry that was
15008 applies to the entire scope in which the variable is
15010 if (list && loc_list->first->next)
15016 /* Return if the loc_list has only single element and thus can be represented
15017 as location description. */
15020 single_element_loc_list_p (dw_loc_list_ref list)
15022 gcc_assert (!list->dw_loc_next || list->ll_symbol);
15023 return !list->ll_symbol;
15026 /* To each location in list LIST add loc descr REF. */
15029 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
15031 dw_loc_descr_ref copy;
15032 add_loc_descr (&list->expr, ref);
15033 list = list->dw_loc_next;
15036 copy = ggc_alloc_dw_loc_descr_node ();
15037 memcpy (copy, ref, sizeof (dw_loc_descr_node));
15038 add_loc_descr (&list->expr, copy);
15039 while (copy->dw_loc_next)
15041 dw_loc_descr_ref new_copy = ggc_alloc_dw_loc_descr_node ();
15042 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
15043 copy->dw_loc_next = new_copy;
15046 list = list->dw_loc_next;
15050 /* Given two lists RET and LIST
15051 produce location list that is result of adding expression in LIST
15052 to expression in RET on each possition in program.
15053 Might be destructive on both RET and LIST.
15055 TODO: We handle only simple cases of RET or LIST having at most one
15056 element. General case would inolve sorting the lists in program order
15057 and merging them that will need some additional work.
15058 Adding that will improve quality of debug info especially for SRA-ed
15062 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
15071 if (!list->dw_loc_next)
15073 add_loc_descr_to_each (*ret, list->expr);
15076 if (!(*ret)->dw_loc_next)
15078 add_loc_descr_to_each (list, (*ret)->expr);
15082 expansion_failed (NULL_TREE, NULL_RTX,
15083 "Don't know how to merge two non-trivial"
15084 " location lists.\n");
15089 /* LOC is constant expression. Try a luck, look it up in constant
15090 pool and return its loc_descr of its address. */
15092 static dw_loc_descr_ref
15093 cst_pool_loc_descr (tree loc)
15095 /* Get an RTL for this, if something has been emitted. */
15096 rtx rtl = lookup_constant_def (loc);
15097 enum machine_mode mode;
15099 if (!rtl || !MEM_P (rtl))
15104 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
15106 /* TODO: We might get more coverage if we was actually delaying expansion
15107 of all expressions till end of compilation when constant pools are fully
15109 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
15111 expansion_failed (loc, NULL_RTX,
15112 "CST value in contant pool but not marked.");
15115 mode = GET_MODE (rtl);
15116 rtl = XEXP (rtl, 0);
15117 return mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
15120 /* Return dw_loc_list representing address of addr_expr LOC
15121 by looking for innder INDIRECT_REF expression and turing it
15122 into simple arithmetics. */
15124 static dw_loc_list_ref
15125 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev)
15128 HOST_WIDE_INT bitsize, bitpos, bytepos;
15129 enum machine_mode mode;
15131 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
15132 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
15134 obj = get_inner_reference (TREE_OPERAND (loc, 0),
15135 &bitsize, &bitpos, &offset, &mode,
15136 &unsignedp, &volatilep, false);
15138 if (bitpos % BITS_PER_UNIT)
15140 expansion_failed (loc, NULL_RTX, "bitfield access");
15143 if (!INDIRECT_REF_P (obj))
15145 expansion_failed (obj,
15146 NULL_RTX, "no indirect ref in inner refrence");
15149 if (!offset && !bitpos)
15150 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1);
15152 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
15153 && (dwarf_version >= 4 || !dwarf_strict))
15155 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0);
15160 /* Variable offset. */
15161 list_ret1 = loc_list_from_tree (offset, 0);
15162 if (list_ret1 == 0)
15164 add_loc_list (&list_ret, list_ret1);
15167 add_loc_descr_to_each (list_ret,
15168 new_loc_descr (DW_OP_plus, 0, 0));
15170 bytepos = bitpos / BITS_PER_UNIT;
15172 add_loc_descr_to_each (list_ret,
15173 new_loc_descr (DW_OP_plus_uconst,
15175 else if (bytepos < 0)
15176 loc_list_plus_const (list_ret, bytepos);
15177 add_loc_descr_to_each (list_ret,
15178 new_loc_descr (DW_OP_stack_value, 0, 0));
15184 /* Generate Dwarf location list representing LOC.
15185 If WANT_ADDRESS is false, expression computing LOC will be computed
15186 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
15187 if WANT_ADDRESS is 2, expression computing address useable in location
15188 will be returned (i.e. DW_OP_reg can be used
15189 to refer to register values). */
15191 static dw_loc_list_ref
15192 loc_list_from_tree (tree loc, int want_address)
15194 dw_loc_descr_ref ret = NULL, ret1 = NULL;
15195 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
15196 int have_address = 0;
15197 enum dwarf_location_atom op;
15199 /* ??? Most of the time we do not take proper care for sign/zero
15200 extending the values properly. Hopefully this won't be a real
15203 switch (TREE_CODE (loc))
15206 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
15209 case PLACEHOLDER_EXPR:
15210 /* This case involves extracting fields from an object to determine the
15211 position of other fields. We don't try to encode this here. The
15212 only user of this is Ada, which encodes the needed information using
15213 the names of types. */
15214 expansion_failed (loc, NULL_RTX, "PLACEHOLDER_EXPR");
15218 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
15219 /* There are no opcodes for these operations. */
15222 case PREINCREMENT_EXPR:
15223 case PREDECREMENT_EXPR:
15224 case POSTINCREMENT_EXPR:
15225 case POSTDECREMENT_EXPR:
15226 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
15227 /* There are no opcodes for these operations. */
15231 /* If we already want an address, see if there is INDIRECT_REF inside
15232 e.g. for &this->field. */
15235 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
15236 (loc, want_address == 2);
15239 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
15240 && (ret = cst_pool_loc_descr (loc)))
15243 /* Otherwise, process the argument and look for the address. */
15244 if (!list_ret && !ret)
15245 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1);
15249 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
15255 if (DECL_THREAD_LOCAL_P (loc))
15258 enum dwarf_location_atom first_op;
15259 enum dwarf_location_atom second_op;
15260 bool dtprel = false;
15262 if (targetm.have_tls)
15264 /* If this is not defined, we have no way to emit the
15266 if (!targetm.asm_out.output_dwarf_dtprel)
15269 /* The way DW_OP_GNU_push_tls_address is specified, we
15270 can only look up addresses of objects in the current
15271 module. We used DW_OP_addr as first op, but that's
15272 wrong, because DW_OP_addr is relocated by the debug
15273 info consumer, while DW_OP_GNU_push_tls_address
15274 operand shouldn't be. */
15275 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
15277 first_op = DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u;
15279 second_op = DW_OP_GNU_push_tls_address;
15283 if (!targetm.emutls.debug_form_tls_address
15284 || !(dwarf_version >= 3 || !dwarf_strict))
15286 /* We stuffed the control variable into the DECL_VALUE_EXPR
15287 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
15288 no longer appear in gimple code. We used the control
15289 variable in specific so that we could pick it up here. */
15290 loc = DECL_VALUE_EXPR (loc);
15291 first_op = DW_OP_addr;
15292 second_op = DW_OP_form_tls_address;
15295 rtl = rtl_for_decl_location (loc);
15296 if (rtl == NULL_RTX)
15301 rtl = XEXP (rtl, 0);
15302 if (! CONSTANT_P (rtl))
15305 ret = new_loc_descr (first_op, 0, 0);
15306 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
15307 ret->dw_loc_oprnd1.v.val_addr = rtl;
15308 ret->dtprel = dtprel;
15310 ret1 = new_loc_descr (second_op, 0, 0);
15311 add_loc_descr (&ret, ret1);
15319 if (DECL_HAS_VALUE_EXPR_P (loc))
15320 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
15325 case FUNCTION_DECL:
15328 var_loc_list *loc_list = lookup_decl_loc (loc);
15330 if (loc_list && loc_list->first)
15332 list_ret = dw_loc_list (loc_list, loc, want_address);
15333 have_address = want_address != 0;
15336 rtl = rtl_for_decl_location (loc);
15337 if (rtl == NULL_RTX)
15339 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
15342 else if (CONST_INT_P (rtl))
15344 HOST_WIDE_INT val = INTVAL (rtl);
15345 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
15346 val &= GET_MODE_MASK (DECL_MODE (loc));
15347 ret = int_loc_descriptor (val);
15349 else if (GET_CODE (rtl) == CONST_STRING)
15351 expansion_failed (loc, NULL_RTX, "CONST_STRING");
15354 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
15356 ret = new_loc_descr (DW_OP_addr, 0, 0);
15357 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
15358 ret->dw_loc_oprnd1.v.val_addr = rtl;
15362 enum machine_mode mode;
15364 /* Certain constructs can only be represented at top-level. */
15365 if (want_address == 2)
15367 ret = loc_descriptor (rtl, VOIDmode,
15368 VAR_INIT_STATUS_INITIALIZED);
15373 mode = GET_MODE (rtl);
15376 rtl = XEXP (rtl, 0);
15379 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
15382 expansion_failed (loc, rtl,
15383 "failed to produce loc descriptor for rtl");
15390 if (!integer_zerop (TREE_OPERAND (loc, 1)))
15394 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15398 case COMPOUND_EXPR:
15399 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address);
15402 case VIEW_CONVERT_EXPR:
15405 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address);
15407 case COMPONENT_REF:
15408 case BIT_FIELD_REF:
15410 case ARRAY_RANGE_REF:
15411 case REALPART_EXPR:
15412 case IMAGPART_EXPR:
15415 HOST_WIDE_INT bitsize, bitpos, bytepos;
15416 enum machine_mode mode;
15418 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
15420 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
15421 &unsignedp, &volatilep, false);
15423 gcc_assert (obj != loc);
15425 list_ret = loc_list_from_tree (obj,
15427 && !bitpos && !offset ? 2 : 1);
15428 /* TODO: We can extract value of the small expression via shifting even
15429 for nonzero bitpos. */
15432 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
15434 expansion_failed (loc, NULL_RTX,
15435 "bitfield access");
15439 if (offset != NULL_TREE)
15441 /* Variable offset. */
15442 list_ret1 = loc_list_from_tree (offset, 0);
15443 if (list_ret1 == 0)
15445 add_loc_list (&list_ret, list_ret1);
15448 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
15451 bytepos = bitpos / BITS_PER_UNIT;
15453 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
15454 else if (bytepos < 0)
15455 loc_list_plus_const (list_ret, bytepos);
15462 if ((want_address || !host_integerp (loc, 0))
15463 && (ret = cst_pool_loc_descr (loc)))
15465 else if (want_address == 2
15466 && host_integerp (loc, 0)
15467 && (ret = address_of_int_loc_descriptor
15468 (int_size_in_bytes (TREE_TYPE (loc)),
15469 tree_low_cst (loc, 0))))
15471 else if (host_integerp (loc, 0))
15472 ret = int_loc_descriptor (tree_low_cst (loc, 0));
15475 expansion_failed (loc, NULL_RTX,
15476 "Integer operand is not host integer");
15485 if ((ret = cst_pool_loc_descr (loc)))
15488 /* We can construct small constants here using int_loc_descriptor. */
15489 expansion_failed (loc, NULL_RTX,
15490 "constructor or constant not in constant pool");
15493 case TRUTH_AND_EXPR:
15494 case TRUTH_ANDIF_EXPR:
15499 case TRUTH_XOR_EXPR:
15504 case TRUTH_OR_EXPR:
15505 case TRUTH_ORIF_EXPR:
15510 case FLOOR_DIV_EXPR:
15511 case CEIL_DIV_EXPR:
15512 case ROUND_DIV_EXPR:
15513 case TRUNC_DIV_EXPR:
15514 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
15523 case FLOOR_MOD_EXPR:
15524 case CEIL_MOD_EXPR:
15525 case ROUND_MOD_EXPR:
15526 case TRUNC_MOD_EXPR:
15527 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
15532 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15533 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
15534 if (list_ret == 0 || list_ret1 == 0)
15537 add_loc_list (&list_ret, list_ret1);
15540 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
15541 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
15542 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
15543 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
15544 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
15556 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
15559 case POINTER_PLUS_EXPR:
15561 if (host_integerp (TREE_OPERAND (loc, 1), 0))
15563 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15567 loc_list_plus_const (list_ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
15575 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15582 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15589 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15596 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15611 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15612 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
15613 if (list_ret == 0 || list_ret1 == 0)
15616 add_loc_list (&list_ret, list_ret1);
15619 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
15622 case TRUTH_NOT_EXPR:
15636 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15640 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
15646 const enum tree_code code =
15647 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
15649 loc = build3 (COND_EXPR, TREE_TYPE (loc),
15650 build2 (code, integer_type_node,
15651 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
15652 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
15655 /* ... fall through ... */
15659 dw_loc_descr_ref lhs
15660 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
15661 dw_loc_list_ref rhs
15662 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0);
15663 dw_loc_descr_ref bra_node, jump_node, tmp;
15665 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15666 if (list_ret == 0 || lhs == 0 || rhs == 0)
15669 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
15670 add_loc_descr_to_each (list_ret, bra_node);
15672 add_loc_list (&list_ret, rhs);
15673 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
15674 add_loc_descr_to_each (list_ret, jump_node);
15676 add_loc_descr_to_each (list_ret, lhs);
15677 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
15678 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
15680 /* ??? Need a node to point the skip at. Use a nop. */
15681 tmp = new_loc_descr (DW_OP_nop, 0, 0);
15682 add_loc_descr_to_each (list_ret, tmp);
15683 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
15684 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
15688 case FIX_TRUNC_EXPR:
15692 /* Leave front-end specific codes as simply unknown. This comes
15693 up, for instance, with the C STMT_EXPR. */
15694 if ((unsigned int) TREE_CODE (loc)
15695 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
15697 expansion_failed (loc, NULL_RTX,
15698 "language specific tree node");
15702 #ifdef ENABLE_CHECKING
15703 /* Otherwise this is a generic code; we should just lists all of
15704 these explicitly. We forgot one. */
15705 gcc_unreachable ();
15707 /* In a release build, we want to degrade gracefully: better to
15708 generate incomplete debugging information than to crash. */
15713 if (!ret && !list_ret)
15716 if (want_address == 2 && !have_address
15717 && (dwarf_version >= 4 || !dwarf_strict))
15719 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
15721 expansion_failed (loc, NULL_RTX,
15722 "DWARF address size mismatch");
15726 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
15728 add_loc_descr_to_each (list_ret,
15729 new_loc_descr (DW_OP_stack_value, 0, 0));
15732 /* Show if we can't fill the request for an address. */
15733 if (want_address && !have_address)
15735 expansion_failed (loc, NULL_RTX,
15736 "Want address and only have value");
15740 gcc_assert (!ret || !list_ret);
15742 /* If we've got an address and don't want one, dereference. */
15743 if (!want_address && have_address)
15745 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
15747 if (size > DWARF2_ADDR_SIZE || size == -1)
15749 expansion_failed (loc, NULL_RTX,
15750 "DWARF address size mismatch");
15753 else if (size == DWARF2_ADDR_SIZE)
15756 op = DW_OP_deref_size;
15759 add_loc_descr (&ret, new_loc_descr (op, size, 0));
15761 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
15764 list_ret = new_loc_list (ret, NULL, NULL, NULL);
15769 /* Same as above but return only single location expression. */
15770 static dw_loc_descr_ref
15771 loc_descriptor_from_tree (tree loc, int want_address)
15773 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address);
15776 if (ret->dw_loc_next)
15778 expansion_failed (loc, NULL_RTX,
15779 "Location list where only loc descriptor needed");
15785 /* Given a value, round it up to the lowest multiple of `boundary'
15786 which is not less than the value itself. */
15788 static inline HOST_WIDE_INT
15789 ceiling (HOST_WIDE_INT value, unsigned int boundary)
15791 return (((value + boundary - 1) / boundary) * boundary);
15794 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
15795 pointer to the declared type for the relevant field variable, or return
15796 `integer_type_node' if the given node turns out to be an
15797 ERROR_MARK node. */
15800 field_type (const_tree decl)
15804 if (TREE_CODE (decl) == ERROR_MARK)
15805 return integer_type_node;
15807 type = DECL_BIT_FIELD_TYPE (decl);
15808 if (type == NULL_TREE)
15809 type = TREE_TYPE (decl);
15814 /* Given a pointer to a tree node, return the alignment in bits for
15815 it, or else return BITS_PER_WORD if the node actually turns out to
15816 be an ERROR_MARK node. */
15818 static inline unsigned
15819 simple_type_align_in_bits (const_tree type)
15821 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
15824 static inline unsigned
15825 simple_decl_align_in_bits (const_tree decl)
15827 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
15830 /* Return the result of rounding T up to ALIGN. */
15832 static inline double_int
15833 round_up_to_align (double_int t, unsigned int align)
15835 double_int alignd = uhwi_to_double_int (align);
15836 t = double_int_add (t, alignd);
15837 t = double_int_add (t, double_int_minus_one);
15838 t = double_int_div (t, alignd, true, TRUNC_DIV_EXPR);
15839 t = double_int_mul (t, alignd);
15843 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
15844 lowest addressed byte of the "containing object" for the given FIELD_DECL,
15845 or return 0 if we are unable to determine what that offset is, either
15846 because the argument turns out to be a pointer to an ERROR_MARK node, or
15847 because the offset is actually variable. (We can't handle the latter case
15850 static HOST_WIDE_INT
15851 field_byte_offset (const_tree decl)
15853 double_int object_offset_in_bits;
15854 double_int object_offset_in_bytes;
15855 double_int bitpos_int;
15857 if (TREE_CODE (decl) == ERROR_MARK)
15860 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
15862 /* We cannot yet cope with fields whose positions are variable, so
15863 for now, when we see such things, we simply return 0. Someday, we may
15864 be able to handle such cases, but it will be damn difficult. */
15865 if (TREE_CODE (bit_position (decl)) != INTEGER_CST)
15868 bitpos_int = tree_to_double_int (bit_position (decl));
15870 #ifdef PCC_BITFIELD_TYPE_MATTERS
15871 if (PCC_BITFIELD_TYPE_MATTERS)
15874 tree field_size_tree;
15875 double_int deepest_bitpos;
15876 double_int field_size_in_bits;
15877 unsigned int type_align_in_bits;
15878 unsigned int decl_align_in_bits;
15879 double_int type_size_in_bits;
15881 type = field_type (decl);
15882 type_size_in_bits = double_int_type_size_in_bits (type);
15883 type_align_in_bits = simple_type_align_in_bits (type);
15885 field_size_tree = DECL_SIZE (decl);
15887 /* The size could be unspecified if there was an error, or for
15888 a flexible array member. */
15889 if (!field_size_tree)
15890 field_size_tree = bitsize_zero_node;
15892 /* If the size of the field is not constant, use the type size. */
15893 if (TREE_CODE (field_size_tree) == INTEGER_CST)
15894 field_size_in_bits = tree_to_double_int (field_size_tree);
15896 field_size_in_bits = type_size_in_bits;
15898 decl_align_in_bits = simple_decl_align_in_bits (decl);
15900 /* The GCC front-end doesn't make any attempt to keep track of the
15901 starting bit offset (relative to the start of the containing
15902 structure type) of the hypothetical "containing object" for a
15903 bit-field. Thus, when computing the byte offset value for the
15904 start of the "containing object" of a bit-field, we must deduce
15905 this information on our own. This can be rather tricky to do in
15906 some cases. For example, handling the following structure type
15907 definition when compiling for an i386/i486 target (which only
15908 aligns long long's to 32-bit boundaries) can be very tricky:
15910 struct S { int field1; long long field2:31; };
15912 Fortunately, there is a simple rule-of-thumb which can be used
15913 in such cases. When compiling for an i386/i486, GCC will
15914 allocate 8 bytes for the structure shown above. It decides to
15915 do this based upon one simple rule for bit-field allocation.
15916 GCC allocates each "containing object" for each bit-field at
15917 the first (i.e. lowest addressed) legitimate alignment boundary
15918 (based upon the required minimum alignment for the declared
15919 type of the field) which it can possibly use, subject to the
15920 condition that there is still enough available space remaining
15921 in the containing object (when allocated at the selected point)
15922 to fully accommodate all of the bits of the bit-field itself.
15924 This simple rule makes it obvious why GCC allocates 8 bytes for
15925 each object of the structure type shown above. When looking
15926 for a place to allocate the "containing object" for `field2',
15927 the compiler simply tries to allocate a 64-bit "containing
15928 object" at each successive 32-bit boundary (starting at zero)
15929 until it finds a place to allocate that 64- bit field such that
15930 at least 31 contiguous (and previously unallocated) bits remain
15931 within that selected 64 bit field. (As it turns out, for the
15932 example above, the compiler finds it is OK to allocate the
15933 "containing object" 64-bit field at bit-offset zero within the
15936 Here we attempt to work backwards from the limited set of facts
15937 we're given, and we try to deduce from those facts, where GCC
15938 must have believed that the containing object started (within
15939 the structure type). The value we deduce is then used (by the
15940 callers of this routine) to generate DW_AT_location and
15941 DW_AT_bit_offset attributes for fields (both bit-fields and, in
15942 the case of DW_AT_location, regular fields as well). */
15944 /* Figure out the bit-distance from the start of the structure to
15945 the "deepest" bit of the bit-field. */
15946 deepest_bitpos = double_int_add (bitpos_int, field_size_in_bits);
15948 /* This is the tricky part. Use some fancy footwork to deduce
15949 where the lowest addressed bit of the containing object must
15951 object_offset_in_bits
15952 = double_int_sub (deepest_bitpos, type_size_in_bits);
15954 /* Round up to type_align by default. This works best for
15956 object_offset_in_bits
15957 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
15959 if (double_int_ucmp (object_offset_in_bits, bitpos_int) > 0)
15961 object_offset_in_bits
15962 = double_int_sub (deepest_bitpos, type_size_in_bits);
15964 /* Round up to decl_align instead. */
15965 object_offset_in_bits
15966 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
15970 #endif /* PCC_BITFIELD_TYPE_MATTERS */
15971 object_offset_in_bits = bitpos_int;
15973 object_offset_in_bytes
15974 = double_int_div (object_offset_in_bits,
15975 uhwi_to_double_int (BITS_PER_UNIT), true,
15977 return double_int_to_shwi (object_offset_in_bytes);
15980 /* The following routines define various Dwarf attributes and any data
15981 associated with them. */
15983 /* Add a location description attribute value to a DIE.
15985 This emits location attributes suitable for whole variables and
15986 whole parameters. Note that the location attributes for struct fields are
15987 generated by the routine `data_member_location_attribute' below. */
15990 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
15991 dw_loc_list_ref descr)
15995 if (single_element_loc_list_p (descr))
15996 add_AT_loc (die, attr_kind, descr->expr);
15998 add_AT_loc_list (die, attr_kind, descr);
16001 /* Add DW_AT_accessibility attribute to DIE if needed. */
16004 add_accessibility_attribute (dw_die_ref die, tree decl)
16006 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
16007 children, otherwise the default is DW_ACCESS_public. In DWARF2
16008 the default has always been DW_ACCESS_public. */
16009 if (TREE_PROTECTED (decl))
16010 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
16011 else if (TREE_PRIVATE (decl))
16013 if (dwarf_version == 2
16014 || die->die_parent == NULL
16015 || die->die_parent->die_tag != DW_TAG_class_type)
16016 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
16018 else if (dwarf_version > 2
16020 && die->die_parent->die_tag == DW_TAG_class_type)
16021 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
16024 /* Attach the specialized form of location attribute used for data members of
16025 struct and union types. In the special case of a FIELD_DECL node which
16026 represents a bit-field, the "offset" part of this special location
16027 descriptor must indicate the distance in bytes from the lowest-addressed
16028 byte of the containing struct or union type to the lowest-addressed byte of
16029 the "containing object" for the bit-field. (See the `field_byte_offset'
16032 For any given bit-field, the "containing object" is a hypothetical object
16033 (of some integral or enum type) within which the given bit-field lives. The
16034 type of this hypothetical "containing object" is always the same as the
16035 declared type of the individual bit-field itself (for GCC anyway... the
16036 DWARF spec doesn't actually mandate this). Note that it is the size (in
16037 bytes) of the hypothetical "containing object" which will be given in the
16038 DW_AT_byte_size attribute for this bit-field. (See the
16039 `byte_size_attribute' function below.) It is also used when calculating the
16040 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
16041 function below.) */
16044 add_data_member_location_attribute (dw_die_ref die, tree decl)
16046 HOST_WIDE_INT offset;
16047 dw_loc_descr_ref loc_descr = 0;
16049 if (TREE_CODE (decl) == TREE_BINFO)
16051 /* We're working on the TAG_inheritance for a base class. */
16052 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
16054 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
16055 aren't at a fixed offset from all (sub)objects of the same
16056 type. We need to extract the appropriate offset from our
16057 vtable. The following dwarf expression means
16059 BaseAddr = ObAddr + *((*ObAddr) - Offset)
16061 This is specific to the V3 ABI, of course. */
16063 dw_loc_descr_ref tmp;
16065 /* Make a copy of the object address. */
16066 tmp = new_loc_descr (DW_OP_dup, 0, 0);
16067 add_loc_descr (&loc_descr, tmp);
16069 /* Extract the vtable address. */
16070 tmp = new_loc_descr (DW_OP_deref, 0, 0);
16071 add_loc_descr (&loc_descr, tmp);
16073 /* Calculate the address of the offset. */
16074 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
16075 gcc_assert (offset < 0);
16077 tmp = int_loc_descriptor (-offset);
16078 add_loc_descr (&loc_descr, tmp);
16079 tmp = new_loc_descr (DW_OP_minus, 0, 0);
16080 add_loc_descr (&loc_descr, tmp);
16082 /* Extract the offset. */
16083 tmp = new_loc_descr (DW_OP_deref, 0, 0);
16084 add_loc_descr (&loc_descr, tmp);
16086 /* Add it to the object address. */
16087 tmp = new_loc_descr (DW_OP_plus, 0, 0);
16088 add_loc_descr (&loc_descr, tmp);
16091 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
16094 offset = field_byte_offset (decl);
16098 if (dwarf_version > 2)
16100 /* Don't need to output a location expression, just the constant. */
16102 add_AT_int (die, DW_AT_data_member_location, offset);
16104 add_AT_unsigned (die, DW_AT_data_member_location, offset);
16109 enum dwarf_location_atom op;
16111 /* The DWARF2 standard says that we should assume that the structure
16112 address is already on the stack, so we can specify a structure
16113 field address by using DW_OP_plus_uconst. */
16115 #ifdef MIPS_DEBUGGING_INFO
16116 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
16117 operator correctly. It works only if we leave the offset on the
16121 op = DW_OP_plus_uconst;
16124 loc_descr = new_loc_descr (op, offset, 0);
16128 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
16131 /* Writes integer values to dw_vec_const array. */
16134 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
16138 *dest++ = val & 0xff;
16144 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
16146 static HOST_WIDE_INT
16147 extract_int (const unsigned char *src, unsigned int size)
16149 HOST_WIDE_INT val = 0;
16155 val |= *--src & 0xff;
16161 /* Writes double_int values to dw_vec_const array. */
16164 insert_double (double_int val, unsigned char *dest)
16166 unsigned char *p0 = dest;
16167 unsigned char *p1 = dest + sizeof (HOST_WIDE_INT);
16169 if (WORDS_BIG_ENDIAN)
16175 insert_int ((HOST_WIDE_INT) val.low, sizeof (HOST_WIDE_INT), p0);
16176 insert_int ((HOST_WIDE_INT) val.high, sizeof (HOST_WIDE_INT), p1);
16179 /* Writes floating point values to dw_vec_const array. */
16182 insert_float (const_rtx rtl, unsigned char *array)
16184 REAL_VALUE_TYPE rv;
16188 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
16189 real_to_target (val, &rv, GET_MODE (rtl));
16191 /* real_to_target puts 32-bit pieces in each long. Pack them. */
16192 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
16194 insert_int (val[i], 4, array);
16199 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
16200 does not have a "location" either in memory or in a register. These
16201 things can arise in GNU C when a constant is passed as an actual parameter
16202 to an inlined function. They can also arise in C++ where declared
16203 constants do not necessarily get memory "homes". */
16206 add_const_value_attribute (dw_die_ref die, rtx rtl)
16208 switch (GET_CODE (rtl))
16212 HOST_WIDE_INT val = INTVAL (rtl);
16215 add_AT_int (die, DW_AT_const_value, val);
16217 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
16222 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
16223 floating-point constant. A CONST_DOUBLE is used whenever the
16224 constant requires more than one word in order to be adequately
16227 enum machine_mode mode = GET_MODE (rtl);
16229 if (SCALAR_FLOAT_MODE_P (mode))
16231 unsigned int length = GET_MODE_SIZE (mode);
16232 unsigned char *array = (unsigned char *) ggc_alloc_atomic (length);
16234 insert_float (rtl, array);
16235 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
16238 add_AT_double (die, DW_AT_const_value,
16239 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
16245 enum machine_mode mode = GET_MODE (rtl);
16246 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
16247 unsigned int length = CONST_VECTOR_NUNITS (rtl);
16248 unsigned char *array = (unsigned char *) ggc_alloc_atomic
16249 (length * elt_size);
16253 switch (GET_MODE_CLASS (mode))
16255 case MODE_VECTOR_INT:
16256 for (i = 0, p = array; i < length; i++, p += elt_size)
16258 rtx elt = CONST_VECTOR_ELT (rtl, i);
16259 double_int val = rtx_to_double_int (elt);
16261 if (elt_size <= sizeof (HOST_WIDE_INT))
16262 insert_int (double_int_to_shwi (val), elt_size, p);
16265 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
16266 insert_double (val, p);
16271 case MODE_VECTOR_FLOAT:
16272 for (i = 0, p = array; i < length; i++, p += elt_size)
16274 rtx elt = CONST_VECTOR_ELT (rtl, i);
16275 insert_float (elt, p);
16280 gcc_unreachable ();
16283 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
16288 if (dwarf_version >= 4 || !dwarf_strict)
16290 dw_loc_descr_ref loc_result;
16291 resolve_one_addr (&rtl, NULL);
16293 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
16294 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
16295 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
16296 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
16297 add_AT_loc (die, DW_AT_location, loc_result);
16298 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
16304 if (CONSTANT_P (XEXP (rtl, 0)))
16305 return add_const_value_attribute (die, XEXP (rtl, 0));
16308 if (!const_ok_for_output (rtl))
16311 if (dwarf_version >= 4 || !dwarf_strict)
16316 /* In cases where an inlined instance of an inline function is passed
16317 the address of an `auto' variable (which is local to the caller) we
16318 can get a situation where the DECL_RTL of the artificial local
16319 variable (for the inlining) which acts as a stand-in for the
16320 corresponding formal parameter (of the inline function) will look
16321 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
16322 exactly a compile-time constant expression, but it isn't the address
16323 of the (artificial) local variable either. Rather, it represents the
16324 *value* which the artificial local variable always has during its
16325 lifetime. We currently have no way to represent such quasi-constant
16326 values in Dwarf, so for now we just punt and generate nothing. */
16334 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
16335 && MEM_READONLY_P (rtl)
16336 && GET_MODE (rtl) == BLKmode)
16338 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
16344 /* No other kinds of rtx should be possible here. */
16345 gcc_unreachable ();
16350 /* Determine whether the evaluation of EXPR references any variables
16351 or functions which aren't otherwise used (and therefore may not be
16354 reference_to_unused (tree * tp, int * walk_subtrees,
16355 void * data ATTRIBUTE_UNUSED)
16357 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
16358 *walk_subtrees = 0;
16360 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
16361 && ! TREE_ASM_WRITTEN (*tp))
16363 /* ??? The C++ FE emits debug information for using decls, so
16364 putting gcc_unreachable here falls over. See PR31899. For now
16365 be conservative. */
16366 else if (!cgraph_global_info_ready
16367 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
16369 else if (TREE_CODE (*tp) == VAR_DECL)
16371 struct varpool_node *node = varpool_get_node (*tp);
16372 if (!node || !node->needed)
16375 else if (TREE_CODE (*tp) == FUNCTION_DECL
16376 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
16378 /* The call graph machinery must have finished analyzing,
16379 optimizing and gimplifying the CU by now.
16380 So if *TP has no call graph node associated
16381 to it, it means *TP will not be emitted. */
16382 if (!cgraph_get_node (*tp))
16385 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
16391 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
16392 for use in a later add_const_value_attribute call. */
16395 rtl_for_decl_init (tree init, tree type)
16397 rtx rtl = NULL_RTX;
16399 /* If a variable is initialized with a string constant without embedded
16400 zeros, build CONST_STRING. */
16401 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
16403 tree enttype = TREE_TYPE (type);
16404 tree domain = TYPE_DOMAIN (type);
16405 enum machine_mode mode = TYPE_MODE (enttype);
16407 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
16409 && integer_zerop (TYPE_MIN_VALUE (domain))
16410 && compare_tree_int (TYPE_MAX_VALUE (domain),
16411 TREE_STRING_LENGTH (init) - 1) == 0
16412 && ((size_t) TREE_STRING_LENGTH (init)
16413 == strlen (TREE_STRING_POINTER (init)) + 1))
16415 rtl = gen_rtx_CONST_STRING (VOIDmode,
16416 ggc_strdup (TREE_STRING_POINTER (init)));
16417 rtl = gen_rtx_MEM (BLKmode, rtl);
16418 MEM_READONLY_P (rtl) = 1;
16421 /* Other aggregates, and complex values, could be represented using
16423 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
16425 /* Vectors only work if their mode is supported by the target.
16426 FIXME: generic vectors ought to work too. */
16427 else if (TREE_CODE (type) == VECTOR_TYPE
16428 && !VECTOR_MODE_P (TYPE_MODE (type)))
16430 /* If the initializer is something that we know will expand into an
16431 immediate RTL constant, expand it now. We must be careful not to
16432 reference variables which won't be output. */
16433 else if (initializer_constant_valid_p (init, type)
16434 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
16436 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
16438 if (TREE_CODE (type) == VECTOR_TYPE)
16439 switch (TREE_CODE (init))
16444 if (TREE_CONSTANT (init))
16446 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
16447 bool constant_p = true;
16449 unsigned HOST_WIDE_INT ix;
16451 /* Even when ctor is constant, it might contain non-*_CST
16452 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
16453 belong into VECTOR_CST nodes. */
16454 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
16455 if (!CONSTANT_CLASS_P (value))
16457 constant_p = false;
16463 init = build_vector_from_ctor (type, elts);
16473 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
16475 /* If expand_expr returns a MEM, it wasn't immediate. */
16476 gcc_assert (!rtl || !MEM_P (rtl));
16482 /* Generate RTL for the variable DECL to represent its location. */
16485 rtl_for_decl_location (tree decl)
16489 /* Here we have to decide where we are going to say the parameter "lives"
16490 (as far as the debugger is concerned). We only have a couple of
16491 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
16493 DECL_RTL normally indicates where the parameter lives during most of the
16494 activation of the function. If optimization is enabled however, this
16495 could be either NULL or else a pseudo-reg. Both of those cases indicate
16496 that the parameter doesn't really live anywhere (as far as the code
16497 generation parts of GCC are concerned) during most of the function's
16498 activation. That will happen (for example) if the parameter is never
16499 referenced within the function.
16501 We could just generate a location descriptor here for all non-NULL
16502 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
16503 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
16504 where DECL_RTL is NULL or is a pseudo-reg.
16506 Note however that we can only get away with using DECL_INCOMING_RTL as
16507 a backup substitute for DECL_RTL in certain limited cases. In cases
16508 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
16509 we can be sure that the parameter was passed using the same type as it is
16510 declared to have within the function, and that its DECL_INCOMING_RTL
16511 points us to a place where a value of that type is passed.
16513 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
16514 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
16515 because in these cases DECL_INCOMING_RTL points us to a value of some
16516 type which is *different* from the type of the parameter itself. Thus,
16517 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
16518 such cases, the debugger would end up (for example) trying to fetch a
16519 `float' from a place which actually contains the first part of a
16520 `double'. That would lead to really incorrect and confusing
16521 output at debug-time.
16523 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
16524 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
16525 are a couple of exceptions however. On little-endian machines we can
16526 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
16527 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
16528 an integral type that is smaller than TREE_TYPE (decl). These cases arise
16529 when (on a little-endian machine) a non-prototyped function has a
16530 parameter declared to be of type `short' or `char'. In such cases,
16531 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
16532 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
16533 passed `int' value. If the debugger then uses that address to fetch
16534 a `short' or a `char' (on a little-endian machine) the result will be
16535 the correct data, so we allow for such exceptional cases below.
16537 Note that our goal here is to describe the place where the given formal
16538 parameter lives during most of the function's activation (i.e. between the
16539 end of the prologue and the start of the epilogue). We'll do that as best
16540 as we can. Note however that if the given formal parameter is modified
16541 sometime during the execution of the function, then a stack backtrace (at
16542 debug-time) will show the function as having been called with the *new*
16543 value rather than the value which was originally passed in. This happens
16544 rarely enough that it is not a major problem, but it *is* a problem, and
16545 I'd like to fix it.
16547 A future version of dwarf2out.c may generate two additional attributes for
16548 any given DW_TAG_formal_parameter DIE which will describe the "passed
16549 type" and the "passed location" for the given formal parameter in addition
16550 to the attributes we now generate to indicate the "declared type" and the
16551 "active location" for each parameter. This additional set of attributes
16552 could be used by debuggers for stack backtraces. Separately, note that
16553 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
16554 This happens (for example) for inlined-instances of inline function formal
16555 parameters which are never referenced. This really shouldn't be
16556 happening. All PARM_DECL nodes should get valid non-NULL
16557 DECL_INCOMING_RTL values. FIXME. */
16559 /* Use DECL_RTL as the "location" unless we find something better. */
16560 rtl = DECL_RTL_IF_SET (decl);
16562 /* When generating abstract instances, ignore everything except
16563 constants, symbols living in memory, and symbols living in
16564 fixed registers. */
16565 if (! reload_completed)
16568 && (CONSTANT_P (rtl)
16570 && CONSTANT_P (XEXP (rtl, 0)))
16572 && TREE_CODE (decl) == VAR_DECL
16573 && TREE_STATIC (decl))))
16575 rtl = targetm.delegitimize_address (rtl);
16580 else if (TREE_CODE (decl) == PARM_DECL)
16582 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
16584 tree declared_type = TREE_TYPE (decl);
16585 tree passed_type = DECL_ARG_TYPE (decl);
16586 enum machine_mode dmode = TYPE_MODE (declared_type);
16587 enum machine_mode pmode = TYPE_MODE (passed_type);
16589 /* This decl represents a formal parameter which was optimized out.
16590 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
16591 all cases where (rtl == NULL_RTX) just below. */
16592 if (dmode == pmode)
16593 rtl = DECL_INCOMING_RTL (decl);
16594 else if (SCALAR_INT_MODE_P (dmode)
16595 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
16596 && DECL_INCOMING_RTL (decl))
16598 rtx inc = DECL_INCOMING_RTL (decl);
16601 else if (MEM_P (inc))
16603 if (BYTES_BIG_ENDIAN)
16604 rtl = adjust_address_nv (inc, dmode,
16605 GET_MODE_SIZE (pmode)
16606 - GET_MODE_SIZE (dmode));
16613 /* If the parm was passed in registers, but lives on the stack, then
16614 make a big endian correction if the mode of the type of the
16615 parameter is not the same as the mode of the rtl. */
16616 /* ??? This is the same series of checks that are made in dbxout.c before
16617 we reach the big endian correction code there. It isn't clear if all
16618 of these checks are necessary here, but keeping them all is the safe
16620 else if (MEM_P (rtl)
16621 && XEXP (rtl, 0) != const0_rtx
16622 && ! CONSTANT_P (XEXP (rtl, 0))
16623 /* Not passed in memory. */
16624 && !MEM_P (DECL_INCOMING_RTL (decl))
16625 /* Not passed by invisible reference. */
16626 && (!REG_P (XEXP (rtl, 0))
16627 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
16628 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
16629 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
16630 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
16633 /* Big endian correction check. */
16634 && BYTES_BIG_ENDIAN
16635 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
16636 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
16639 int offset = (UNITS_PER_WORD
16640 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
16642 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
16643 plus_constant (XEXP (rtl, 0), offset));
16646 else if (TREE_CODE (decl) == VAR_DECL
16649 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
16650 && BYTES_BIG_ENDIAN)
16652 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
16653 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
16655 /* If a variable is declared "register" yet is smaller than
16656 a register, then if we store the variable to memory, it
16657 looks like we're storing a register-sized value, when in
16658 fact we are not. We need to adjust the offset of the
16659 storage location to reflect the actual value's bytes,
16660 else gdb will not be able to display it. */
16662 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
16663 plus_constant (XEXP (rtl, 0), rsize-dsize));
16666 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
16667 and will have been substituted directly into all expressions that use it.
16668 C does not have such a concept, but C++ and other languages do. */
16669 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
16670 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
16673 rtl = targetm.delegitimize_address (rtl);
16675 /* If we don't look past the constant pool, we risk emitting a
16676 reference to a constant pool entry that isn't referenced from
16677 code, and thus is not emitted. */
16679 rtl = avoid_constant_pool_reference (rtl);
16681 /* Try harder to get a rtl. If this symbol ends up not being emitted
16682 in the current CU, resolve_addr will remove the expression referencing
16684 if (rtl == NULL_RTX
16685 && TREE_CODE (decl) == VAR_DECL
16686 && !DECL_EXTERNAL (decl)
16687 && TREE_STATIC (decl)
16688 && DECL_NAME (decl)
16689 && !DECL_HARD_REGISTER (decl)
16690 && DECL_MODE (decl) != VOIDmode)
16692 rtl = make_decl_rtl_for_debug (decl);
16694 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
16695 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
16702 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
16703 returned. If so, the decl for the COMMON block is returned, and the
16704 value is the offset into the common block for the symbol. */
16707 fortran_common (tree decl, HOST_WIDE_INT *value)
16709 tree val_expr, cvar;
16710 enum machine_mode mode;
16711 HOST_WIDE_INT bitsize, bitpos;
16713 int volatilep = 0, unsignedp = 0;
16715 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
16716 it does not have a value (the offset into the common area), or if it
16717 is thread local (as opposed to global) then it isn't common, and shouldn't
16718 be handled as such. */
16719 if (TREE_CODE (decl) != VAR_DECL
16720 || !TREE_STATIC (decl)
16721 || !DECL_HAS_VALUE_EXPR_P (decl)
16725 val_expr = DECL_VALUE_EXPR (decl);
16726 if (TREE_CODE (val_expr) != COMPONENT_REF)
16729 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
16730 &mode, &unsignedp, &volatilep, true);
16732 if (cvar == NULL_TREE
16733 || TREE_CODE (cvar) != VAR_DECL
16734 || DECL_ARTIFICIAL (cvar)
16735 || !TREE_PUBLIC (cvar))
16739 if (offset != NULL)
16741 if (!host_integerp (offset, 0))
16743 *value = tree_low_cst (offset, 0);
16746 *value += bitpos / BITS_PER_UNIT;
16751 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
16752 data attribute for a variable or a parameter. We generate the
16753 DW_AT_const_value attribute only in those cases where the given variable
16754 or parameter does not have a true "location" either in memory or in a
16755 register. This can happen (for example) when a constant is passed as an
16756 actual argument in a call to an inline function. (It's possible that
16757 these things can crop up in other ways also.) Note that one type of
16758 constant value which can be passed into an inlined function is a constant
16759 pointer. This can happen for example if an actual argument in an inlined
16760 function call evaluates to a compile-time constant address. */
16763 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
16764 enum dwarf_attribute attr)
16767 dw_loc_list_ref list;
16768 var_loc_list *loc_list;
16770 if (TREE_CODE (decl) == ERROR_MARK)
16773 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
16774 || TREE_CODE (decl) == RESULT_DECL);
16776 /* Try to get some constant RTL for this decl, and use that as the value of
16779 rtl = rtl_for_decl_location (decl);
16780 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16781 && add_const_value_attribute (die, rtl))
16784 /* See if we have single element location list that is equivalent to
16785 a constant value. That way we are better to use add_const_value_attribute
16786 rather than expanding constant value equivalent. */
16787 loc_list = lookup_decl_loc (decl);
16790 && loc_list->first->next == NULL
16791 && NOTE_P (loc_list->first->loc)
16792 && NOTE_VAR_LOCATION (loc_list->first->loc)
16793 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
16795 struct var_loc_node *node;
16797 node = loc_list->first;
16798 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
16799 if (GET_CODE (rtl) == EXPR_LIST)
16800 rtl = XEXP (rtl, 0);
16801 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16802 && add_const_value_attribute (die, rtl))
16805 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2);
16808 add_AT_location_description (die, attr, list);
16811 /* None of that worked, so it must not really have a location;
16812 try adding a constant value attribute from the DECL_INITIAL. */
16813 return tree_add_const_value_attribute_for_decl (die, decl);
16816 /* Add VARIABLE and DIE into deferred locations list. */
16819 defer_location (tree variable, dw_die_ref die)
16821 deferred_locations entry;
16822 entry.variable = variable;
16824 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
16827 /* Helper function for tree_add_const_value_attribute. Natively encode
16828 initializer INIT into an array. Return true if successful. */
16831 native_encode_initializer (tree init, unsigned char *array, int size)
16835 if (init == NULL_TREE)
16839 switch (TREE_CODE (init))
16842 type = TREE_TYPE (init);
16843 if (TREE_CODE (type) == ARRAY_TYPE)
16845 tree enttype = TREE_TYPE (type);
16846 enum machine_mode mode = TYPE_MODE (enttype);
16848 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
16850 if (int_size_in_bytes (type) != size)
16852 if (size > TREE_STRING_LENGTH (init))
16854 memcpy (array, TREE_STRING_POINTER (init),
16855 TREE_STRING_LENGTH (init));
16856 memset (array + TREE_STRING_LENGTH (init),
16857 '\0', size - TREE_STRING_LENGTH (init));
16860 memcpy (array, TREE_STRING_POINTER (init), size);
16865 type = TREE_TYPE (init);
16866 if (int_size_in_bytes (type) != size)
16868 if (TREE_CODE (type) == ARRAY_TYPE)
16870 HOST_WIDE_INT min_index;
16871 unsigned HOST_WIDE_INT cnt;
16872 int curpos = 0, fieldsize;
16873 constructor_elt *ce;
16875 if (TYPE_DOMAIN (type) == NULL_TREE
16876 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
16879 fieldsize = int_size_in_bytes (TREE_TYPE (type));
16880 if (fieldsize <= 0)
16883 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
16884 memset (array, '\0', size);
16885 FOR_EACH_VEC_ELT (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce)
16887 tree val = ce->value;
16888 tree index = ce->index;
16890 if (index && TREE_CODE (index) == RANGE_EXPR)
16891 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
16894 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
16899 if (!native_encode_initializer (val, array + pos, fieldsize))
16902 curpos = pos + fieldsize;
16903 if (index && TREE_CODE (index) == RANGE_EXPR)
16905 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
16906 - tree_low_cst (TREE_OPERAND (index, 0), 0);
16910 memcpy (array + curpos, array + pos, fieldsize);
16911 curpos += fieldsize;
16914 gcc_assert (curpos <= size);
16918 else if (TREE_CODE (type) == RECORD_TYPE
16919 || TREE_CODE (type) == UNION_TYPE)
16921 tree field = NULL_TREE;
16922 unsigned HOST_WIDE_INT cnt;
16923 constructor_elt *ce;
16925 if (int_size_in_bytes (type) != size)
16928 if (TREE_CODE (type) == RECORD_TYPE)
16929 field = TYPE_FIELDS (type);
16931 FOR_EACH_VEC_ELT (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce)
16933 tree val = ce->value;
16934 int pos, fieldsize;
16936 if (ce->index != 0)
16942 if (field == NULL_TREE || DECL_BIT_FIELD (field))
16945 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
16946 && TYPE_DOMAIN (TREE_TYPE (field))
16947 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
16949 else if (DECL_SIZE_UNIT (field) == NULL_TREE
16950 || !host_integerp (DECL_SIZE_UNIT (field), 0))
16952 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
16953 pos = int_byte_position (field);
16954 gcc_assert (pos + fieldsize <= size);
16956 && !native_encode_initializer (val, array + pos, fieldsize))
16962 case VIEW_CONVERT_EXPR:
16963 case NON_LVALUE_EXPR:
16964 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
16966 return native_encode_expr (init, array, size) == size;
16970 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16971 attribute is the const value T. */
16974 tree_add_const_value_attribute (dw_die_ref die, tree t)
16977 tree type = TREE_TYPE (t);
16980 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
16984 gcc_assert (!DECL_P (init));
16986 rtl = rtl_for_decl_init (init, type);
16988 return add_const_value_attribute (die, rtl);
16989 /* If the host and target are sane, try harder. */
16990 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
16991 && initializer_constant_valid_p (init, type))
16993 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
16994 if (size > 0 && (int) size == size)
16996 unsigned char *array = (unsigned char *)
16997 ggc_alloc_cleared_atomic (size);
16999 if (native_encode_initializer (init, array, size))
17001 add_AT_vec (die, DW_AT_const_value, size, 1, array);
17009 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
17010 attribute is the const value of T, where T is an integral constant
17011 variable with static storage duration
17012 (so it can't be a PARM_DECL or a RESULT_DECL). */
17015 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
17019 || (TREE_CODE (decl) != VAR_DECL
17020 && TREE_CODE (decl) != CONST_DECL))
17023 if (TREE_READONLY (decl)
17024 && ! TREE_THIS_VOLATILE (decl)
17025 && DECL_INITIAL (decl))
17030 /* Don't add DW_AT_const_value if abstract origin already has one. */
17031 if (get_AT (var_die, DW_AT_const_value))
17034 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
17037 /* Convert the CFI instructions for the current function into a
17038 location list. This is used for DW_AT_frame_base when we targeting
17039 a dwarf2 consumer that does not support the dwarf3
17040 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
17043 static dw_loc_list_ref
17044 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
17047 dw_loc_list_ref list, *list_tail;
17049 dw_cfa_location last_cfa, next_cfa;
17050 const char *start_label, *last_label, *section;
17051 dw_cfa_location remember;
17053 fde = current_fde ();
17054 gcc_assert (fde != NULL);
17056 section = secname_for_decl (current_function_decl);
17060 memset (&next_cfa, 0, sizeof (next_cfa));
17061 next_cfa.reg = INVALID_REGNUM;
17062 remember = next_cfa;
17064 start_label = fde->dw_fde_begin;
17066 /* ??? Bald assumption that the CIE opcode list does not contain
17067 advance opcodes. */
17068 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
17069 lookup_cfa_1 (cfi, &next_cfa, &remember);
17071 last_cfa = next_cfa;
17072 last_label = start_label;
17074 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
17075 switch (cfi->dw_cfi_opc)
17077 case DW_CFA_set_loc:
17078 case DW_CFA_advance_loc1:
17079 case DW_CFA_advance_loc2:
17080 case DW_CFA_advance_loc4:
17081 if (!cfa_equal_p (&last_cfa, &next_cfa))
17083 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
17084 start_label, last_label, section);
17086 list_tail = &(*list_tail)->dw_loc_next;
17087 last_cfa = next_cfa;
17088 start_label = last_label;
17090 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
17093 case DW_CFA_advance_loc:
17094 /* The encoding is complex enough that we should never emit this. */
17095 gcc_unreachable ();
17098 lookup_cfa_1 (cfi, &next_cfa, &remember);
17102 if (!cfa_equal_p (&last_cfa, &next_cfa))
17104 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
17105 start_label, last_label, section);
17106 list_tail = &(*list_tail)->dw_loc_next;
17107 start_label = last_label;
17110 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
17111 start_label, fde->dw_fde_end, section);
17113 if (list && list->dw_loc_next)
17119 /* Compute a displacement from the "steady-state frame pointer" to the
17120 frame base (often the same as the CFA), and store it in
17121 frame_pointer_fb_offset. OFFSET is added to the displacement
17122 before the latter is negated. */
17125 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
17129 #ifdef FRAME_POINTER_CFA_OFFSET
17130 reg = frame_pointer_rtx;
17131 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
17133 reg = arg_pointer_rtx;
17134 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
17137 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
17138 if (GET_CODE (elim) == PLUS)
17140 offset += INTVAL (XEXP (elim, 1));
17141 elim = XEXP (elim, 0);
17144 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
17145 && (elim == hard_frame_pointer_rtx
17146 || elim == stack_pointer_rtx))
17147 || elim == (frame_pointer_needed
17148 ? hard_frame_pointer_rtx
17149 : stack_pointer_rtx));
17151 frame_pointer_fb_offset = -offset;
17154 /* Generate a DW_AT_name attribute given some string value to be included as
17155 the value of the attribute. */
17158 add_name_attribute (dw_die_ref die, const char *name_string)
17160 if (name_string != NULL && *name_string != 0)
17162 if (demangle_name_func)
17163 name_string = (*demangle_name_func) (name_string);
17165 add_AT_string (die, DW_AT_name, name_string);
17169 /* Generate a DW_AT_comp_dir attribute for DIE. */
17172 add_comp_dir_attribute (dw_die_ref die)
17174 const char *wd = get_src_pwd ();
17180 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
17184 wdlen = strlen (wd);
17185 wd1 = (char *) ggc_alloc_atomic (wdlen + 2);
17187 wd1 [wdlen] = DIR_SEPARATOR;
17188 wd1 [wdlen + 1] = 0;
17192 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
17195 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
17199 lower_bound_default (void)
17201 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
17206 case DW_LANG_C_plus_plus:
17208 case DW_LANG_ObjC_plus_plus:
17211 case DW_LANG_Fortran77:
17212 case DW_LANG_Fortran90:
17213 case DW_LANG_Fortran95:
17217 case DW_LANG_Python:
17218 return dwarf_version >= 4 ? 0 : -1;
17219 case DW_LANG_Ada95:
17220 case DW_LANG_Ada83:
17221 case DW_LANG_Cobol74:
17222 case DW_LANG_Cobol85:
17223 case DW_LANG_Pascal83:
17224 case DW_LANG_Modula2:
17226 return dwarf_version >= 4 ? 1 : -1;
17232 /* Given a tree node describing an array bound (either lower or upper) output
17233 a representation for that bound. */
17236 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
17238 switch (TREE_CODE (bound))
17243 /* All fixed-bounds are represented by INTEGER_CST nodes. */
17246 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (bound));
17249 /* Use the default if possible. */
17250 if (bound_attr == DW_AT_lower_bound
17251 && host_integerp (bound, 0)
17252 && (dflt = lower_bound_default ()) != -1
17253 && tree_low_cst (bound, 0) == dflt)
17256 /* Otherwise represent the bound as an unsigned value with the
17257 precision of its type. The precision and signedness of the
17258 type will be necessary to re-interpret it unambiguously. */
17259 else if (prec < HOST_BITS_PER_WIDE_INT)
17261 unsigned HOST_WIDE_INT mask
17262 = ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
17263 add_AT_unsigned (subrange_die, bound_attr,
17264 TREE_INT_CST_LOW (bound) & mask);
17266 else if (prec == HOST_BITS_PER_WIDE_INT
17267 || TREE_INT_CST_HIGH (bound) == 0)
17268 add_AT_unsigned (subrange_die, bound_attr,
17269 TREE_INT_CST_LOW (bound));
17271 add_AT_double (subrange_die, bound_attr, TREE_INT_CST_HIGH (bound),
17272 TREE_INT_CST_LOW (bound));
17277 case VIEW_CONVERT_EXPR:
17278 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
17288 dw_die_ref decl_die = lookup_decl_die (bound);
17290 /* ??? Can this happen, or should the variable have been bound
17291 first? Probably it can, since I imagine that we try to create
17292 the types of parameters in the order in which they exist in
17293 the list, and won't have created a forward reference to a
17294 later parameter. */
17295 if (decl_die != NULL)
17297 add_AT_die_ref (subrange_die, bound_attr, decl_die);
17305 /* Otherwise try to create a stack operation procedure to
17306 evaluate the value of the array bound. */
17308 dw_die_ref ctx, decl_die;
17309 dw_loc_list_ref list;
17311 list = loc_list_from_tree (bound, 2);
17312 if (list == NULL || single_element_loc_list_p (list))
17314 /* If DW_AT_*bound is not a reference nor constant, it is
17315 a DWARF expression rather than location description.
17316 For that loc_list_from_tree (bound, 0) is needed.
17317 If that fails to give a single element list,
17318 fall back to outputting this as a reference anyway. */
17319 dw_loc_list_ref list2 = loc_list_from_tree (bound, 0);
17320 if (list2 && single_element_loc_list_p (list2))
17322 add_AT_loc (subrange_die, bound_attr, list2->expr);
17329 if (current_function_decl == 0)
17330 ctx = comp_unit_die ();
17332 ctx = lookup_decl_die (current_function_decl);
17334 decl_die = new_die (DW_TAG_variable, ctx, bound);
17335 add_AT_flag (decl_die, DW_AT_artificial, 1);
17336 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
17337 add_AT_location_description (decl_die, DW_AT_location, list);
17338 add_AT_die_ref (subrange_die, bound_attr, decl_die);
17344 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
17345 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
17346 Note that the block of subscript information for an array type also
17347 includes information about the element type of the given array type. */
17350 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
17352 unsigned dimension_number;
17354 dw_die_ref subrange_die;
17356 for (dimension_number = 0;
17357 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
17358 type = TREE_TYPE (type), dimension_number++)
17360 tree domain = TYPE_DOMAIN (type);
17362 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
17365 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
17366 and (in GNU C only) variable bounds. Handle all three forms
17368 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
17371 /* We have an array type with specified bounds. */
17372 lower = TYPE_MIN_VALUE (domain);
17373 upper = TYPE_MAX_VALUE (domain);
17375 /* Define the index type. */
17376 if (TREE_TYPE (domain))
17378 /* ??? This is probably an Ada unnamed subrange type. Ignore the
17379 TREE_TYPE field. We can't emit debug info for this
17380 because it is an unnamed integral type. */
17381 if (TREE_CODE (domain) == INTEGER_TYPE
17382 && TYPE_NAME (domain) == NULL_TREE
17383 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
17384 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
17387 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
17391 /* ??? If upper is NULL, the array has unspecified length,
17392 but it does have a lower bound. This happens with Fortran
17394 Since the debugger is definitely going to need to know N
17395 to produce useful results, go ahead and output the lower
17396 bound solo, and hope the debugger can cope. */
17398 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
17400 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
17403 /* Otherwise we have an array type with an unspecified length. The
17404 DWARF-2 spec does not say how to handle this; let's just leave out the
17410 add_byte_size_attribute (dw_die_ref die, tree tree_node)
17414 switch (TREE_CODE (tree_node))
17419 case ENUMERAL_TYPE:
17422 case QUAL_UNION_TYPE:
17423 size = int_size_in_bytes (tree_node);
17426 /* For a data member of a struct or union, the DW_AT_byte_size is
17427 generally given as the number of bytes normally allocated for an
17428 object of the *declared* type of the member itself. This is true
17429 even for bit-fields. */
17430 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
17433 gcc_unreachable ();
17436 /* Note that `size' might be -1 when we get to this point. If it is, that
17437 indicates that the byte size of the entity in question is variable. We
17438 have no good way of expressing this fact in Dwarf at the present time,
17439 so just let the -1 pass on through. */
17440 add_AT_unsigned (die, DW_AT_byte_size, size);
17443 /* For a FIELD_DECL node which represents a bit-field, output an attribute
17444 which specifies the distance in bits from the highest order bit of the
17445 "containing object" for the bit-field to the highest order bit of the
17448 For any given bit-field, the "containing object" is a hypothetical object
17449 (of some integral or enum type) within which the given bit-field lives. The
17450 type of this hypothetical "containing object" is always the same as the
17451 declared type of the individual bit-field itself. The determination of the
17452 exact location of the "containing object" for a bit-field is rather
17453 complicated. It's handled by the `field_byte_offset' function (above).
17455 Note that it is the size (in bytes) of the hypothetical "containing object"
17456 which will be given in the DW_AT_byte_size attribute for this bit-field.
17457 (See `byte_size_attribute' above). */
17460 add_bit_offset_attribute (dw_die_ref die, tree decl)
17462 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
17463 tree type = DECL_BIT_FIELD_TYPE (decl);
17464 HOST_WIDE_INT bitpos_int;
17465 HOST_WIDE_INT highest_order_object_bit_offset;
17466 HOST_WIDE_INT highest_order_field_bit_offset;
17467 HOST_WIDE_INT unsigned bit_offset;
17469 /* Must be a field and a bit field. */
17470 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
17472 /* We can't yet handle bit-fields whose offsets are variable, so if we
17473 encounter such things, just return without generating any attribute
17474 whatsoever. Likewise for variable or too large size. */
17475 if (! host_integerp (bit_position (decl), 0)
17476 || ! host_integerp (DECL_SIZE (decl), 1))
17479 bitpos_int = int_bit_position (decl);
17481 /* Note that the bit offset is always the distance (in bits) from the
17482 highest-order bit of the "containing object" to the highest-order bit of
17483 the bit-field itself. Since the "high-order end" of any object or field
17484 is different on big-endian and little-endian machines, the computation
17485 below must take account of these differences. */
17486 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
17487 highest_order_field_bit_offset = bitpos_int;
17489 if (! BYTES_BIG_ENDIAN)
17491 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
17492 highest_order_object_bit_offset += simple_type_size_in_bits (type);
17496 = (! BYTES_BIG_ENDIAN
17497 ? highest_order_object_bit_offset - highest_order_field_bit_offset
17498 : highest_order_field_bit_offset - highest_order_object_bit_offset);
17500 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
17503 /* For a FIELD_DECL node which represents a bit field, output an attribute
17504 which specifies the length in bits of the given field. */
17507 add_bit_size_attribute (dw_die_ref die, tree decl)
17509 /* Must be a field and a bit field. */
17510 gcc_assert (TREE_CODE (decl) == FIELD_DECL
17511 && DECL_BIT_FIELD_TYPE (decl));
17513 if (host_integerp (DECL_SIZE (decl), 1))
17514 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
17517 /* If the compiled language is ANSI C, then add a 'prototyped'
17518 attribute, if arg types are given for the parameters of a function. */
17521 add_prototyped_attribute (dw_die_ref die, tree func_type)
17523 if (get_AT_unsigned (comp_unit_die (), DW_AT_language) == DW_LANG_C89
17524 && TYPE_ARG_TYPES (func_type) != NULL)
17525 add_AT_flag (die, DW_AT_prototyped, 1);
17528 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
17529 by looking in either the type declaration or object declaration
17532 static inline dw_die_ref
17533 add_abstract_origin_attribute (dw_die_ref die, tree origin)
17535 dw_die_ref origin_die = NULL;
17537 if (TREE_CODE (origin) != FUNCTION_DECL)
17539 /* We may have gotten separated from the block for the inlined
17540 function, if we're in an exception handler or some such; make
17541 sure that the abstract function has been written out.
17543 Doing this for nested functions is wrong, however; functions are
17544 distinct units, and our context might not even be inline. */
17548 fn = TYPE_STUB_DECL (fn);
17550 fn = decl_function_context (fn);
17552 dwarf2out_abstract_function (fn);
17555 if (DECL_P (origin))
17556 origin_die = lookup_decl_die (origin);
17557 else if (TYPE_P (origin))
17558 origin_die = lookup_type_die (origin);
17560 /* XXX: Functions that are never lowered don't always have correct block
17561 trees (in the case of java, they simply have no block tree, in some other
17562 languages). For these functions, there is nothing we can really do to
17563 output correct debug info for inlined functions in all cases. Rather
17564 than die, we'll just produce deficient debug info now, in that we will
17565 have variables without a proper abstract origin. In the future, when all
17566 functions are lowered, we should re-add a gcc_assert (origin_die)
17570 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
17574 /* We do not currently support the pure_virtual attribute. */
17577 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
17579 if (DECL_VINDEX (func_decl))
17581 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
17583 if (host_integerp (DECL_VINDEX (func_decl), 0))
17584 add_AT_loc (die, DW_AT_vtable_elem_location,
17585 new_loc_descr (DW_OP_constu,
17586 tree_low_cst (DECL_VINDEX (func_decl), 0),
17589 /* GNU extension: Record what type this method came from originally. */
17590 if (debug_info_level > DINFO_LEVEL_TERSE
17591 && DECL_CONTEXT (func_decl))
17592 add_AT_die_ref (die, DW_AT_containing_type,
17593 lookup_type_die (DECL_CONTEXT (func_decl)));
17597 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
17598 given decl. This used to be a vendor extension until after DWARF 4
17599 standardized it. */
17602 add_linkage_attr (dw_die_ref die, tree decl)
17604 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
17606 /* Mimic what assemble_name_raw does with a leading '*'. */
17607 if (name[0] == '*')
17610 if (dwarf_version >= 4)
17611 add_AT_string (die, DW_AT_linkage_name, name);
17613 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
17616 /* Add source coordinate attributes for the given decl. */
17619 add_src_coords_attributes (dw_die_ref die, tree decl)
17621 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
17623 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
17624 add_AT_unsigned (die, DW_AT_decl_line, s.line);
17627 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
17630 add_linkage_name (dw_die_ref die, tree decl)
17632 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
17633 && TREE_PUBLIC (decl)
17634 && !DECL_ABSTRACT (decl)
17635 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
17636 && die->die_tag != DW_TAG_member)
17638 /* Defer until we have an assembler name set. */
17639 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
17641 limbo_die_node *asm_name;
17643 asm_name = ggc_alloc_cleared_limbo_die_node ();
17644 asm_name->die = die;
17645 asm_name->created_for = decl;
17646 asm_name->next = deferred_asm_name;
17647 deferred_asm_name = asm_name;
17649 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
17650 add_linkage_attr (die, decl);
17654 /* Add a DW_AT_name attribute and source coordinate attribute for the
17655 given decl, but only if it actually has a name. */
17658 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
17662 decl_name = DECL_NAME (decl);
17663 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
17665 const char *name = dwarf2_name (decl, 0);
17667 add_name_attribute (die, name);
17668 if (! DECL_ARTIFICIAL (decl))
17669 add_src_coords_attributes (die, decl);
17671 add_linkage_name (die, decl);
17674 #ifdef VMS_DEBUGGING_INFO
17675 /* Get the function's name, as described by its RTL. This may be different
17676 from the DECL_NAME name used in the source file. */
17677 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
17679 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
17680 XEXP (DECL_RTL (decl), 0));
17681 VEC_safe_push (rtx, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
17683 #endif /* VMS_DEBUGGING_INFO */
17686 #ifdef VMS_DEBUGGING_INFO
17687 /* Output the debug main pointer die for VMS */
17690 dwarf2out_vms_debug_main_pointer (void)
17692 char label[MAX_ARTIFICIAL_LABEL_BYTES];
17695 /* Allocate the VMS debug main subprogram die. */
17696 die = ggc_alloc_cleared_die_node ();
17697 die->die_tag = DW_TAG_subprogram;
17698 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
17699 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
17700 current_function_funcdef_no);
17701 add_AT_lbl_id (die, DW_AT_entry_pc, label);
17703 /* Make it the first child of comp_unit_die (). */
17704 die->die_parent = comp_unit_die ();
17705 if (comp_unit_die ()->die_child)
17707 die->die_sib = comp_unit_die ()->die_child->die_sib;
17708 comp_unit_die ()->die_child->die_sib = die;
17712 die->die_sib = die;
17713 comp_unit_die ()->die_child = die;
17716 #endif /* VMS_DEBUGGING_INFO */
17718 /* Push a new declaration scope. */
17721 push_decl_scope (tree scope)
17723 VEC_safe_push (tree, gc, decl_scope_table, scope);
17726 /* Pop a declaration scope. */
17729 pop_decl_scope (void)
17731 VEC_pop (tree, decl_scope_table);
17734 /* Return the DIE for the scope that immediately contains this type.
17735 Non-named types get global scope. Named types nested in other
17736 types get their containing scope if it's open, or global scope
17737 otherwise. All other types (i.e. function-local named types) get
17738 the current active scope. */
17741 scope_die_for (tree t, dw_die_ref context_die)
17743 dw_die_ref scope_die = NULL;
17744 tree containing_scope;
17747 /* Non-types always go in the current scope. */
17748 gcc_assert (TYPE_P (t));
17750 containing_scope = TYPE_CONTEXT (t);
17752 /* Use the containing namespace if it was passed in (for a declaration). */
17753 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
17755 if (context_die == lookup_decl_die (containing_scope))
17758 containing_scope = NULL_TREE;
17761 /* Ignore function type "scopes" from the C frontend. They mean that
17762 a tagged type is local to a parmlist of a function declarator, but
17763 that isn't useful to DWARF. */
17764 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
17765 containing_scope = NULL_TREE;
17767 if (SCOPE_FILE_SCOPE_P (containing_scope))
17768 scope_die = comp_unit_die ();
17769 else if (TYPE_P (containing_scope))
17771 /* For types, we can just look up the appropriate DIE. But
17772 first we check to see if we're in the middle of emitting it
17773 so we know where the new DIE should go. */
17774 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
17775 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
17780 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
17781 || TREE_ASM_WRITTEN (containing_scope));
17782 /*We are not in the middle of emitting the type
17783 CONTAINING_SCOPE. Let's see if it's emitted already. */
17784 scope_die = lookup_type_die (containing_scope);
17786 /* If none of the current dies are suitable, we get file scope. */
17787 if (scope_die == NULL)
17788 scope_die = comp_unit_die ();
17791 scope_die = lookup_type_die (containing_scope);
17794 scope_die = context_die;
17799 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17802 local_scope_p (dw_die_ref context_die)
17804 for (; context_die; context_die = context_die->die_parent)
17805 if (context_die->die_tag == DW_TAG_inlined_subroutine
17806 || context_die->die_tag == DW_TAG_subprogram)
17812 /* Returns nonzero if CONTEXT_DIE is a class. */
17815 class_scope_p (dw_die_ref context_die)
17817 return (context_die
17818 && (context_die->die_tag == DW_TAG_structure_type
17819 || context_die->die_tag == DW_TAG_class_type
17820 || context_die->die_tag == DW_TAG_interface_type
17821 || context_die->die_tag == DW_TAG_union_type));
17824 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17825 whether or not to treat a DIE in this context as a declaration. */
17828 class_or_namespace_scope_p (dw_die_ref context_die)
17830 return (class_scope_p (context_die)
17831 || (context_die && context_die->die_tag == DW_TAG_namespace));
17834 /* Many forms of DIEs require a "type description" attribute. This
17835 routine locates the proper "type descriptor" die for the type given
17836 by 'type', and adds a DW_AT_type attribute below the given die. */
17839 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
17840 int decl_volatile, dw_die_ref context_die)
17842 enum tree_code code = TREE_CODE (type);
17843 dw_die_ref type_die = NULL;
17845 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17846 or fixed-point type, use the inner type. This is because we have no
17847 support for unnamed types in base_type_die. This can happen if this is
17848 an Ada subrange type. Correct solution is emit a subrange type die. */
17849 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
17850 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
17851 type = TREE_TYPE (type), code = TREE_CODE (type);
17853 if (code == ERROR_MARK
17854 /* Handle a special case. For functions whose return type is void, we
17855 generate *no* type attribute. (Note that no object may have type
17856 `void', so this only applies to function return types). */
17857 || code == VOID_TYPE)
17860 type_die = modified_type_die (type,
17861 decl_const || TYPE_READONLY (type),
17862 decl_volatile || TYPE_VOLATILE (type),
17865 if (type_die != NULL)
17866 add_AT_die_ref (object_die, DW_AT_type, type_die);
17869 /* Given an object die, add the calling convention attribute for the
17870 function call type. */
17872 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
17874 enum dwarf_calling_convention value = DW_CC_normal;
17876 value = ((enum dwarf_calling_convention)
17877 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
17880 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
17882 /* DWARF 2 doesn't provide a way to identify a program's source-level
17883 entry point. DW_AT_calling_convention attributes are only meant
17884 to describe functions' calling conventions. However, lacking a
17885 better way to signal the Fortran main program, we used this for
17886 a long time, following existing custom. Now, DWARF 4 has
17887 DW_AT_main_subprogram, which we add below, but some tools still
17888 rely on the old way, which we thus keep. */
17889 value = DW_CC_program;
17891 if (dwarf_version >= 4 || !dwarf_strict)
17892 add_AT_flag (subr_die, DW_AT_main_subprogram, 1);
17895 /* Only add the attribute if the backend requests it, and
17896 is not DW_CC_normal. */
17897 if (value && (value != DW_CC_normal))
17898 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
17901 /* Given a tree pointer to a struct, class, union, or enum type node, return
17902 a pointer to the (string) tag name for the given type, or zero if the type
17903 was declared without a tag. */
17905 static const char *
17906 type_tag (const_tree type)
17908 const char *name = 0;
17910 if (TYPE_NAME (type) != 0)
17914 /* Find the IDENTIFIER_NODE for the type name. */
17915 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
17916 && !TYPE_NAMELESS (type))
17917 t = TYPE_NAME (type);
17919 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17920 a TYPE_DECL node, regardless of whether or not a `typedef' was
17922 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
17923 && ! DECL_IGNORED_P (TYPE_NAME (type)))
17925 /* We want to be extra verbose. Don't call dwarf_name if
17926 DECL_NAME isn't set. The default hook for decl_printable_name
17927 doesn't like that, and in this context it's correct to return
17928 0, instead of "<anonymous>" or the like. */
17929 if (DECL_NAME (TYPE_NAME (type))
17930 && !DECL_NAMELESS (TYPE_NAME (type)))
17931 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
17934 /* Now get the name as a string, or invent one. */
17935 if (!name && t != 0)
17936 name = IDENTIFIER_POINTER (t);
17939 return (name == 0 || *name == '\0') ? 0 : name;
17942 /* Return the type associated with a data member, make a special check
17943 for bit field types. */
17946 member_declared_type (const_tree member)
17948 return (DECL_BIT_FIELD_TYPE (member)
17949 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
17952 /* Get the decl's label, as described by its RTL. This may be different
17953 from the DECL_NAME name used in the source file. */
17956 static const char *
17957 decl_start_label (tree decl)
17960 const char *fnname;
17962 x = DECL_RTL (decl);
17963 gcc_assert (MEM_P (x));
17966 gcc_assert (GET_CODE (x) == SYMBOL_REF);
17968 fnname = XSTR (x, 0);
17973 /* These routines generate the internal representation of the DIE's for
17974 the compilation unit. Debugging information is collected by walking
17975 the declaration trees passed in from dwarf2out_decl(). */
17978 gen_array_type_die (tree type, dw_die_ref context_die)
17980 dw_die_ref scope_die = scope_die_for (type, context_die);
17981 dw_die_ref array_die;
17983 /* GNU compilers represent multidimensional array types as sequences of one
17984 dimensional array types whose element types are themselves array types.
17985 We sometimes squish that down to a single array_type DIE with multiple
17986 subscripts in the Dwarf debugging info. The draft Dwarf specification
17987 say that we are allowed to do this kind of compression in C, because
17988 there is no difference between an array of arrays and a multidimensional
17989 array. We don't do this for Ada to remain as close as possible to the
17990 actual representation, which is especially important against the language
17991 flexibilty wrt arrays of variable size. */
17993 bool collapse_nested_arrays = !is_ada ();
17996 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17997 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17998 if (TYPE_STRING_FLAG (type)
17999 && TREE_CODE (type) == ARRAY_TYPE
18001 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
18003 HOST_WIDE_INT size;
18005 array_die = new_die (DW_TAG_string_type, scope_die, type);
18006 add_name_attribute (array_die, type_tag (type));
18007 equate_type_number_to_die (type, array_die);
18008 size = int_size_in_bytes (type);
18010 add_AT_unsigned (array_die, DW_AT_byte_size, size);
18011 else if (TYPE_DOMAIN (type) != NULL_TREE
18012 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
18013 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
18015 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
18016 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2);
18018 size = int_size_in_bytes (TREE_TYPE (szdecl));
18019 if (loc && size > 0)
18021 add_AT_location_description (array_die, DW_AT_string_length, loc);
18022 if (size != DWARF2_ADDR_SIZE)
18023 add_AT_unsigned (array_die, DW_AT_byte_size, size);
18029 /* ??? The SGI dwarf reader fails for array of array of enum types
18030 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
18031 array type comes before the outer array type. We thus call gen_type_die
18032 before we new_die and must prevent nested array types collapsing for this
18035 #ifdef MIPS_DEBUGGING_INFO
18036 gen_type_die (TREE_TYPE (type), context_die);
18037 collapse_nested_arrays = false;
18040 array_die = new_die (DW_TAG_array_type, scope_die, type);
18041 add_name_attribute (array_die, type_tag (type));
18042 equate_type_number_to_die (type, array_die);
18044 if (TREE_CODE (type) == VECTOR_TYPE)
18045 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
18047 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
18049 && TREE_CODE (type) == ARRAY_TYPE
18050 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
18051 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
18052 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
18055 /* We default the array ordering. SDB will probably do
18056 the right things even if DW_AT_ordering is not present. It's not even
18057 an issue until we start to get into multidimensional arrays anyway. If
18058 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
18059 then we'll have to put the DW_AT_ordering attribute back in. (But if
18060 and when we find out that we need to put these in, we will only do so
18061 for multidimensional arrays. */
18062 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
18065 #ifdef MIPS_DEBUGGING_INFO
18066 /* The SGI compilers handle arrays of unknown bound by setting
18067 AT_declaration and not emitting any subrange DIEs. */
18068 if (TREE_CODE (type) == ARRAY_TYPE
18069 && ! TYPE_DOMAIN (type))
18070 add_AT_flag (array_die, DW_AT_declaration, 1);
18073 if (TREE_CODE (type) == VECTOR_TYPE)
18075 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
18076 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
18077 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node);
18078 add_bound_info (subrange_die, DW_AT_upper_bound,
18079 size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
18082 add_subscript_info (array_die, type, collapse_nested_arrays);
18084 /* Add representation of the type of the elements of this array type and
18085 emit the corresponding DIE if we haven't done it already. */
18086 element_type = TREE_TYPE (type);
18087 if (collapse_nested_arrays)
18088 while (TREE_CODE (element_type) == ARRAY_TYPE)
18090 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
18092 element_type = TREE_TYPE (element_type);
18095 #ifndef MIPS_DEBUGGING_INFO
18096 gen_type_die (element_type, context_die);
18099 add_type_attribute (array_die, element_type, 0, 0, context_die);
18101 if (get_AT (array_die, DW_AT_name))
18102 add_pubtype (type, array_die);
18105 static dw_loc_descr_ref
18106 descr_info_loc (tree val, tree base_decl)
18108 HOST_WIDE_INT size;
18109 dw_loc_descr_ref loc, loc2;
18110 enum dwarf_location_atom op;
18112 if (val == base_decl)
18113 return new_loc_descr (DW_OP_push_object_address, 0, 0);
18115 switch (TREE_CODE (val))
18118 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18120 return loc_descriptor_from_tree (val, 0);
18122 if (host_integerp (val, 0))
18123 return int_loc_descriptor (tree_low_cst (val, 0));
18126 size = int_size_in_bytes (TREE_TYPE (val));
18129 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18132 if (size == DWARF2_ADDR_SIZE)
18133 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
18135 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
18137 case POINTER_PLUS_EXPR:
18139 if (host_integerp (TREE_OPERAND (val, 1), 1)
18140 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
18143 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18146 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
18152 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
18155 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
18158 add_loc_descr (&loc, loc2);
18159 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
18181 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
18182 tree val, tree base_decl)
18184 dw_loc_descr_ref loc;
18186 if (host_integerp (val, 0))
18188 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
18192 loc = descr_info_loc (val, base_decl);
18196 add_AT_loc (die, attr, loc);
18199 /* This routine generates DIE for array with hidden descriptor, details
18200 are filled into *info by a langhook. */
18203 gen_descr_array_type_die (tree type, struct array_descr_info *info,
18204 dw_die_ref context_die)
18206 dw_die_ref scope_die = scope_die_for (type, context_die);
18207 dw_die_ref array_die;
18210 array_die = new_die (DW_TAG_array_type, scope_die, type);
18211 add_name_attribute (array_die, type_tag (type));
18212 equate_type_number_to_die (type, array_die);
18214 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
18216 && info->ndimensions >= 2)
18217 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
18219 if (info->data_location)
18220 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
18222 if (info->associated)
18223 add_descr_info_field (array_die, DW_AT_associated, info->associated,
18225 if (info->allocated)
18226 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
18229 for (dim = 0; dim < info->ndimensions; dim++)
18231 dw_die_ref subrange_die
18232 = new_die (DW_TAG_subrange_type, array_die, NULL);
18234 if (info->dimen[dim].lower_bound)
18236 /* If it is the default value, omit it. */
18239 if (host_integerp (info->dimen[dim].lower_bound, 0)
18240 && (dflt = lower_bound_default ()) != -1
18241 && tree_low_cst (info->dimen[dim].lower_bound, 0) == dflt)
18244 add_descr_info_field (subrange_die, DW_AT_lower_bound,
18245 info->dimen[dim].lower_bound,
18248 if (info->dimen[dim].upper_bound)
18249 add_descr_info_field (subrange_die, DW_AT_upper_bound,
18250 info->dimen[dim].upper_bound,
18252 if (info->dimen[dim].stride)
18253 add_descr_info_field (subrange_die, DW_AT_byte_stride,
18254 info->dimen[dim].stride,
18258 gen_type_die (info->element_type, context_die);
18259 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
18261 if (get_AT (array_die, DW_AT_name))
18262 add_pubtype (type, array_die);
18267 gen_entry_point_die (tree decl, dw_die_ref context_die)
18269 tree origin = decl_ultimate_origin (decl);
18270 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
18272 if (origin != NULL)
18273 add_abstract_origin_attribute (decl_die, origin);
18276 add_name_and_src_coords_attributes (decl_die, decl);
18277 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
18278 0, 0, context_die);
18281 if (DECL_ABSTRACT (decl))
18282 equate_decl_number_to_die (decl, decl_die);
18284 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
18288 /* Walk through the list of incomplete types again, trying once more to
18289 emit full debugging info for them. */
18292 retry_incomplete_types (void)
18296 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
18297 if (should_emit_struct_debug (VEC_index (tree, incomplete_types, i),
18298 DINFO_USAGE_DIR_USE))
18299 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die ());
18302 /* Determine what tag to use for a record type. */
18304 static enum dwarf_tag
18305 record_type_tag (tree type)
18307 if (! lang_hooks.types.classify_record)
18308 return DW_TAG_structure_type;
18310 switch (lang_hooks.types.classify_record (type))
18312 case RECORD_IS_STRUCT:
18313 return DW_TAG_structure_type;
18315 case RECORD_IS_CLASS:
18316 return DW_TAG_class_type;
18318 case RECORD_IS_INTERFACE:
18319 if (dwarf_version >= 3 || !dwarf_strict)
18320 return DW_TAG_interface_type;
18321 return DW_TAG_structure_type;
18324 gcc_unreachable ();
18328 /* Generate a DIE to represent an enumeration type. Note that these DIEs
18329 include all of the information about the enumeration values also. Each
18330 enumerated type name/value is listed as a child of the enumerated type
18334 gen_enumeration_type_die (tree type, dw_die_ref context_die)
18336 dw_die_ref type_die = lookup_type_die (type);
18338 if (type_die == NULL)
18340 type_die = new_die (DW_TAG_enumeration_type,
18341 scope_die_for (type, context_die), type);
18342 equate_type_number_to_die (type, type_die);
18343 add_name_attribute (type_die, type_tag (type));
18344 if (dwarf_version >= 4 || !dwarf_strict)
18346 if (ENUM_IS_SCOPED (type))
18347 add_AT_flag (type_die, DW_AT_enum_class, 1);
18348 if (ENUM_IS_OPAQUE (type))
18349 add_AT_flag (type_die, DW_AT_declaration, 1);
18352 else if (! TYPE_SIZE (type))
18355 remove_AT (type_die, DW_AT_declaration);
18357 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
18358 given enum type is incomplete, do not generate the DW_AT_byte_size
18359 attribute or the DW_AT_element_list attribute. */
18360 if (TYPE_SIZE (type))
18364 TREE_ASM_WRITTEN (type) = 1;
18365 add_byte_size_attribute (type_die, type);
18366 if (TYPE_STUB_DECL (type) != NULL_TREE)
18368 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
18369 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
18372 /* If the first reference to this type was as the return type of an
18373 inline function, then it may not have a parent. Fix this now. */
18374 if (type_die->die_parent == NULL)
18375 add_child_die (scope_die_for (type, context_die), type_die);
18377 for (link = TYPE_VALUES (type);
18378 link != NULL; link = TREE_CHAIN (link))
18380 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
18381 tree value = TREE_VALUE (link);
18383 add_name_attribute (enum_die,
18384 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
18386 if (TREE_CODE (value) == CONST_DECL)
18387 value = DECL_INITIAL (value);
18389 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
18390 /* DWARF2 does not provide a way of indicating whether or
18391 not enumeration constants are signed or unsigned. GDB
18392 always assumes the values are signed, so we output all
18393 values as if they were signed. That means that
18394 enumeration constants with very large unsigned values
18395 will appear to have negative values in the debugger. */
18396 add_AT_int (enum_die, DW_AT_const_value,
18397 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
18401 add_AT_flag (type_die, DW_AT_declaration, 1);
18403 if (get_AT (type_die, DW_AT_name))
18404 add_pubtype (type, type_die);
18409 /* Generate a DIE to represent either a real live formal parameter decl or to
18410 represent just the type of some formal parameter position in some function
18413 Note that this routine is a bit unusual because its argument may be a
18414 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
18415 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
18416 node. If it's the former then this function is being called to output a
18417 DIE to represent a formal parameter object (or some inlining thereof). If
18418 it's the latter, then this function is only being called to output a
18419 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
18420 argument type of some subprogram type.
18421 If EMIT_NAME_P is true, name and source coordinate attributes
18425 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
18426 dw_die_ref context_die)
18428 tree node_or_origin = node ? node : origin;
18429 tree ultimate_origin;
18430 dw_die_ref parm_die
18431 = new_die (DW_TAG_formal_parameter, context_die, node);
18433 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
18435 case tcc_declaration:
18436 ultimate_origin = decl_ultimate_origin (node_or_origin);
18437 if (node || ultimate_origin)
18438 origin = ultimate_origin;
18439 if (origin != NULL)
18440 add_abstract_origin_attribute (parm_die, origin);
18441 else if (emit_name_p)
18442 add_name_and_src_coords_attributes (parm_die, node);
18444 || (! DECL_ABSTRACT (node_or_origin)
18445 && variably_modified_type_p (TREE_TYPE (node_or_origin),
18446 decl_function_context
18447 (node_or_origin))))
18449 tree type = TREE_TYPE (node_or_origin);
18450 if (decl_by_reference_p (node_or_origin))
18451 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
18454 add_type_attribute (parm_die, type,
18455 TREE_READONLY (node_or_origin),
18456 TREE_THIS_VOLATILE (node_or_origin),
18459 if (origin == NULL && DECL_ARTIFICIAL (node))
18460 add_AT_flag (parm_die, DW_AT_artificial, 1);
18462 if (node && node != origin)
18463 equate_decl_number_to_die (node, parm_die);
18464 if (! DECL_ABSTRACT (node_or_origin))
18465 add_location_or_const_value_attribute (parm_die, node_or_origin,
18471 /* We were called with some kind of a ..._TYPE node. */
18472 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
18476 gcc_unreachable ();
18482 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
18483 children DW_TAG_formal_parameter DIEs representing the arguments of the
18486 PARM_PACK must be a function parameter pack.
18487 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
18488 must point to the subsequent arguments of the function PACK_ARG belongs to.
18489 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
18490 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
18491 following the last one for which a DIE was generated. */
18494 gen_formal_parameter_pack_die (tree parm_pack,
18496 dw_die_ref subr_die,
18500 dw_die_ref parm_pack_die;
18502 gcc_assert (parm_pack
18503 && lang_hooks.function_parameter_pack_p (parm_pack)
18506 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
18507 add_src_coords_attributes (parm_pack_die, parm_pack);
18509 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg))
18511 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
18514 gen_formal_parameter_die (arg, NULL,
18515 false /* Don't emit name attribute. */,
18520 return parm_pack_die;
18523 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
18524 at the end of an (ANSI prototyped) formal parameters list. */
18527 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
18529 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
18532 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
18533 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
18534 parameters as specified in some function type specification (except for
18535 those which appear as part of a function *definition*). */
18538 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
18541 tree formal_type = NULL;
18542 tree first_parm_type;
18545 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
18547 arg = DECL_ARGUMENTS (function_or_method_type);
18548 function_or_method_type = TREE_TYPE (function_or_method_type);
18553 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
18555 /* Make our first pass over the list of formal parameter types and output a
18556 DW_TAG_formal_parameter DIE for each one. */
18557 for (link = first_parm_type; link; )
18559 dw_die_ref parm_die;
18561 formal_type = TREE_VALUE (link);
18562 if (formal_type == void_type_node)
18565 /* Output a (nameless) DIE to represent the formal parameter itself. */
18566 parm_die = gen_formal_parameter_die (formal_type, NULL,
18567 true /* Emit name attribute. */,
18569 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
18570 && link == first_parm_type)
18572 add_AT_flag (parm_die, DW_AT_artificial, 1);
18573 if (dwarf_version >= 3 || !dwarf_strict)
18574 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die);
18576 else if (arg && DECL_ARTIFICIAL (arg))
18577 add_AT_flag (parm_die, DW_AT_artificial, 1);
18579 link = TREE_CHAIN (link);
18581 arg = DECL_CHAIN (arg);
18584 /* If this function type has an ellipsis, add a
18585 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
18586 if (formal_type != void_type_node)
18587 gen_unspecified_parameters_die (function_or_method_type, context_die);
18589 /* Make our second (and final) pass over the list of formal parameter types
18590 and output DIEs to represent those types (as necessary). */
18591 for (link = TYPE_ARG_TYPES (function_or_method_type);
18592 link && TREE_VALUE (link);
18593 link = TREE_CHAIN (link))
18594 gen_type_die (TREE_VALUE (link), context_die);
18597 /* We want to generate the DIE for TYPE so that we can generate the
18598 die for MEMBER, which has been defined; we will need to refer back
18599 to the member declaration nested within TYPE. If we're trying to
18600 generate minimal debug info for TYPE, processing TYPE won't do the
18601 trick; we need to attach the member declaration by hand. */
18604 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
18606 gen_type_die (type, context_die);
18608 /* If we're trying to avoid duplicate debug info, we may not have
18609 emitted the member decl for this function. Emit it now. */
18610 if (TYPE_STUB_DECL (type)
18611 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
18612 && ! lookup_decl_die (member))
18614 dw_die_ref type_die;
18615 gcc_assert (!decl_ultimate_origin (member));
18617 push_decl_scope (type);
18618 type_die = lookup_type_die (type);
18619 if (TREE_CODE (member) == FUNCTION_DECL)
18620 gen_subprogram_die (member, type_die);
18621 else if (TREE_CODE (member) == FIELD_DECL)
18623 /* Ignore the nameless fields that are used to skip bits but handle
18624 C++ anonymous unions and structs. */
18625 if (DECL_NAME (member) != NULL_TREE
18626 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
18627 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
18629 gen_type_die (member_declared_type (member), type_die);
18630 gen_field_die (member, type_die);
18634 gen_variable_die (member, NULL_TREE, type_die);
18640 /* Generate the DWARF2 info for the "abstract" instance of a function which we
18641 may later generate inlined and/or out-of-line instances of. */
18644 dwarf2out_abstract_function (tree decl)
18646 dw_die_ref old_die;
18650 htab_t old_decl_loc_table;
18652 /* Make sure we have the actual abstract inline, not a clone. */
18653 decl = DECL_ORIGIN (decl);
18655 old_die = lookup_decl_die (decl);
18656 if (old_die && get_AT (old_die, DW_AT_inline))
18657 /* We've already generated the abstract instance. */
18660 /* We can be called while recursively when seeing block defining inlined subroutine
18661 DIE. Be sure to not clobber the outer location table nor use it or we would
18662 get locations in abstract instantces. */
18663 old_decl_loc_table = decl_loc_table;
18664 decl_loc_table = NULL;
18666 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
18667 we don't get confused by DECL_ABSTRACT. */
18668 if (debug_info_level > DINFO_LEVEL_TERSE)
18670 context = decl_class_context (decl);
18672 gen_type_die_for_member
18673 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die ());
18676 /* Pretend we've just finished compiling this function. */
18677 save_fn = current_function_decl;
18678 current_function_decl = decl;
18679 push_cfun (DECL_STRUCT_FUNCTION (decl));
18681 was_abstract = DECL_ABSTRACT (decl);
18682 set_decl_abstract_flags (decl, 1);
18683 dwarf2out_decl (decl);
18684 if (! was_abstract)
18685 set_decl_abstract_flags (decl, 0);
18687 current_function_decl = save_fn;
18688 decl_loc_table = old_decl_loc_table;
18692 /* Helper function of premark_used_types() which gets called through
18695 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18696 marked as unused by prune_unused_types. */
18699 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
18704 type = (tree) *slot;
18705 die = lookup_type_die (type);
18707 die->die_perennial_p = 1;
18711 /* Helper function of premark_types_used_by_global_vars which gets called
18712 through htab_traverse.
18714 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18715 marked as unused by prune_unused_types. The DIE of the type is marked
18716 only if the global variable using the type will actually be emitted. */
18719 premark_types_used_by_global_vars_helper (void **slot,
18720 void *data ATTRIBUTE_UNUSED)
18722 struct types_used_by_vars_entry *entry;
18725 entry = (struct types_used_by_vars_entry *) *slot;
18726 gcc_assert (entry->type != NULL
18727 && entry->var_decl != NULL);
18728 die = lookup_type_die (entry->type);
18731 /* Ask cgraph if the global variable really is to be emitted.
18732 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18733 struct varpool_node *node = varpool_get_node (entry->var_decl);
18734 if (node && node->needed)
18736 die->die_perennial_p = 1;
18737 /* Keep the parent DIEs as well. */
18738 while ((die = die->die_parent) && die->die_perennial_p == 0)
18739 die->die_perennial_p = 1;
18745 /* Mark all members of used_types_hash as perennial. */
18748 premark_used_types (void)
18750 if (cfun && cfun->used_types_hash)
18751 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
18754 /* Mark all members of types_used_by_vars_entry as perennial. */
18757 premark_types_used_by_global_vars (void)
18759 if (types_used_by_vars_hash)
18760 htab_traverse (types_used_by_vars_hash,
18761 premark_types_used_by_global_vars_helper, NULL);
18764 /* Generate a DIE to represent a declared function (either file-scope or
18768 gen_subprogram_die (tree decl, dw_die_ref context_die)
18770 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
18771 tree origin = decl_ultimate_origin (decl);
18772 dw_die_ref subr_die;
18775 dw_die_ref old_die = lookup_decl_die (decl);
18776 int declaration = (current_function_decl != decl
18777 || class_or_namespace_scope_p (context_die));
18779 premark_used_types ();
18781 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
18782 started to generate the abstract instance of an inline, decided to output
18783 its containing class, and proceeded to emit the declaration of the inline
18784 from the member list for the class. If so, DECLARATION takes priority;
18785 we'll get back to the abstract instance when done with the class. */
18787 /* The class-scope declaration DIE must be the primary DIE. */
18788 if (origin && declaration && class_or_namespace_scope_p (context_die))
18791 gcc_assert (!old_die);
18794 /* Now that the C++ front end lazily declares artificial member fns, we
18795 might need to retrofit the declaration into its class. */
18796 if (!declaration && !origin && !old_die
18797 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
18798 && !class_or_namespace_scope_p (context_die)
18799 && debug_info_level > DINFO_LEVEL_TERSE)
18800 old_die = force_decl_die (decl);
18802 if (origin != NULL)
18804 gcc_assert (!declaration || local_scope_p (context_die));
18806 /* Fixup die_parent for the abstract instance of a nested
18807 inline function. */
18808 if (old_die && old_die->die_parent == NULL)
18809 add_child_die (context_die, old_die);
18811 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18812 add_abstract_origin_attribute (subr_die, origin);
18816 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
18817 struct dwarf_file_data * file_index = lookup_filename (s.file);
18819 if (!get_AT_flag (old_die, DW_AT_declaration)
18820 /* We can have a normal definition following an inline one in the
18821 case of redefinition of GNU C extern inlines.
18822 It seems reasonable to use AT_specification in this case. */
18823 && !get_AT (old_die, DW_AT_inline))
18825 /* Detect and ignore this case, where we are trying to output
18826 something we have already output. */
18830 /* If the definition comes from the same place as the declaration,
18831 maybe use the old DIE. We always want the DIE for this function
18832 that has the *_pc attributes to be under comp_unit_die so the
18833 debugger can find it. We also need to do this for abstract
18834 instances of inlines, since the spec requires the out-of-line copy
18835 to have the same parent. For local class methods, this doesn't
18836 apply; we just use the old DIE. */
18837 if ((is_cu_die (old_die->die_parent) || context_die == NULL)
18838 && (DECL_ARTIFICIAL (decl)
18839 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
18840 && (get_AT_unsigned (old_die, DW_AT_decl_line)
18841 == (unsigned) s.line))))
18843 subr_die = old_die;
18845 /* Clear out the declaration attribute and the formal parameters.
18846 Do not remove all children, because it is possible that this
18847 declaration die was forced using force_decl_die(). In such
18848 cases die that forced declaration die (e.g. TAG_imported_module)
18849 is one of the children that we do not want to remove. */
18850 remove_AT (subr_die, DW_AT_declaration);
18851 remove_AT (subr_die, DW_AT_object_pointer);
18852 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
18856 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18857 add_AT_specification (subr_die, old_die);
18858 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
18859 add_AT_file (subr_die, DW_AT_decl_file, file_index);
18860 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
18861 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
18866 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18868 if (TREE_PUBLIC (decl))
18869 add_AT_flag (subr_die, DW_AT_external, 1);
18871 add_name_and_src_coords_attributes (subr_die, decl);
18872 if (debug_info_level > DINFO_LEVEL_TERSE)
18874 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
18875 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18876 0, 0, context_die);
18879 add_pure_or_virtual_attribute (subr_die, decl);
18880 if (DECL_ARTIFICIAL (decl))
18881 add_AT_flag (subr_die, DW_AT_artificial, 1);
18883 add_accessibility_attribute (subr_die, decl);
18888 if (!old_die || !get_AT (old_die, DW_AT_inline))
18890 add_AT_flag (subr_die, DW_AT_declaration, 1);
18892 /* If this is an explicit function declaration then generate
18893 a DW_AT_explicit attribute. */
18894 if (lang_hooks.decls.function_decl_explicit_p (decl)
18895 && (dwarf_version >= 3 || !dwarf_strict))
18896 add_AT_flag (subr_die, DW_AT_explicit, 1);
18898 /* The first time we see a member function, it is in the context of
18899 the class to which it belongs. We make sure of this by emitting
18900 the class first. The next time is the definition, which is
18901 handled above. The two may come from the same source text.
18903 Note that force_decl_die() forces function declaration die. It is
18904 later reused to represent definition. */
18905 equate_decl_number_to_die (decl, subr_die);
18908 else if (DECL_ABSTRACT (decl))
18910 if (DECL_DECLARED_INLINE_P (decl))
18912 if (cgraph_function_possibly_inlined_p (decl))
18913 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
18915 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
18919 if (cgraph_function_possibly_inlined_p (decl))
18920 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
18922 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
18925 if (DECL_DECLARED_INLINE_P (decl)
18926 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
18927 add_AT_flag (subr_die, DW_AT_artificial, 1);
18929 equate_decl_number_to_die (decl, subr_die);
18931 else if (!DECL_EXTERNAL (decl))
18933 HOST_WIDE_INT cfa_fb_offset;
18935 if (!old_die || !get_AT (old_die, DW_AT_inline))
18936 equate_decl_number_to_die (decl, subr_die);
18938 if (!flag_reorder_blocks_and_partition)
18940 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
18941 current_function_funcdef_no);
18942 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
18943 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
18944 current_function_funcdef_no);
18945 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
18947 #if VMS_DEBUGGING_INFO
18948 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18949 Section 2.3 Prologue and Epilogue Attributes:
18950 When a breakpoint is set on entry to a function, it is generally
18951 desirable for execution to be suspended, not on the very first
18952 instruction of the function, but rather at a point after the
18953 function's frame has been set up, after any language defined local
18954 declaration processing has been completed, and before execution of
18955 the first statement of the function begins. Debuggers generally
18956 cannot properly determine where this point is. Similarly for a
18957 breakpoint set on exit from a function. The prologue and epilogue
18958 attributes allow a compiler to communicate the location(s) to use. */
18961 dw_fde_ref fde = &fde_table[current_funcdef_fde];
18963 if (fde->dw_fde_vms_end_prologue)
18964 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
18965 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
18967 if (fde->dw_fde_vms_begin_epilogue)
18968 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
18969 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
18973 add_pubname (decl, subr_die);
18974 add_arange (decl, subr_die);
18977 { /* Do nothing for now; maybe need to duplicate die, one for
18978 hot section and one for cold section, then use the hot/cold
18979 section begin/end labels to generate the aranges... */
18981 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
18982 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
18983 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
18984 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
18986 add_pubname (decl, subr_die);
18987 add_arange (decl, subr_die);
18988 add_arange (decl, subr_die);
18992 #ifdef MIPS_DEBUGGING_INFO
18993 /* Add a reference to the FDE for this routine. */
18994 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
18997 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
18999 /* We define the "frame base" as the function's CFA. This is more
19000 convenient for several reasons: (1) It's stable across the prologue
19001 and epilogue, which makes it better than just a frame pointer,
19002 (2) With dwarf3, there exists a one-byte encoding that allows us
19003 to reference the .debug_frame data by proxy, but failing that,
19004 (3) We can at least reuse the code inspection and interpretation
19005 code that determines the CFA position at various points in the
19007 if (dwarf_version >= 3)
19009 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
19010 add_AT_loc (subr_die, DW_AT_frame_base, op);
19014 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
19015 if (list->dw_loc_next)
19016 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
19018 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
19021 /* Compute a displacement from the "steady-state frame pointer" to
19022 the CFA. The former is what all stack slots and argument slots
19023 will reference in the rtl; the later is what we've told the
19024 debugger about. We'll need to adjust all frame_base references
19025 by this displacement. */
19026 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
19028 if (cfun->static_chain_decl)
19029 add_AT_location_description (subr_die, DW_AT_static_link,
19030 loc_list_from_tree (cfun->static_chain_decl, 2));
19033 /* Generate child dies for template paramaters. */
19034 if (debug_info_level > DINFO_LEVEL_TERSE)
19035 gen_generic_params_dies (decl);
19037 /* Now output descriptions of the arguments for this function. This gets
19038 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
19039 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
19040 `...' at the end of the formal parameter list. In order to find out if
19041 there was a trailing ellipsis or not, we must instead look at the type
19042 associated with the FUNCTION_DECL. This will be a node of type
19043 FUNCTION_TYPE. If the chain of type nodes hanging off of this
19044 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
19045 an ellipsis at the end. */
19047 /* In the case where we are describing a mere function declaration, all we
19048 need to do here (and all we *can* do here) is to describe the *types* of
19049 its formal parameters. */
19050 if (debug_info_level <= DINFO_LEVEL_TERSE)
19052 else if (declaration)
19053 gen_formal_types_die (decl, subr_die);
19056 /* Generate DIEs to represent all known formal parameters. */
19057 tree parm = DECL_ARGUMENTS (decl);
19058 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
19059 tree generic_decl_parm = generic_decl
19060 ? DECL_ARGUMENTS (generic_decl)
19063 /* Now we want to walk the list of parameters of the function and
19064 emit their relevant DIEs.
19066 We consider the case of DECL being an instance of a generic function
19067 as well as it being a normal function.
19069 If DECL is an instance of a generic function we walk the
19070 parameters of the generic function declaration _and_ the parameters of
19071 DECL itself. This is useful because we want to emit specific DIEs for
19072 function parameter packs and those are declared as part of the
19073 generic function declaration. In that particular case,
19074 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
19075 That DIE has children DIEs representing the set of arguments
19076 of the pack. Note that the set of pack arguments can be empty.
19077 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
19080 Otherwise, we just consider the parameters of DECL. */
19081 while (generic_decl_parm || parm)
19083 if (generic_decl_parm
19084 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
19085 gen_formal_parameter_pack_die (generic_decl_parm,
19090 dw_die_ref parm_die = gen_decl_die (parm, NULL, subr_die);
19092 if (parm == DECL_ARGUMENTS (decl)
19093 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
19095 && (dwarf_version >= 3 || !dwarf_strict))
19096 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die);
19098 parm = DECL_CHAIN (parm);
19101 if (generic_decl_parm)
19102 generic_decl_parm = DECL_CHAIN (generic_decl_parm);
19105 /* Decide whether we need an unspecified_parameters DIE at the end.
19106 There are 2 more cases to do this for: 1) the ansi ... declaration -
19107 this is detectable when the end of the arg list is not a
19108 void_type_node 2) an unprototyped function declaration (not a
19109 definition). This just means that we have no info about the
19110 parameters at all. */
19111 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
19112 if (fn_arg_types != NULL)
19114 /* This is the prototyped case, check for.... */
19115 if (stdarg_p (TREE_TYPE (decl)))
19116 gen_unspecified_parameters_die (decl, subr_die);
19118 else if (DECL_INITIAL (decl) == NULL_TREE)
19119 gen_unspecified_parameters_die (decl, subr_die);
19122 /* Output Dwarf info for all of the stuff within the body of the function
19123 (if it has one - it may be just a declaration). */
19124 outer_scope = DECL_INITIAL (decl);
19126 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
19127 a function. This BLOCK actually represents the outermost binding contour
19128 for the function, i.e. the contour in which the function's formal
19129 parameters and labels get declared. Curiously, it appears that the front
19130 end doesn't actually put the PARM_DECL nodes for the current function onto
19131 the BLOCK_VARS list for this outer scope, but are strung off of the
19132 DECL_ARGUMENTS list for the function instead.
19134 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
19135 the LABEL_DECL nodes for the function however, and we output DWARF info
19136 for those in decls_for_scope. Just within the `outer_scope' there will be
19137 a BLOCK node representing the function's outermost pair of curly braces,
19138 and any blocks used for the base and member initializers of a C++
19139 constructor function. */
19140 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
19142 /* Emit a DW_TAG_variable DIE for a named return value. */
19143 if (DECL_NAME (DECL_RESULT (decl)))
19144 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
19146 current_function_has_inlines = 0;
19147 decls_for_scope (outer_scope, subr_die, 0);
19149 /* Add the calling convention attribute if requested. */
19150 add_calling_convention_attribute (subr_die, decl);
19154 /* Returns a hash value for X (which really is a die_struct). */
19157 common_block_die_table_hash (const void *x)
19159 const_dw_die_ref d = (const_dw_die_ref) x;
19160 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
19163 /* Return nonzero if decl_id and die_parent of die_struct X is the same
19164 as decl_id and die_parent of die_struct Y. */
19167 common_block_die_table_eq (const void *x, const void *y)
19169 const_dw_die_ref d = (const_dw_die_ref) x;
19170 const_dw_die_ref e = (const_dw_die_ref) y;
19171 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
19174 /* Generate a DIE to represent a declared data object.
19175 Either DECL or ORIGIN must be non-null. */
19178 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
19182 tree decl_or_origin = decl ? decl : origin;
19183 tree ultimate_origin;
19184 dw_die_ref var_die;
19185 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
19186 dw_die_ref origin_die;
19187 bool declaration = (DECL_EXTERNAL (decl_or_origin)
19188 || class_or_namespace_scope_p (context_die));
19189 bool specialization_p = false;
19191 ultimate_origin = decl_ultimate_origin (decl_or_origin);
19192 if (decl || ultimate_origin)
19193 origin = ultimate_origin;
19194 com_decl = fortran_common (decl_or_origin, &off);
19196 /* Symbol in common gets emitted as a child of the common block, in the form
19197 of a data member. */
19200 dw_die_ref com_die;
19201 dw_loc_list_ref loc;
19202 die_node com_die_arg;
19204 var_die = lookup_decl_die (decl_or_origin);
19207 if (get_AT (var_die, DW_AT_location) == NULL)
19209 loc = loc_list_from_tree (com_decl, off ? 1 : 2);
19214 /* Optimize the common case. */
19215 if (single_element_loc_list_p (loc)
19216 && loc->expr->dw_loc_opc == DW_OP_addr
19217 && loc->expr->dw_loc_next == NULL
19218 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
19220 loc->expr->dw_loc_oprnd1.v.val_addr
19221 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
19223 loc_list_plus_const (loc, off);
19225 add_AT_location_description (var_die, DW_AT_location, loc);
19226 remove_AT (var_die, DW_AT_declaration);
19232 if (common_block_die_table == NULL)
19233 common_block_die_table
19234 = htab_create_ggc (10, common_block_die_table_hash,
19235 common_block_die_table_eq, NULL);
19237 com_die_arg.decl_id = DECL_UID (com_decl);
19238 com_die_arg.die_parent = context_die;
19239 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
19240 loc = loc_list_from_tree (com_decl, 2);
19241 if (com_die == NULL)
19244 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
19247 com_die = new_die (DW_TAG_common_block, context_die, decl);
19248 add_name_and_src_coords_attributes (com_die, com_decl);
19251 add_AT_location_description (com_die, DW_AT_location, loc);
19252 /* Avoid sharing the same loc descriptor between
19253 DW_TAG_common_block and DW_TAG_variable. */
19254 loc = loc_list_from_tree (com_decl, 2);
19256 else if (DECL_EXTERNAL (decl))
19257 add_AT_flag (com_die, DW_AT_declaration, 1);
19258 add_pubname_string (cnam, com_die); /* ??? needed? */
19259 com_die->decl_id = DECL_UID (com_decl);
19260 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
19261 *slot = (void *) com_die;
19263 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
19265 add_AT_location_description (com_die, DW_AT_location, loc);
19266 loc = loc_list_from_tree (com_decl, 2);
19267 remove_AT (com_die, DW_AT_declaration);
19269 var_die = new_die (DW_TAG_variable, com_die, decl);
19270 add_name_and_src_coords_attributes (var_die, decl);
19271 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
19272 TREE_THIS_VOLATILE (decl), context_die);
19273 add_AT_flag (var_die, DW_AT_external, 1);
19278 /* Optimize the common case. */
19279 if (single_element_loc_list_p (loc)
19280 && loc->expr->dw_loc_opc == DW_OP_addr
19281 && loc->expr->dw_loc_next == NULL
19282 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
19283 loc->expr->dw_loc_oprnd1.v.val_addr
19284 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
19286 loc_list_plus_const (loc, off);
19288 add_AT_location_description (var_die, DW_AT_location, loc);
19290 else if (DECL_EXTERNAL (decl))
19291 add_AT_flag (var_die, DW_AT_declaration, 1);
19292 equate_decl_number_to_die (decl, var_die);
19296 /* If the compiler emitted a definition for the DECL declaration
19297 and if we already emitted a DIE for it, don't emit a second
19298 DIE for it again. Allow re-declarations of DECLs that are
19299 inside functions, though. */
19300 if (old_die && declaration && !local_scope_p (context_die))
19303 /* For static data members, the declaration in the class is supposed
19304 to have DW_TAG_member tag; the specification should still be
19305 DW_TAG_variable referencing the DW_TAG_member DIE. */
19306 if (declaration && class_scope_p (context_die))
19307 var_die = new_die (DW_TAG_member, context_die, decl);
19309 var_die = new_die (DW_TAG_variable, context_die, decl);
19312 if (origin != NULL)
19313 origin_die = add_abstract_origin_attribute (var_die, origin);
19315 /* Loop unrolling can create multiple blocks that refer to the same
19316 static variable, so we must test for the DW_AT_declaration flag.
19318 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
19319 copy decls and set the DECL_ABSTRACT flag on them instead of
19322 ??? Duplicated blocks have been rewritten to use .debug_ranges.
19324 ??? The declare_in_namespace support causes us to get two DIEs for one
19325 variable, both of which are declarations. We want to avoid considering
19326 one to be a specification, so we must test that this DIE is not a
19328 else if (old_die && TREE_STATIC (decl) && ! declaration
19329 && get_AT_flag (old_die, DW_AT_declaration) == 1)
19331 /* This is a definition of a C++ class level static. */
19332 add_AT_specification (var_die, old_die);
19333 specialization_p = true;
19334 if (DECL_NAME (decl))
19336 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
19337 struct dwarf_file_data * file_index = lookup_filename (s.file);
19339 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
19340 add_AT_file (var_die, DW_AT_decl_file, file_index);
19342 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
19343 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
19345 if (old_die->die_tag == DW_TAG_member)
19346 add_linkage_name (var_die, decl);
19350 add_name_and_src_coords_attributes (var_die, decl);
19352 if ((origin == NULL && !specialization_p)
19354 && !DECL_ABSTRACT (decl_or_origin)
19355 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
19356 decl_function_context
19357 (decl_or_origin))))
19359 tree type = TREE_TYPE (decl_or_origin);
19361 if (decl_by_reference_p (decl_or_origin))
19362 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
19364 add_type_attribute (var_die, type, TREE_READONLY (decl_or_origin),
19365 TREE_THIS_VOLATILE (decl_or_origin), context_die);
19368 if (origin == NULL && !specialization_p)
19370 if (TREE_PUBLIC (decl))
19371 add_AT_flag (var_die, DW_AT_external, 1);
19373 if (DECL_ARTIFICIAL (decl))
19374 add_AT_flag (var_die, DW_AT_artificial, 1);
19376 add_accessibility_attribute (var_die, decl);
19380 add_AT_flag (var_die, DW_AT_declaration, 1);
19382 if (decl && (DECL_ABSTRACT (decl) || declaration || old_die == NULL))
19383 equate_decl_number_to_die (decl, var_die);
19386 && (! DECL_ABSTRACT (decl_or_origin)
19387 /* Local static vars are shared between all clones/inlines,
19388 so emit DW_AT_location on the abstract DIE if DECL_RTL is
19390 || (TREE_CODE (decl_or_origin) == VAR_DECL
19391 && TREE_STATIC (decl_or_origin)
19392 && DECL_RTL_SET_P (decl_or_origin)))
19393 /* When abstract origin already has DW_AT_location attribute, no need
19394 to add it again. */
19395 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
19397 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
19398 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
19399 defer_location (decl_or_origin, var_die);
19401 add_location_or_const_value_attribute (var_die,
19404 add_pubname (decl_or_origin, var_die);
19407 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
19410 /* Generate a DIE to represent a named constant. */
19413 gen_const_die (tree decl, dw_die_ref context_die)
19415 dw_die_ref const_die;
19416 tree type = TREE_TYPE (decl);
19418 const_die = new_die (DW_TAG_constant, context_die, decl);
19419 add_name_and_src_coords_attributes (const_die, decl);
19420 add_type_attribute (const_die, type, 1, 0, context_die);
19421 if (TREE_PUBLIC (decl))
19422 add_AT_flag (const_die, DW_AT_external, 1);
19423 if (DECL_ARTIFICIAL (decl))
19424 add_AT_flag (const_die, DW_AT_artificial, 1);
19425 tree_add_const_value_attribute_for_decl (const_die, decl);
19428 /* Generate a DIE to represent a label identifier. */
19431 gen_label_die (tree decl, dw_die_ref context_die)
19433 tree origin = decl_ultimate_origin (decl);
19434 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
19436 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19438 if (origin != NULL)
19439 add_abstract_origin_attribute (lbl_die, origin);
19441 add_name_and_src_coords_attributes (lbl_die, decl);
19443 if (DECL_ABSTRACT (decl))
19444 equate_decl_number_to_die (decl, lbl_die);
19447 insn = DECL_RTL_IF_SET (decl);
19449 /* Deleted labels are programmer specified labels which have been
19450 eliminated because of various optimizations. We still emit them
19451 here so that it is possible to put breakpoints on them. */
19455 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
19457 /* When optimization is enabled (via -O) some parts of the compiler
19458 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19459 represent source-level labels which were explicitly declared by
19460 the user. This really shouldn't be happening though, so catch
19461 it if it ever does happen. */
19462 gcc_assert (!INSN_DELETED_P (insn));
19464 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
19465 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19470 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19471 attributes to the DIE for a block STMT, to describe where the inlined
19472 function was called from. This is similar to add_src_coords_attributes. */
19475 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
19477 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
19479 if (dwarf_version >= 3 || !dwarf_strict)
19481 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
19482 add_AT_unsigned (die, DW_AT_call_line, s.line);
19487 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19488 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19491 add_high_low_attributes (tree stmt, dw_die_ref die)
19493 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19495 if (BLOCK_FRAGMENT_CHAIN (stmt)
19496 && (dwarf_version >= 3 || !dwarf_strict))
19500 if (inlined_function_outer_scope_p (stmt))
19502 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19503 BLOCK_NUMBER (stmt));
19504 add_AT_lbl_id (die, DW_AT_entry_pc, label);
19507 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
19509 chain = BLOCK_FRAGMENT_CHAIN (stmt);
19512 add_ranges (chain);
19513 chain = BLOCK_FRAGMENT_CHAIN (chain);
19520 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19521 BLOCK_NUMBER (stmt));
19522 add_AT_lbl_id (die, DW_AT_low_pc, label);
19523 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
19524 BLOCK_NUMBER (stmt));
19525 add_AT_lbl_id (die, DW_AT_high_pc, label);
19529 /* Generate a DIE for a lexical block. */
19532 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
19534 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
19536 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
19537 add_high_low_attributes (stmt, stmt_die);
19539 decls_for_scope (stmt, stmt_die, depth);
19542 /* Generate a DIE for an inlined subprogram. */
19545 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
19549 /* The instance of function that is effectively being inlined shall not
19551 gcc_assert (! BLOCK_ABSTRACT (stmt));
19553 decl = block_ultimate_origin (stmt);
19555 /* Emit info for the abstract instance first, if we haven't yet. We
19556 must emit this even if the block is abstract, otherwise when we
19557 emit the block below (or elsewhere), we may end up trying to emit
19558 a die whose origin die hasn't been emitted, and crashing. */
19559 dwarf2out_abstract_function (decl);
19561 if (! BLOCK_ABSTRACT (stmt))
19563 dw_die_ref subr_die
19564 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
19566 add_abstract_origin_attribute (subr_die, decl);
19567 if (TREE_ASM_WRITTEN (stmt))
19568 add_high_low_attributes (stmt, subr_die);
19569 add_call_src_coords_attributes (stmt, subr_die);
19571 decls_for_scope (stmt, subr_die, depth);
19572 current_function_has_inlines = 1;
19576 /* Generate a DIE for a field in a record, or structure. */
19579 gen_field_die (tree decl, dw_die_ref context_die)
19581 dw_die_ref decl_die;
19583 if (TREE_TYPE (decl) == error_mark_node)
19586 decl_die = new_die (DW_TAG_member, context_die, decl);
19587 add_name_and_src_coords_attributes (decl_die, decl);
19588 add_type_attribute (decl_die, member_declared_type (decl),
19589 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
19592 if (DECL_BIT_FIELD_TYPE (decl))
19594 add_byte_size_attribute (decl_die, decl);
19595 add_bit_size_attribute (decl_die, decl);
19596 add_bit_offset_attribute (decl_die, decl);
19599 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
19600 add_data_member_location_attribute (decl_die, decl);
19602 if (DECL_ARTIFICIAL (decl))
19603 add_AT_flag (decl_die, DW_AT_artificial, 1);
19605 add_accessibility_attribute (decl_die, decl);
19607 /* Equate decl number to die, so that we can look up this decl later on. */
19608 equate_decl_number_to_die (decl, decl_die);
19612 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19613 Use modified_type_die instead.
19614 We keep this code here just in case these types of DIEs may be needed to
19615 represent certain things in other languages (e.g. Pascal) someday. */
19618 gen_pointer_type_die (tree type, dw_die_ref context_die)
19621 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
19623 equate_type_number_to_die (type, ptr_die);
19624 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
19625 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19628 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19629 Use modified_type_die instead.
19630 We keep this code here just in case these types of DIEs may be needed to
19631 represent certain things in other languages (e.g. Pascal) someday. */
19634 gen_reference_type_die (tree type, dw_die_ref context_die)
19636 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die);
19638 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
19639 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type);
19641 ref_die = new_die (DW_TAG_reference_type, scope_die, type);
19643 equate_type_number_to_die (type, ref_die);
19644 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
19645 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19649 /* Generate a DIE for a pointer to a member type. */
19652 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
19655 = new_die (DW_TAG_ptr_to_member_type,
19656 scope_die_for (type, context_die), type);
19658 equate_type_number_to_die (type, ptr_die);
19659 add_AT_die_ref (ptr_die, DW_AT_containing_type,
19660 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
19661 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
19664 /* Generate the DIE for the compilation unit. */
19667 gen_compile_unit_die (const char *filename)
19670 char producer[250];
19671 const char *language_string = lang_hooks.name;
19674 die = new_die (DW_TAG_compile_unit, NULL, NULL);
19678 add_name_attribute (die, filename);
19679 /* Don't add cwd for <built-in>. */
19680 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
19681 add_comp_dir_attribute (die);
19684 sprintf (producer, "%s %s", language_string, version_string);
19686 #ifdef MIPS_DEBUGGING_INFO
19687 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
19688 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
19689 not appear in the producer string, the debugger reaches the conclusion
19690 that the object file is stripped and has no debugging information.
19691 To get the MIPS/SGI debugger to believe that there is debugging
19692 information in the object file, we add a -g to the producer string. */
19693 if (debug_info_level > DINFO_LEVEL_TERSE)
19694 strcat (producer, " -g");
19697 add_AT_string (die, DW_AT_producer, producer);
19699 /* If our producer is LTO try to figure out a common language to use
19700 from the global list of translation units. */
19701 if (strcmp (language_string, "GNU GIMPLE") == 0)
19705 const char *common_lang = NULL;
19707 FOR_EACH_VEC_ELT (tree, all_translation_units, i, t)
19709 if (!TRANSLATION_UNIT_LANGUAGE (t))
19712 common_lang = TRANSLATION_UNIT_LANGUAGE (t);
19713 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
19715 else if (strncmp (common_lang, "GNU C", 5) == 0
19716 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
19717 /* Mixing C and C++ is ok, use C++ in that case. */
19718 common_lang = "GNU C++";
19721 /* Fall back to C. */
19722 common_lang = NULL;
19728 language_string = common_lang;
19731 language = DW_LANG_C89;
19732 if (strcmp (language_string, "GNU C++") == 0)
19733 language = DW_LANG_C_plus_plus;
19734 else if (strcmp (language_string, "GNU F77") == 0)
19735 language = DW_LANG_Fortran77;
19736 else if (strcmp (language_string, "GNU Pascal") == 0)
19737 language = DW_LANG_Pascal83;
19738 else if (dwarf_version >= 3 || !dwarf_strict)
19740 if (strcmp (language_string, "GNU Ada") == 0)
19741 language = DW_LANG_Ada95;
19742 else if (strcmp (language_string, "GNU Fortran") == 0)
19743 language = DW_LANG_Fortran95;
19744 else if (strcmp (language_string, "GNU Java") == 0)
19745 language = DW_LANG_Java;
19746 else if (strcmp (language_string, "GNU Objective-C") == 0)
19747 language = DW_LANG_ObjC;
19748 else if (strcmp (language_string, "GNU Objective-C++") == 0)
19749 language = DW_LANG_ObjC_plus_plus;
19752 add_AT_unsigned (die, DW_AT_language, language);
19756 case DW_LANG_Fortran77:
19757 case DW_LANG_Fortran90:
19758 case DW_LANG_Fortran95:
19759 /* Fortran has case insensitive identifiers and the front-end
19760 lowercases everything. */
19761 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
19764 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19770 /* Generate the DIE for a base class. */
19773 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
19775 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
19777 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
19778 add_data_member_location_attribute (die, binfo);
19780 if (BINFO_VIRTUAL_P (binfo))
19781 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
19783 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19784 children, otherwise the default is DW_ACCESS_public. In DWARF2
19785 the default has always been DW_ACCESS_private. */
19786 if (access == access_public_node)
19788 if (dwarf_version == 2
19789 || context_die->die_tag == DW_TAG_class_type)
19790 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
19792 else if (access == access_protected_node)
19793 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
19794 else if (dwarf_version > 2
19795 && context_die->die_tag != DW_TAG_class_type)
19796 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
19799 /* Generate a DIE for a class member. */
19802 gen_member_die (tree type, dw_die_ref context_die)
19805 tree binfo = TYPE_BINFO (type);
19808 /* If this is not an incomplete type, output descriptions of each of its
19809 members. Note that as we output the DIEs necessary to represent the
19810 members of this record or union type, we will also be trying to output
19811 DIEs to represent the *types* of those members. However the `type'
19812 function (above) will specifically avoid generating type DIEs for member
19813 types *within* the list of member DIEs for this (containing) type except
19814 for those types (of members) which are explicitly marked as also being
19815 members of this (containing) type themselves. The g++ front- end can
19816 force any given type to be treated as a member of some other (containing)
19817 type by setting the TYPE_CONTEXT of the given (member) type to point to
19818 the TREE node representing the appropriate (containing) type. */
19820 /* First output info about the base classes. */
19823 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
19827 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
19828 gen_inheritance_die (base,
19829 (accesses ? VEC_index (tree, accesses, i)
19830 : access_public_node), context_die);
19833 /* Now output info about the data members and type members. */
19834 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
19836 /* If we thought we were generating minimal debug info for TYPE
19837 and then changed our minds, some of the member declarations
19838 may have already been defined. Don't define them again, but
19839 do put them in the right order. */
19841 child = lookup_decl_die (member);
19843 splice_child_die (context_die, child);
19845 gen_decl_die (member, NULL, context_die);
19848 /* Now output info about the function members (if any). */
19849 for (member = TYPE_METHODS (type); member; member = DECL_CHAIN (member))
19851 /* Don't include clones in the member list. */
19852 if (DECL_ABSTRACT_ORIGIN (member))
19855 child = lookup_decl_die (member);
19857 splice_child_die (context_die, child);
19859 gen_decl_die (member, NULL, context_die);
19863 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19864 is set, we pretend that the type was never defined, so we only get the
19865 member DIEs needed by later specification DIEs. */
19868 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
19869 enum debug_info_usage usage)
19871 dw_die_ref type_die = lookup_type_die (type);
19872 dw_die_ref scope_die = 0;
19874 int complete = (TYPE_SIZE (type)
19875 && (! TYPE_STUB_DECL (type)
19876 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
19877 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
19878 complete = complete && should_emit_struct_debug (type, usage);
19880 if (type_die && ! complete)
19883 if (TYPE_CONTEXT (type) != NULL_TREE
19884 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
19885 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
19888 scope_die = scope_die_for (type, context_die);
19890 if (! type_die || (nested && is_cu_die (scope_die)))
19891 /* First occurrence of type or toplevel definition of nested class. */
19893 dw_die_ref old_die = type_die;
19895 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
19896 ? record_type_tag (type) : DW_TAG_union_type,
19898 equate_type_number_to_die (type, type_die);
19900 add_AT_specification (type_die, old_die);
19902 add_name_attribute (type_die, type_tag (type));
19905 remove_AT (type_die, DW_AT_declaration);
19907 /* Generate child dies for template paramaters. */
19908 if (debug_info_level > DINFO_LEVEL_TERSE
19909 && COMPLETE_TYPE_P (type))
19910 gen_generic_params_dies (type);
19912 /* If this type has been completed, then give it a byte_size attribute and
19913 then give a list of members. */
19914 if (complete && !ns_decl)
19916 /* Prevent infinite recursion in cases where the type of some member of
19917 this type is expressed in terms of this type itself. */
19918 TREE_ASM_WRITTEN (type) = 1;
19919 add_byte_size_attribute (type_die, type);
19920 if (TYPE_STUB_DECL (type) != NULL_TREE)
19922 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
19923 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
19926 /* If the first reference to this type was as the return type of an
19927 inline function, then it may not have a parent. Fix this now. */
19928 if (type_die->die_parent == NULL)
19929 add_child_die (scope_die, type_die);
19931 push_decl_scope (type);
19932 gen_member_die (type, type_die);
19935 /* GNU extension: Record what type our vtable lives in. */
19936 if (TYPE_VFIELD (type))
19938 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
19940 gen_type_die (vtype, context_die);
19941 add_AT_die_ref (type_die, DW_AT_containing_type,
19942 lookup_type_die (vtype));
19947 add_AT_flag (type_die, DW_AT_declaration, 1);
19949 /* We don't need to do this for function-local types. */
19950 if (TYPE_STUB_DECL (type)
19951 && ! decl_function_context (TYPE_STUB_DECL (type)))
19952 VEC_safe_push (tree, gc, incomplete_types, type);
19955 if (get_AT (type_die, DW_AT_name))
19956 add_pubtype (type, type_die);
19959 /* Generate a DIE for a subroutine _type_. */
19962 gen_subroutine_type_die (tree type, dw_die_ref context_die)
19964 tree return_type = TREE_TYPE (type);
19965 dw_die_ref subr_die
19966 = new_die (DW_TAG_subroutine_type,
19967 scope_die_for (type, context_die), type);
19969 equate_type_number_to_die (type, subr_die);
19970 add_prototyped_attribute (subr_die, type);
19971 add_type_attribute (subr_die, return_type, 0, 0, context_die);
19972 gen_formal_types_die (type, subr_die);
19974 if (get_AT (subr_die, DW_AT_name))
19975 add_pubtype (type, subr_die);
19978 /* Generate a DIE for a type definition. */
19981 gen_typedef_die (tree decl, dw_die_ref context_die)
19983 dw_die_ref type_die;
19986 if (TREE_ASM_WRITTEN (decl))
19989 TREE_ASM_WRITTEN (decl) = 1;
19990 type_die = new_die (DW_TAG_typedef, context_die, decl);
19991 origin = decl_ultimate_origin (decl);
19992 if (origin != NULL)
19993 add_abstract_origin_attribute (type_die, origin);
19998 add_name_and_src_coords_attributes (type_die, decl);
19999 if (DECL_ORIGINAL_TYPE (decl))
20001 type = DECL_ORIGINAL_TYPE (decl);
20003 gcc_assert (type != TREE_TYPE (decl));
20004 equate_type_number_to_die (TREE_TYPE (decl), type_die);
20008 type = TREE_TYPE (decl);
20010 if (is_naming_typedef_decl (TYPE_NAME (type)))
20012 /* Here, we are in the case of decl being a typedef naming
20013 an anonymous type, e.g:
20014 typedef struct {...} foo;
20015 In that case TREE_TYPE (decl) is not a typedef variant
20016 type and TYPE_NAME of the anonymous type is set to the
20017 TYPE_DECL of the typedef. This construct is emitted by
20020 TYPE is the anonymous struct named by the typedef
20021 DECL. As we need the DW_AT_type attribute of the
20022 DW_TAG_typedef to point to the DIE of TYPE, let's
20023 generate that DIE right away. add_type_attribute
20024 called below will then pick (via lookup_type_die) that
20025 anonymous struct DIE. */
20026 if (!TREE_ASM_WRITTEN (type))
20027 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
20031 add_type_attribute (type_die, type, TREE_READONLY (decl),
20032 TREE_THIS_VOLATILE (decl), context_die);
20034 if (is_naming_typedef_decl (decl))
20035 /* We want that all subsequent calls to lookup_type_die with
20036 TYPE in argument yield the DW_TAG_typedef we have just
20038 equate_type_number_to_die (type, type_die);
20040 add_accessibility_attribute (type_die, decl);
20043 if (DECL_ABSTRACT (decl))
20044 equate_decl_number_to_die (decl, type_die);
20046 if (get_AT (type_die, DW_AT_name))
20047 add_pubtype (decl, type_die);
20050 /* Generate a DIE for a struct, class, enum or union type. */
20053 gen_tagged_type_die (tree type,
20054 dw_die_ref context_die,
20055 enum debug_info_usage usage)
20059 if (type == NULL_TREE
20060 || !is_tagged_type (type))
20063 /* If this is a nested type whose containing class hasn't been written
20064 out yet, writing it out will cover this one, too. This does not apply
20065 to instantiations of member class templates; they need to be added to
20066 the containing class as they are generated. FIXME: This hurts the
20067 idea of combining type decls from multiple TUs, since we can't predict
20068 what set of template instantiations we'll get. */
20069 if (TYPE_CONTEXT (type)
20070 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
20071 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
20073 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
20075 if (TREE_ASM_WRITTEN (type))
20078 /* If that failed, attach ourselves to the stub. */
20079 push_decl_scope (TYPE_CONTEXT (type));
20080 context_die = lookup_type_die (TYPE_CONTEXT (type));
20083 else if (TYPE_CONTEXT (type) != NULL_TREE
20084 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
20086 /* If this type is local to a function that hasn't been written
20087 out yet, use a NULL context for now; it will be fixed up in
20088 decls_for_scope. */
20089 context_die = lookup_decl_die (TYPE_CONTEXT (type));
20094 context_die = declare_in_namespace (type, context_die);
20098 if (TREE_CODE (type) == ENUMERAL_TYPE)
20100 /* This might have been written out by the call to
20101 declare_in_namespace. */
20102 if (!TREE_ASM_WRITTEN (type))
20103 gen_enumeration_type_die (type, context_die);
20106 gen_struct_or_union_type_die (type, context_die, usage);
20111 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
20112 it up if it is ever completed. gen_*_type_die will set it for us
20113 when appropriate. */
20116 /* Generate a type description DIE. */
20119 gen_type_die_with_usage (tree type, dw_die_ref context_die,
20120 enum debug_info_usage usage)
20122 struct array_descr_info info;
20124 if (type == NULL_TREE || type == error_mark_node)
20127 /* If TYPE is a typedef type variant, let's generate debug info
20128 for the parent typedef which TYPE is a type of. */
20129 if (typedef_variant_p (type))
20131 if (TREE_ASM_WRITTEN (type))
20134 /* Prevent broken recursion; we can't hand off to the same type. */
20135 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
20137 /* Use the DIE of the containing namespace as the parent DIE of
20138 the type description DIE we want to generate. */
20139 if (DECL_CONTEXT (TYPE_NAME (type))
20140 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
20141 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
20143 TREE_ASM_WRITTEN (type) = 1;
20145 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20149 /* If type is an anonymous tagged type named by a typedef, let's
20150 generate debug info for the typedef. */
20151 if (is_naming_typedef_decl (TYPE_NAME (type)))
20153 /* Use the DIE of the containing namespace as the parent DIE of
20154 the type description DIE we want to generate. */
20155 if (DECL_CONTEXT (TYPE_NAME (type))
20156 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
20157 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
20159 gen_decl_die (TYPE_NAME (type), NULL, context_die);
20163 /* If this is an array type with hidden descriptor, handle it first. */
20164 if (!TREE_ASM_WRITTEN (type)
20165 && lang_hooks.types.get_array_descr_info
20166 && lang_hooks.types.get_array_descr_info (type, &info)
20167 && (dwarf_version >= 3 || !dwarf_strict))
20169 gen_descr_array_type_die (type, &info, context_die);
20170 TREE_ASM_WRITTEN (type) = 1;
20174 /* We are going to output a DIE to represent the unqualified version
20175 of this type (i.e. without any const or volatile qualifiers) so
20176 get the main variant (i.e. the unqualified version) of this type
20177 now. (Vectors are special because the debugging info is in the
20178 cloned type itself). */
20179 if (TREE_CODE (type) != VECTOR_TYPE)
20180 type = type_main_variant (type);
20182 if (TREE_ASM_WRITTEN (type))
20185 switch (TREE_CODE (type))
20191 case REFERENCE_TYPE:
20192 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
20193 ensures that the gen_type_die recursion will terminate even if the
20194 type is recursive. Recursive types are possible in Ada. */
20195 /* ??? We could perhaps do this for all types before the switch
20197 TREE_ASM_WRITTEN (type) = 1;
20199 /* For these types, all that is required is that we output a DIE (or a
20200 set of DIEs) to represent the "basis" type. */
20201 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20202 DINFO_USAGE_IND_USE);
20206 /* This code is used for C++ pointer-to-data-member types.
20207 Output a description of the relevant class type. */
20208 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
20209 DINFO_USAGE_IND_USE);
20211 /* Output a description of the type of the object pointed to. */
20212 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20213 DINFO_USAGE_IND_USE);
20215 /* Now output a DIE to represent this pointer-to-data-member type
20217 gen_ptr_to_mbr_type_die (type, context_die);
20220 case FUNCTION_TYPE:
20221 /* Force out return type (in case it wasn't forced out already). */
20222 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20223 DINFO_USAGE_DIR_USE);
20224 gen_subroutine_type_die (type, context_die);
20228 /* Force out return type (in case it wasn't forced out already). */
20229 gen_type_die_with_usage (TREE_TYPE (type), context_die,
20230 DINFO_USAGE_DIR_USE);
20231 gen_subroutine_type_die (type, context_die);
20235 gen_array_type_die (type, context_die);
20239 gen_array_type_die (type, context_die);
20242 case ENUMERAL_TYPE:
20245 case QUAL_UNION_TYPE:
20246 gen_tagged_type_die (type, context_die, usage);
20252 case FIXED_POINT_TYPE:
20255 /* No DIEs needed for fundamental types. */
20260 /* Just use DW_TAG_unspecified_type. */
20262 dw_die_ref type_die = lookup_type_die (type);
20263 if (type_die == NULL)
20265 tree name = TYPE_NAME (type);
20266 if (TREE_CODE (name) == TYPE_DECL)
20267 name = DECL_NAME (name);
20268 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (), type);
20269 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
20270 equate_type_number_to_die (type, type_die);
20276 gcc_unreachable ();
20279 TREE_ASM_WRITTEN (type) = 1;
20283 gen_type_die (tree type, dw_die_ref context_die)
20285 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
20288 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20289 things which are local to the given block. */
20292 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
20294 int must_output_die = 0;
20297 /* Ignore blocks that are NULL. */
20298 if (stmt == NULL_TREE)
20301 inlined_func = inlined_function_outer_scope_p (stmt);
20303 /* If the block is one fragment of a non-contiguous block, do not
20304 process the variables, since they will have been done by the
20305 origin block. Do process subblocks. */
20306 if (BLOCK_FRAGMENT_ORIGIN (stmt))
20310 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
20311 gen_block_die (sub, context_die, depth + 1);
20316 /* Determine if we need to output any Dwarf DIEs at all to represent this
20319 /* The outer scopes for inlinings *must* always be represented. We
20320 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20321 must_output_die = 1;
20324 /* Determine if this block directly contains any "significant"
20325 local declarations which we will need to output DIEs for. */
20326 if (debug_info_level > DINFO_LEVEL_TERSE)
20327 /* We are not in terse mode so *any* local declaration counts
20328 as being a "significant" one. */
20329 must_output_die = ((BLOCK_VARS (stmt) != NULL
20330 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
20331 && (TREE_USED (stmt)
20332 || TREE_ASM_WRITTEN (stmt)
20333 || BLOCK_ABSTRACT (stmt)));
20334 else if ((TREE_USED (stmt)
20335 || TREE_ASM_WRITTEN (stmt)
20336 || BLOCK_ABSTRACT (stmt))
20337 && !dwarf2out_ignore_block (stmt))
20338 must_output_die = 1;
20341 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20342 DIE for any block which contains no significant local declarations at
20343 all. Rather, in such cases we just call `decls_for_scope' so that any
20344 needed Dwarf info for any sub-blocks will get properly generated. Note
20345 that in terse mode, our definition of what constitutes a "significant"
20346 local declaration gets restricted to include only inlined function
20347 instances and local (nested) function definitions. */
20348 if (must_output_die)
20352 /* If STMT block is abstract, that means we have been called
20353 indirectly from dwarf2out_abstract_function.
20354 That function rightfully marks the descendent blocks (of
20355 the abstract function it is dealing with) as being abstract,
20356 precisely to prevent us from emitting any
20357 DW_TAG_inlined_subroutine DIE as a descendent
20358 of an abstract function instance. So in that case, we should
20359 not call gen_inlined_subroutine_die.
20361 Later though, when cgraph asks dwarf2out to emit info
20362 for the concrete instance of the function decl into which
20363 the concrete instance of STMT got inlined, the later will lead
20364 to the generation of a DW_TAG_inlined_subroutine DIE. */
20365 if (! BLOCK_ABSTRACT (stmt))
20366 gen_inlined_subroutine_die (stmt, context_die, depth);
20369 gen_lexical_block_die (stmt, context_die, depth);
20372 decls_for_scope (stmt, context_die, depth);
20375 /* Process variable DECL (or variable with origin ORIGIN) within
20376 block STMT and add it to CONTEXT_DIE. */
20378 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
20381 tree decl_or_origin = decl ? decl : origin;
20383 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
20384 die = lookup_decl_die (decl_or_origin);
20385 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
20386 && TYPE_DECL_IS_STUB (decl_or_origin))
20387 die = lookup_type_die (TREE_TYPE (decl_or_origin));
20391 if (die != NULL && die->die_parent == NULL)
20392 add_child_die (context_die, die);
20393 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
20394 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
20395 stmt, context_die);
20397 gen_decl_die (decl, origin, context_die);
20400 /* Generate all of the decls declared within a given scope and (recursively)
20401 all of its sub-blocks. */
20404 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
20410 /* Ignore NULL blocks. */
20411 if (stmt == NULL_TREE)
20414 /* Output the DIEs to represent all of the data objects and typedefs
20415 declared directly within this block but not within any nested
20416 sub-blocks. Also, nested function and tag DIEs have been
20417 generated with a parent of NULL; fix that up now. */
20418 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl))
20419 process_scope_var (stmt, decl, NULL_TREE, context_die);
20420 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
20421 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
20424 /* If we're at -g1, we're not interested in subblocks. */
20425 if (debug_info_level <= DINFO_LEVEL_TERSE)
20428 /* Output the DIEs to represent all sub-blocks (and the items declared
20429 therein) of this block. */
20430 for (subblocks = BLOCK_SUBBLOCKS (stmt);
20432 subblocks = BLOCK_CHAIN (subblocks))
20433 gen_block_die (subblocks, context_die, depth + 1);
20436 /* Is this a typedef we can avoid emitting? */
20439 is_redundant_typedef (const_tree decl)
20441 if (TYPE_DECL_IS_STUB (decl))
20444 if (DECL_ARTIFICIAL (decl)
20445 && DECL_CONTEXT (decl)
20446 && is_tagged_type (DECL_CONTEXT (decl))
20447 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
20448 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
20449 /* Also ignore the artificial member typedef for the class name. */
20455 /* Return TRUE if TYPE is a typedef that names a type for linkage
20456 purposes. This kind of typedefs is produced by the C++ FE for
20459 typedef struct {...} foo;
20461 In that case, there is no typedef variant type produced for foo.
20462 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20466 is_naming_typedef_decl (const_tree decl)
20468 if (decl == NULL_TREE
20469 || TREE_CODE (decl) != TYPE_DECL
20470 || !is_tagged_type (TREE_TYPE (decl))
20471 || DECL_IS_BUILTIN (decl)
20472 || is_redundant_typedef (decl)
20473 /* It looks like Ada produces TYPE_DECLs that are very similar
20474 to C++ naming typedefs but that have different
20475 semantics. Let's be specific to c++ for now. */
20479 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
20480 && TYPE_NAME (TREE_TYPE (decl)) == decl
20481 && (TYPE_STUB_DECL (TREE_TYPE (decl))
20482 != TYPE_NAME (TREE_TYPE (decl))));
20485 /* Returns the DIE for a context. */
20487 static inline dw_die_ref
20488 get_context_die (tree context)
20492 /* Find die that represents this context. */
20493 if (TYPE_P (context))
20494 return force_type_die (TYPE_MAIN_VARIANT (context));
20496 return force_decl_die (context);
20498 return comp_unit_die ();
20501 /* Returns the DIE for decl. A DIE will always be returned. */
20504 force_decl_die (tree decl)
20506 dw_die_ref decl_die;
20507 unsigned saved_external_flag;
20508 tree save_fn = NULL_TREE;
20509 decl_die = lookup_decl_die (decl);
20512 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
20514 decl_die = lookup_decl_die (decl);
20518 switch (TREE_CODE (decl))
20520 case FUNCTION_DECL:
20521 /* Clear current_function_decl, so that gen_subprogram_die thinks
20522 that this is a declaration. At this point, we just want to force
20523 declaration die. */
20524 save_fn = current_function_decl;
20525 current_function_decl = NULL_TREE;
20526 gen_subprogram_die (decl, context_die);
20527 current_function_decl = save_fn;
20531 /* Set external flag to force declaration die. Restore it after
20532 gen_decl_die() call. */
20533 saved_external_flag = DECL_EXTERNAL (decl);
20534 DECL_EXTERNAL (decl) = 1;
20535 gen_decl_die (decl, NULL, context_die);
20536 DECL_EXTERNAL (decl) = saved_external_flag;
20539 case NAMESPACE_DECL:
20540 if (dwarf_version >= 3 || !dwarf_strict)
20541 dwarf2out_decl (decl);
20543 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20544 decl_die = comp_unit_die ();
20547 case TRANSLATION_UNIT_DECL:
20548 decl_die = comp_unit_die ();
20552 gcc_unreachable ();
20555 /* We should be able to find the DIE now. */
20557 decl_die = lookup_decl_die (decl);
20558 gcc_assert (decl_die);
20564 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20565 always returned. */
20568 force_type_die (tree type)
20570 dw_die_ref type_die;
20572 type_die = lookup_type_die (type);
20575 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
20577 type_die = modified_type_die (type, TYPE_READONLY (type),
20578 TYPE_VOLATILE (type), context_die);
20579 gcc_assert (type_die);
20584 /* Force out any required namespaces to be able to output DECL,
20585 and return the new context_die for it, if it's changed. */
20588 setup_namespace_context (tree thing, dw_die_ref context_die)
20590 tree context = (DECL_P (thing)
20591 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
20592 if (context && TREE_CODE (context) == NAMESPACE_DECL)
20593 /* Force out the namespace. */
20594 context_die = force_decl_die (context);
20596 return context_die;
20599 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20600 type) within its namespace, if appropriate.
20602 For compatibility with older debuggers, namespace DIEs only contain
20603 declarations; all definitions are emitted at CU scope. */
20606 declare_in_namespace (tree thing, dw_die_ref context_die)
20608 dw_die_ref ns_context;
20610 if (debug_info_level <= DINFO_LEVEL_TERSE)
20611 return context_die;
20613 /* If this decl is from an inlined function, then don't try to emit it in its
20614 namespace, as we will get confused. It would have already been emitted
20615 when the abstract instance of the inline function was emitted anyways. */
20616 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
20617 return context_die;
20619 ns_context = setup_namespace_context (thing, context_die);
20621 if (ns_context != context_die)
20625 if (DECL_P (thing))
20626 gen_decl_die (thing, NULL, ns_context);
20628 gen_type_die (thing, ns_context);
20630 return context_die;
20633 /* Generate a DIE for a namespace or namespace alias. */
20636 gen_namespace_die (tree decl, dw_die_ref context_die)
20638 dw_die_ref namespace_die;
20640 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20641 they are an alias of. */
20642 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
20644 /* Output a real namespace or module. */
20645 context_die = setup_namespace_context (decl, comp_unit_die ());
20646 namespace_die = new_die (is_fortran ()
20647 ? DW_TAG_module : DW_TAG_namespace,
20648 context_die, decl);
20649 /* For Fortran modules defined in different CU don't add src coords. */
20650 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
20652 const char *name = dwarf2_name (decl, 0);
20654 add_name_attribute (namespace_die, name);
20657 add_name_and_src_coords_attributes (namespace_die, decl);
20658 if (DECL_EXTERNAL (decl))
20659 add_AT_flag (namespace_die, DW_AT_declaration, 1);
20660 equate_decl_number_to_die (decl, namespace_die);
20664 /* Output a namespace alias. */
20666 /* Force out the namespace we are an alias of, if necessary. */
20667 dw_die_ref origin_die
20668 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
20670 if (DECL_FILE_SCOPE_P (decl)
20671 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
20672 context_die = setup_namespace_context (decl, comp_unit_die ());
20673 /* Now create the namespace alias DIE. */
20674 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
20675 add_name_and_src_coords_attributes (namespace_die, decl);
20676 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
20677 equate_decl_number_to_die (decl, namespace_die);
20681 /* Generate Dwarf debug information for a decl described by DECL.
20682 The return value is currently only meaningful for PARM_DECLs,
20683 for all other decls it returns NULL. */
20686 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
20688 tree decl_or_origin = decl ? decl : origin;
20689 tree class_origin = NULL, ultimate_origin;
20691 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
20694 switch (TREE_CODE (decl_or_origin))
20700 if (!is_fortran () && !is_ada ())
20702 /* The individual enumerators of an enum type get output when we output
20703 the Dwarf representation of the relevant enum type itself. */
20707 /* Emit its type. */
20708 gen_type_die (TREE_TYPE (decl), context_die);
20710 /* And its containing namespace. */
20711 context_die = declare_in_namespace (decl, context_die);
20713 gen_const_die (decl, context_die);
20716 case FUNCTION_DECL:
20717 /* Don't output any DIEs to represent mere function declarations,
20718 unless they are class members or explicit block externs. */
20719 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
20720 && DECL_FILE_SCOPE_P (decl_or_origin)
20721 && (current_function_decl == NULL_TREE
20722 || DECL_ARTIFICIAL (decl_or_origin)))
20727 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20728 on local redeclarations of global functions. That seems broken. */
20729 if (current_function_decl != decl)
20730 /* This is only a declaration. */;
20733 /* If we're emitting a clone, emit info for the abstract instance. */
20734 if (origin || DECL_ORIGIN (decl) != decl)
20735 dwarf2out_abstract_function (origin
20736 ? DECL_ORIGIN (origin)
20737 : DECL_ABSTRACT_ORIGIN (decl));
20739 /* If we're emitting an out-of-line copy of an inline function,
20740 emit info for the abstract instance and set up to refer to it. */
20741 else if (cgraph_function_possibly_inlined_p (decl)
20742 && ! DECL_ABSTRACT (decl)
20743 && ! class_or_namespace_scope_p (context_die)
20744 /* dwarf2out_abstract_function won't emit a die if this is just
20745 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20746 that case, because that works only if we have a die. */
20747 && DECL_INITIAL (decl) != NULL_TREE)
20749 dwarf2out_abstract_function (decl);
20750 set_decl_origin_self (decl);
20753 /* Otherwise we're emitting the primary DIE for this decl. */
20754 else if (debug_info_level > DINFO_LEVEL_TERSE)
20756 /* Before we describe the FUNCTION_DECL itself, make sure that we
20757 have its containing type. */
20759 origin = decl_class_context (decl);
20760 if (origin != NULL_TREE)
20761 gen_type_die (origin, context_die);
20763 /* And its return type. */
20764 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
20766 /* And its virtual context. */
20767 if (DECL_VINDEX (decl) != NULL_TREE)
20768 gen_type_die (DECL_CONTEXT (decl), context_die);
20770 /* Make sure we have a member DIE for decl. */
20771 if (origin != NULL_TREE)
20772 gen_type_die_for_member (origin, decl, context_die);
20774 /* And its containing namespace. */
20775 context_die = declare_in_namespace (decl, context_die);
20778 /* Now output a DIE to represent the function itself. */
20780 gen_subprogram_die (decl, context_die);
20784 /* If we are in terse mode, don't generate any DIEs to represent any
20785 actual typedefs. */
20786 if (debug_info_level <= DINFO_LEVEL_TERSE)
20789 /* In the special case of a TYPE_DECL node representing the declaration
20790 of some type tag, if the given TYPE_DECL is marked as having been
20791 instantiated from some other (original) TYPE_DECL node (e.g. one which
20792 was generated within the original definition of an inline function) we
20793 used to generate a special (abbreviated) DW_TAG_structure_type,
20794 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20795 should be actually referencing those DIEs, as variable DIEs with that
20796 type would be emitted already in the abstract origin, so it was always
20797 removed during unused type prunning. Don't add anything in this
20799 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
20802 if (is_redundant_typedef (decl))
20803 gen_type_die (TREE_TYPE (decl), context_die);
20805 /* Output a DIE to represent the typedef itself. */
20806 gen_typedef_die (decl, context_die);
20810 if (debug_info_level >= DINFO_LEVEL_NORMAL)
20811 gen_label_die (decl, context_die);
20816 /* If we are in terse mode, don't generate any DIEs to represent any
20817 variable declarations or definitions. */
20818 if (debug_info_level <= DINFO_LEVEL_TERSE)
20821 /* Output any DIEs that are needed to specify the type of this data
20823 if (decl_by_reference_p (decl_or_origin))
20824 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
20826 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
20828 /* And its containing type. */
20829 class_origin = decl_class_context (decl_or_origin);
20830 if (class_origin != NULL_TREE)
20831 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
20833 /* And its containing namespace. */
20834 context_die = declare_in_namespace (decl_or_origin, context_die);
20836 /* Now output the DIE to represent the data object itself. This gets
20837 complicated because of the possibility that the VAR_DECL really
20838 represents an inlined instance of a formal parameter for an inline
20840 ultimate_origin = decl_ultimate_origin (decl_or_origin);
20841 if (ultimate_origin != NULL_TREE
20842 && TREE_CODE (ultimate_origin) == PARM_DECL)
20843 gen_formal_parameter_die (decl, origin,
20844 true /* Emit name attribute. */,
20847 gen_variable_die (decl, origin, context_die);
20851 /* Ignore the nameless fields that are used to skip bits but handle C++
20852 anonymous unions and structs. */
20853 if (DECL_NAME (decl) != NULL_TREE
20854 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
20855 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
20857 gen_type_die (member_declared_type (decl), context_die);
20858 gen_field_die (decl, context_die);
20863 if (DECL_BY_REFERENCE (decl_or_origin))
20864 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
20866 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
20867 return gen_formal_parameter_die (decl, origin,
20868 true /* Emit name attribute. */,
20871 case NAMESPACE_DECL:
20872 case IMPORTED_DECL:
20873 if (dwarf_version >= 3 || !dwarf_strict)
20874 gen_namespace_die (decl, context_die);
20878 /* Probably some frontend-internal decl. Assume we don't care. */
20879 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
20886 /* Output debug information for global decl DECL. Called from toplev.c after
20887 compilation proper has finished. */
20890 dwarf2out_global_decl (tree decl)
20892 /* Output DWARF2 information for file-scope tentative data object
20893 declarations, file-scope (extern) function declarations (which
20894 had no corresponding body) and file-scope tagged type declarations
20895 and definitions which have not yet been forced out. */
20896 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
20897 dwarf2out_decl (decl);
20900 /* Output debug information for type decl DECL. Called from toplev.c
20901 and from language front ends (to record built-in types). */
20903 dwarf2out_type_decl (tree decl, int local)
20906 dwarf2out_decl (decl);
20909 /* Output debug information for imported module or decl DECL.
20910 NAME is non-NULL name in the lexical block if the decl has been renamed.
20911 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20912 that DECL belongs to.
20913 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20915 dwarf2out_imported_module_or_decl_1 (tree decl,
20917 tree lexical_block,
20918 dw_die_ref lexical_block_die)
20920 expanded_location xloc;
20921 dw_die_ref imported_die = NULL;
20922 dw_die_ref at_import_die;
20924 if (TREE_CODE (decl) == IMPORTED_DECL)
20926 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
20927 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
20931 xloc = expand_location (input_location);
20933 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
20935 at_import_die = force_type_die (TREE_TYPE (decl));
20936 /* For namespace N { typedef void T; } using N::T; base_type_die
20937 returns NULL, but DW_TAG_imported_declaration requires
20938 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20939 if (!at_import_die)
20941 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
20942 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
20943 at_import_die = lookup_type_die (TREE_TYPE (decl));
20944 gcc_assert (at_import_die);
20949 at_import_die = lookup_decl_die (decl);
20950 if (!at_import_die)
20952 /* If we're trying to avoid duplicate debug info, we may not have
20953 emitted the member decl for this field. Emit it now. */
20954 if (TREE_CODE (decl) == FIELD_DECL)
20956 tree type = DECL_CONTEXT (decl);
20958 if (TYPE_CONTEXT (type)
20959 && TYPE_P (TYPE_CONTEXT (type))
20960 && !should_emit_struct_debug (TYPE_CONTEXT (type),
20961 DINFO_USAGE_DIR_USE))
20963 gen_type_die_for_member (type, decl,
20964 get_context_die (TYPE_CONTEXT (type)));
20966 at_import_die = force_decl_die (decl);
20970 if (TREE_CODE (decl) == NAMESPACE_DECL)
20972 if (dwarf_version >= 3 || !dwarf_strict)
20973 imported_die = new_die (DW_TAG_imported_module,
20980 imported_die = new_die (DW_TAG_imported_declaration,
20984 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
20985 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
20987 add_AT_string (imported_die, DW_AT_name,
20988 IDENTIFIER_POINTER (name));
20989 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
20992 /* Output debug information for imported module or decl DECL.
20993 NAME is non-NULL name in context if the decl has been renamed.
20994 CHILD is true if decl is one of the renamed decls as part of
20995 importing whole module. */
20998 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
21001 /* dw_die_ref at_import_die; */
21002 dw_die_ref scope_die;
21004 if (debug_info_level <= DINFO_LEVEL_TERSE)
21009 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
21010 We need decl DIE for reference and scope die. First, get DIE for the decl
21013 /* Get the scope die for decl context. Use comp_unit_die for global module
21014 or decl. If die is not found for non globals, force new die. */
21016 && TYPE_P (context)
21017 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
21020 if (!(dwarf_version >= 3 || !dwarf_strict))
21023 scope_die = get_context_die (context);
21027 gcc_assert (scope_die->die_child);
21028 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
21029 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
21030 scope_die = scope_die->die_child;
21033 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
21034 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
21038 /* Write the debugging output for DECL. */
21041 dwarf2out_decl (tree decl)
21043 dw_die_ref context_die = comp_unit_die ();
21045 switch (TREE_CODE (decl))
21050 case FUNCTION_DECL:
21051 /* What we would really like to do here is to filter out all mere
21052 file-scope declarations of file-scope functions which are never
21053 referenced later within this translation unit (and keep all of ones
21054 that *are* referenced later on) but we aren't clairvoyant, so we have
21055 no idea which functions will be referenced in the future (i.e. later
21056 on within the current translation unit). So here we just ignore all
21057 file-scope function declarations which are not also definitions. If
21058 and when the debugger needs to know something about these functions,
21059 it will have to hunt around and find the DWARF information associated
21060 with the definition of the function.
21062 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
21063 nodes represent definitions and which ones represent mere
21064 declarations. We have to check DECL_INITIAL instead. That's because
21065 the C front-end supports some weird semantics for "extern inline"
21066 function definitions. These can get inlined within the current
21067 translation unit (and thus, we need to generate Dwarf info for their
21068 abstract instances so that the Dwarf info for the concrete inlined
21069 instances can have something to refer to) but the compiler never
21070 generates any out-of-lines instances of such things (despite the fact
21071 that they *are* definitions).
21073 The important point is that the C front-end marks these "extern
21074 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
21075 them anyway. Note that the C++ front-end also plays some similar games
21076 for inline function definitions appearing within include files which
21077 also contain `#pragma interface' pragmas. */
21078 if (DECL_INITIAL (decl) == NULL_TREE)
21081 /* If we're a nested function, initially use a parent of NULL; if we're
21082 a plain function, this will be fixed up in decls_for_scope. If
21083 we're a method, it will be ignored, since we already have a DIE. */
21084 if (decl_function_context (decl)
21085 /* But if we're in terse mode, we don't care about scope. */
21086 && debug_info_level > DINFO_LEVEL_TERSE)
21087 context_die = NULL;
21091 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
21092 declaration and if the declaration was never even referenced from
21093 within this entire compilation unit. We suppress these DIEs in
21094 order to save space in the .debug section (by eliminating entries
21095 which are probably useless). Note that we must not suppress
21096 block-local extern declarations (whether used or not) because that
21097 would screw-up the debugger's name lookup mechanism and cause it to
21098 miss things which really ought to be in scope at a given point. */
21099 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
21102 /* For local statics lookup proper context die. */
21103 if (TREE_STATIC (decl) && decl_function_context (decl))
21104 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21106 /* If we are in terse mode, don't generate any DIEs to represent any
21107 variable declarations or definitions. */
21108 if (debug_info_level <= DINFO_LEVEL_TERSE)
21113 if (debug_info_level <= DINFO_LEVEL_TERSE)
21115 if (!is_fortran () && !is_ada ())
21117 if (TREE_STATIC (decl) && decl_function_context (decl))
21118 context_die = lookup_decl_die (DECL_CONTEXT (decl));
21121 case NAMESPACE_DECL:
21122 case IMPORTED_DECL:
21123 if (debug_info_level <= DINFO_LEVEL_TERSE)
21125 if (lookup_decl_die (decl) != NULL)
21130 /* Don't emit stubs for types unless they are needed by other DIEs. */
21131 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
21134 /* Don't bother trying to generate any DIEs to represent any of the
21135 normal built-in types for the language we are compiling. */
21136 if (DECL_IS_BUILTIN (decl))
21139 /* If we are in terse mode, don't generate any DIEs for types. */
21140 if (debug_info_level <= DINFO_LEVEL_TERSE)
21143 /* If we're a function-scope tag, initially use a parent of NULL;
21144 this will be fixed up in decls_for_scope. */
21145 if (decl_function_context (decl))
21146 context_die = NULL;
21154 gen_decl_die (decl, NULL, context_die);
21157 /* Write the debugging output for DECL. */
21160 dwarf2out_function_decl (tree decl)
21162 dwarf2out_decl (decl);
21164 htab_empty (decl_loc_table);
21167 /* Output a marker (i.e. a label) for the beginning of the generated code for
21168 a lexical block. */
21171 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
21172 unsigned int blocknum)
21174 switch_to_section (current_function_section ());
21175 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
21178 /* Output a marker (i.e. a label) for the end of the generated code for a
21182 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
21184 switch_to_section (current_function_section ());
21185 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
21188 /* Returns nonzero if it is appropriate not to emit any debugging
21189 information for BLOCK, because it doesn't contain any instructions.
21191 Don't allow this for blocks with nested functions or local classes
21192 as we would end up with orphans, and in the presence of scheduling
21193 we may end up calling them anyway. */
21196 dwarf2out_ignore_block (const_tree block)
21201 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
21202 if (TREE_CODE (decl) == FUNCTION_DECL
21203 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21205 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
21207 decl = BLOCK_NONLOCALIZED_VAR (block, i);
21208 if (TREE_CODE (decl) == FUNCTION_DECL
21209 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
21216 /* Hash table routines for file_hash. */
21219 file_table_eq (const void *p1_p, const void *p2_p)
21221 const struct dwarf_file_data *const p1 =
21222 (const struct dwarf_file_data *) p1_p;
21223 const char *const p2 = (const char *) p2_p;
21224 return strcmp (p1->filename, p2) == 0;
21228 file_table_hash (const void *p_p)
21230 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
21231 return htab_hash_string (p->filename);
21234 /* Lookup FILE_NAME (in the list of filenames that we know about here in
21235 dwarf2out.c) and return its "index". The index of each (known) filename is
21236 just a unique number which is associated with only that one filename. We
21237 need such numbers for the sake of generating labels (in the .debug_sfnames
21238 section) and references to those files numbers (in the .debug_srcinfo
21239 and.debug_macinfo sections). If the filename given as an argument is not
21240 found in our current list, add it to the list and assign it the next
21241 available unique index number. In order to speed up searches, we remember
21242 the index of the filename was looked up last. This handles the majority of
21245 static struct dwarf_file_data *
21246 lookup_filename (const char *file_name)
21249 struct dwarf_file_data * created;
21251 /* Check to see if the file name that was searched on the previous
21252 call matches this file name. If so, return the index. */
21253 if (file_table_last_lookup
21254 && (file_name == file_table_last_lookup->filename
21255 || strcmp (file_table_last_lookup->filename, file_name) == 0))
21256 return file_table_last_lookup;
21258 /* Didn't match the previous lookup, search the table. */
21259 slot = htab_find_slot_with_hash (file_table, file_name,
21260 htab_hash_string (file_name), INSERT);
21262 return (struct dwarf_file_data *) *slot;
21264 created = ggc_alloc_dwarf_file_data ();
21265 created->filename = file_name;
21266 created->emitted_number = 0;
21271 /* If the assembler will construct the file table, then translate the compiler
21272 internal file table number into the assembler file table number, and emit
21273 a .file directive if we haven't already emitted one yet. The file table
21274 numbers are different because we prune debug info for unused variables and
21275 types, which may include filenames. */
21278 maybe_emit_file (struct dwarf_file_data * fd)
21280 if (! fd->emitted_number)
21282 if (last_emitted_file)
21283 fd->emitted_number = last_emitted_file->emitted_number + 1;
21285 fd->emitted_number = 1;
21286 last_emitted_file = fd;
21288 if (DWARF2_ASM_LINE_DEBUG_INFO)
21290 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
21291 output_quoted_string (asm_out_file,
21292 remap_debug_filename (fd->filename));
21293 fputc ('\n', asm_out_file);
21297 return fd->emitted_number;
21300 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21301 That generation should happen after function debug info has been
21302 generated. The value of the attribute is the constant value of ARG. */
21305 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
21307 die_arg_entry entry;
21312 if (!tmpl_value_parm_die_table)
21313 tmpl_value_parm_die_table
21314 = VEC_alloc (die_arg_entry, gc, 32);
21318 VEC_safe_push (die_arg_entry, gc,
21319 tmpl_value_parm_die_table,
21323 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21324 by append_entry_to_tmpl_value_parm_die_table. This function must
21325 be called after function DIEs have been generated. */
21328 gen_remaining_tmpl_value_param_die_attribute (void)
21330 if (tmpl_value_parm_die_table)
21335 FOR_EACH_VEC_ELT (die_arg_entry, tmpl_value_parm_die_table, i, e)
21336 tree_add_const_value_attribute (e->die, e->arg);
21341 /* Replace DW_AT_name for the decl with name. */
21344 dwarf2out_set_name (tree decl, tree name)
21350 die = TYPE_SYMTAB_DIE (decl);
21354 dname = dwarf2_name (name, 0);
21358 attr = get_AT (die, DW_AT_name);
21361 struct indirect_string_node *node;
21363 node = find_AT_string (dname);
21364 /* replace the string. */
21365 attr->dw_attr_val.v.val_str = node;
21369 add_name_attribute (die, dname);
21372 /* Called by the final INSN scan whenever we see a direct function call.
21373 Make an entry into the direct call table, recording the point of call
21374 and a reference to the target function's debug entry. */
21377 dwarf2out_direct_call (tree targ)
21380 tree origin = decl_ultimate_origin (targ);
21382 /* If this is a clone, use the abstract origin as the target. */
21386 e.poc_label_num = poc_label_num++;
21387 e.poc_decl = current_function_decl;
21388 e.targ_die = force_decl_die (targ);
21389 VEC_safe_push (dcall_entry, gc, dcall_table, &e);
21391 /* Drop a label at the return point to mark the point of call. */
21392 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LPOC", e.poc_label_num);
21395 /* Returns a hash value for X (which really is a struct vcall_insn). */
21398 vcall_insn_table_hash (const void *x)
21400 return (hashval_t) ((const struct vcall_insn *) x)->insn_uid;
21403 /* Return nonzero if insn_uid of struct vcall_insn *X is the same as
21404 insnd_uid of *Y. */
21407 vcall_insn_table_eq (const void *x, const void *y)
21409 return (((const struct vcall_insn *) x)->insn_uid
21410 == ((const struct vcall_insn *) y)->insn_uid);
21413 /* Associate VTABLE_SLOT with INSN_UID in the VCALL_INSN_TABLE. */
21416 store_vcall_insn (unsigned int vtable_slot, int insn_uid)
21418 struct vcall_insn *item = ggc_alloc_vcall_insn ();
21419 struct vcall_insn **slot;
21422 item->insn_uid = insn_uid;
21423 item->vtable_slot = vtable_slot;
21424 slot = (struct vcall_insn **)
21425 htab_find_slot_with_hash (vcall_insn_table, &item,
21426 (hashval_t) insn_uid, INSERT);
21430 /* Return the VTABLE_SLOT associated with INSN_UID. */
21432 static unsigned int
21433 lookup_vcall_insn (unsigned int insn_uid)
21435 struct vcall_insn item;
21436 struct vcall_insn *p;
21438 item.insn_uid = insn_uid;
21439 item.vtable_slot = 0;
21440 p = (struct vcall_insn *) htab_find_with_hash (vcall_insn_table,
21442 (hashval_t) insn_uid);
21444 return (unsigned int) -1;
21445 return p->vtable_slot;
21449 /* Called when lowering indirect calls to RTL. We make a note of INSN_UID
21450 and the OBJ_TYPE_REF_TOKEN from ADDR. For C++ virtual calls, the token
21451 is the vtable slot index that we will need to put in the virtual call
21455 dwarf2out_virtual_call_token (tree addr, int insn_uid)
21457 if (is_cxx() && TREE_CODE (addr) == OBJ_TYPE_REF)
21459 tree token = OBJ_TYPE_REF_TOKEN (addr);
21460 if (TREE_CODE (token) == INTEGER_CST)
21461 store_vcall_insn (TREE_INT_CST_LOW (token), insn_uid);
21465 /* Called when scheduling RTL, when a CALL_INSN is split. Copies the
21466 OBJ_TYPE_REF_TOKEN previously associated with OLD_INSN and associates it
21470 dwarf2out_copy_call_info (rtx old_insn, rtx new_insn)
21472 unsigned int vtable_slot = lookup_vcall_insn (INSN_UID (old_insn));
21474 if (vtable_slot != (unsigned int) -1)
21475 store_vcall_insn (vtable_slot, INSN_UID (new_insn));
21478 /* Called by the final INSN scan whenever we see a virtual function call.
21479 Make an entry into the virtual call table, recording the point of call
21480 and the slot index of the vtable entry used to call the virtual member
21481 function. The slot index was associated with the INSN_UID during the
21482 lowering to RTL. */
21485 dwarf2out_virtual_call (int insn_uid)
21487 unsigned int vtable_slot = lookup_vcall_insn (insn_uid);
21490 if (vtable_slot == (unsigned int) -1)
21493 e.poc_label_num = poc_label_num++;
21494 e.vtable_slot = vtable_slot;
21495 VEC_safe_push (vcall_entry, gc, vcall_table, &e);
21497 /* Drop a label at the return point to mark the point of call. */
21498 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LPOC", e.poc_label_num);
21501 /* Called by the final INSN scan whenever we see a var location. We
21502 use it to drop labels in the right places, and throw the location in
21503 our lookup table. */
21506 dwarf2out_var_location (rtx loc_note)
21508 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
21509 struct var_loc_node *newloc;
21511 static const char *last_label;
21512 static const char *last_postcall_label;
21513 static bool last_in_cold_section_p;
21516 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
21519 next_real = next_real_insn (loc_note);
21520 /* If there are no instructions which would be affected by this note,
21521 don't do anything. */
21522 if (next_real == NULL_RTX && !NOTE_DURING_CALL_P (loc_note))
21525 /* If there were any real insns between note we processed last time
21526 and this note (or if it is the first note), clear
21527 last_{,postcall_}label so that they are not reused this time. */
21528 if (last_var_location_insn == NULL_RTX
21529 || last_var_location_insn != next_real
21530 || last_in_cold_section_p != in_cold_section_p)
21533 last_postcall_label = NULL;
21536 decl = NOTE_VAR_LOCATION_DECL (loc_note);
21537 newloc = add_var_loc_to_decl (decl, loc_note,
21538 NOTE_DURING_CALL_P (loc_note)
21539 ? last_postcall_label : last_label);
21540 if (newloc == NULL)
21543 /* If there were no real insns between note we processed last time
21544 and this note, use the label we emitted last time. Otherwise
21545 create a new label and emit it. */
21546 if (last_label == NULL)
21548 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
21549 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
21551 last_label = ggc_strdup (loclabel);
21554 if (!NOTE_DURING_CALL_P (loc_note))
21555 newloc->label = last_label;
21558 if (!last_postcall_label)
21560 sprintf (loclabel, "%s-1", last_label);
21561 last_postcall_label = ggc_strdup (loclabel);
21563 newloc->label = last_postcall_label;
21566 last_var_location_insn = next_real;
21567 last_in_cold_section_p = in_cold_section_p;
21570 /* We need to reset the locations at the beginning of each
21571 function. We can't do this in the end_function hook, because the
21572 declarations that use the locations won't have been output when
21573 that hook is called. Also compute have_multiple_function_sections here. */
21576 dwarf2out_begin_function (tree fun)
21578 if (function_section (fun) != text_section)
21579 have_multiple_function_sections = true;
21581 dwarf2out_note_section_used ();
21584 /* Output a label to mark the beginning of a source code line entry
21585 and record information relating to this source line, in
21586 'line_info_table' for later output of the .debug_line section. */
21589 dwarf2out_source_line (unsigned int line, const char *filename,
21590 int discriminator, bool is_stmt)
21592 static bool last_is_stmt = true;
21594 if (debug_info_level >= DINFO_LEVEL_NORMAL
21597 int file_num = maybe_emit_file (lookup_filename (filename));
21599 switch_to_section (current_function_section ());
21601 /* If requested, emit something human-readable. */
21602 if (flag_debug_asm)
21603 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
21606 if (DWARF2_ASM_LINE_DEBUG_INFO)
21608 /* Emit the .loc directive understood by GNU as. */
21609 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
21610 if (is_stmt != last_is_stmt)
21612 fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
21613 last_is_stmt = is_stmt;
21615 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
21616 fprintf (asm_out_file, " discriminator %d", discriminator);
21617 fputc ('\n', asm_out_file);
21619 /* Indicate that line number info exists. */
21620 line_info_table_in_use++;
21622 else if (function_section (current_function_decl) != text_section)
21624 dw_separate_line_info_ref line_info;
21625 targetm.asm_out.internal_label (asm_out_file,
21626 SEPARATE_LINE_CODE_LABEL,
21627 separate_line_info_table_in_use);
21629 /* Expand the line info table if necessary. */
21630 if (separate_line_info_table_in_use
21631 == separate_line_info_table_allocated)
21633 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
21634 separate_line_info_table
21635 = GGC_RESIZEVEC (dw_separate_line_info_entry,
21636 separate_line_info_table,
21637 separate_line_info_table_allocated);
21638 memset (separate_line_info_table
21639 + separate_line_info_table_in_use,
21641 (LINE_INFO_TABLE_INCREMENT
21642 * sizeof (dw_separate_line_info_entry)));
21645 /* Add the new entry at the end of the line_info_table. */
21647 = &separate_line_info_table[separate_line_info_table_in_use++];
21648 line_info->dw_file_num = file_num;
21649 line_info->dw_line_num = line;
21650 line_info->function = current_function_funcdef_no;
21654 dw_line_info_ref line_info;
21656 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
21657 line_info_table_in_use);
21659 /* Expand the line info table if necessary. */
21660 if (line_info_table_in_use == line_info_table_allocated)
21662 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
21664 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
21665 line_info_table_allocated);
21666 memset (line_info_table + line_info_table_in_use, 0,
21667 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
21670 /* Add the new entry at the end of the line_info_table. */
21671 line_info = &line_info_table[line_info_table_in_use++];
21672 line_info->dw_file_num = file_num;
21673 line_info->dw_line_num = line;
21678 /* Record the beginning of a new source file. */
21681 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
21683 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
21685 /* Record the beginning of the file for break_out_includes. */
21686 dw_die_ref bincl_die;
21688 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die (), NULL);
21689 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
21692 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21695 e.code = DW_MACINFO_start_file;
21697 e.info = xstrdup (filename);
21698 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
21702 /* Record the end of a source file. */
21705 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
21707 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
21708 /* Record the end of the file for break_out_includes. */
21709 new_die (DW_TAG_GNU_EINCL, comp_unit_die (), NULL);
21711 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21714 e.code = DW_MACINFO_end_file;
21717 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
21721 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21722 the tail part of the directive line, i.e. the part which is past the
21723 initial whitespace, #, whitespace, directive-name, whitespace part. */
21726 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
21727 const char *buffer ATTRIBUTE_UNUSED)
21729 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21732 e.code = DW_MACINFO_define;
21734 e.info = xstrdup (buffer);;
21735 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
21739 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21740 the tail part of the directive line, i.e. the part which is past the
21741 initial whitespace, #, whitespace, directive-name, whitespace part. */
21744 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
21745 const char *buffer ATTRIBUTE_UNUSED)
21747 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21750 e.code = DW_MACINFO_undef;
21752 e.info = xstrdup (buffer);;
21753 VEC_safe_push (macinfo_entry, gc, macinfo_table, &e);
21758 output_macinfo (void)
21761 unsigned long length = VEC_length (macinfo_entry, macinfo_table);
21762 macinfo_entry *ref;
21767 for (i = 0; VEC_iterate (macinfo_entry, macinfo_table, i, ref); i++)
21771 case DW_MACINFO_start_file:
21773 int file_num = maybe_emit_file (lookup_filename (ref->info));
21774 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
21775 dw2_asm_output_data_uleb128
21776 (ref->lineno, "Included from line number %lu",
21777 (unsigned long)ref->lineno);
21778 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info);
21781 case DW_MACINFO_end_file:
21782 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
21784 case DW_MACINFO_define:
21785 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
21786 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
21787 (unsigned long)ref->lineno);
21788 dw2_asm_output_nstring (ref->info, -1, "The macro");
21790 case DW_MACINFO_undef:
21791 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
21792 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
21793 (unsigned long)ref->lineno);
21794 dw2_asm_output_nstring (ref->info, -1, "The macro");
21797 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n",
21798 ASM_COMMENT_START, (unsigned long)ref->code);
21804 /* Set up for Dwarf output at the start of compilation. */
21807 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
21809 /* Allocate the file_table. */
21810 file_table = htab_create_ggc (50, file_table_hash,
21811 file_table_eq, NULL);
21813 /* Allocate the decl_die_table. */
21814 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
21815 decl_die_table_eq, NULL);
21817 /* Allocate the decl_loc_table. */
21818 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
21819 decl_loc_table_eq, NULL);
21821 /* Allocate the initial hunk of the decl_scope_table. */
21822 decl_scope_table = VEC_alloc (tree, gc, 256);
21824 /* Allocate the initial hunk of the abbrev_die_table. */
21825 abbrev_die_table = ggc_alloc_cleared_vec_dw_die_ref
21826 (ABBREV_DIE_TABLE_INCREMENT);
21827 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
21828 /* Zero-th entry is allocated, but unused. */
21829 abbrev_die_table_in_use = 1;
21831 /* Allocate the initial hunk of the line_info_table. */
21832 line_info_table = ggc_alloc_cleared_vec_dw_line_info_entry
21833 (LINE_INFO_TABLE_INCREMENT);
21834 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
21836 /* Zero-th entry is allocated, but unused. */
21837 line_info_table_in_use = 1;
21839 /* Allocate the pubtypes and pubnames vectors. */
21840 pubname_table = VEC_alloc (pubname_entry, gc, 32);
21841 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
21843 /* Allocate the table that maps insn UIDs to vtable slot indexes. */
21844 vcall_insn_table = htab_create_ggc (10, vcall_insn_table_hash,
21845 vcall_insn_table_eq, NULL);
21847 incomplete_types = VEC_alloc (tree, gc, 64);
21849 used_rtx_array = VEC_alloc (rtx, gc, 32);
21851 debug_info_section = get_section (DEBUG_INFO_SECTION,
21852 SECTION_DEBUG, NULL);
21853 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
21854 SECTION_DEBUG, NULL);
21855 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
21856 SECTION_DEBUG, NULL);
21857 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
21858 SECTION_DEBUG, NULL);
21859 debug_line_section = get_section (DEBUG_LINE_SECTION,
21860 SECTION_DEBUG, NULL);
21861 debug_loc_section = get_section (DEBUG_LOC_SECTION,
21862 SECTION_DEBUG, NULL);
21863 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
21864 SECTION_DEBUG, NULL);
21865 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
21866 SECTION_DEBUG, NULL);
21867 debug_dcall_section = get_section (DEBUG_DCALL_SECTION,
21868 SECTION_DEBUG, NULL);
21869 debug_vcall_section = get_section (DEBUG_VCALL_SECTION,
21870 SECTION_DEBUG, NULL);
21871 debug_str_section = get_section (DEBUG_STR_SECTION,
21872 DEBUG_STR_SECTION_FLAGS, NULL);
21873 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
21874 SECTION_DEBUG, NULL);
21875 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
21876 SECTION_DEBUG, NULL);
21878 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
21879 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
21880 DEBUG_ABBREV_SECTION_LABEL, 0);
21881 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
21882 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
21883 COLD_TEXT_SECTION_LABEL, 0);
21884 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
21886 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
21887 DEBUG_INFO_SECTION_LABEL, 0);
21888 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
21889 DEBUG_LINE_SECTION_LABEL, 0);
21890 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
21891 DEBUG_RANGES_SECTION_LABEL, 0);
21892 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
21893 DEBUG_MACINFO_SECTION_LABEL, 0);
21895 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21896 macinfo_table = VEC_alloc (macinfo_entry, gc, 64);
21898 switch_to_section (text_section);
21899 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
21900 if (flag_reorder_blocks_and_partition)
21902 cold_text_section = unlikely_text_section ();
21903 switch_to_section (cold_text_section);
21904 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
21909 /* Called before cgraph_optimize starts outputtting functions, variables
21910 and toplevel asms into assembly. */
21913 dwarf2out_assembly_start (void)
21915 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
21916 && dwarf2out_do_cfi_asm ()
21917 && (!(flag_unwind_tables || flag_exceptions)
21918 || targetm.except_unwind_info () != UI_DWARF2))
21919 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
21922 /* A helper function for dwarf2out_finish called through
21923 htab_traverse. Emit one queued .debug_str string. */
21926 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
21928 struct indirect_string_node *node = (struct indirect_string_node *) *h;
21930 if (node->label && node->refcount)
21932 switch_to_section (debug_str_section);
21933 ASM_OUTPUT_LABEL (asm_out_file, node->label);
21934 assemble_string (node->str, strlen (node->str) + 1);
21940 #if ENABLE_ASSERT_CHECKING
21941 /* Verify that all marks are clear. */
21944 verify_marks_clear (dw_die_ref die)
21948 gcc_assert (! die->die_mark);
21949 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
21951 #endif /* ENABLE_ASSERT_CHECKING */
21953 /* Clear the marks for a die and its children.
21954 Be cool if the mark isn't set. */
21957 prune_unmark_dies (dw_die_ref die)
21963 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
21966 /* Given DIE that we're marking as used, find any other dies
21967 it references as attributes and mark them as used. */
21970 prune_unused_types_walk_attribs (dw_die_ref die)
21975 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
21977 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
21979 /* A reference to another DIE.
21980 Make sure that it will get emitted.
21981 If it was broken out into a comdat group, don't follow it. */
21982 if (dwarf_version < 4
21983 || a->dw_attr == DW_AT_specification
21984 || a->dw_attr_val.v.val_die_ref.die->die_id.die_type_node == NULL)
21985 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
21987 /* Set the string's refcount to 0 so that prune_unused_types_mark
21988 accounts properly for it. */
21989 if (AT_class (a) == dw_val_class_str)
21990 a->dw_attr_val.v.val_str->refcount = 0;
21995 /* Mark DIE as being used. If DOKIDS is true, then walk down
21996 to DIE's children. */
21999 prune_unused_types_mark (dw_die_ref die, int dokids)
22003 if (die->die_mark == 0)
22005 /* We haven't done this node yet. Mark it as used. */
22008 /* We also have to mark its parents as used.
22009 (But we don't want to mark our parents' kids due to this.) */
22010 if (die->die_parent)
22011 prune_unused_types_mark (die->die_parent, 0);
22013 /* Mark any referenced nodes. */
22014 prune_unused_types_walk_attribs (die);
22016 /* If this node is a specification,
22017 also mark the definition, if it exists. */
22018 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
22019 prune_unused_types_mark (die->die_definition, 1);
22022 if (dokids && die->die_mark != 2)
22024 /* We need to walk the children, but haven't done so yet.
22025 Remember that we've walked the kids. */
22028 /* If this is an array type, we need to make sure our
22029 kids get marked, even if they're types. If we're
22030 breaking out types into comdat sections, do this
22031 for all type definitions. */
22032 if (die->die_tag == DW_TAG_array_type
22033 || (dwarf_version >= 4
22034 && is_type_die (die) && ! is_declaration_die (die)))
22035 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
22037 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
22041 /* For local classes, look if any static member functions were emitted
22042 and if so, mark them. */
22045 prune_unused_types_walk_local_classes (dw_die_ref die)
22049 if (die->die_mark == 2)
22052 switch (die->die_tag)
22054 case DW_TAG_structure_type:
22055 case DW_TAG_union_type:
22056 case DW_TAG_class_type:
22059 case DW_TAG_subprogram:
22060 if (!get_AT_flag (die, DW_AT_declaration)
22061 || die->die_definition != NULL)
22062 prune_unused_types_mark (die, 1);
22069 /* Mark children. */
22070 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
22073 /* Walk the tree DIE and mark types that we actually use. */
22076 prune_unused_types_walk (dw_die_ref die)
22080 /* Don't do anything if this node is already marked and
22081 children have been marked as well. */
22082 if (die->die_mark == 2)
22085 switch (die->die_tag)
22087 case DW_TAG_structure_type:
22088 case DW_TAG_union_type:
22089 case DW_TAG_class_type:
22090 if (die->die_perennial_p)
22093 for (c = die->die_parent; c; c = c->die_parent)
22094 if (c->die_tag == DW_TAG_subprogram)
22097 /* Finding used static member functions inside of classes
22098 is needed just for local classes, because for other classes
22099 static member function DIEs with DW_AT_specification
22100 are emitted outside of the DW_TAG_*_type. If we ever change
22101 it, we'd need to call this even for non-local classes. */
22103 prune_unused_types_walk_local_classes (die);
22105 /* It's a type node --- don't mark it. */
22108 case DW_TAG_const_type:
22109 case DW_TAG_packed_type:
22110 case DW_TAG_pointer_type:
22111 case DW_TAG_reference_type:
22112 case DW_TAG_rvalue_reference_type:
22113 case DW_TAG_volatile_type:
22114 case DW_TAG_typedef:
22115 case DW_TAG_array_type:
22116 case DW_TAG_interface_type:
22117 case DW_TAG_friend:
22118 case DW_TAG_variant_part:
22119 case DW_TAG_enumeration_type:
22120 case DW_TAG_subroutine_type:
22121 case DW_TAG_string_type:
22122 case DW_TAG_set_type:
22123 case DW_TAG_subrange_type:
22124 case DW_TAG_ptr_to_member_type:
22125 case DW_TAG_file_type:
22126 if (die->die_perennial_p)
22129 /* It's a type node --- don't mark it. */
22133 /* Mark everything else. */
22137 if (die->die_mark == 0)
22141 /* Now, mark any dies referenced from here. */
22142 prune_unused_types_walk_attribs (die);
22147 /* Mark children. */
22148 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
22151 /* Increment the string counts on strings referred to from DIE's
22155 prune_unused_types_update_strings (dw_die_ref die)
22160 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
22161 if (AT_class (a) == dw_val_class_str)
22163 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
22165 /* Avoid unnecessarily putting strings that are used less than
22166 twice in the hash table. */
22168 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
22171 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
22172 htab_hash_string (s->str),
22174 gcc_assert (*slot == NULL);
22180 /* Remove from the tree DIE any dies that aren't marked. */
22183 prune_unused_types_prune (dw_die_ref die)
22187 gcc_assert (die->die_mark);
22188 prune_unused_types_update_strings (die);
22190 if (! die->die_child)
22193 c = die->die_child;
22195 dw_die_ref prev = c;
22196 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
22197 if (c == die->die_child)
22199 /* No marked children between 'prev' and the end of the list. */
22201 /* No marked children at all. */
22202 die->die_child = NULL;
22205 prev->die_sib = c->die_sib;
22206 die->die_child = prev;
22211 if (c != prev->die_sib)
22213 prune_unused_types_prune (c);
22214 } while (c != die->die_child);
22217 /* A helper function for dwarf2out_finish called through
22218 htab_traverse. Clear .debug_str strings that we haven't already
22219 decided to emit. */
22222 prune_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
22224 struct indirect_string_node *node = (struct indirect_string_node *) *h;
22226 if (!node->label || !node->refcount)
22227 htab_clear_slot (debug_str_hash, h);
22232 /* Remove dies representing declarations that we never use. */
22235 prune_unused_types (void)
22238 limbo_die_node *node;
22239 comdat_type_node *ctnode;
22241 dcall_entry *dcall;
22243 #if ENABLE_ASSERT_CHECKING
22244 /* All the marks should already be clear. */
22245 verify_marks_clear (comp_unit_die ());
22246 for (node = limbo_die_list; node; node = node->next)
22247 verify_marks_clear (node->die);
22248 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
22249 verify_marks_clear (ctnode->root_die);
22250 #endif /* ENABLE_ASSERT_CHECKING */
22252 /* Mark types that are used in global variables. */
22253 premark_types_used_by_global_vars ();
22255 /* Set the mark on nodes that are actually used. */
22256 prune_unused_types_walk (comp_unit_die ());
22257 for (node = limbo_die_list; node; node = node->next)
22258 prune_unused_types_walk (node->die);
22259 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
22261 prune_unused_types_walk (ctnode->root_die);
22262 prune_unused_types_mark (ctnode->type_die, 1);
22265 /* Also set the mark on nodes referenced from the
22266 pubname_table or arange_table. */
22267 FOR_EACH_VEC_ELT (pubname_entry, pubname_table, i, pub)
22268 prune_unused_types_mark (pub->die, 1);
22269 for (i = 0; i < arange_table_in_use; i++)
22270 prune_unused_types_mark (arange_table[i], 1);
22272 /* Mark nodes referenced from the direct call table. */
22273 FOR_EACH_VEC_ELT (dcall_entry, dcall_table, i, dcall)
22274 prune_unused_types_mark (dcall->targ_die, 1);
22276 /* Get rid of nodes that aren't marked; and update the string counts. */
22277 if (debug_str_hash && debug_str_hash_forced)
22278 htab_traverse (debug_str_hash, prune_indirect_string, NULL);
22279 else if (debug_str_hash)
22280 htab_empty (debug_str_hash);
22281 prune_unused_types_prune (comp_unit_die ());
22282 for (node = limbo_die_list; node; node = node->next)
22283 prune_unused_types_prune (node->die);
22284 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
22285 prune_unused_types_prune (ctnode->root_die);
22287 /* Leave the marks clear. */
22288 prune_unmark_dies (comp_unit_die ());
22289 for (node = limbo_die_list; node; node = node->next)
22290 prune_unmark_dies (node->die);
22291 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
22292 prune_unmark_dies (ctnode->root_die);
22295 /* Set the parameter to true if there are any relative pathnames in
22298 file_table_relative_p (void ** slot, void *param)
22300 bool *p = (bool *) param;
22301 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
22302 if (!IS_ABSOLUTE_PATH (d->filename))
22310 /* Routines to manipulate hash table of comdat type units. */
22313 htab_ct_hash (const void *of)
22316 const comdat_type_node *const type_node = (const comdat_type_node *) of;
22318 memcpy (&h, type_node->signature, sizeof (h));
22323 htab_ct_eq (const void *of1, const void *of2)
22325 const comdat_type_node *const type_node_1 = (const comdat_type_node *) of1;
22326 const comdat_type_node *const type_node_2 = (const comdat_type_node *) of2;
22328 return (! memcmp (type_node_1->signature, type_node_2->signature,
22329 DWARF_TYPE_SIGNATURE_SIZE));
22332 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
22333 to the location it would have been added, should we know its
22334 DECL_ASSEMBLER_NAME when we added other attributes. This will
22335 probably improve compactness of debug info, removing equivalent
22336 abbrevs, and hide any differences caused by deferring the
22337 computation of the assembler name, triggered by e.g. PCH. */
22340 move_linkage_attr (dw_die_ref die)
22342 unsigned ix = VEC_length (dw_attr_node, die->die_attr);
22343 dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1);
22345 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
22346 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
22350 dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1);
22352 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
22356 if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
22358 VEC_pop (dw_attr_node, die->die_attr);
22359 VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
22363 /* Helper function for resolve_addr, attempt to resolve
22364 one CONST_STRING, return non-zero if not successful. Similarly verify that
22365 SYMBOL_REFs refer to variables emitted in the current CU. */
22368 resolve_one_addr (rtx *addr, void *data ATTRIBUTE_UNUSED)
22372 if (GET_CODE (rtl) == CONST_STRING)
22374 size_t len = strlen (XSTR (rtl, 0)) + 1;
22375 tree t = build_string (len, XSTR (rtl, 0));
22376 tree tlen = build_int_cst (NULL_TREE, len - 1);
22378 = build_array_type (char_type_node, build_index_type (tlen));
22379 rtl = lookup_constant_def (t);
22380 if (!rtl || !MEM_P (rtl))
22382 rtl = XEXP (rtl, 0);
22383 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
22388 if (GET_CODE (rtl) == SYMBOL_REF
22389 && SYMBOL_REF_DECL (rtl)
22390 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
22393 if (GET_CODE (rtl) == CONST
22394 && for_each_rtx (&XEXP (rtl, 0), resolve_one_addr, NULL))
22400 /* Helper function for resolve_addr, handle one location
22401 expression, return false if at least one CONST_STRING or SYMBOL_REF in
22402 the location list couldn't be resolved. */
22405 resolve_addr_in_expr (dw_loc_descr_ref loc)
22407 for (; loc; loc = loc->dw_loc_next)
22408 if (((loc->dw_loc_opc == DW_OP_addr || loc->dtprel)
22409 && resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr, NULL))
22410 || (loc->dw_loc_opc == DW_OP_implicit_value
22411 && loc->dw_loc_oprnd2.val_class == dw_val_class_addr
22412 && resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr, NULL)))
22414 else if (loc->dw_loc_opc == DW_OP_GNU_implicit_pointer
22415 && loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
22418 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
22421 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
22422 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
22423 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
22428 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
22429 an address in .rodata section if the string literal is emitted there,
22430 or remove the containing location list or replace DW_AT_const_value
22431 with DW_AT_location and empty location expression, if it isn't found
22432 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
22433 to something that has been emitted in the current CU. */
22436 resolve_addr (dw_die_ref die)
22440 dw_loc_list_ref *curr;
22443 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
22444 switch (AT_class (a))
22446 case dw_val_class_loc_list:
22447 curr = AT_loc_list_ptr (a);
22450 if (!resolve_addr_in_expr ((*curr)->expr))
22452 dw_loc_list_ref next = (*curr)->dw_loc_next;
22453 if (next && (*curr)->ll_symbol)
22455 gcc_assert (!next->ll_symbol);
22456 next->ll_symbol = (*curr)->ll_symbol;
22461 curr = &(*curr)->dw_loc_next;
22463 if (!AT_loc_list (a))
22465 remove_AT (die, a->dw_attr);
22469 case dw_val_class_loc:
22470 if (!resolve_addr_in_expr (AT_loc (a)))
22472 remove_AT (die, a->dw_attr);
22476 case dw_val_class_addr:
22477 if (a->dw_attr == DW_AT_const_value
22478 && resolve_one_addr (&a->dw_attr_val.v.val_addr, NULL))
22480 remove_AT (die, a->dw_attr);
22488 FOR_EACH_CHILD (die, c, resolve_addr (c));
22491 /* Helper routines for optimize_location_lists.
22492 This pass tries to share identical local lists in .debug_loc
22495 /* Iteratively hash operands of LOC opcode. */
22497 static inline hashval_t
22498 hash_loc_operands (dw_loc_descr_ref loc, hashval_t hash)
22500 dw_val_ref val1 = &loc->dw_loc_oprnd1;
22501 dw_val_ref val2 = &loc->dw_loc_oprnd2;
22503 switch (loc->dw_loc_opc)
22505 case DW_OP_const4u:
22506 case DW_OP_const8u:
22510 case DW_OP_const1u:
22511 case DW_OP_const1s:
22512 case DW_OP_const2u:
22513 case DW_OP_const2s:
22514 case DW_OP_const4s:
22515 case DW_OP_const8s:
22519 case DW_OP_plus_uconst:
22555 case DW_OP_deref_size:
22556 case DW_OP_xderef_size:
22557 hash = iterative_hash_object (val1->v.val_int, hash);
22564 gcc_assert (val1->val_class == dw_val_class_loc);
22565 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
22566 hash = iterative_hash_object (offset, hash);
22569 case DW_OP_implicit_value:
22570 hash = iterative_hash_object (val1->v.val_unsigned, hash);
22571 switch (val2->val_class)
22573 case dw_val_class_const:
22574 hash = iterative_hash_object (val2->v.val_int, hash);
22576 case dw_val_class_vec:
22578 unsigned int elt_size = val2->v.val_vec.elt_size;
22579 unsigned int len = val2->v.val_vec.length;
22581 hash = iterative_hash_object (elt_size, hash);
22582 hash = iterative_hash_object (len, hash);
22583 hash = iterative_hash (val2->v.val_vec.array,
22584 len * elt_size, hash);
22587 case dw_val_class_const_double:
22588 hash = iterative_hash_object (val2->v.val_double.low, hash);
22589 hash = iterative_hash_object (val2->v.val_double.high, hash);
22591 case dw_val_class_addr:
22592 hash = iterative_hash_rtx (val2->v.val_addr, hash);
22595 gcc_unreachable ();
22599 case DW_OP_bit_piece:
22600 hash = iterative_hash_object (val1->v.val_int, hash);
22601 hash = iterative_hash_object (val2->v.val_int, hash);
22607 unsigned char dtprel = 0xd1;
22608 hash = iterative_hash_object (dtprel, hash);
22610 hash = iterative_hash_rtx (val1->v.val_addr, hash);
22612 case DW_OP_GNU_implicit_pointer:
22613 hash = iterative_hash_object (val2->v.val_int, hash);
22617 /* Other codes have no operands. */
22623 /* Iteratively hash the whole DWARF location expression LOC. */
22625 static inline hashval_t
22626 hash_locs (dw_loc_descr_ref loc, hashval_t hash)
22628 dw_loc_descr_ref l;
22629 bool sizes_computed = false;
22630 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
22631 size_of_locs (loc);
22633 for (l = loc; l != NULL; l = l->dw_loc_next)
22635 enum dwarf_location_atom opc = l->dw_loc_opc;
22636 hash = iterative_hash_object (opc, hash);
22637 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed)
22639 size_of_locs (loc);
22640 sizes_computed = true;
22642 hash = hash_loc_operands (l, hash);
22647 /* Compute hash of the whole location list LIST_HEAD. */
22650 hash_loc_list (dw_loc_list_ref list_head)
22652 dw_loc_list_ref curr = list_head;
22653 hashval_t hash = 0;
22655 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
22657 hash = iterative_hash (curr->begin, strlen (curr->begin) + 1, hash);
22658 hash = iterative_hash (curr->end, strlen (curr->end) + 1, hash);
22660 hash = iterative_hash (curr->section, strlen (curr->section) + 1,
22662 hash = hash_locs (curr->expr, hash);
22664 list_head->hash = hash;
22667 /* Return true if X and Y opcodes have the same operands. */
22670 compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y)
22672 dw_val_ref valx1 = &x->dw_loc_oprnd1;
22673 dw_val_ref valx2 = &x->dw_loc_oprnd2;
22674 dw_val_ref valy1 = &y->dw_loc_oprnd1;
22675 dw_val_ref valy2 = &y->dw_loc_oprnd2;
22677 switch (x->dw_loc_opc)
22679 case DW_OP_const4u:
22680 case DW_OP_const8u:
22684 case DW_OP_const1u:
22685 case DW_OP_const1s:
22686 case DW_OP_const2u:
22687 case DW_OP_const2s:
22688 case DW_OP_const4s:
22689 case DW_OP_const8s:
22693 case DW_OP_plus_uconst:
22729 case DW_OP_deref_size:
22730 case DW_OP_xderef_size:
22731 return valx1->v.val_int == valy1->v.val_int;
22734 gcc_assert (valx1->val_class == dw_val_class_loc
22735 && valy1->val_class == dw_val_class_loc
22736 && x->dw_loc_addr == y->dw_loc_addr);
22737 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr;
22738 case DW_OP_implicit_value:
22739 if (valx1->v.val_unsigned != valy1->v.val_unsigned
22740 || valx2->val_class != valy2->val_class)
22742 switch (valx2->val_class)
22744 case dw_val_class_const:
22745 return valx2->v.val_int == valy2->v.val_int;
22746 case dw_val_class_vec:
22747 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
22748 && valx2->v.val_vec.length == valy2->v.val_vec.length
22749 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
22750 valx2->v.val_vec.elt_size
22751 * valx2->v.val_vec.length) == 0;
22752 case dw_val_class_const_double:
22753 return valx2->v.val_double.low == valy2->v.val_double.low
22754 && valx2->v.val_double.high == valy2->v.val_double.high;
22755 case dw_val_class_addr:
22756 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr);
22758 gcc_unreachable ();
22761 case DW_OP_bit_piece:
22762 return valx1->v.val_int == valy1->v.val_int
22763 && valx2->v.val_int == valy2->v.val_int;
22766 return rtx_equal_p (valx1->v.val_addr, valx2->v.val_addr);
22767 case DW_OP_GNU_implicit_pointer:
22768 return valx1->val_class == dw_val_class_die_ref
22769 && valx1->val_class == valy1->val_class
22770 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die
22771 && valx2->v.val_int == valy2->v.val_int;
22773 /* Other codes have no operands. */
22778 /* Return true if DWARF location expressions X and Y are the same. */
22781 compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y)
22783 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next)
22784 if (x->dw_loc_opc != y->dw_loc_opc
22785 || x->dtprel != y->dtprel
22786 || !compare_loc_operands (x, y))
22788 return x == NULL && y == NULL;
22791 /* Return precomputed hash of location list X. */
22794 loc_list_hash (const void *x)
22796 return ((const struct dw_loc_list_struct *) x)->hash;
22799 /* Return 1 if location lists X and Y are the same. */
22802 loc_list_eq (const void *x, const void *y)
22804 const struct dw_loc_list_struct *a = (const struct dw_loc_list_struct *) x;
22805 const struct dw_loc_list_struct *b = (const struct dw_loc_list_struct *) y;
22808 if (a->hash != b->hash)
22810 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next)
22811 if (strcmp (a->begin, b->begin) != 0
22812 || strcmp (a->end, b->end) != 0
22813 || (a->section == NULL) != (b->section == NULL)
22814 || (a->section && strcmp (a->section, b->section) != 0)
22815 || !compare_locs (a->expr, b->expr))
22817 return a == NULL && b == NULL;
22820 /* Recursively optimize location lists referenced from DIE
22821 children and share them whenever possible. */
22824 optimize_location_lists_1 (dw_die_ref die, htab_t htab)
22831 FOR_EACH_VEC_ELT (dw_attr_node, die->die_attr, ix, a)
22832 if (AT_class (a) == dw_val_class_loc_list)
22834 dw_loc_list_ref list = AT_loc_list (a);
22835 /* TODO: perform some optimizations here, before hashing
22836 it and storing into the hash table. */
22837 hash_loc_list (list);
22838 slot = htab_find_slot_with_hash (htab, list, list->hash,
22841 *slot = (void *) list;
22843 a->dw_attr_val.v.val_loc_list = (dw_loc_list_ref) *slot;
22846 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab));
22849 /* Optimize location lists referenced from DIE
22850 children and share them whenever possible. */
22853 optimize_location_lists (dw_die_ref die)
22855 htab_t htab = htab_create (500, loc_list_hash, loc_list_eq, NULL);
22856 optimize_location_lists_1 (die, htab);
22857 htab_delete (htab);
22860 /* Output stuff that dwarf requires at the end of every file,
22861 and generate the DWARF-2 debugging info. */
22864 dwarf2out_finish (const char *filename)
22866 limbo_die_node *node, *next_node;
22867 comdat_type_node *ctnode;
22868 htab_t comdat_type_table;
22869 dw_die_ref die = 0;
22872 gen_remaining_tmpl_value_param_die_attribute ();
22874 /* Add the name for the main input file now. We delayed this from
22875 dwarf2out_init to avoid complications with PCH. */
22876 add_name_attribute (comp_unit_die (), remap_debug_filename (filename));
22877 if (!IS_ABSOLUTE_PATH (filename))
22878 add_comp_dir_attribute (comp_unit_die ());
22879 else if (get_AT (comp_unit_die (), DW_AT_comp_dir) == NULL)
22882 htab_traverse (file_table, file_table_relative_p, &p);
22884 add_comp_dir_attribute (comp_unit_die ());
22887 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
22889 add_location_or_const_value_attribute (
22890 VEC_index (deferred_locations, deferred_locations_list, i)->die,
22891 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
22895 /* Traverse the limbo die list, and add parent/child links. The only
22896 dies without parents that should be here are concrete instances of
22897 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
22898 For concrete instances, we can get the parent die from the abstract
22900 for (node = limbo_die_list; node; node = next_node)
22902 next_node = node->next;
22905 if (die->die_parent == NULL)
22907 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
22910 add_child_die (origin->die_parent, die);
22911 else if (is_cu_die (die))
22913 else if (seen_error ())
22914 /* It's OK to be confused by errors in the input. */
22915 add_child_die (comp_unit_die (), die);
22918 /* In certain situations, the lexical block containing a
22919 nested function can be optimized away, which results
22920 in the nested function die being orphaned. Likewise
22921 with the return type of that nested function. Force
22922 this to be a child of the containing function.
22924 It may happen that even the containing function got fully
22925 inlined and optimized out. In that case we are lost and
22926 assign the empty child. This should not be big issue as
22927 the function is likely unreachable too. */
22928 tree context = NULL_TREE;
22930 gcc_assert (node->created_for);
22932 if (DECL_P (node->created_for))
22933 context = DECL_CONTEXT (node->created_for);
22934 else if (TYPE_P (node->created_for))
22935 context = TYPE_CONTEXT (node->created_for);
22937 gcc_assert (context
22938 && (TREE_CODE (context) == FUNCTION_DECL
22939 || TREE_CODE (context) == NAMESPACE_DECL));
22941 origin = lookup_decl_die (context);
22943 add_child_die (origin, die);
22945 add_child_die (comp_unit_die (), die);
22950 limbo_die_list = NULL;
22952 resolve_addr (comp_unit_die ());
22954 for (node = deferred_asm_name; node; node = node->next)
22956 tree decl = node->created_for;
22957 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
22959 add_linkage_attr (node->die, decl);
22960 move_linkage_attr (node->die);
22964 deferred_asm_name = NULL;
22966 /* Walk through the list of incomplete types again, trying once more to
22967 emit full debugging info for them. */
22968 retry_incomplete_types ();
22970 if (flag_eliminate_unused_debug_types)
22971 prune_unused_types ();
22973 /* Generate separate CUs for each of the include files we've seen.
22974 They will go into limbo_die_list. */
22975 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
22976 break_out_includes (comp_unit_die ());
22978 /* Generate separate COMDAT sections for type DIEs. */
22979 if (dwarf_version >= 4)
22981 break_out_comdat_types (comp_unit_die ());
22983 /* Each new type_unit DIE was added to the limbo die list when created.
22984 Since these have all been added to comdat_type_list, clear the
22986 limbo_die_list = NULL;
22988 /* For each new comdat type unit, copy declarations for incomplete
22989 types to make the new unit self-contained (i.e., no direct
22990 references to the main compile unit). */
22991 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
22992 copy_decls_for_unworthy_types (ctnode->root_die);
22993 copy_decls_for_unworthy_types (comp_unit_die ());
22995 /* In the process of copying declarations from one unit to another,
22996 we may have left some declarations behind that are no longer
22997 referenced. Prune them. */
22998 prune_unused_types ();
23001 /* Traverse the DIE's and add add sibling attributes to those DIE's
23002 that have children. */
23003 add_sibling_attributes (comp_unit_die ());
23004 for (node = limbo_die_list; node; node = node->next)
23005 add_sibling_attributes (node->die);
23006 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
23007 add_sibling_attributes (ctnode->root_die);
23009 /* Output a terminator label for the .text section. */
23010 switch_to_section (text_section);
23011 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
23012 if (flag_reorder_blocks_and_partition)
23014 switch_to_section (unlikely_text_section ());
23015 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
23018 /* We can only use the low/high_pc attributes if all of the code was
23020 if (!have_multiple_function_sections
23021 || !(dwarf_version >= 3 || !dwarf_strict))
23023 add_AT_lbl_id (comp_unit_die (), DW_AT_low_pc, text_section_label);
23024 add_AT_lbl_id (comp_unit_die (), DW_AT_high_pc, text_end_label);
23029 unsigned fde_idx = 0;
23030 bool range_list_added = false;
23032 /* We need to give .debug_loc and .debug_ranges an appropriate
23033 "base address". Use zero so that these addresses become
23034 absolute. Historically, we've emitted the unexpected
23035 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
23036 Emit both to give time for other tools to adapt. */
23037 add_AT_addr (comp_unit_die (), DW_AT_low_pc, const0_rtx);
23038 add_AT_addr (comp_unit_die (), DW_AT_entry_pc, const0_rtx);
23040 if (text_section_used)
23041 add_ranges_by_labels (comp_unit_die (), text_section_label,
23042 text_end_label, &range_list_added);
23043 if (flag_reorder_blocks_and_partition && cold_text_section_used)
23044 add_ranges_by_labels (comp_unit_die (), cold_text_section_label,
23045 cold_end_label, &range_list_added);
23047 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
23049 dw_fde_ref fde = &fde_table[fde_idx];
23051 if (fde->dw_fde_switched_sections)
23053 if (!fde->in_std_section)
23054 add_ranges_by_labels (comp_unit_die (),
23055 fde->dw_fde_hot_section_label,
23056 fde->dw_fde_hot_section_end_label,
23057 &range_list_added);
23058 if (!fde->cold_in_std_section)
23059 add_ranges_by_labels (comp_unit_die (),
23060 fde->dw_fde_unlikely_section_label,
23061 fde->dw_fde_unlikely_section_end_label,
23062 &range_list_added);
23064 else if (!fde->in_std_section)
23065 add_ranges_by_labels (comp_unit_die (), fde->dw_fde_begin,
23066 fde->dw_fde_end, &range_list_added);
23069 if (range_list_added)
23073 if (debug_info_level >= DINFO_LEVEL_NORMAL)
23074 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list,
23075 debug_line_section_label);
23077 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
23078 add_AT_macptr (comp_unit_die (), DW_AT_macro_info, macinfo_section_label);
23080 if (have_location_lists)
23081 optimize_location_lists (die);
23083 /* Output all of the compilation units. We put the main one last so that
23084 the offsets are available to output_pubnames. */
23085 for (node = limbo_die_list; node; node = node->next)
23086 output_comp_unit (node->die, 0);
23088 comdat_type_table = htab_create (100, htab_ct_hash, htab_ct_eq, NULL);
23089 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
23091 void **slot = htab_find_slot (comdat_type_table, ctnode, INSERT);
23093 /* Don't output duplicate types. */
23094 if (*slot != HTAB_EMPTY_ENTRY)
23097 /* Add a pointer to the line table for the main compilation unit
23098 so that the debugger can make sense of DW_AT_decl_file
23100 if (debug_info_level >= DINFO_LEVEL_NORMAL)
23101 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
23102 debug_line_section_label);
23104 output_comdat_type_unit (ctnode);
23107 htab_delete (comdat_type_table);
23109 /* Output the main compilation unit if non-empty or if .debug_macinfo
23110 will be emitted. */
23111 output_comp_unit (comp_unit_die (), debug_info_level >= DINFO_LEVEL_VERBOSE);
23113 /* Output the abbreviation table. */
23114 switch_to_section (debug_abbrev_section);
23115 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
23116 output_abbrev_section ();
23118 /* Output location list section if necessary. */
23119 if (have_location_lists)
23121 /* Output the location lists info. */
23122 switch_to_section (debug_loc_section);
23123 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
23124 DEBUG_LOC_SECTION_LABEL, 0);
23125 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
23126 output_location_lists (die);
23129 /* Output public names table if necessary. */
23130 if (!VEC_empty (pubname_entry, pubname_table))
23132 gcc_assert (info_section_emitted);
23133 switch_to_section (debug_pubnames_section);
23134 output_pubnames (pubname_table);
23137 /* Output public types table if necessary. */
23138 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
23139 It shouldn't hurt to emit it always, since pure DWARF2 consumers
23140 simply won't look for the section. */
23141 if (!VEC_empty (pubname_entry, pubtype_table))
23143 bool empty = false;
23145 if (flag_eliminate_unused_debug_types)
23147 /* The pubtypes table might be emptied by pruning unused items. */
23151 FOR_EACH_VEC_ELT (pubname_entry, pubtype_table, i, p)
23152 if (p->die->die_offset != 0)
23160 gcc_assert (info_section_emitted);
23161 switch_to_section (debug_pubtypes_section);
23162 output_pubnames (pubtype_table);
23166 /* Output direct and virtual call tables if necessary. */
23167 if (!VEC_empty (dcall_entry, dcall_table))
23169 switch_to_section (debug_dcall_section);
23170 output_dcall_table ();
23172 if (!VEC_empty (vcall_entry, vcall_table))
23174 switch_to_section (debug_vcall_section);
23175 output_vcall_table ();
23178 /* Output the address range information. We only put functions in the arange
23179 table, so don't write it out if we don't have any. */
23180 if (fde_table_in_use)
23182 switch_to_section (debug_aranges_section);
23186 /* Output ranges section if necessary. */
23187 if (ranges_table_in_use)
23189 switch_to_section (debug_ranges_section);
23190 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
23194 /* Output the source line correspondence table. We must do this
23195 even if there is no line information. Otherwise, on an empty
23196 translation unit, we will generate a present, but empty,
23197 .debug_info section. IRIX 6.5 `nm' will then complain when
23198 examining the file. This is done late so that any filenames
23199 used by the debug_info section are marked as 'used'. */
23200 switch_to_section (debug_line_section);
23201 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
23202 if (! DWARF2_ASM_LINE_DEBUG_INFO)
23203 output_line_info ();
23205 /* Have to end the macro section. */
23206 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
23208 switch_to_section (debug_macinfo_section);
23209 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
23210 if (!VEC_empty (macinfo_entry, macinfo_table))
23212 dw2_asm_output_data (1, 0, "End compilation unit");
23215 /* If we emitted any DW_FORM_strp form attribute, output the string
23217 if (debug_str_hash)
23218 htab_traverse (debug_str_hash, output_indirect_string, NULL);
23221 #include "gt-dwarf2out.h"