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"
69 #include "hard-reg-set.h"
71 #include "insn-config.h"
79 #include "dwarf2out.h"
80 #include "dwarf2asm.h"
86 #include "diagnostic.h"
89 #include "langhooks.h"
94 #include "tree-pass.h"
96 #ifdef DWARF2_DEBUGGING_INFO
97 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
99 static rtx last_var_location_insn;
102 #ifdef VMS_DEBUGGING_INFO
103 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
105 /* Define this macro to be a nonzero value if the directory specifications
106 which are output in the debug info should end with a separator. */
107 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
108 /* Define this macro to evaluate to a nonzero value if GCC should refrain
109 from generating indirect strings in DWARF2 debug information, for instance
110 if your target is stuck with an old version of GDB that is unable to
111 process them properly or uses VMS Debug. */
112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
114 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
115 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
118 #ifndef DWARF2_FRAME_INFO
119 # ifdef DWARF2_DEBUGGING_INFO
120 # define DWARF2_FRAME_INFO \
121 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
123 # define DWARF2_FRAME_INFO 0
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 return (write_symbols == DWARF2_DEBUG
147 || write_symbols == VMS_AND_DWARF2_DEBUG
148 || DWARF2_FRAME_INFO || saved_do_cfi_asm
149 #ifdef DWARF2_UNWIND_INFO
150 || (DWARF2_UNWIND_INFO
151 && (flag_unwind_tables
152 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
157 /* Decide whether to emit frame unwind via assembler directives. */
160 dwarf2out_do_cfi_asm (void)
164 #ifdef MIPS_DEBUGGING_INFO
167 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
169 if (saved_do_cfi_asm)
171 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
174 /* Make sure the personality encoding is one the assembler can support.
175 In particular, aligned addresses can't be handled. */
176 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
177 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
179 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
180 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
183 if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
185 #ifdef TARGET_UNWIND_INFO
188 if (USING_SJLJ_EXCEPTIONS || (!flag_unwind_tables && !flag_exceptions))
193 saved_do_cfi_asm = true;
197 /* The size of the target's pointer type. */
199 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
202 /* Array of RTXes referenced by the debugging information, which therefore
203 must be kept around forever. */
204 static GTY(()) VEC(rtx,gc) *used_rtx_array;
206 /* A pointer to the base of a list of incomplete types which might be
207 completed at some later time. incomplete_types_list needs to be a
208 VEC(tree,gc) because we want to tell the garbage collector about
210 static GTY(()) VEC(tree,gc) *incomplete_types;
212 /* A pointer to the base of a table of references to declaration
213 scopes. This table is a display which tracks the nesting
214 of declaration scopes at the current scope and containing
215 scopes. This table is used to find the proper place to
216 define type declaration DIE's. */
217 static GTY(()) VEC(tree,gc) *decl_scope_table;
219 /* Pointers to various DWARF2 sections. */
220 static GTY(()) section *debug_info_section;
221 static GTY(()) section *debug_abbrev_section;
222 static GTY(()) section *debug_aranges_section;
223 static GTY(()) section *debug_macinfo_section;
224 static GTY(()) section *debug_line_section;
225 static GTY(()) section *debug_loc_section;
226 static GTY(()) section *debug_pubnames_section;
227 static GTY(()) section *debug_pubtypes_section;
228 static GTY(()) section *debug_dcall_section;
229 static GTY(()) section *debug_vcall_section;
230 static GTY(()) section *debug_str_section;
231 static GTY(()) section *debug_ranges_section;
232 static GTY(()) section *debug_frame_section;
234 /* Personality decl of current unit. Used only when assembler does not support
236 static GTY(()) rtx current_unit_personality;
238 /* How to start an assembler comment. */
239 #ifndef ASM_COMMENT_START
240 #define ASM_COMMENT_START ";#"
243 typedef struct dw_cfi_struct *dw_cfi_ref;
244 typedef struct dw_fde_struct *dw_fde_ref;
245 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
247 /* Call frames are described using a sequence of Call Frame
248 Information instructions. The register number, offset
249 and address fields are provided as possible operands;
250 their use is selected by the opcode field. */
252 enum dw_cfi_oprnd_type {
254 dw_cfi_oprnd_reg_num,
260 typedef union GTY(()) dw_cfi_oprnd_struct {
261 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
262 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
263 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
264 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
268 typedef struct GTY(()) dw_cfi_struct {
269 dw_cfi_ref dw_cfi_next;
270 enum dwarf_call_frame_info dw_cfi_opc;
271 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
273 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
278 /* This is how we define the location of the CFA. We use to handle it
279 as REG + OFFSET all the time, but now it can be more complex.
280 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
281 Instead of passing around REG and OFFSET, we pass a copy
282 of this structure. */
283 typedef struct GTY(()) cfa_loc {
284 HOST_WIDE_INT offset;
285 HOST_WIDE_INT base_offset;
287 BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
288 BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
291 /* All call frame descriptions (FDE's) in the GCC generated DWARF
292 refer to a single Common Information Entry (CIE), defined at
293 the beginning of the .debug_frame section. This use of a single
294 CIE obviates the need to keep track of multiple CIE's
295 in the DWARF generation routines below. */
297 typedef struct GTY(()) dw_fde_struct {
299 const char *dw_fde_begin;
300 const char *dw_fde_current_label;
301 const char *dw_fde_end;
302 const char *dw_fde_hot_section_label;
303 const char *dw_fde_hot_section_end_label;
304 const char *dw_fde_unlikely_section_label;
305 const char *dw_fde_unlikely_section_end_label;
306 dw_cfi_ref dw_fde_cfi;
307 dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections. */
308 unsigned funcdef_number;
309 HOST_WIDE_INT stack_realignment;
310 /* Dynamic realign argument pointer register. */
311 unsigned int drap_reg;
312 /* Virtual dynamic realign argument pointer register. */
313 unsigned int vdrap_reg;
314 unsigned all_throwers_are_sibcalls : 1;
315 unsigned nothrow : 1;
316 unsigned uses_eh_lsda : 1;
317 /* Whether we did stack realign in this call frame. */
318 unsigned stack_realign : 1;
319 /* Whether dynamic realign argument pointer register has been saved. */
320 unsigned drap_reg_saved: 1;
321 /* True iff dw_fde_begin label is in text_section or cold_text_section. */
322 unsigned in_std_section : 1;
323 /* True iff dw_fde_unlikely_section_label is in text_section or
324 cold_text_section. */
325 unsigned cold_in_std_section : 1;
326 /* True iff switched sections. */
327 unsigned dw_fde_switched_sections : 1;
328 /* True iff switching from cold to hot section. */
329 unsigned dw_fde_switched_cold_to_hot : 1;
333 /* Maximum size (in bytes) of an artificially generated label. */
334 #define MAX_ARTIFICIAL_LABEL_BYTES 30
336 /* The size of addresses as they appear in the Dwarf 2 data.
337 Some architectures use word addresses to refer to code locations,
338 but Dwarf 2 info always uses byte addresses. On such machines,
339 Dwarf 2 addresses need to be larger than the architecture's
341 #ifndef DWARF2_ADDR_SIZE
342 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
345 /* The size in bytes of a DWARF field indicating an offset or length
346 relative to a debug info section, specified to be 4 bytes in the
347 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
350 #ifndef DWARF_OFFSET_SIZE
351 #define DWARF_OFFSET_SIZE 4
354 /* The size in bytes of a DWARF 4 type signature. */
356 #ifndef DWARF_TYPE_SIGNATURE_SIZE
357 #define DWARF_TYPE_SIGNATURE_SIZE 8
360 /* According to the (draft) DWARF 3 specification, the initial length
361 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
362 bytes are 0xffffffff, followed by the length stored in the next 8
365 However, the SGI/MIPS ABI uses an initial length which is equal to
366 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
368 #ifndef DWARF_INITIAL_LENGTH_SIZE
369 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
372 /* Round SIZE up to the nearest BOUNDARY. */
373 #define DWARF_ROUND(SIZE,BOUNDARY) \
374 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
376 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
377 #ifndef DWARF_CIE_DATA_ALIGNMENT
378 #ifdef STACK_GROWS_DOWNWARD
379 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
381 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
385 /* CIE identifier. */
386 #if HOST_BITS_PER_WIDE_INT >= 64
387 #define DWARF_CIE_ID \
388 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
390 #define DWARF_CIE_ID DW_CIE_ID
393 /* A pointer to the base of a table that contains frame description
394 information for each routine. */
395 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
397 /* Number of elements currently allocated for fde_table. */
398 static GTY(()) unsigned fde_table_allocated;
400 /* Number of elements in fde_table currently in use. */
401 static GTY(()) unsigned fde_table_in_use;
403 /* Size (in elements) of increments by which we may expand the
405 #define FDE_TABLE_INCREMENT 256
407 /* Get the current fde_table entry we should use. */
409 static inline dw_fde_ref
412 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
415 /* A list of call frame insns for the CIE. */
416 static GTY(()) dw_cfi_ref cie_cfi_head;
418 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
419 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
420 attribute that accelerates the lookup of the FDE associated
421 with the subprogram. This variable holds the table index of the FDE
422 associated with the current function (body) definition. */
423 static unsigned current_funcdef_fde;
426 struct GTY(()) indirect_string_node {
428 unsigned int refcount;
429 enum dwarf_form form;
433 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
435 /* True if the compilation unit has location entries that reference
437 static GTY(()) bool debug_str_hash_forced = false;
439 static GTY(()) int dw2_string_counter;
440 static GTY(()) unsigned long dwarf2out_cfi_label_num;
442 /* True if the compilation unit places functions in more than one section. */
443 static GTY(()) bool have_multiple_function_sections = false;
445 /* Whether the default text and cold text sections have been used at all. */
447 static GTY(()) bool text_section_used = false;
448 static GTY(()) bool cold_text_section_used = false;
450 /* The default cold text section. */
451 static GTY(()) section *cold_text_section;
453 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
455 /* Forward declarations for functions defined in this file. */
457 static char *stripattributes (const char *);
458 static const char *dwarf_cfi_name (unsigned);
459 static dw_cfi_ref new_cfi (void);
460 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
461 static void add_fde_cfi (const char *, dw_cfi_ref);
462 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
463 static void lookup_cfa (dw_cfa_location *);
464 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
465 #ifdef DWARF2_UNWIND_INFO
466 static void initial_return_save (rtx);
468 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
470 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
471 static void output_cfi_directive (dw_cfi_ref);
472 static void output_call_frame_info (int);
473 static void dwarf2out_note_section_used (void);
474 static void flush_queued_reg_saves (void);
475 static bool clobbers_queued_reg_save (const_rtx);
476 static void dwarf2out_frame_debug_expr (rtx, const char *);
478 /* Support for complex CFA locations. */
479 static void output_cfa_loc (dw_cfi_ref);
480 static void output_cfa_loc_raw (dw_cfi_ref);
481 static void get_cfa_from_loc_descr (dw_cfa_location *,
482 struct dw_loc_descr_struct *);
483 static struct dw_loc_descr_struct *build_cfa_loc
484 (dw_cfa_location *, HOST_WIDE_INT);
485 static struct dw_loc_descr_struct *build_cfa_aligned_loc
486 (HOST_WIDE_INT, HOST_WIDE_INT);
487 static void def_cfa_1 (const char *, dw_cfa_location *);
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 FRAME_BEGIN_LABEL
511 #define FRAME_BEGIN_LABEL "Lframe"
513 #define CIE_AFTER_SIZE_LABEL "LSCIE"
514 #define CIE_END_LABEL "LECIE"
515 #define FDE_LABEL "LSFDE"
516 #define FDE_AFTER_SIZE_LABEL "LASFDE"
517 #define FDE_END_LABEL "LEFDE"
518 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
519 #define LINE_NUMBER_END_LABEL "LELT"
520 #define LN_PROLOG_AS_LABEL "LASLTP"
521 #define LN_PROLOG_END_LABEL "LELTP"
522 #define DIE_LABEL_PREFIX "DW"
524 /* The DWARF 2 CFA column which tracks the return address. Normally this
525 is the column for PC, or the first column after all of the hard
527 #ifndef DWARF_FRAME_RETURN_COLUMN
529 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
531 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
535 /* The mapping from gcc register number to DWARF 2 CFA column number. By
536 default, we just provide columns for all registers. */
537 #ifndef DWARF_FRAME_REGNUM
538 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
541 /* Hook used by __throw. */
544 expand_builtin_dwarf_sp_column (void)
546 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
547 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
550 /* Return a pointer to a copy of the section string name S with all
551 attributes stripped off, and an asterisk prepended (for assemble_name). */
554 stripattributes (const char *s)
556 char *stripped = XNEWVEC (char, strlen (s) + 2);
561 while (*s && *s != ',')
568 /* MEM is a memory reference for the register size table, each element of
569 which has mode MODE. Initialize column C as a return address column. */
572 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
574 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
575 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
576 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
579 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
581 static inline HOST_WIDE_INT
582 div_data_align (HOST_WIDE_INT off)
584 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
585 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
589 /* Return true if we need a signed version of a given opcode
590 (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended). */
593 need_data_align_sf_opcode (HOST_WIDE_INT off)
595 return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
598 /* Generate code to initialize the register size table. */
601 expand_builtin_init_dwarf_reg_sizes (tree address)
604 enum machine_mode mode = TYPE_MODE (char_type_node);
605 rtx addr = expand_normal (address);
606 rtx mem = gen_rtx_MEM (BLKmode, addr);
607 bool wrote_return_column = false;
609 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
611 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
613 if (rnum < DWARF_FRAME_REGISTERS)
615 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
616 enum machine_mode save_mode = reg_raw_mode[i];
619 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
620 save_mode = choose_hard_reg_mode (i, 1, true);
621 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
623 if (save_mode == VOIDmode)
625 wrote_return_column = true;
627 size = GET_MODE_SIZE (save_mode);
631 emit_move_insn (adjust_address (mem, mode, offset),
632 gen_int_mode (size, mode));
636 if (!wrote_return_column)
637 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
639 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
640 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
643 targetm.init_dwarf_reg_sizes_extra (address);
646 /* Convert a DWARF call frame info. operation to its string name */
649 dwarf_cfi_name (unsigned int cfi_opc)
653 case DW_CFA_advance_loc:
654 return "DW_CFA_advance_loc";
656 return "DW_CFA_offset";
658 return "DW_CFA_restore";
662 return "DW_CFA_set_loc";
663 case DW_CFA_advance_loc1:
664 return "DW_CFA_advance_loc1";
665 case DW_CFA_advance_loc2:
666 return "DW_CFA_advance_loc2";
667 case DW_CFA_advance_loc4:
668 return "DW_CFA_advance_loc4";
669 case DW_CFA_offset_extended:
670 return "DW_CFA_offset_extended";
671 case DW_CFA_restore_extended:
672 return "DW_CFA_restore_extended";
673 case DW_CFA_undefined:
674 return "DW_CFA_undefined";
675 case DW_CFA_same_value:
676 return "DW_CFA_same_value";
677 case DW_CFA_register:
678 return "DW_CFA_register";
679 case DW_CFA_remember_state:
680 return "DW_CFA_remember_state";
681 case DW_CFA_restore_state:
682 return "DW_CFA_restore_state";
684 return "DW_CFA_def_cfa";
685 case DW_CFA_def_cfa_register:
686 return "DW_CFA_def_cfa_register";
687 case DW_CFA_def_cfa_offset:
688 return "DW_CFA_def_cfa_offset";
691 case DW_CFA_def_cfa_expression:
692 return "DW_CFA_def_cfa_expression";
693 case DW_CFA_expression:
694 return "DW_CFA_expression";
695 case DW_CFA_offset_extended_sf:
696 return "DW_CFA_offset_extended_sf";
697 case DW_CFA_def_cfa_sf:
698 return "DW_CFA_def_cfa_sf";
699 case DW_CFA_def_cfa_offset_sf:
700 return "DW_CFA_def_cfa_offset_sf";
702 /* SGI/MIPS specific */
703 case DW_CFA_MIPS_advance_loc8:
704 return "DW_CFA_MIPS_advance_loc8";
707 case DW_CFA_GNU_window_save:
708 return "DW_CFA_GNU_window_save";
709 case DW_CFA_GNU_args_size:
710 return "DW_CFA_GNU_args_size";
711 case DW_CFA_GNU_negative_offset_extended:
712 return "DW_CFA_GNU_negative_offset_extended";
715 return "DW_CFA_<unknown>";
719 /* Return a pointer to a newly allocated Call Frame Instruction. */
721 static inline dw_cfi_ref
724 dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
726 cfi->dw_cfi_next = NULL;
727 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
728 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
733 /* Add a Call Frame Instruction to list of instructions. */
736 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
739 dw_fde_ref fde = current_fde ();
741 /* When DRAP is used, CFA is defined with an expression. Redefine
742 CFA may lead to a different CFA value. */
743 /* ??? Of course, this heuristic fails when we're annotating epilogues,
744 because of course we'll always want to redefine the CFA back to the
745 stack pointer on the way out. Where should we move this check? */
746 if (0 && fde && fde->drap_reg != INVALID_REGNUM)
747 switch (cfi->dw_cfi_opc)
749 case DW_CFA_def_cfa_register:
750 case DW_CFA_def_cfa_offset:
751 case DW_CFA_def_cfa_offset_sf:
753 case DW_CFA_def_cfa_sf:
760 /* Find the end of the chain. */
761 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
767 /* Generate a new label for the CFI info to refer to. FORCE is true
768 if a label needs to be output even when using .cfi_* directives. */
771 dwarf2out_cfi_label (bool force)
773 static char label[20];
775 if (!force && dwarf2out_do_cfi_asm ())
777 /* In this case, we will be emitting the asm directive instead of
778 the label, so just return a placeholder to keep the rest of the
780 strcpy (label, "<do not output>");
784 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
785 ASM_OUTPUT_LABEL (asm_out_file, label);
791 /* True if remember_state should be emitted before following CFI directive. */
792 static bool emit_cfa_remember;
794 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
795 or to the CIE if LABEL is NULL. */
798 add_fde_cfi (const char *label, dw_cfi_ref cfi)
800 dw_cfi_ref *list_head;
802 if (emit_cfa_remember)
804 dw_cfi_ref cfi_remember;
806 /* Emit the state save. */
807 emit_cfa_remember = false;
808 cfi_remember = new_cfi ();
809 cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
810 add_fde_cfi (label, cfi_remember);
813 list_head = &cie_cfi_head;
815 if (dwarf2out_do_cfi_asm ())
819 dw_fde_ref fde = current_fde ();
821 gcc_assert (fde != NULL);
823 /* We still have to add the cfi to the list so that lookup_cfa
824 works later on. When -g2 and above we even need to force
825 emitting of CFI labels and add to list a DW_CFA_set_loc for
826 convert_cfa_to_fb_loc_list purposes. If we're generating
827 DWARF3 output we use DW_OP_call_frame_cfa and so don't use
828 convert_cfa_to_fb_loc_list. */
829 if (dwarf_version == 2
830 && debug_info_level > DINFO_LEVEL_TERSE
831 && (write_symbols == DWARF2_DEBUG
832 || write_symbols == VMS_AND_DWARF2_DEBUG))
834 switch (cfi->dw_cfi_opc)
836 case DW_CFA_def_cfa_offset:
837 case DW_CFA_def_cfa_offset_sf:
838 case DW_CFA_def_cfa_register:
840 case DW_CFA_def_cfa_sf:
841 case DW_CFA_def_cfa_expression:
842 case DW_CFA_restore_state:
843 if (*label == 0 || strcmp (label, "<do not output>") == 0)
844 label = dwarf2out_cfi_label (true);
846 if (fde->dw_fde_current_label == NULL
847 || strcmp (label, fde->dw_fde_current_label) != 0)
851 label = xstrdup (label);
853 /* Set the location counter to the new label. */
855 /* It doesn't metter whether DW_CFA_set_loc
856 or DW_CFA_advance_loc4 is added here, those aren't
857 emitted into assembly, only looked up by
858 convert_cfa_to_fb_loc_list. */
859 xcfi->dw_cfi_opc = DW_CFA_set_loc;
860 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
861 add_cfi (&fde->dw_fde_cfi, xcfi);
862 fde->dw_fde_current_label = label;
870 output_cfi_directive (cfi);
872 list_head = &fde->dw_fde_cfi;
874 /* ??? If this is a CFI for the CIE, we don't emit. This
875 assumes that the standard CIE contents that the assembler
876 uses matches the standard CIE contents that the compiler
877 uses. This is probably a bad assumption. I'm not quite
878 sure how to address this for now. */
882 dw_fde_ref fde = current_fde ();
884 gcc_assert (fde != NULL);
887 label = dwarf2out_cfi_label (false);
889 if (fde->dw_fde_current_label == NULL
890 || strcmp (label, fde->dw_fde_current_label) != 0)
894 label = xstrdup (label);
896 /* Set the location counter to the new label. */
898 /* If we have a current label, advance from there, otherwise
899 set the location directly using set_loc. */
900 xcfi->dw_cfi_opc = fde->dw_fde_current_label
901 ? DW_CFA_advance_loc4
903 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
904 add_cfi (&fde->dw_fde_cfi, xcfi);
906 fde->dw_fde_current_label = label;
909 list_head = &fde->dw_fde_cfi;
912 add_cfi (list_head, cfi);
915 /* Subroutine of lookup_cfa. */
918 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
920 switch (cfi->dw_cfi_opc)
922 case DW_CFA_def_cfa_offset:
923 case DW_CFA_def_cfa_offset_sf:
924 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
926 case DW_CFA_def_cfa_register:
927 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
930 case DW_CFA_def_cfa_sf:
931 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
932 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
934 case DW_CFA_def_cfa_expression:
935 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
938 case DW_CFA_remember_state:
939 gcc_assert (!remember->in_use);
941 remember->in_use = 1;
943 case DW_CFA_restore_state:
944 gcc_assert (remember->in_use);
946 remember->in_use = 0;
954 /* Find the previous value for the CFA. */
957 lookup_cfa (dw_cfa_location *loc)
961 dw_cfa_location remember;
963 memset (loc, 0, sizeof (*loc));
964 loc->reg = INVALID_REGNUM;
967 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
968 lookup_cfa_1 (cfi, loc, &remember);
970 fde = current_fde ();
972 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
973 lookup_cfa_1 (cfi, loc, &remember);
976 /* The current rule for calculating the DWARF2 canonical frame address. */
977 static dw_cfa_location cfa;
979 /* The register used for saving registers to the stack, and its offset
981 static dw_cfa_location cfa_store;
983 /* The current save location around an epilogue. */
984 static dw_cfa_location cfa_remember;
986 /* The running total of the size of arguments pushed onto the stack. */
987 static HOST_WIDE_INT args_size;
989 /* The last args_size we actually output. */
990 static HOST_WIDE_INT old_args_size;
992 /* Entry point to update the canonical frame address (CFA).
993 LABEL is passed to add_fde_cfi. The value of CFA is now to be
994 calculated from REG+OFFSET. */
997 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1001 loc.base_offset = 0;
1003 loc.offset = offset;
1004 def_cfa_1 (label, &loc);
1007 /* Determine if two dw_cfa_location structures define the same data. */
1010 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
1012 return (loc1->reg == loc2->reg
1013 && loc1->offset == loc2->offset
1014 && loc1->indirect == loc2->indirect
1015 && (loc1->indirect == 0
1016 || loc1->base_offset == loc2->base_offset));
1019 /* This routine does the actual work. The CFA is now calculated from
1020 the dw_cfa_location structure. */
1023 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1026 dw_cfa_location old_cfa, loc;
1031 if (cfa_store.reg == loc.reg && loc.indirect == 0)
1032 cfa_store.offset = loc.offset;
1034 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1035 lookup_cfa (&old_cfa);
1037 /* If nothing changed, no need to issue any call frame instructions. */
1038 if (cfa_equal_p (&loc, &old_cfa))
1043 if (loc.reg == old_cfa.reg && !loc.indirect)
1045 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1046 the CFA register did not change but the offset did. The data
1047 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1048 in the assembler via the .cfi_def_cfa_offset directive. */
1050 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1052 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1053 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1056 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
1057 else if (loc.offset == old_cfa.offset
1058 && old_cfa.reg != INVALID_REGNUM
1061 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1062 indicating the CFA register has changed to <register> but the
1063 offset has not changed. */
1064 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1065 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1069 else if (loc.indirect == 0)
1071 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1072 indicating the CFA register has changed to <register> with
1073 the specified offset. The data factoring for DW_CFA_def_cfa_sf
1074 happens in output_cfi, or in the assembler via the .cfi_def_cfa
1077 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1079 cfi->dw_cfi_opc = DW_CFA_def_cfa;
1080 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1081 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1085 /* Construct a DW_CFA_def_cfa_expression instruction to
1086 calculate the CFA using a full location expression since no
1087 register-offset pair is available. */
1088 struct dw_loc_descr_struct *loc_list;
1090 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1091 loc_list = build_cfa_loc (&loc, 0);
1092 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1095 add_fde_cfi (label, cfi);
1098 /* Add the CFI for saving a register. REG is the CFA column number.
1099 LABEL is passed to add_fde_cfi.
1100 If SREG is -1, the register is saved at OFFSET from the CFA;
1101 otherwise it is saved in SREG. */
1104 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1106 dw_cfi_ref cfi = new_cfi ();
1107 dw_fde_ref fde = current_fde ();
1109 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1111 /* When stack is aligned, store REG using DW_CFA_expression with
1114 && fde->stack_realign
1115 && sreg == INVALID_REGNUM)
1117 cfi->dw_cfi_opc = DW_CFA_expression;
1118 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = reg;
1119 cfi->dw_cfi_oprnd1.dw_cfi_loc
1120 = build_cfa_aligned_loc (offset, fde->stack_realignment);
1122 else if (sreg == INVALID_REGNUM)
1124 if (need_data_align_sf_opcode (offset))
1125 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1126 else if (reg & ~0x3f)
1127 cfi->dw_cfi_opc = DW_CFA_offset_extended;
1129 cfi->dw_cfi_opc = DW_CFA_offset;
1130 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1132 else if (sreg == reg)
1133 cfi->dw_cfi_opc = DW_CFA_same_value;
1136 cfi->dw_cfi_opc = DW_CFA_register;
1137 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1140 add_fde_cfi (label, cfi);
1143 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1144 This CFI tells the unwinder that it needs to restore the window registers
1145 from the previous frame's window save area.
1147 ??? Perhaps we should note in the CIE where windows are saved (instead of
1148 assuming 0(cfa)) and what registers are in the window. */
1151 dwarf2out_window_save (const char *label)
1153 dw_cfi_ref cfi = new_cfi ();
1155 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1156 add_fde_cfi (label, cfi);
1159 /* Entry point for saving a register to the stack. REG is the GCC register
1160 number. LABEL and OFFSET are passed to reg_save. */
1163 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1165 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1168 /* Entry point for saving the return address in the stack.
1169 LABEL and OFFSET are passed to reg_save. */
1172 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1174 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1177 /* Entry point for saving the return address in a register.
1178 LABEL and SREG are passed to reg_save. */
1181 dwarf2out_return_reg (const char *label, unsigned int sreg)
1183 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1186 #ifdef DWARF2_UNWIND_INFO
1187 /* Record the initial position of the return address. RTL is
1188 INCOMING_RETURN_ADDR_RTX. */
1191 initial_return_save (rtx rtl)
1193 unsigned int reg = INVALID_REGNUM;
1194 HOST_WIDE_INT offset = 0;
1196 switch (GET_CODE (rtl))
1199 /* RA is in a register. */
1200 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1204 /* RA is on the stack. */
1205 rtl = XEXP (rtl, 0);
1206 switch (GET_CODE (rtl))
1209 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1214 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1215 offset = INTVAL (XEXP (rtl, 1));
1219 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1220 offset = -INTVAL (XEXP (rtl, 1));
1230 /* The return address is at some offset from any value we can
1231 actually load. For instance, on the SPARC it is in %i7+8. Just
1232 ignore the offset for now; it doesn't matter for unwinding frames. */
1233 gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1234 initial_return_save (XEXP (rtl, 0));
1241 if (reg != DWARF_FRAME_RETURN_COLUMN)
1242 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1246 /* Given a SET, calculate the amount of stack adjustment it
1249 static HOST_WIDE_INT
1250 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1251 HOST_WIDE_INT cur_offset)
1253 const_rtx src = SET_SRC (pattern);
1254 const_rtx dest = SET_DEST (pattern);
1255 HOST_WIDE_INT offset = 0;
1258 if (dest == stack_pointer_rtx)
1260 code = GET_CODE (src);
1262 /* Assume (set (reg sp) (reg whatever)) sets args_size
1264 if (code == REG && src != stack_pointer_rtx)
1266 offset = -cur_args_size;
1267 #ifndef STACK_GROWS_DOWNWARD
1270 return offset - cur_offset;
1273 if (! (code == PLUS || code == MINUS)
1274 || XEXP (src, 0) != stack_pointer_rtx
1275 || !CONST_INT_P (XEXP (src, 1)))
1278 /* (set (reg sp) (plus (reg sp) (const_int))) */
1279 offset = INTVAL (XEXP (src, 1));
1285 if (MEM_P (src) && !MEM_P (dest))
1289 /* (set (mem (pre_dec (reg sp))) (foo)) */
1290 src = XEXP (dest, 0);
1291 code = GET_CODE (src);
1297 if (XEXP (src, 0) == stack_pointer_rtx)
1299 rtx val = XEXP (XEXP (src, 1), 1);
1300 /* We handle only adjustments by constant amount. */
1301 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1302 && CONST_INT_P (val));
1303 offset = -INTVAL (val);
1310 if (XEXP (src, 0) == stack_pointer_rtx)
1312 offset = GET_MODE_SIZE (GET_MODE (dest));
1319 if (XEXP (src, 0) == stack_pointer_rtx)
1321 offset = -GET_MODE_SIZE (GET_MODE (dest));
1336 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1337 indexed by INSN_UID. */
1339 static HOST_WIDE_INT *barrier_args_size;
1341 /* Helper function for compute_barrier_args_size. Handle one insn. */
1343 static HOST_WIDE_INT
1344 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1345 VEC (rtx, heap) **next)
1347 HOST_WIDE_INT offset = 0;
1350 if (! RTX_FRAME_RELATED_P (insn))
1352 if (prologue_epilogue_contains (insn))
1354 else if (GET_CODE (PATTERN (insn)) == SET)
1355 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1356 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1357 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1359 /* There may be stack adjustments inside compound insns. Search
1361 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1362 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1363 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1364 cur_args_size, offset);
1369 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1373 expr = XEXP (expr, 0);
1374 if (GET_CODE (expr) == PARALLEL
1375 || GET_CODE (expr) == SEQUENCE)
1376 for (i = 1; i < XVECLEN (expr, 0); i++)
1378 rtx elem = XVECEXP (expr, 0, i);
1380 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1381 offset += stack_adjust_offset (elem, cur_args_size, offset);
1386 #ifndef STACK_GROWS_DOWNWARD
1390 cur_args_size += offset;
1391 if (cur_args_size < 0)
1396 rtx dest = JUMP_LABEL (insn);
1400 if (barrier_args_size [INSN_UID (dest)] < 0)
1402 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1403 VEC_safe_push (rtx, heap, *next, dest);
1408 return cur_args_size;
1411 /* Walk the whole function and compute args_size on BARRIERs. */
1414 compute_barrier_args_size (void)
1416 int max_uid = get_max_uid (), i;
1418 VEC (rtx, heap) *worklist, *next, *tmp;
1420 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1421 for (i = 0; i < max_uid; i++)
1422 barrier_args_size[i] = -1;
1424 worklist = VEC_alloc (rtx, heap, 20);
1425 next = VEC_alloc (rtx, heap, 20);
1426 insn = get_insns ();
1427 barrier_args_size[INSN_UID (insn)] = 0;
1428 VEC_quick_push (rtx, worklist, insn);
1431 while (!VEC_empty (rtx, worklist))
1433 rtx prev, body, first_insn;
1434 HOST_WIDE_INT cur_args_size;
1436 first_insn = insn = VEC_pop (rtx, worklist);
1437 cur_args_size = barrier_args_size[INSN_UID (insn)];
1438 prev = prev_nonnote_insn (insn);
1439 if (prev && BARRIER_P (prev))
1440 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1442 for (; insn; insn = NEXT_INSN (insn))
1444 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1446 if (BARRIER_P (insn))
1451 if (insn == first_insn)
1453 else if (barrier_args_size[INSN_UID (insn)] < 0)
1455 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1460 /* The insns starting with this label have been
1461 already scanned or are in the worklist. */
1466 body = PATTERN (insn);
1467 if (GET_CODE (body) == SEQUENCE)
1469 HOST_WIDE_INT dest_args_size = cur_args_size;
1470 for (i = 1; i < XVECLEN (body, 0); i++)
1471 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1472 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1474 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1475 dest_args_size, &next);
1478 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1479 cur_args_size, &next);
1481 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1482 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1483 dest_args_size, &next);
1486 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1487 cur_args_size, &next);
1491 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1495 if (VEC_empty (rtx, next))
1498 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1502 VEC_truncate (rtx, next, 0);
1505 VEC_free (rtx, heap, worklist);
1506 VEC_free (rtx, heap, next);
1509 /* Add a CFI to update the running total of the size of arguments
1510 pushed onto the stack. */
1513 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1517 if (size == old_args_size)
1520 old_args_size = size;
1523 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1524 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1525 add_fde_cfi (label, cfi);
1528 /* Record a stack adjustment of OFFSET bytes. */
1531 dwarf2out_stack_adjust (HOST_WIDE_INT offset, const char *label)
1533 if (cfa.reg == STACK_POINTER_REGNUM)
1534 cfa.offset += offset;
1536 if (cfa_store.reg == STACK_POINTER_REGNUM)
1537 cfa_store.offset += offset;
1539 if (ACCUMULATE_OUTGOING_ARGS)
1542 #ifndef STACK_GROWS_DOWNWARD
1546 args_size += offset;
1550 def_cfa_1 (label, &cfa);
1551 if (flag_asynchronous_unwind_tables)
1552 dwarf2out_args_size (label, args_size);
1555 /* Check INSN to see if it looks like a push or a stack adjustment, and
1556 make a note of it if it does. EH uses this information to find out
1557 how much extra space it needs to pop off the stack. */
1560 dwarf2out_notice_stack_adjust (rtx insn, bool after_p)
1562 HOST_WIDE_INT offset;
1566 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1567 with this function. Proper support would require all frame-related
1568 insns to be marked, and to be able to handle saving state around
1569 epilogues textually in the middle of the function. */
1570 if (prologue_epilogue_contains (insn))
1573 /* If INSN is an instruction from target of an annulled branch, the
1574 effects are for the target only and so current argument size
1575 shouldn't change at all. */
1577 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1578 && INSN_FROM_TARGET_P (insn))
1581 /* If only calls can throw, and we have a frame pointer,
1582 save up adjustments until we see the CALL_INSN. */
1583 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1585 if (CALL_P (insn) && !after_p)
1587 /* Extract the size of the args from the CALL rtx itself. */
1588 insn = PATTERN (insn);
1589 if (GET_CODE (insn) == PARALLEL)
1590 insn = XVECEXP (insn, 0, 0);
1591 if (GET_CODE (insn) == SET)
1592 insn = SET_SRC (insn);
1593 gcc_assert (GET_CODE (insn) == CALL);
1594 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1599 if (CALL_P (insn) && !after_p)
1601 if (!flag_asynchronous_unwind_tables)
1602 dwarf2out_args_size ("", args_size);
1605 else if (BARRIER_P (insn))
1607 /* Don't call compute_barrier_args_size () if the only
1608 BARRIER is at the end of function. */
1609 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1610 compute_barrier_args_size ();
1611 if (barrier_args_size == NULL)
1615 offset = barrier_args_size[INSN_UID (insn)];
1620 offset -= args_size;
1621 #ifndef STACK_GROWS_DOWNWARD
1625 else if (GET_CODE (PATTERN (insn)) == SET)
1626 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1627 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1628 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1630 /* There may be stack adjustments inside compound insns. Search
1632 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1633 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1634 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1643 label = dwarf2out_cfi_label (false);
1644 dwarf2out_stack_adjust (offset, label);
1649 /* We delay emitting a register save until either (a) we reach the end
1650 of the prologue or (b) the register is clobbered. This clusters
1651 register saves so that there are fewer pc advances. */
1653 struct GTY(()) queued_reg_save {
1654 struct queued_reg_save *next;
1656 HOST_WIDE_INT cfa_offset;
1660 static GTY(()) struct queued_reg_save *queued_reg_saves;
1662 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1663 struct GTY(()) reg_saved_in_data {
1668 /* A list of registers saved in other registers.
1669 The list intentionally has a small maximum capacity of 4; if your
1670 port needs more than that, you might consider implementing a
1671 more efficient data structure. */
1672 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1673 static GTY(()) size_t num_regs_saved_in_regs;
1675 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1676 static const char *last_reg_save_label;
1678 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1679 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1682 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1684 struct queued_reg_save *q;
1686 /* Duplicates waste space, but it's also necessary to remove them
1687 for correctness, since the queue gets output in reverse
1689 for (q = queued_reg_saves; q != NULL; q = q->next)
1690 if (REGNO (q->reg) == REGNO (reg))
1695 q = GGC_NEW (struct queued_reg_save);
1696 q->next = queued_reg_saves;
1697 queued_reg_saves = q;
1701 q->cfa_offset = offset;
1702 q->saved_reg = sreg;
1704 last_reg_save_label = label;
1707 /* Output all the entries in QUEUED_REG_SAVES. */
1710 flush_queued_reg_saves (void)
1712 struct queued_reg_save *q;
1714 for (q = queued_reg_saves; q; q = q->next)
1717 unsigned int reg, sreg;
1719 for (i = 0; i < num_regs_saved_in_regs; i++)
1720 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1722 if (q->saved_reg && i == num_regs_saved_in_regs)
1724 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1725 num_regs_saved_in_regs++;
1727 if (i != num_regs_saved_in_regs)
1729 regs_saved_in_regs[i].orig_reg = q->reg;
1730 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1733 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1735 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1737 sreg = INVALID_REGNUM;
1738 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1741 queued_reg_saves = NULL;
1742 last_reg_save_label = NULL;
1745 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1746 location for? Or, does it clobber a register which we've previously
1747 said that some other register is saved in, and for which we now
1748 have a new location for? */
1751 clobbers_queued_reg_save (const_rtx insn)
1753 struct queued_reg_save *q;
1755 for (q = queued_reg_saves; q; q = q->next)
1758 if (modified_in_p (q->reg, insn))
1760 for (i = 0; i < num_regs_saved_in_regs; i++)
1761 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1762 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1769 /* Entry point for saving the first register into the second. */
1772 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1775 unsigned int regno, sregno;
1777 for (i = 0; i < num_regs_saved_in_regs; i++)
1778 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1780 if (i == num_regs_saved_in_regs)
1782 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1783 num_regs_saved_in_regs++;
1785 regs_saved_in_regs[i].orig_reg = reg;
1786 regs_saved_in_regs[i].saved_in_reg = sreg;
1788 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1789 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1790 reg_save (label, regno, sregno, 0);
1793 /* What register, if any, is currently saved in REG? */
1796 reg_saved_in (rtx reg)
1798 unsigned int regn = REGNO (reg);
1800 struct queued_reg_save *q;
1802 for (q = queued_reg_saves; q; q = q->next)
1803 if (q->saved_reg && regn == REGNO (q->saved_reg))
1806 for (i = 0; i < num_regs_saved_in_regs; i++)
1807 if (regs_saved_in_regs[i].saved_in_reg
1808 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1809 return regs_saved_in_regs[i].orig_reg;
1815 /* A temporary register holding an integral value used in adjusting SP
1816 or setting up the store_reg. The "offset" field holds the integer
1817 value, not an offset. */
1818 static dw_cfa_location cfa_temp;
1820 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1823 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1825 memset (&cfa, 0, sizeof (cfa));
1827 switch (GET_CODE (pat))
1830 cfa.reg = REGNO (XEXP (pat, 0));
1831 cfa.offset = INTVAL (XEXP (pat, 1));
1835 cfa.reg = REGNO (pat);
1839 /* Recurse and define an expression. */
1843 def_cfa_1 (label, &cfa);
1846 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1849 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1853 gcc_assert (GET_CODE (pat) == SET);
1854 dest = XEXP (pat, 0);
1855 src = XEXP (pat, 1);
1857 switch (GET_CODE (src))
1860 gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1861 cfa.offset -= INTVAL (XEXP (src, 1));
1871 cfa.reg = REGNO (dest);
1872 gcc_assert (cfa.indirect == 0);
1874 def_cfa_1 (label, &cfa);
1877 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1880 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1882 HOST_WIDE_INT offset;
1883 rtx src, addr, span;
1885 src = XEXP (set, 1);
1886 addr = XEXP (set, 0);
1887 gcc_assert (MEM_P (addr));
1888 addr = XEXP (addr, 0);
1890 /* As documented, only consider extremely simple addresses. */
1891 switch (GET_CODE (addr))
1894 gcc_assert (REGNO (addr) == cfa.reg);
1895 offset = -cfa.offset;
1898 gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1899 offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1905 span = targetm.dwarf_register_span (src);
1907 /* ??? We'd like to use queue_reg_save, but we need to come up with
1908 a different flushing heuristic for epilogues. */
1910 reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1913 /* We have a PARALLEL describing where the contents of SRC live.
1914 Queue register saves for each piece of the PARALLEL. */
1917 HOST_WIDE_INT span_offset = offset;
1919 gcc_assert (GET_CODE (span) == PARALLEL);
1921 limit = XVECLEN (span, 0);
1922 for (par_index = 0; par_index < limit; par_index++)
1924 rtx elem = XVECEXP (span, 0, par_index);
1926 reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1927 INVALID_REGNUM, span_offset);
1928 span_offset += GET_MODE_SIZE (GET_MODE (elem));
1933 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
1936 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1939 unsigned sregno, dregno;
1941 src = XEXP (set, 1);
1942 dest = XEXP (set, 0);
1945 sregno = DWARF_FRAME_RETURN_COLUMN;
1947 sregno = DWARF_FRAME_REGNUM (REGNO (src));
1949 dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1951 /* ??? We'd like to use queue_reg_save, but we need to come up with
1952 a different flushing heuristic for epilogues. */
1953 reg_save (label, sregno, dregno, 0);
1956 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
1959 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
1961 dw_cfi_ref cfi = new_cfi ();
1962 unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
1964 cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
1965 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
1967 add_fde_cfi (label, cfi);
1970 /* Record call frame debugging information for an expression EXPR,
1971 which either sets SP or FP (adjusting how we calculate the frame
1972 address) or saves a register to the stack or another register.
1973 LABEL indicates the address of EXPR.
1975 This function encodes a state machine mapping rtxes to actions on
1976 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1977 users need not read the source code.
1979 The High-Level Picture
1981 Changes in the register we use to calculate the CFA: Currently we
1982 assume that if you copy the CFA register into another register, we
1983 should take the other one as the new CFA register; this seems to
1984 work pretty well. If it's wrong for some target, it's simple
1985 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1987 Changes in the register we use for saving registers to the stack:
1988 This is usually SP, but not always. Again, we deduce that if you
1989 copy SP into another register (and SP is not the CFA register),
1990 then the new register is the one we will be using for register
1991 saves. This also seems to work.
1993 Register saves: There's not much guesswork about this one; if
1994 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1995 register save, and the register used to calculate the destination
1996 had better be the one we think we're using for this purpose.
1997 It's also assumed that a copy from a call-saved register to another
1998 register is saving that register if RTX_FRAME_RELATED_P is set on
1999 that instruction. If the copy is from a call-saved register to
2000 the *same* register, that means that the register is now the same
2001 value as in the caller.
2003 Except: If the register being saved is the CFA register, and the
2004 offset is nonzero, we are saving the CFA, so we assume we have to
2005 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
2006 the intent is to save the value of SP from the previous frame.
2008 In addition, if a register has previously been saved to a different
2011 Invariants / Summaries of Rules
2013 cfa current rule for calculating the CFA. It usually
2014 consists of a register and an offset.
2015 cfa_store register used by prologue code to save things to the stack
2016 cfa_store.offset is the offset from the value of
2017 cfa_store.reg to the actual CFA
2018 cfa_temp register holding an integral value. cfa_temp.offset
2019 stores the value, which will be used to adjust the
2020 stack pointer. cfa_temp is also used like cfa_store,
2021 to track stores to the stack via fp or a temp reg.
2023 Rules 1- 4: Setting a register's value to cfa.reg or an expression
2024 with cfa.reg as the first operand changes the cfa.reg and its
2025 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
2028 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
2029 expression yielding a constant. This sets cfa_temp.reg
2030 and cfa_temp.offset.
2032 Rule 5: Create a new register cfa_store used to save items to the
2035 Rules 10-14: Save a register to the stack. Define offset as the
2036 difference of the original location and cfa_store's
2037 location (or cfa_temp's location if cfa_temp is used).
2039 Rules 16-20: If AND operation happens on sp in prologue, we assume
2040 stack is realigned. We will use a group of DW_OP_XXX
2041 expressions to represent the location of the stored
2042 register instead of CFA+offset.
2046 "{a,b}" indicates a choice of a xor b.
2047 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2050 (set <reg1> <reg2>:cfa.reg)
2051 effects: cfa.reg = <reg1>
2052 cfa.offset unchanged
2053 cfa_temp.reg = <reg1>
2054 cfa_temp.offset = cfa.offset
2057 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2058 {<const_int>,<reg>:cfa_temp.reg}))
2059 effects: cfa.reg = sp if fp used
2060 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2061 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2062 if cfa_store.reg==sp
2065 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2066 effects: cfa.reg = fp
2067 cfa_offset += +/- <const_int>
2070 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2071 constraints: <reg1> != fp
2073 effects: cfa.reg = <reg1>
2074 cfa_temp.reg = <reg1>
2075 cfa_temp.offset = cfa.offset
2078 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2079 constraints: <reg1> != fp
2081 effects: cfa_store.reg = <reg1>
2082 cfa_store.offset = cfa.offset - cfa_temp.offset
2085 (set <reg> <const_int>)
2086 effects: cfa_temp.reg = <reg>
2087 cfa_temp.offset = <const_int>
2090 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2091 effects: cfa_temp.reg = <reg1>
2092 cfa_temp.offset |= <const_int>
2095 (set <reg> (high <exp>))
2099 (set <reg> (lo_sum <exp> <const_int>))
2100 effects: cfa_temp.reg = <reg>
2101 cfa_temp.offset = <const_int>
2104 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2105 effects: cfa_store.offset -= <const_int>
2106 cfa.offset = cfa_store.offset if cfa.reg == sp
2108 cfa.base_offset = -cfa_store.offset
2111 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2112 effects: cfa_store.offset += -/+ mode_size(mem)
2113 cfa.offset = cfa_store.offset if cfa.reg == sp
2115 cfa.base_offset = -cfa_store.offset
2118 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2121 effects: cfa.reg = <reg1>
2122 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2125 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2126 effects: cfa.reg = <reg1>
2127 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2130 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2131 effects: cfa.reg = <reg1>
2132 cfa.base_offset = -cfa_temp.offset
2133 cfa_temp.offset -= mode_size(mem)
2136 (set <reg> {unspec, unspec_volatile})
2137 effects: target-dependent
2140 (set sp (and: sp <const_int>))
2141 constraints: cfa_store.reg == sp
2142 effects: current_fde.stack_realign = 1
2143 cfa_store.offset = 0
2144 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2147 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2148 effects: cfa_store.offset += -/+ mode_size(mem)
2151 (set (mem ({pre_inc, pre_dec} sp)) fp)
2152 constraints: fde->stack_realign == 1
2153 effects: cfa_store.offset = 0
2154 cfa.reg != HARD_FRAME_POINTER_REGNUM
2157 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2158 constraints: fde->stack_realign == 1
2160 && cfa.indirect == 0
2161 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2162 effects: Use DW_CFA_def_cfa_expression to define cfa
2163 cfa.reg == fde->drap_reg */
2166 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2168 rtx src, dest, span;
2169 HOST_WIDE_INT offset;
2172 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2173 the PARALLEL independently. The first element is always processed if
2174 it is a SET. This is for backward compatibility. Other elements
2175 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2176 flag is set in them. */
2177 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2180 int limit = XVECLEN (expr, 0);
2183 /* PARALLELs have strict read-modify-write semantics, so we
2184 ought to evaluate every rvalue before changing any lvalue.
2185 It's cumbersome to do that in general, but there's an
2186 easy approximation that is enough for all current users:
2187 handle register saves before register assignments. */
2188 if (GET_CODE (expr) == PARALLEL)
2189 for (par_index = 0; par_index < limit; par_index++)
2191 elem = XVECEXP (expr, 0, par_index);
2192 if (GET_CODE (elem) == SET
2193 && MEM_P (SET_DEST (elem))
2194 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2195 dwarf2out_frame_debug_expr (elem, label);
2198 for (par_index = 0; par_index < limit; par_index++)
2200 elem = XVECEXP (expr, 0, par_index);
2201 if (GET_CODE (elem) == SET
2202 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2203 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2204 dwarf2out_frame_debug_expr (elem, label);
2205 else if (GET_CODE (elem) == SET
2207 && !RTX_FRAME_RELATED_P (elem))
2209 /* Stack adjustment combining might combine some post-prologue
2210 stack adjustment into a prologue stack adjustment. */
2211 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2214 dwarf2out_stack_adjust (offset, label);
2220 gcc_assert (GET_CODE (expr) == SET);
2222 src = SET_SRC (expr);
2223 dest = SET_DEST (expr);
2227 rtx rsi = reg_saved_in (src);
2232 fde = current_fde ();
2234 switch (GET_CODE (dest))
2237 switch (GET_CODE (src))
2239 /* Setting FP from SP. */
2241 if (cfa.reg == (unsigned) REGNO (src))
2244 /* Update the CFA rule wrt SP or FP. Make sure src is
2245 relative to the current CFA register.
2247 We used to require that dest be either SP or FP, but the
2248 ARM copies SP to a temporary register, and from there to
2249 FP. So we just rely on the backends to only set
2250 RTX_FRAME_RELATED_P on appropriate insns. */
2251 cfa.reg = REGNO (dest);
2252 cfa_temp.reg = cfa.reg;
2253 cfa_temp.offset = cfa.offset;
2257 /* Saving a register in a register. */
2258 gcc_assert (!fixed_regs [REGNO (dest)]
2259 /* For the SPARC and its register window. */
2260 || (DWARF_FRAME_REGNUM (REGNO (src))
2261 == DWARF_FRAME_RETURN_COLUMN));
2263 /* After stack is aligned, we can only save SP in FP
2264 if drap register is used. In this case, we have
2265 to restore stack pointer with the CFA value and we
2266 don't generate this DWARF information. */
2268 && fde->stack_realign
2269 && REGNO (src) == STACK_POINTER_REGNUM)
2270 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2271 && fde->drap_reg != INVALID_REGNUM
2272 && cfa.reg != REGNO (src));
2274 queue_reg_save (label, src, dest, 0);
2281 if (dest == stack_pointer_rtx)
2285 switch (GET_CODE (XEXP (src, 1)))
2288 offset = INTVAL (XEXP (src, 1));
2291 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2293 offset = cfa_temp.offset;
2299 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2301 /* Restoring SP from FP in the epilogue. */
2302 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2303 cfa.reg = STACK_POINTER_REGNUM;
2305 else if (GET_CODE (src) == LO_SUM)
2306 /* Assume we've set the source reg of the LO_SUM from sp. */
2309 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2311 if (GET_CODE (src) != MINUS)
2313 if (cfa.reg == STACK_POINTER_REGNUM)
2314 cfa.offset += offset;
2315 if (cfa_store.reg == STACK_POINTER_REGNUM)
2316 cfa_store.offset += offset;
2318 else if (dest == hard_frame_pointer_rtx)
2321 /* Either setting the FP from an offset of the SP,
2322 or adjusting the FP */
2323 gcc_assert (frame_pointer_needed);
2325 gcc_assert (REG_P (XEXP (src, 0))
2326 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2327 && CONST_INT_P (XEXP (src, 1)));
2328 offset = INTVAL (XEXP (src, 1));
2329 if (GET_CODE (src) != MINUS)
2331 cfa.offset += offset;
2332 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2336 gcc_assert (GET_CODE (src) != MINUS);
2339 if (REG_P (XEXP (src, 0))
2340 && REGNO (XEXP (src, 0)) == cfa.reg
2341 && CONST_INT_P (XEXP (src, 1)))
2343 /* Setting a temporary CFA register that will be copied
2344 into the FP later on. */
2345 offset = - INTVAL (XEXP (src, 1));
2346 cfa.offset += offset;
2347 cfa.reg = REGNO (dest);
2348 /* Or used to save regs to the stack. */
2349 cfa_temp.reg = cfa.reg;
2350 cfa_temp.offset = cfa.offset;
2354 else if (REG_P (XEXP (src, 0))
2355 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2356 && XEXP (src, 1) == stack_pointer_rtx)
2358 /* Setting a scratch register that we will use instead
2359 of SP for saving registers to the stack. */
2360 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2361 cfa_store.reg = REGNO (dest);
2362 cfa_store.offset = cfa.offset - cfa_temp.offset;
2366 else if (GET_CODE (src) == LO_SUM
2367 && CONST_INT_P (XEXP (src, 1)))
2369 cfa_temp.reg = REGNO (dest);
2370 cfa_temp.offset = INTVAL (XEXP (src, 1));
2379 cfa_temp.reg = REGNO (dest);
2380 cfa_temp.offset = INTVAL (src);
2385 gcc_assert (REG_P (XEXP (src, 0))
2386 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2387 && CONST_INT_P (XEXP (src, 1)));
2389 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2390 cfa_temp.reg = REGNO (dest);
2391 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2394 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2395 which will fill in all of the bits. */
2402 case UNSPEC_VOLATILE:
2403 gcc_assert (targetm.dwarf_handle_frame_unspec);
2404 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2409 /* If this AND operation happens on stack pointer in prologue,
2410 we assume the stack is realigned and we extract the
2412 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2414 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2415 fde->stack_realign = 1;
2416 fde->stack_realignment = INTVAL (XEXP (src, 1));
2417 cfa_store.offset = 0;
2419 if (cfa.reg != STACK_POINTER_REGNUM
2420 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2421 fde->drap_reg = cfa.reg;
2429 def_cfa_1 (label, &cfa);
2434 /* Saving a register to the stack. Make sure dest is relative to the
2436 switch (GET_CODE (XEXP (dest, 0)))
2441 /* We can't handle variable size modifications. */
2442 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2444 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2446 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2447 && cfa_store.reg == STACK_POINTER_REGNUM);
2449 cfa_store.offset += offset;
2450 if (cfa.reg == STACK_POINTER_REGNUM)
2451 cfa.offset = cfa_store.offset;
2453 offset = -cfa_store.offset;
2459 offset = GET_MODE_SIZE (GET_MODE (dest));
2460 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2463 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2464 == STACK_POINTER_REGNUM)
2465 && cfa_store.reg == STACK_POINTER_REGNUM);
2467 cfa_store.offset += offset;
2469 /* Rule 18: If stack is aligned, we will use FP as a
2470 reference to represent the address of the stored
2473 && fde->stack_realign
2474 && src == hard_frame_pointer_rtx)
2476 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2477 cfa_store.offset = 0;
2480 if (cfa.reg == STACK_POINTER_REGNUM)
2481 cfa.offset = cfa_store.offset;
2483 offset = -cfa_store.offset;
2487 /* With an offset. */
2494 gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2495 && REG_P (XEXP (XEXP (dest, 0), 0)));
2496 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2497 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2500 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2502 if (cfa_store.reg == (unsigned) regno)
2503 offset -= cfa_store.offset;
2506 gcc_assert (cfa_temp.reg == (unsigned) regno);
2507 offset -= cfa_temp.offset;
2513 /* Without an offset. */
2516 int regno = REGNO (XEXP (dest, 0));
2518 if (cfa_store.reg == (unsigned) regno)
2519 offset = -cfa_store.offset;
2522 gcc_assert (cfa_temp.reg == (unsigned) regno);
2523 offset = -cfa_temp.offset;
2530 gcc_assert (cfa_temp.reg
2531 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2532 offset = -cfa_temp.offset;
2533 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2541 /* If the source operand of this MEM operation is not a
2542 register, basically the source is return address. Here
2543 we only care how much stack grew and we don't save it. */
2547 if (REGNO (src) != STACK_POINTER_REGNUM
2548 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2549 && (unsigned) REGNO (src) == cfa.reg)
2551 /* We're storing the current CFA reg into the stack. */
2553 if (cfa.offset == 0)
2556 /* If stack is aligned, putting CFA reg into stack means
2557 we can no longer use reg + offset to represent CFA.
2558 Here we use DW_CFA_def_cfa_expression instead. The
2559 result of this expression equals to the original CFA
2562 && fde->stack_realign
2563 && cfa.indirect == 0
2564 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2566 dw_cfa_location cfa_exp;
2568 gcc_assert (fde->drap_reg == cfa.reg);
2570 cfa_exp.indirect = 1;
2571 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2572 cfa_exp.base_offset = offset;
2575 fde->drap_reg_saved = 1;
2577 def_cfa_1 (label, &cfa_exp);
2581 /* If the source register is exactly the CFA, assume
2582 we're saving SP like any other register; this happens
2584 def_cfa_1 (label, &cfa);
2585 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2590 /* Otherwise, we'll need to look in the stack to
2591 calculate the CFA. */
2592 rtx x = XEXP (dest, 0);
2596 gcc_assert (REG_P (x));
2598 cfa.reg = REGNO (x);
2599 cfa.base_offset = offset;
2601 def_cfa_1 (label, &cfa);
2606 def_cfa_1 (label, &cfa);
2608 span = targetm.dwarf_register_span (src);
2611 queue_reg_save (label, src, NULL_RTX, offset);
2614 /* We have a PARALLEL describing where the contents of SRC
2615 live. Queue register saves for each piece of the
2619 HOST_WIDE_INT span_offset = offset;
2621 gcc_assert (GET_CODE (span) == PARALLEL);
2623 limit = XVECLEN (span, 0);
2624 for (par_index = 0; par_index < limit; par_index++)
2626 rtx elem = XVECEXP (span, 0, par_index);
2628 queue_reg_save (label, elem, NULL_RTX, span_offset);
2629 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2640 /* Record call frame debugging information for INSN, which either
2641 sets SP or FP (adjusting how we calculate the frame address) or saves a
2642 register to the stack. If INSN is NULL_RTX, initialize our state.
2644 If AFTER_P is false, we're being called before the insn is emitted,
2645 otherwise after. Call instructions get invoked twice. */
2648 dwarf2out_frame_debug (rtx insn, bool after_p)
2652 bool handled_one = false;
2654 if (insn == NULL_RTX)
2658 /* Flush any queued register saves. */
2659 flush_queued_reg_saves ();
2661 /* Set up state for generating call frame debug info. */
2664 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2666 cfa.reg = STACK_POINTER_REGNUM;
2669 cfa_temp.offset = 0;
2671 for (i = 0; i < num_regs_saved_in_regs; i++)
2673 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2674 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2676 num_regs_saved_in_regs = 0;
2678 if (barrier_args_size)
2680 XDELETEVEC (barrier_args_size);
2681 barrier_args_size = NULL;
2686 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2687 flush_queued_reg_saves ();
2689 if (!RTX_FRAME_RELATED_P (insn))
2691 /* ??? This should be done unconditionally since stack adjustments
2692 matter if the stack pointer is not the CFA register anymore but
2693 is still used to save registers. */
2694 if (!ACCUMULATE_OUTGOING_ARGS)
2695 dwarf2out_notice_stack_adjust (insn, after_p);
2699 label = dwarf2out_cfi_label (false);
2701 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2702 switch (REG_NOTE_KIND (note))
2704 case REG_FRAME_RELATED_EXPR:
2705 insn = XEXP (note, 0);
2708 case REG_CFA_DEF_CFA:
2709 dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2713 case REG_CFA_ADJUST_CFA:
2718 if (GET_CODE (n) == PARALLEL)
2719 n = XVECEXP (n, 0, 0);
2721 dwarf2out_frame_debug_adjust_cfa (n, label);
2725 case REG_CFA_OFFSET:
2728 n = single_set (insn);
2729 dwarf2out_frame_debug_cfa_offset (n, label);
2733 case REG_CFA_REGISTER:
2738 if (GET_CODE (n) == PARALLEL)
2739 n = XVECEXP (n, 0, 0);
2741 dwarf2out_frame_debug_cfa_register (n, label);
2745 case REG_CFA_RESTORE:
2750 if (GET_CODE (n) == PARALLEL)
2751 n = XVECEXP (n, 0, 0);
2754 dwarf2out_frame_debug_cfa_restore (n, label);
2758 case REG_CFA_SET_VDRAP:
2762 dw_fde_ref fde = current_fde ();
2765 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2767 fde->vdrap_reg = REGNO (n);
2779 insn = PATTERN (insn);
2781 dwarf2out_frame_debug_expr (insn, label);
2784 /* Determine if we need to save and restore CFI information around this
2785 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2786 we do need to save/restore, then emit the save now, and insert a
2787 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2790 dwarf2out_begin_epilogue (rtx insn)
2792 bool saw_frp = false;
2795 /* Scan forward to the return insn, noticing if there are possible
2796 frame related insns. */
2797 for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2802 /* Look for both regular and sibcalls to end the block. */
2803 if (returnjump_p (i))
2805 if (CALL_P (i) && SIBLING_CALL_P (i))
2808 if (GET_CODE (PATTERN (i)) == SEQUENCE)
2811 rtx seq = PATTERN (i);
2813 if (returnjump_p (XVECEXP (seq, 0, 0)))
2815 if (CALL_P (XVECEXP (seq, 0, 0))
2816 && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2819 for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2820 if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2824 if (RTX_FRAME_RELATED_P (i))
2828 /* If the port doesn't emit epilogue unwind info, we don't need a
2829 save/restore pair. */
2833 /* Otherwise, search forward to see if the return insn was the last
2834 basic block of the function. If so, we don't need save/restore. */
2835 gcc_assert (i != NULL);
2836 i = next_real_insn (i);
2840 /* Insert the restore before that next real insn in the stream, and before
2841 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2842 properly nested. This should be after any label or alignment. This
2843 will be pushed into the CFI stream by the function below. */
2846 rtx p = PREV_INSN (i);
2849 if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2853 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2855 emit_cfa_remember = true;
2857 /* And emulate the state save. */
2858 gcc_assert (!cfa_remember.in_use);
2860 cfa_remember.in_use = 1;
2863 /* A "subroutine" of dwarf2out_begin_epilogue. Emit the restore required. */
2866 dwarf2out_frame_debug_restore_state (void)
2868 dw_cfi_ref cfi = new_cfi ();
2869 const char *label = dwarf2out_cfi_label (false);
2871 cfi->dw_cfi_opc = DW_CFA_restore_state;
2872 add_fde_cfi (label, cfi);
2874 gcc_assert (cfa_remember.in_use);
2876 cfa_remember.in_use = 0;
2881 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2882 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2883 (enum dwarf_call_frame_info cfi);
2885 static enum dw_cfi_oprnd_type
2886 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2891 case DW_CFA_GNU_window_save:
2892 case DW_CFA_remember_state:
2893 case DW_CFA_restore_state:
2894 return dw_cfi_oprnd_unused;
2896 case DW_CFA_set_loc:
2897 case DW_CFA_advance_loc1:
2898 case DW_CFA_advance_loc2:
2899 case DW_CFA_advance_loc4:
2900 case DW_CFA_MIPS_advance_loc8:
2901 return dw_cfi_oprnd_addr;
2904 case DW_CFA_offset_extended:
2905 case DW_CFA_def_cfa:
2906 case DW_CFA_offset_extended_sf:
2907 case DW_CFA_def_cfa_sf:
2908 case DW_CFA_restore:
2909 case DW_CFA_restore_extended:
2910 case DW_CFA_undefined:
2911 case DW_CFA_same_value:
2912 case DW_CFA_def_cfa_register:
2913 case DW_CFA_register:
2914 return dw_cfi_oprnd_reg_num;
2916 case DW_CFA_def_cfa_offset:
2917 case DW_CFA_GNU_args_size:
2918 case DW_CFA_def_cfa_offset_sf:
2919 return dw_cfi_oprnd_offset;
2921 case DW_CFA_def_cfa_expression:
2922 case DW_CFA_expression:
2923 return dw_cfi_oprnd_loc;
2930 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2931 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2932 (enum dwarf_call_frame_info cfi);
2934 static enum dw_cfi_oprnd_type
2935 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2939 case DW_CFA_def_cfa:
2940 case DW_CFA_def_cfa_sf:
2942 case DW_CFA_offset_extended_sf:
2943 case DW_CFA_offset_extended:
2944 return dw_cfi_oprnd_offset;
2946 case DW_CFA_register:
2947 return dw_cfi_oprnd_reg_num;
2950 return dw_cfi_oprnd_unused;
2954 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2956 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
2957 switch to the data section instead, and write out a synthetic start label
2958 for collect2 the first time around. */
2961 switch_to_eh_frame_section (bool back)
2965 #ifdef EH_FRAME_SECTION_NAME
2966 if (eh_frame_section == 0)
2970 if (EH_TABLES_CAN_BE_READ_ONLY)
2976 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2978 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2980 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2982 flags = ((! flag_pic
2983 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2984 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2985 && (per_encoding & 0x70) != DW_EH_PE_absptr
2986 && (per_encoding & 0x70) != DW_EH_PE_aligned
2987 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2988 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2989 ? 0 : SECTION_WRITE);
2992 flags = SECTION_WRITE;
2993 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2997 if (eh_frame_section)
2998 switch_to_section (eh_frame_section);
3001 /* We have no special eh_frame section. Put the information in
3002 the data section and emit special labels to guide collect2. */
3003 switch_to_section (data_section);
3007 label = get_file_function_name ("F");
3008 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3009 targetm.asm_out.globalize_label (asm_out_file,
3010 IDENTIFIER_POINTER (label));
3011 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
3016 /* Switch [BACK] to the eh or debug frame table section, depending on
3020 switch_to_frame_table_section (int for_eh, bool back)
3023 switch_to_eh_frame_section (back);
3026 if (!debug_frame_section)
3027 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3028 SECTION_DEBUG, NULL);
3029 switch_to_section (debug_frame_section);
3033 /* Output a Call Frame Information opcode and its operand(s). */
3036 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3041 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3042 dw2_asm_output_data (1, (cfi->dw_cfi_opc
3043 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3044 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3045 ((unsigned HOST_WIDE_INT)
3046 cfi->dw_cfi_oprnd1.dw_cfi_offset));
3047 else if (cfi->dw_cfi_opc == DW_CFA_offset)
3049 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3050 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3051 "DW_CFA_offset, column 0x%lx", r);
3052 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3053 dw2_asm_output_data_uleb128 (off, NULL);
3055 else if (cfi->dw_cfi_opc == DW_CFA_restore)
3057 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3058 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3059 "DW_CFA_restore, column 0x%lx", r);
3063 dw2_asm_output_data (1, cfi->dw_cfi_opc,
3064 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3066 switch (cfi->dw_cfi_opc)
3068 case DW_CFA_set_loc:
3070 dw2_asm_output_encoded_addr_rtx (
3071 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3072 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3075 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3076 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3077 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3080 case DW_CFA_advance_loc1:
3081 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3082 fde->dw_fde_current_label, NULL);
3083 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3086 case DW_CFA_advance_loc2:
3087 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3088 fde->dw_fde_current_label, NULL);
3089 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3092 case DW_CFA_advance_loc4:
3093 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3094 fde->dw_fde_current_label, NULL);
3095 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3098 case DW_CFA_MIPS_advance_loc8:
3099 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3100 fde->dw_fde_current_label, NULL);
3101 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3104 case DW_CFA_offset_extended:
3105 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3106 dw2_asm_output_data_uleb128 (r, NULL);
3107 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3108 dw2_asm_output_data_uleb128 (off, NULL);
3111 case DW_CFA_def_cfa:
3112 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3113 dw2_asm_output_data_uleb128 (r, NULL);
3114 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3117 case DW_CFA_offset_extended_sf:
3118 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3119 dw2_asm_output_data_uleb128 (r, NULL);
3120 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3121 dw2_asm_output_data_sleb128 (off, NULL);
3124 case DW_CFA_def_cfa_sf:
3125 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3126 dw2_asm_output_data_uleb128 (r, NULL);
3127 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3128 dw2_asm_output_data_sleb128 (off, NULL);
3131 case DW_CFA_restore_extended:
3132 case DW_CFA_undefined:
3133 case DW_CFA_same_value:
3134 case DW_CFA_def_cfa_register:
3135 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3136 dw2_asm_output_data_uleb128 (r, NULL);
3139 case DW_CFA_register:
3140 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3141 dw2_asm_output_data_uleb128 (r, NULL);
3142 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3143 dw2_asm_output_data_uleb128 (r, NULL);
3146 case DW_CFA_def_cfa_offset:
3147 case DW_CFA_GNU_args_size:
3148 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3151 case DW_CFA_def_cfa_offset_sf:
3152 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3153 dw2_asm_output_data_sleb128 (off, NULL);
3156 case DW_CFA_GNU_window_save:
3159 case DW_CFA_def_cfa_expression:
3160 case DW_CFA_expression:
3161 output_cfa_loc (cfi);
3164 case DW_CFA_GNU_negative_offset_extended:
3165 /* Obsoleted by DW_CFA_offset_extended_sf. */
3174 /* Similar, but do it via assembler directives instead. */
3177 output_cfi_directive (dw_cfi_ref cfi)
3179 unsigned long r, r2;
3181 switch (cfi->dw_cfi_opc)
3183 case DW_CFA_advance_loc:
3184 case DW_CFA_advance_loc1:
3185 case DW_CFA_advance_loc2:
3186 case DW_CFA_advance_loc4:
3187 case DW_CFA_MIPS_advance_loc8:
3188 case DW_CFA_set_loc:
3189 /* Should only be created by add_fde_cfi in a code path not
3190 followed when emitting via directives. The assembler is
3191 going to take care of this for us. */
3195 case DW_CFA_offset_extended:
3196 case DW_CFA_offset_extended_sf:
3197 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3198 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3199 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3202 case DW_CFA_restore:
3203 case DW_CFA_restore_extended:
3204 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3205 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3208 case DW_CFA_undefined:
3209 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3210 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3213 case DW_CFA_same_value:
3214 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3215 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3218 case DW_CFA_def_cfa:
3219 case DW_CFA_def_cfa_sf:
3220 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3221 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3222 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3225 case DW_CFA_def_cfa_register:
3226 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3227 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3230 case DW_CFA_register:
3231 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3232 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3233 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3236 case DW_CFA_def_cfa_offset:
3237 case DW_CFA_def_cfa_offset_sf:
3238 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3239 HOST_WIDE_INT_PRINT_DEC"\n",
3240 cfi->dw_cfi_oprnd1.dw_cfi_offset);
3243 case DW_CFA_remember_state:
3244 fprintf (asm_out_file, "\t.cfi_remember_state\n");
3246 case DW_CFA_restore_state:
3247 fprintf (asm_out_file, "\t.cfi_restore_state\n");
3250 case DW_CFA_GNU_args_size:
3251 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size);
3252 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3254 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3255 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3256 fputc ('\n', asm_out_file);
3259 case DW_CFA_GNU_window_save:
3260 fprintf (asm_out_file, "\t.cfi_window_save\n");
3263 case DW_CFA_def_cfa_expression:
3264 case DW_CFA_expression:
3265 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", cfi->dw_cfi_opc);
3266 output_cfa_loc_raw (cfi);
3267 fputc ('\n', asm_out_file);
3275 DEF_VEC_P (dw_cfi_ref);
3276 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
3278 /* Output CFIs to bring current FDE to the same state as after executing
3279 CFIs in CFI chain. DO_CFI_ASM is true if .cfi_* directives shall
3280 be emitted, false otherwise. If it is false, FDE and FOR_EH are the
3281 other arguments to pass to output_cfi. */
3284 output_cfis (dw_cfi_ref cfi, bool do_cfi_asm, dw_fde_ref fde, bool for_eh)
3286 struct dw_cfi_struct cfi_buf;
3288 dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3289 VEC (dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3290 unsigned int len, idx;
3292 for (;; cfi = cfi->dw_cfi_next)
3293 switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3295 case DW_CFA_advance_loc:
3296 case DW_CFA_advance_loc1:
3297 case DW_CFA_advance_loc2:
3298 case DW_CFA_advance_loc4:
3299 case DW_CFA_MIPS_advance_loc8:
3300 case DW_CFA_set_loc:
3301 /* All advances should be ignored. */
3303 case DW_CFA_remember_state:
3305 dw_cfi_ref args_size = cfi_args_size;
3307 /* Skip everything between .cfi_remember_state and
3308 .cfi_restore_state. */
3309 for (cfi2 = cfi->dw_cfi_next; cfi2; cfi2 = cfi2->dw_cfi_next)
3310 if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3312 else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3315 gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3322 cfi_args_size = args_size;
3326 case DW_CFA_GNU_args_size:
3327 cfi_args_size = cfi;
3329 case DW_CFA_GNU_window_save:
3332 case DW_CFA_offset_extended:
3333 case DW_CFA_offset_extended_sf:
3334 case DW_CFA_restore:
3335 case DW_CFA_restore_extended:
3336 case DW_CFA_undefined:
3337 case DW_CFA_same_value:
3338 case DW_CFA_register:
3339 case DW_CFA_val_offset:
3340 case DW_CFA_val_offset_sf:
3341 case DW_CFA_expression:
3342 case DW_CFA_val_expression:
3343 case DW_CFA_GNU_negative_offset_extended:
3344 if (VEC_length (dw_cfi_ref, regs) <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3345 VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3346 cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3347 VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, cfi);
3349 case DW_CFA_def_cfa:
3350 case DW_CFA_def_cfa_sf:
3351 case DW_CFA_def_cfa_expression:
3353 cfi_cfa_offset = cfi;
3355 case DW_CFA_def_cfa_register:
3358 case DW_CFA_def_cfa_offset:
3359 case DW_CFA_def_cfa_offset_sf:
3360 cfi_cfa_offset = cfi;
3363 gcc_assert (cfi == NULL);
3365 len = VEC_length (dw_cfi_ref, regs);
3366 for (idx = 0; idx < len; idx++)
3368 cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3370 && cfi2->dw_cfi_opc != DW_CFA_restore
3371 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3374 output_cfi_directive (cfi2);
3376 output_cfi (cfi2, fde, for_eh);
3379 if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3381 gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3383 switch (cfi_cfa_offset->dw_cfi_opc)
3385 case DW_CFA_def_cfa_offset:
3386 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3387 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3389 case DW_CFA_def_cfa_offset_sf:
3390 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3391 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3393 case DW_CFA_def_cfa:
3394 case DW_CFA_def_cfa_sf:
3395 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3396 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3403 else if (cfi_cfa_offset)
3404 cfi_cfa = cfi_cfa_offset;
3408 output_cfi_directive (cfi_cfa);
3410 output_cfi (cfi_cfa, fde, for_eh);
3413 cfi_cfa_offset = NULL;
3415 && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3418 output_cfi_directive (cfi_args_size);
3420 output_cfi (cfi_args_size, fde, for_eh);
3422 cfi_args_size = NULL;
3425 VEC_free (dw_cfi_ref, heap, regs);
3428 else if (do_cfi_asm)
3429 output_cfi_directive (cfi);
3431 output_cfi (cfi, fde, for_eh);
3438 /* Output one FDE. */
3441 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3442 char *section_start_label, int fde_encoding, char *augmentation,
3443 bool any_lsda_needed, int lsda_encoding)
3445 const char *begin, *end;
3446 static unsigned int j;
3447 char l1[20], l2[20];
3450 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh,
3452 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3454 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3455 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3456 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3457 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3458 " indicating 64-bit DWARF extension");
3459 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3461 ASM_OUTPUT_LABEL (asm_out_file, l1);
3464 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3466 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3467 debug_frame_section, "FDE CIE offset");
3469 if (!fde->dw_fde_switched_sections)
3471 begin = fde->dw_fde_begin;
3472 end = fde->dw_fde_end;
3476 /* For the first section, prefer dw_fde_begin over
3477 dw_fde_{hot,cold}_section_label, as the latter
3478 might be separated from the real start of the
3479 function by alignment padding. */
3481 begin = fde->dw_fde_begin;
3482 else if (fde->dw_fde_switched_cold_to_hot)
3483 begin = fde->dw_fde_hot_section_label;
3485 begin = fde->dw_fde_unlikely_section_label;
3486 if (second ^ fde->dw_fde_switched_cold_to_hot)
3487 end = fde->dw_fde_unlikely_section_end_label;
3489 end = fde->dw_fde_hot_section_end_label;
3494 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
3495 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3496 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
3497 "FDE initial location");
3498 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3499 end, begin, "FDE address range");
3503 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
3504 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
3507 if (augmentation[0])
3509 if (any_lsda_needed)
3511 int size = size_of_encoded_value (lsda_encoding);
3513 if (lsda_encoding == DW_EH_PE_aligned)
3515 int offset = ( 4 /* Length */
3516 + 4 /* CIE offset */
3517 + 2 * size_of_encoded_value (fde_encoding)
3518 + 1 /* Augmentation size */ );
3519 int pad = -offset & (PTR_SIZE - 1);
3522 gcc_assert (size_of_uleb128 (size) == 1);
3525 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3527 if (fde->uses_eh_lsda)
3529 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
3530 fde->funcdef_number);
3531 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
3532 gen_rtx_SYMBOL_REF (Pmode, l1),
3534 "Language Specific Data Area");
3538 if (lsda_encoding == DW_EH_PE_aligned)
3539 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3540 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
3541 "Language Specific Data Area (none)");
3545 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3548 /* Loop through the Call Frame Instructions associated with
3550 fde->dw_fde_current_label = begin;
3551 if (!fde->dw_fde_switched_sections)
3552 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3553 output_cfi (cfi, fde, for_eh);
3556 if (fde->dw_fde_switch_cfi)
3557 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3559 output_cfi (cfi, fde, for_eh);
3560 if (cfi == fde->dw_fde_switch_cfi)
3566 dw_cfi_ref cfi_next = fde->dw_fde_cfi;
3568 if (fde->dw_fde_switch_cfi)
3570 cfi_next = fde->dw_fde_switch_cfi->dw_cfi_next;
3571 fde->dw_fde_switch_cfi->dw_cfi_next = NULL;
3572 output_cfis (fde->dw_fde_cfi, false, fde, for_eh);
3573 fde->dw_fde_switch_cfi->dw_cfi_next = cfi_next;
3575 for (cfi = cfi_next; cfi != NULL; cfi = cfi->dw_cfi_next)
3576 output_cfi (cfi, fde, for_eh);
3579 /* If we are to emit a ref/link from function bodies to their frame tables,
3580 do it now. This is typically performed to make sure that tables
3581 associated with functions are dragged with them and not discarded in
3582 garbage collecting links. We need to do this on a per function basis to
3583 cope with -ffunction-sections. */
3585 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3586 /* Switch to the function section, emit the ref to the tables, and
3587 switch *back* into the table section. */
3588 switch_to_section (function_section (fde->decl));
3589 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
3590 switch_to_frame_table_section (for_eh, true);
3593 /* Pad the FDE out to an address sized boundary. */
3594 ASM_OUTPUT_ALIGN (asm_out_file,
3595 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3596 ASM_OUTPUT_LABEL (asm_out_file, l2);
3601 /* Output the call frame information used to record information
3602 that relates to calculating the frame pointer, and records the
3603 location of saved registers. */
3606 output_call_frame_info (int for_eh)
3611 char l1[20], l2[20], section_start_label[20];
3612 bool any_lsda_needed = false;
3613 char augmentation[6];
3614 int augmentation_size;
3615 int fde_encoding = DW_EH_PE_absptr;
3616 int per_encoding = DW_EH_PE_absptr;
3617 int lsda_encoding = DW_EH_PE_absptr;
3619 rtx personality = NULL;
3622 /* Don't emit a CIE if there won't be any FDEs. */
3623 if (fde_table_in_use == 0)
3626 /* Nothing to do if the assembler's doing it all. */
3627 if (dwarf2out_do_cfi_asm ())
3630 /* If we make FDEs linkonce, we may have to emit an empty label for
3631 an FDE that wouldn't otherwise be emitted. We want to avoid
3632 having an FDE kept around when the function it refers to is
3633 discarded. Example where this matters: a primary function
3634 template in C++ requires EH information, but an explicit
3635 specialization doesn't. */
3636 if (TARGET_USES_WEAK_UNWIND_INFO
3637 && ! flag_asynchronous_unwind_tables
3640 for (i = 0; i < fde_table_in_use; i++)
3641 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
3642 && !fde_table[i].uses_eh_lsda
3643 && ! DECL_WEAK (fde_table[i].decl))
3644 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
3645 for_eh, /* empty */ 1);
3647 /* If we don't have any functions we'll want to unwind out of, don't
3648 emit any EH unwind information. Note that if exceptions aren't
3649 enabled, we won't have collected nothrow information, and if we
3650 asked for asynchronous tables, we always want this info. */
3653 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
3655 for (i = 0; i < fde_table_in_use; i++)
3656 if (fde_table[i].uses_eh_lsda)
3657 any_eh_needed = any_lsda_needed = true;
3658 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3659 any_eh_needed = true;
3660 else if (! fde_table[i].nothrow
3661 && ! fde_table[i].all_throwers_are_sibcalls)
3662 any_eh_needed = true;
3664 if (! any_eh_needed)
3668 /* We're going to be generating comments, so turn on app. */
3672 /* Switch to the proper frame section, first time. */
3673 switch_to_frame_table_section (for_eh, false);
3675 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3676 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3678 /* Output the CIE. */
3679 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3680 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3681 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3682 dw2_asm_output_data (4, 0xffffffff,
3683 "Initial length escape value indicating 64-bit DWARF extension");
3684 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3685 "Length of Common Information Entry");
3686 ASM_OUTPUT_LABEL (asm_out_file, l1);
3688 /* Now that the CIE pointer is PC-relative for EH,
3689 use 0 to identify the CIE. */
3690 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3691 (for_eh ? 0 : DWARF_CIE_ID),
3692 "CIE Identifier Tag");
3694 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3695 use CIE version 1, unless that would produce incorrect results
3696 due to overflowing the return register column. */
3697 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3699 if (return_reg >= 256 || dwarf_version > 2)
3701 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
3703 augmentation[0] = 0;
3704 augmentation_size = 0;
3706 personality = current_unit_personality;
3712 z Indicates that a uleb128 is present to size the
3713 augmentation section.
3714 L Indicates the encoding (and thus presence) of
3715 an LSDA pointer in the FDE augmentation.
3716 R Indicates a non-default pointer encoding for
3718 P Indicates the presence of an encoding + language
3719 personality routine in the CIE augmentation. */
3721 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3722 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3723 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3725 p = augmentation + 1;
3729 augmentation_size += 1 + size_of_encoded_value (per_encoding);
3730 assemble_external_libcall (personality);
3732 if (any_lsda_needed)
3735 augmentation_size += 1;
3737 if (fde_encoding != DW_EH_PE_absptr)
3740 augmentation_size += 1;
3742 if (p > augmentation + 1)
3744 augmentation[0] = 'z';
3748 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3749 if (personality && per_encoding == DW_EH_PE_aligned)
3751 int offset = ( 4 /* Length */
3753 + 1 /* CIE version */
3754 + strlen (augmentation) + 1 /* Augmentation */
3755 + size_of_uleb128 (1) /* Code alignment */
3756 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3758 + 1 /* Augmentation size */
3759 + 1 /* Personality encoding */ );
3760 int pad = -offset & (PTR_SIZE - 1);
3762 augmentation_size += pad;
3764 /* Augmentations should be small, so there's scarce need to
3765 iterate for a solution. Die if we exceed one uleb128 byte. */
3766 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3770 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3771 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3772 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3773 "CIE Data Alignment Factor");
3775 if (dw_cie_version == 1)
3776 dw2_asm_output_data (1, return_reg, "CIE RA Column");
3778 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3780 if (augmentation[0])
3782 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3785 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3786 eh_data_format_name (per_encoding));
3787 dw2_asm_output_encoded_addr_rtx (per_encoding,
3792 if (any_lsda_needed)
3793 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3794 eh_data_format_name (lsda_encoding));
3796 if (fde_encoding != DW_EH_PE_absptr)
3797 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3798 eh_data_format_name (fde_encoding));
3801 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3802 output_cfi (cfi, NULL, for_eh);
3804 /* Pad the CIE out to an address sized boundary. */
3805 ASM_OUTPUT_ALIGN (asm_out_file,
3806 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3807 ASM_OUTPUT_LABEL (asm_out_file, l2);
3809 /* Loop through all of the FDE's. */
3810 for (i = 0; i < fde_table_in_use; i++)
3813 fde = &fde_table[i];
3815 /* Don't emit EH unwind info for leaf functions that don't need it. */
3816 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3817 && (fde->nothrow || fde->all_throwers_are_sibcalls)
3818 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3819 && !fde->uses_eh_lsda)
3822 for (k = 0; k < (fde->dw_fde_switched_sections ? 2 : 1); k++)
3823 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
3824 augmentation, any_lsda_needed, lsda_encoding);
3827 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3828 dw2_asm_output_data (4, 0, "End of Table");
3829 #ifdef MIPS_DEBUGGING_INFO
3830 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3831 get a value of 0. Putting .align 0 after the label fixes it. */
3832 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3835 /* Turn off app to make assembly quicker. */
3840 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
3843 dwarf2out_do_cfi_startproc (bool second)
3847 rtx personality = get_personality_function (current_function_decl);
3849 fprintf (asm_out_file, "\t.cfi_startproc\n");
3853 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3856 /* ??? The GAS support isn't entirely consistent. We have to
3857 handle indirect support ourselves, but PC-relative is done
3858 in the assembler. Further, the assembler can't handle any
3859 of the weirder relocation types. */
3860 if (enc & DW_EH_PE_indirect)
3861 ref = dw2_force_const_mem (ref, true);
3863 fprintf (asm_out_file, "\t.cfi_personality 0x%x,", enc);
3864 output_addr_const (asm_out_file, ref);
3865 fputc ('\n', asm_out_file);
3868 if (crtl->uses_eh_lsda)
3872 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3873 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
3874 current_function_funcdef_no);
3875 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3876 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3878 if (enc & DW_EH_PE_indirect)
3879 ref = dw2_force_const_mem (ref, true);
3881 fprintf (asm_out_file, "\t.cfi_lsda 0x%x,", enc);
3882 output_addr_const (asm_out_file, ref);
3883 fputc ('\n', asm_out_file);
3887 /* Output a marker (i.e. a label) for the beginning of a function, before
3891 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3892 const char *file ATTRIBUTE_UNUSED)
3894 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3899 current_function_func_begin_label = NULL;
3901 #ifdef TARGET_UNWIND_INFO
3902 /* ??? current_function_func_begin_label is also used by except.c
3903 for call-site information. We must emit this label if it might
3905 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3906 && ! dwarf2out_do_frame ())
3909 if (! dwarf2out_do_frame ())
3913 fnsec = function_section (current_function_decl);
3914 switch_to_section (fnsec);
3915 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3916 current_function_funcdef_no);
3917 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3918 current_function_funcdef_no);
3919 dup_label = xstrdup (label);
3920 current_function_func_begin_label = dup_label;
3922 #ifdef TARGET_UNWIND_INFO
3923 /* We can elide the fde allocation if we're not emitting debug info. */
3924 if (! dwarf2out_do_frame ())
3928 /* Expand the fde table if necessary. */
3929 if (fde_table_in_use == fde_table_allocated)
3931 fde_table_allocated += FDE_TABLE_INCREMENT;
3932 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3933 memset (fde_table + fde_table_in_use, 0,
3934 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3937 /* Record the FDE associated with this function. */
3938 current_funcdef_fde = fde_table_in_use;
3940 /* Add the new FDE at the end of the fde_table. */
3941 fde = &fde_table[fde_table_in_use++];
3942 fde->decl = current_function_decl;
3943 fde->dw_fde_begin = dup_label;
3944 fde->dw_fde_current_label = dup_label;
3945 fde->dw_fde_hot_section_label = NULL;
3946 fde->dw_fde_hot_section_end_label = NULL;
3947 fde->dw_fde_unlikely_section_label = NULL;
3948 fde->dw_fde_unlikely_section_end_label = NULL;
3949 fde->dw_fde_switched_sections = 0;
3950 fde->dw_fde_switched_cold_to_hot = 0;
3951 fde->dw_fde_end = NULL;
3952 fde->dw_fde_cfi = NULL;
3953 fde->dw_fde_switch_cfi = NULL;
3954 fde->funcdef_number = current_function_funcdef_no;
3955 fde->nothrow = crtl->nothrow;
3956 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3957 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3958 fde->drap_reg = INVALID_REGNUM;
3959 fde->vdrap_reg = INVALID_REGNUM;
3960 if (flag_reorder_blocks_and_partition)
3962 section *unlikelysec;
3963 if (first_function_block_is_cold)
3964 fde->in_std_section = 1;
3967 = (fnsec == text_section
3968 || (cold_text_section && fnsec == cold_text_section));
3969 unlikelysec = unlikely_text_section ();
3970 fde->cold_in_std_section
3971 = (unlikelysec == text_section
3972 || (cold_text_section && unlikelysec == cold_text_section));
3977 = (fnsec == text_section
3978 || (cold_text_section && fnsec == cold_text_section));
3979 fde->cold_in_std_section = 0;
3982 args_size = old_args_size = 0;
3984 /* We only want to output line number information for the genuine dwarf2
3985 prologue case, not the eh frame case. */
3986 #ifdef DWARF2_DEBUGGING_INFO
3988 dwarf2out_source_line (line, file, 0, true);
3991 if (dwarf2out_do_cfi_asm ())
3992 dwarf2out_do_cfi_startproc (false);
3995 rtx personality = get_personality_function (current_function_decl);
3996 if (!current_unit_personality)
3997 current_unit_personality = personality;
3999 /* We cannot keep a current personality per function as without CFI
4000 asm at the point where we emit the CFI data there is no current
4001 function anymore. */
4003 && current_unit_personality != personality)
4004 sorry ("Multiple EH personalities are supported only with assemblers "
4005 "supporting .cfi.personality directive.");
4009 /* Output a marker (i.e. a label) for the absolute end of the generated code
4010 for a function definition. This gets called *after* the epilogue code has
4014 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4015 const char *file ATTRIBUTE_UNUSED)
4018 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4020 #ifdef DWARF2_DEBUGGING_INFO
4021 last_var_location_insn = NULL_RTX;
4024 if (dwarf2out_do_cfi_asm ())
4025 fprintf (asm_out_file, "\t.cfi_endproc\n");
4027 /* Output a label to mark the endpoint of the code generated for this
4029 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
4030 current_function_funcdef_no);
4031 ASM_OUTPUT_LABEL (asm_out_file, label);
4032 fde = current_fde ();
4033 gcc_assert (fde != NULL);
4034 fde->dw_fde_end = xstrdup (label);
4038 dwarf2out_frame_init (void)
4040 /* Allocate the initial hunk of the fde_table. */
4041 fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
4042 fde_table_allocated = FDE_TABLE_INCREMENT;
4043 fde_table_in_use = 0;
4045 /* Generate the CFA instructions common to all FDE's. Do it now for the
4046 sake of lookup_cfa. */
4048 /* On entry, the Canonical Frame Address is at SP. */
4049 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
4051 #ifdef DWARF2_UNWIND_INFO
4052 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
4053 initial_return_save (INCOMING_RETURN_ADDR_RTX);
4058 dwarf2out_frame_finish (void)
4060 /* Output call frame information. */
4061 if (DWARF2_FRAME_INFO)
4062 output_call_frame_info (0);
4064 #ifndef TARGET_UNWIND_INFO
4065 /* Output another copy for the unwinder. */
4066 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
4067 output_call_frame_info (1);
4071 /* Note that the current function section is being used for code. */
4074 dwarf2out_note_section_used (void)
4076 section *sec = current_function_section ();
4077 if (sec == text_section)
4078 text_section_used = true;
4079 else if (sec == cold_text_section)
4080 cold_text_section_used = true;
4084 dwarf2out_switch_text_section (void)
4086 dw_fde_ref fde = current_fde ();
4088 gcc_assert (cfun && fde && !fde->dw_fde_switched_sections);
4090 fde->dw_fde_switched_sections = 1;
4091 fde->dw_fde_switched_cold_to_hot = !in_cold_section_p;
4093 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
4094 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
4095 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
4096 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
4097 have_multiple_function_sections = true;
4099 /* Reset the current label on switching text sections, so that we
4100 don't attempt to advance_loc4 between labels in different sections. */
4101 fde->dw_fde_current_label = NULL;
4103 /* There is no need to mark used sections when not debugging. */
4104 if (cold_text_section != NULL)
4105 dwarf2out_note_section_used ();
4107 if (dwarf2out_do_cfi_asm ())
4108 fprintf (asm_out_file, "\t.cfi_endproc\n");
4110 /* Now do the real section switch. */
4111 switch_to_section (current_function_section ());
4113 if (dwarf2out_do_cfi_asm ())
4115 dwarf2out_do_cfi_startproc (true);
4116 /* As this is a different FDE, insert all current CFI instructions
4118 output_cfis (fde->dw_fde_cfi, true, fde, true);
4122 dw_cfi_ref cfi = fde->dw_fde_cfi;
4124 cfi = fde->dw_fde_cfi;
4126 while (cfi->dw_cfi_next != NULL)
4127 cfi = cfi->dw_cfi_next;
4128 fde->dw_fde_switch_cfi = cfi;
4133 /* And now, the subset of the debugging information support code necessary
4134 for emitting location expressions. */
4136 /* Data about a single source file. */
4137 struct GTY(()) dwarf_file_data {
4138 const char * filename;
4142 typedef struct dw_val_struct *dw_val_ref;
4143 typedef struct die_struct *dw_die_ref;
4144 typedef const struct die_struct *const_dw_die_ref;
4145 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
4146 typedef struct dw_loc_list_struct *dw_loc_list_ref;
4148 typedef struct GTY(()) deferred_locations_struct
4152 } deferred_locations;
4154 DEF_VEC_O(deferred_locations);
4155 DEF_VEC_ALLOC_O(deferred_locations,gc);
4157 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
4159 DEF_VEC_P(dw_die_ref);
4160 DEF_VEC_ALLOC_P(dw_die_ref,heap);
4162 /* Each DIE may have a series of attribute/value pairs. Values
4163 can take on several forms. The forms that are used in this
4164 implementation are listed below. */
4169 dw_val_class_offset,
4171 dw_val_class_loc_list,
4172 dw_val_class_range_list,
4174 dw_val_class_unsigned_const,
4175 dw_val_class_const_double,
4178 dw_val_class_die_ref,
4179 dw_val_class_fde_ref,
4180 dw_val_class_lbl_id,
4181 dw_val_class_lineptr,
4183 dw_val_class_macptr,
4188 /* Describe a floating point constant value, or a vector constant value. */
4190 typedef struct GTY(()) dw_vec_struct {
4191 unsigned char * GTY((length ("%h.length"))) array;
4197 /* The dw_val_node describes an attribute's value, as it is
4198 represented internally. */
4200 typedef struct GTY(()) dw_val_struct {
4201 enum dw_val_class val_class;
4202 union dw_val_struct_union
4204 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
4205 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
4206 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
4207 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
4208 HOST_WIDE_INT GTY ((default)) val_int;
4209 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
4210 double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
4211 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
4212 struct dw_val_die_union
4216 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
4217 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
4218 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
4219 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
4220 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
4221 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
4222 unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
4224 GTY ((desc ("%1.val_class"))) v;
4228 /* Locations in memory are described using a sequence of stack machine
4231 typedef struct GTY(()) dw_loc_descr_struct {
4232 dw_loc_descr_ref dw_loc_next;
4233 ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
4234 /* Used to distinguish DW_OP_addr with a direct symbol relocation
4235 from DW_OP_addr with a dtp-relative symbol relocation. */
4236 unsigned int dtprel : 1;
4238 dw_val_node dw_loc_oprnd1;
4239 dw_val_node dw_loc_oprnd2;
4243 /* Location lists are ranges + location descriptions for that range,
4244 so you can track variables that are in different places over
4245 their entire life. */
4246 typedef struct GTY(()) dw_loc_list_struct {
4247 dw_loc_list_ref dw_loc_next;
4248 const char *begin; /* Label for begin address of range */
4249 const char *end; /* Label for end address of range */
4250 char *ll_symbol; /* Label for beginning of location list.
4251 Only on head of list */
4252 const char *section; /* Section this loclist is relative to */
4253 dw_loc_descr_ref expr;
4256 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
4258 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4260 /* Convert a DWARF stack opcode into its string name. */
4263 dwarf_stack_op_name (unsigned int op)
4268 return "DW_OP_addr";
4270 return "DW_OP_deref";
4272 return "DW_OP_const1u";
4274 return "DW_OP_const1s";
4276 return "DW_OP_const2u";
4278 return "DW_OP_const2s";
4280 return "DW_OP_const4u";
4282 return "DW_OP_const4s";
4284 return "DW_OP_const8u";
4286 return "DW_OP_const8s";
4288 return "DW_OP_constu";
4290 return "DW_OP_consts";
4294 return "DW_OP_drop";
4296 return "DW_OP_over";
4298 return "DW_OP_pick";
4300 return "DW_OP_swap";
4304 return "DW_OP_xderef";
4312 return "DW_OP_minus";
4324 return "DW_OP_plus";
4325 case DW_OP_plus_uconst:
4326 return "DW_OP_plus_uconst";
4332 return "DW_OP_shra";
4350 return "DW_OP_skip";
4352 return "DW_OP_lit0";
4354 return "DW_OP_lit1";
4356 return "DW_OP_lit2";
4358 return "DW_OP_lit3";
4360 return "DW_OP_lit4";
4362 return "DW_OP_lit5";
4364 return "DW_OP_lit6";
4366 return "DW_OP_lit7";
4368 return "DW_OP_lit8";
4370 return "DW_OP_lit9";
4372 return "DW_OP_lit10";
4374 return "DW_OP_lit11";
4376 return "DW_OP_lit12";
4378 return "DW_OP_lit13";
4380 return "DW_OP_lit14";
4382 return "DW_OP_lit15";
4384 return "DW_OP_lit16";
4386 return "DW_OP_lit17";
4388 return "DW_OP_lit18";
4390 return "DW_OP_lit19";
4392 return "DW_OP_lit20";
4394 return "DW_OP_lit21";
4396 return "DW_OP_lit22";
4398 return "DW_OP_lit23";
4400 return "DW_OP_lit24";
4402 return "DW_OP_lit25";
4404 return "DW_OP_lit26";
4406 return "DW_OP_lit27";
4408 return "DW_OP_lit28";
4410 return "DW_OP_lit29";
4412 return "DW_OP_lit30";
4414 return "DW_OP_lit31";
4416 return "DW_OP_reg0";
4418 return "DW_OP_reg1";
4420 return "DW_OP_reg2";
4422 return "DW_OP_reg3";
4424 return "DW_OP_reg4";
4426 return "DW_OP_reg5";
4428 return "DW_OP_reg6";
4430 return "DW_OP_reg7";
4432 return "DW_OP_reg8";
4434 return "DW_OP_reg9";
4436 return "DW_OP_reg10";
4438 return "DW_OP_reg11";
4440 return "DW_OP_reg12";
4442 return "DW_OP_reg13";
4444 return "DW_OP_reg14";
4446 return "DW_OP_reg15";
4448 return "DW_OP_reg16";
4450 return "DW_OP_reg17";
4452 return "DW_OP_reg18";
4454 return "DW_OP_reg19";
4456 return "DW_OP_reg20";
4458 return "DW_OP_reg21";
4460 return "DW_OP_reg22";
4462 return "DW_OP_reg23";
4464 return "DW_OP_reg24";
4466 return "DW_OP_reg25";
4468 return "DW_OP_reg26";
4470 return "DW_OP_reg27";
4472 return "DW_OP_reg28";
4474 return "DW_OP_reg29";
4476 return "DW_OP_reg30";
4478 return "DW_OP_reg31";
4480 return "DW_OP_breg0";
4482 return "DW_OP_breg1";
4484 return "DW_OP_breg2";
4486 return "DW_OP_breg3";
4488 return "DW_OP_breg4";
4490 return "DW_OP_breg5";
4492 return "DW_OP_breg6";
4494 return "DW_OP_breg7";
4496 return "DW_OP_breg8";
4498 return "DW_OP_breg9";
4500 return "DW_OP_breg10";
4502 return "DW_OP_breg11";
4504 return "DW_OP_breg12";
4506 return "DW_OP_breg13";
4508 return "DW_OP_breg14";
4510 return "DW_OP_breg15";
4512 return "DW_OP_breg16";
4514 return "DW_OP_breg17";
4516 return "DW_OP_breg18";
4518 return "DW_OP_breg19";
4520 return "DW_OP_breg20";
4522 return "DW_OP_breg21";
4524 return "DW_OP_breg22";
4526 return "DW_OP_breg23";
4528 return "DW_OP_breg24";
4530 return "DW_OP_breg25";
4532 return "DW_OP_breg26";
4534 return "DW_OP_breg27";
4536 return "DW_OP_breg28";
4538 return "DW_OP_breg29";
4540 return "DW_OP_breg30";
4542 return "DW_OP_breg31";
4544 return "DW_OP_regx";
4546 return "DW_OP_fbreg";
4548 return "DW_OP_bregx";
4550 return "DW_OP_piece";
4551 case DW_OP_deref_size:
4552 return "DW_OP_deref_size";
4553 case DW_OP_xderef_size:
4554 return "DW_OP_xderef_size";
4558 case DW_OP_push_object_address:
4559 return "DW_OP_push_object_address";
4561 return "DW_OP_call2";
4563 return "DW_OP_call4";
4564 case DW_OP_call_ref:
4565 return "DW_OP_call_ref";
4566 case DW_OP_implicit_value:
4567 return "DW_OP_implicit_value";
4568 case DW_OP_stack_value:
4569 return "DW_OP_stack_value";
4570 case DW_OP_form_tls_address:
4571 return "DW_OP_form_tls_address";
4572 case DW_OP_call_frame_cfa:
4573 return "DW_OP_call_frame_cfa";
4574 case DW_OP_bit_piece:
4575 return "DW_OP_bit_piece";
4577 case DW_OP_GNU_push_tls_address:
4578 return "DW_OP_GNU_push_tls_address";
4579 case DW_OP_GNU_uninit:
4580 return "DW_OP_GNU_uninit";
4581 case DW_OP_GNU_encoded_addr:
4582 return "DW_OP_GNU_encoded_addr";
4585 return "OP_<unknown>";
4589 /* Return a pointer to a newly allocated location description. Location
4590 descriptions are simple expression terms that can be strung
4591 together to form more complicated location (address) descriptions. */
4593 static inline dw_loc_descr_ref
4594 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
4595 unsigned HOST_WIDE_INT oprnd2)
4597 dw_loc_descr_ref descr = GGC_CNEW (dw_loc_descr_node);
4599 descr->dw_loc_opc = op;
4600 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4601 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4602 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4603 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4608 /* Return a pointer to a newly allocated location description for
4611 static inline dw_loc_descr_ref
4612 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
4615 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
4618 return new_loc_descr (DW_OP_bregx, reg, offset);
4621 /* Add a location description term to a location description expression. */
4624 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
4626 dw_loc_descr_ref *d;
4628 /* Find the end of the chain. */
4629 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4635 /* Add a constant OFFSET to a location expression. */
4638 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
4640 dw_loc_descr_ref loc;
4643 gcc_assert (*list_head != NULL);
4648 /* Find the end of the chain. */
4649 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
4653 if (loc->dw_loc_opc == DW_OP_fbreg
4654 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
4655 p = &loc->dw_loc_oprnd1.v.val_int;
4656 else if (loc->dw_loc_opc == DW_OP_bregx)
4657 p = &loc->dw_loc_oprnd2.v.val_int;
4659 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4660 offset. Don't optimize if an signed integer overflow would happen. */
4662 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
4663 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
4666 else if (offset > 0)
4667 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4671 loc->dw_loc_next = int_loc_descriptor (offset);
4672 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_plus, 0, 0));
4676 #ifdef DWARF2_DEBUGGING_INFO
4677 /* Add a constant OFFSET to a location list. */
4680 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
4683 for (d = list_head; d != NULL; d = d->dw_loc_next)
4684 loc_descr_plus_const (&d->expr, offset);
4688 /* Return the size of a location descriptor. */
4690 static unsigned long
4691 size_of_loc_descr (dw_loc_descr_ref loc)
4693 unsigned long size = 1;
4695 switch (loc->dw_loc_opc)
4698 size += DWARF2_ADDR_SIZE;
4717 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4720 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4725 case DW_OP_plus_uconst:
4726 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4764 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4767 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4770 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4773 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4774 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4777 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4779 case DW_OP_deref_size:
4780 case DW_OP_xderef_size:
4789 case DW_OP_call_ref:
4790 size += DWARF2_ADDR_SIZE;
4792 case DW_OP_implicit_value:
4793 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
4794 + loc->dw_loc_oprnd1.v.val_unsigned;
4803 /* Return the size of a series of location descriptors. */
4805 static unsigned long
4806 size_of_locs (dw_loc_descr_ref loc)
4811 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4812 field, to avoid writing to a PCH file. */
4813 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4815 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4817 size += size_of_loc_descr (l);
4822 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4824 l->dw_loc_addr = size;
4825 size += size_of_loc_descr (l);
4831 #ifdef DWARF2_DEBUGGING_INFO
4832 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4835 /* Output location description stack opcode's operands (if any). */
4838 output_loc_operands (dw_loc_descr_ref loc)
4840 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4841 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4843 switch (loc->dw_loc_opc)
4845 #ifdef DWARF2_DEBUGGING_INFO
4848 dw2_asm_output_data (2, val1->v.val_int, NULL);
4852 dw2_asm_output_data (4, val1->v.val_int, NULL);
4856 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
4857 dw2_asm_output_data (8, val1->v.val_int, NULL);
4864 gcc_assert (val1->val_class == dw_val_class_loc);
4865 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4867 dw2_asm_output_data (2, offset, NULL);
4870 case DW_OP_implicit_value:
4871 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4872 switch (val2->val_class)
4874 case dw_val_class_const:
4875 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
4877 case dw_val_class_vec:
4879 unsigned int elt_size = val2->v.val_vec.elt_size;
4880 unsigned int len = val2->v.val_vec.length;
4884 if (elt_size > sizeof (HOST_WIDE_INT))
4889 for (i = 0, p = val2->v.val_vec.array;
4892 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
4893 "fp or vector constant word %u", i);
4896 case dw_val_class_const_double:
4898 unsigned HOST_WIDE_INT first, second;
4900 if (WORDS_BIG_ENDIAN)
4902 first = val2->v.val_double.high;
4903 second = val2->v.val_double.low;
4907 first = val2->v.val_double.low;
4908 second = val2->v.val_double.high;
4910 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
4912 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
4916 case dw_val_class_addr:
4917 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
4918 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
4933 case DW_OP_implicit_value:
4934 /* We currently don't make any attempt to make sure these are
4935 aligned properly like we do for the main unwind info, so
4936 don't support emitting things larger than a byte if we're
4937 only doing unwinding. */
4942 dw2_asm_output_data (1, val1->v.val_int, NULL);
4945 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4948 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4951 dw2_asm_output_data (1, val1->v.val_int, NULL);
4953 case DW_OP_plus_uconst:
4954 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4988 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4991 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4994 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4997 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4998 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
5001 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5003 case DW_OP_deref_size:
5004 case DW_OP_xderef_size:
5005 dw2_asm_output_data (1, val1->v.val_int, NULL);
5011 if (targetm.asm_out.output_dwarf_dtprel)
5013 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
5016 fputc ('\n', asm_out_file);
5023 #ifdef DWARF2_DEBUGGING_INFO
5024 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
5032 /* Other codes have no operands. */
5037 /* Output a sequence of location operations. */
5040 output_loc_sequence (dw_loc_descr_ref loc)
5042 for (; loc != NULL; loc = loc->dw_loc_next)
5044 /* Output the opcode. */
5045 dw2_asm_output_data (1, loc->dw_loc_opc,
5046 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
5048 /* Output the operand(s) (if any). */
5049 output_loc_operands (loc);
5053 /* Output location description stack opcode's operands (if any).
5054 The output is single bytes on a line, suitable for .cfi_escape. */
5057 output_loc_operands_raw (dw_loc_descr_ref loc)
5059 dw_val_ref val1 = &loc->dw_loc_oprnd1;
5060 dw_val_ref val2 = &loc->dw_loc_oprnd2;
5062 switch (loc->dw_loc_opc)
5065 case DW_OP_implicit_value:
5066 /* We cannot output addresses in .cfi_escape, only bytes. */
5072 case DW_OP_deref_size:
5073 case DW_OP_xderef_size:
5074 fputc (',', asm_out_file);
5075 dw2_asm_output_data_raw (1, val1->v.val_int);
5080 fputc (',', asm_out_file);
5081 dw2_asm_output_data_raw (2, val1->v.val_int);
5086 fputc (',', asm_out_file);
5087 dw2_asm_output_data_raw (4, val1->v.val_int);
5092 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5093 fputc (',', asm_out_file);
5094 dw2_asm_output_data_raw (8, val1->v.val_int);
5102 gcc_assert (val1->val_class == dw_val_class_loc);
5103 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5105 fputc (',', asm_out_file);
5106 dw2_asm_output_data_raw (2, offset);
5111 case DW_OP_plus_uconst:
5114 fputc (',', asm_out_file);
5115 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5152 fputc (',', asm_out_file);
5153 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
5157 fputc (',', asm_out_file);
5158 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5159 fputc (',', asm_out_file);
5160 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
5164 /* Other codes have no operands. */
5170 output_loc_sequence_raw (dw_loc_descr_ref loc)
5174 /* Output the opcode. */
5175 fprintf (asm_out_file, "0x%x", loc->dw_loc_opc);
5176 output_loc_operands_raw (loc);
5178 if (!loc->dw_loc_next)
5180 loc = loc->dw_loc_next;
5182 fputc (',', asm_out_file);
5186 /* This routine will generate the correct assembly data for a location
5187 description based on a cfi entry with a complex address. */
5190 output_cfa_loc (dw_cfi_ref cfi)
5192 dw_loc_descr_ref loc;
5195 if (cfi->dw_cfi_opc == DW_CFA_expression)
5196 dw2_asm_output_data (1, cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL);
5198 /* Output the size of the block. */
5199 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5200 size = size_of_locs (loc);
5201 dw2_asm_output_data_uleb128 (size, NULL);
5203 /* Now output the operations themselves. */
5204 output_loc_sequence (loc);
5207 /* Similar, but used for .cfi_escape. */
5210 output_cfa_loc_raw (dw_cfi_ref cfi)
5212 dw_loc_descr_ref loc;
5215 if (cfi->dw_cfi_opc == DW_CFA_expression)
5216 fprintf (asm_out_file, "0x%x,", cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
5218 /* Output the size of the block. */
5219 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5220 size = size_of_locs (loc);
5221 dw2_asm_output_data_uleb128_raw (size);
5222 fputc (',', asm_out_file);
5224 /* Now output the operations themselves. */
5225 output_loc_sequence_raw (loc);
5228 /* This function builds a dwarf location descriptor sequence from a
5229 dw_cfa_location, adding the given OFFSET to the result of the
5232 static struct dw_loc_descr_struct *
5233 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
5235 struct dw_loc_descr_struct *head, *tmp;
5237 offset += cfa->offset;
5241 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
5242 head->dw_loc_oprnd1.val_class = dw_val_class_const;
5243 tmp = new_loc_descr (DW_OP_deref, 0, 0);
5244 add_loc_descr (&head, tmp);
5247 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
5248 add_loc_descr (&head, tmp);
5252 head = new_reg_loc_descr (cfa->reg, offset);
5257 /* This function builds a dwarf location descriptor sequence for
5258 the address at OFFSET from the CFA when stack is aligned to
5261 static struct dw_loc_descr_struct *
5262 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
5264 struct dw_loc_descr_struct *head;
5265 unsigned int dwarf_fp
5266 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
5268 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
5269 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
5271 head = new_reg_loc_descr (dwarf_fp, 0);
5272 add_loc_descr (&head, int_loc_descriptor (alignment));
5273 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
5274 loc_descr_plus_const (&head, offset);
5277 head = new_reg_loc_descr (dwarf_fp, offset);
5281 /* This function fills in aa dw_cfa_location structure from a dwarf location
5282 descriptor sequence. */
5285 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
5287 struct dw_loc_descr_struct *ptr;
5289 cfa->base_offset = 0;
5293 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
5295 enum dwarf_location_atom op = ptr->dw_loc_opc;
5331 cfa->reg = op - DW_OP_reg0;
5334 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5368 cfa->reg = op - DW_OP_breg0;
5369 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
5372 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5373 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
5378 case DW_OP_plus_uconst:
5379 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
5382 internal_error ("DW_LOC_OP %s not implemented",
5383 dwarf_stack_op_name (ptr->dw_loc_opc));
5387 #endif /* .debug_frame support */
5389 /* And now, the support for symbolic debugging information. */
5390 #ifdef DWARF2_DEBUGGING_INFO
5392 /* .debug_str support. */
5393 static int output_indirect_string (void **, void *);
5395 static void dwarf2out_init (const char *);
5396 static void dwarf2out_finish (const char *);
5397 static void dwarf2out_assembly_start (void);
5398 static void dwarf2out_define (unsigned int, const char *);
5399 static void dwarf2out_undef (unsigned int, const char *);
5400 static void dwarf2out_start_source_file (unsigned, const char *);
5401 static void dwarf2out_end_source_file (unsigned);
5402 static void dwarf2out_begin_block (unsigned, unsigned);
5403 static void dwarf2out_end_block (unsigned, unsigned);
5404 static bool dwarf2out_ignore_block (const_tree);
5405 static void dwarf2out_global_decl (tree);
5406 static void dwarf2out_type_decl (tree, int);
5407 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
5408 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
5410 static void dwarf2out_abstract_function (tree);
5411 static void dwarf2out_var_location (rtx);
5412 static void dwarf2out_direct_call (tree);
5413 static void dwarf2out_virtual_call_token (tree, int);
5414 static void dwarf2out_copy_call_info (rtx, rtx);
5415 static void dwarf2out_virtual_call (int);
5416 static void dwarf2out_begin_function (tree);
5417 static void dwarf2out_set_name (tree, tree);
5419 /* The debug hooks structure. */
5421 const struct gcc_debug_hooks dwarf2_debug_hooks =
5425 dwarf2out_assembly_start,
5428 dwarf2out_start_source_file,
5429 dwarf2out_end_source_file,
5430 dwarf2out_begin_block,
5431 dwarf2out_end_block,
5432 dwarf2out_ignore_block,
5433 dwarf2out_source_line,
5434 dwarf2out_begin_prologue,
5435 debug_nothing_int_charstar, /* end_prologue */
5436 dwarf2out_end_epilogue,
5437 dwarf2out_begin_function,
5438 debug_nothing_int, /* end_function */
5439 dwarf2out_decl, /* function_decl */
5440 dwarf2out_global_decl,
5441 dwarf2out_type_decl, /* type_decl */
5442 dwarf2out_imported_module_or_decl,
5443 debug_nothing_tree, /* deferred_inline_function */
5444 /* The DWARF 2 backend tries to reduce debugging bloat by not
5445 emitting the abstract description of inline functions until
5446 something tries to reference them. */
5447 dwarf2out_abstract_function, /* outlining_inline_function */
5448 debug_nothing_rtx, /* label */
5449 debug_nothing_int, /* handle_pch */
5450 dwarf2out_var_location,
5451 dwarf2out_switch_text_section,
5452 dwarf2out_direct_call,
5453 dwarf2out_virtual_call_token,
5454 dwarf2out_copy_call_info,
5455 dwarf2out_virtual_call,
5457 1 /* start_end_main_source_file */
5461 /* NOTE: In the comments in this file, many references are made to
5462 "Debugging Information Entries". This term is abbreviated as `DIE'
5463 throughout the remainder of this file. */
5465 /* An internal representation of the DWARF output is built, and then
5466 walked to generate the DWARF debugging info. The walk of the internal
5467 representation is done after the entire program has been compiled.
5468 The types below are used to describe the internal representation. */
5470 /* Various DIE's use offsets relative to the beginning of the
5471 .debug_info section to refer to each other. */
5473 typedef long int dw_offset;
5475 /* Define typedefs here to avoid circular dependencies. */
5477 typedef struct dw_attr_struct *dw_attr_ref;
5478 typedef struct dw_line_info_struct *dw_line_info_ref;
5479 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
5480 typedef struct pubname_struct *pubname_ref;
5481 typedef struct dw_ranges_struct *dw_ranges_ref;
5482 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
5483 typedef struct comdat_type_struct *comdat_type_node_ref;
5485 /* Each entry in the line_info_table maintains the file and
5486 line number associated with the label generated for that
5487 entry. The label gives the PC value associated with
5488 the line number entry. */
5490 typedef struct GTY(()) dw_line_info_struct {
5491 unsigned long dw_file_num;
5492 unsigned long dw_line_num;
5496 /* Line information for functions in separate sections; each one gets its
5498 typedef struct GTY(()) dw_separate_line_info_struct {
5499 unsigned long dw_file_num;
5500 unsigned long dw_line_num;
5501 unsigned long function;
5503 dw_separate_line_info_entry;
5505 /* Each DIE attribute has a field specifying the attribute kind,
5506 a link to the next attribute in the chain, and an attribute value.
5507 Attributes are typically linked below the DIE they modify. */
5509 typedef struct GTY(()) dw_attr_struct {
5510 enum dwarf_attribute dw_attr;
5511 dw_val_node dw_attr_val;
5515 DEF_VEC_O(dw_attr_node);
5516 DEF_VEC_ALLOC_O(dw_attr_node,gc);
5518 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
5519 The children of each node form a circular list linked by
5520 die_sib. die_child points to the node *before* the "first" child node. */
5522 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
5523 enum dwarf_tag die_tag;
5524 union die_symbol_or_type_node
5526 char * GTY ((tag ("0"))) die_symbol;
5527 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
5529 GTY ((desc ("dwarf_version >= 4"))) die_id;
5530 VEC(dw_attr_node,gc) * die_attr;
5531 dw_die_ref die_parent;
5532 dw_die_ref die_child;
5534 dw_die_ref die_definition; /* ref from a specification to its definition */
5535 dw_offset die_offset;
5536 unsigned long die_abbrev;
5538 /* Die is used and must not be pruned as unused. */
5539 int die_perennial_p;
5540 unsigned int decl_id;
5544 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
5545 #define FOR_EACH_CHILD(die, c, expr) do { \
5546 c = die->die_child; \
5550 } while (c != die->die_child); \
5553 /* The pubname structure */
5555 typedef struct GTY(()) pubname_struct {
5561 DEF_VEC_O(pubname_entry);
5562 DEF_VEC_ALLOC_O(pubname_entry, gc);
5564 struct GTY(()) dw_ranges_struct {
5565 /* If this is positive, it's a block number, otherwise it's a
5566 bitwise-negated index into dw_ranges_by_label. */
5570 struct GTY(()) dw_ranges_by_label_struct {
5575 /* The comdat type node structure. */
5576 typedef struct GTY(()) comdat_type_struct
5578 dw_die_ref root_die;
5579 dw_die_ref type_die;
5580 char signature[DWARF_TYPE_SIGNATURE_SIZE];
5581 struct comdat_type_struct *next;
5585 /* The limbo die list structure. */
5586 typedef struct GTY(()) limbo_die_struct {
5589 struct limbo_die_struct *next;
5593 typedef struct GTY(()) skeleton_chain_struct
5597 struct skeleton_chain_struct *parent;
5599 skeleton_chain_node;
5601 /* How to start an assembler comment. */
5602 #ifndef ASM_COMMENT_START
5603 #define ASM_COMMENT_START ";#"
5606 /* Define a macro which returns nonzero for a TYPE_DECL which was
5607 implicitly generated for a tagged type.
5609 Note that unlike the gcc front end (which generates a NULL named
5610 TYPE_DECL node for each complete tagged type, each array type, and
5611 each function type node created) the g++ front end generates a
5612 _named_ TYPE_DECL node for each tagged type node created.
5613 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
5614 generate a DW_TAG_typedef DIE for them. */
5616 #define TYPE_DECL_IS_STUB(decl) \
5617 (DECL_NAME (decl) == NULL_TREE \
5618 || (DECL_ARTIFICIAL (decl) \
5619 && is_tagged_type (TREE_TYPE (decl)) \
5620 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
5621 /* This is necessary for stub decls that \
5622 appear in nested inline functions. */ \
5623 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
5624 && (decl_ultimate_origin (decl) \
5625 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
5627 /* Information concerning the compilation unit's programming
5628 language, and compiler version. */
5630 /* Fixed size portion of the DWARF compilation unit header. */
5631 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
5632 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
5634 /* Fixed size portion of the DWARF comdat type unit header. */
5635 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
5636 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
5637 + DWARF_OFFSET_SIZE)
5639 /* Fixed size portion of public names info. */
5640 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
5642 /* Fixed size portion of the address range info. */
5643 #define DWARF_ARANGES_HEADER_SIZE \
5644 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5645 DWARF2_ADDR_SIZE * 2) \
5646 - DWARF_INITIAL_LENGTH_SIZE)
5648 /* Size of padding portion in the address range info. It must be
5649 aligned to twice the pointer size. */
5650 #define DWARF_ARANGES_PAD_SIZE \
5651 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5652 DWARF2_ADDR_SIZE * 2) \
5653 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
5655 /* Use assembler line directives if available. */
5656 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
5657 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
5658 #define DWARF2_ASM_LINE_DEBUG_INFO 1
5660 #define DWARF2_ASM_LINE_DEBUG_INFO 0
5664 /* Minimum line offset in a special line info. opcode.
5665 This value was chosen to give a reasonable range of values. */
5666 #define DWARF_LINE_BASE -10
5668 /* First special line opcode - leave room for the standard opcodes. */
5669 #define DWARF_LINE_OPCODE_BASE 10
5671 /* Range of line offsets in a special line info. opcode. */
5672 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
5674 /* Flag that indicates the initial value of the is_stmt_start flag.
5675 In the present implementation, we do not mark any lines as
5676 the beginning of a source statement, because that information
5677 is not made available by the GCC front-end. */
5678 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
5680 #ifdef DWARF2_DEBUGGING_INFO
5681 /* This location is used by calc_die_sizes() to keep track
5682 the offset of each DIE within the .debug_info section. */
5683 static unsigned long next_die_offset;
5686 /* Record the root of the DIE's built for the current compilation unit. */
5687 static GTY(()) dw_die_ref comp_unit_die;
5689 /* A list of type DIEs that have been separated into comdat sections. */
5690 static GTY(()) comdat_type_node *comdat_type_list;
5692 /* A list of DIEs with a NULL parent waiting to be relocated. */
5693 static GTY(()) limbo_die_node *limbo_die_list;
5695 /* A list of DIEs for which we may have to generate
5696 DW_AT_MIPS_linkage_name once their DECL_ASSEMBLER_NAMEs are
5698 static GTY(()) limbo_die_node *deferred_asm_name;
5700 /* Filenames referenced by this compilation unit. */
5701 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
5703 /* A hash table of references to DIE's that describe declarations.
5704 The key is a DECL_UID() which is a unique number identifying each decl. */
5705 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
5707 /* A hash table of references to DIE's that describe COMMON blocks.
5708 The key is DECL_UID() ^ die_parent. */
5709 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
5711 typedef struct GTY(()) die_arg_entry_struct {
5716 DEF_VEC_O(die_arg_entry);
5717 DEF_VEC_ALLOC_O(die_arg_entry,gc);
5719 /* Node of the variable location list. */
5720 struct GTY ((chain_next ("%h.next"))) var_loc_node {
5721 rtx GTY (()) var_loc_note;
5722 const char * GTY (()) label;
5723 const char * GTY (()) section_label;
5724 struct var_loc_node * GTY (()) next;
5727 /* Variable location list. */
5728 struct GTY (()) var_loc_list_def {
5729 struct var_loc_node * GTY (()) first;
5731 /* Do not mark the last element of the chained list because
5732 it is marked through the chain. */
5733 struct var_loc_node * GTY ((skip ("%h"))) last;
5735 /* DECL_UID of the variable decl. */
5736 unsigned int decl_id;
5738 typedef struct var_loc_list_def var_loc_list;
5741 /* Table of decl location linked lists. */
5742 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
5744 /* A pointer to the base of a list of references to DIE's that
5745 are uniquely identified by their tag, presence/absence of
5746 children DIE's, and list of attribute/value pairs. */
5747 static GTY((length ("abbrev_die_table_allocated")))
5748 dw_die_ref *abbrev_die_table;
5750 /* Number of elements currently allocated for abbrev_die_table. */
5751 static GTY(()) unsigned abbrev_die_table_allocated;
5753 /* Number of elements in type_die_table currently in use. */
5754 static GTY(()) unsigned abbrev_die_table_in_use;
5756 /* Size (in elements) of increments by which we may expand the
5757 abbrev_die_table. */
5758 #define ABBREV_DIE_TABLE_INCREMENT 256
5760 /* A pointer to the base of a table that contains line information
5761 for each source code line in .text in the compilation unit. */
5762 static GTY((length ("line_info_table_allocated")))
5763 dw_line_info_ref line_info_table;
5765 /* Number of elements currently allocated for line_info_table. */
5766 static GTY(()) unsigned line_info_table_allocated;
5768 /* Number of elements in line_info_table currently in use. */
5769 static GTY(()) unsigned line_info_table_in_use;
5771 /* A pointer to the base of a table that contains line information
5772 for each source code line outside of .text in the compilation unit. */
5773 static GTY ((length ("separate_line_info_table_allocated")))
5774 dw_separate_line_info_ref separate_line_info_table;
5776 /* Number of elements currently allocated for separate_line_info_table. */
5777 static GTY(()) unsigned separate_line_info_table_allocated;
5779 /* Number of elements in separate_line_info_table currently in use. */
5780 static GTY(()) unsigned separate_line_info_table_in_use;
5782 /* Size (in elements) of increments by which we may expand the
5784 #define LINE_INFO_TABLE_INCREMENT 1024
5786 /* A pointer to the base of a table that contains a list of publicly
5787 accessible names. */
5788 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
5790 /* A pointer to the base of a table that contains a list of publicly
5791 accessible types. */
5792 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
5794 /* Array of dies for which we should generate .debug_arange info. */
5795 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
5797 /* Number of elements currently allocated for arange_table. */
5798 static GTY(()) unsigned arange_table_allocated;
5800 /* Number of elements in arange_table currently in use. */
5801 static GTY(()) unsigned arange_table_in_use;
5803 /* Size (in elements) of increments by which we may expand the
5805 #define ARANGE_TABLE_INCREMENT 64
5807 /* Array of dies for which we should generate .debug_ranges info. */
5808 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
5810 /* Number of elements currently allocated for ranges_table. */
5811 static GTY(()) unsigned ranges_table_allocated;
5813 /* Number of elements in ranges_table currently in use. */
5814 static GTY(()) unsigned ranges_table_in_use;
5816 /* Array of pairs of labels referenced in ranges_table. */
5817 static GTY ((length ("ranges_by_label_allocated")))
5818 dw_ranges_by_label_ref ranges_by_label;
5820 /* Number of elements currently allocated for ranges_by_label. */
5821 static GTY(()) unsigned ranges_by_label_allocated;
5823 /* Number of elements in ranges_by_label currently in use. */
5824 static GTY(()) unsigned ranges_by_label_in_use;
5826 /* Size (in elements) of increments by which we may expand the
5828 #define RANGES_TABLE_INCREMENT 64
5830 /* Whether we have location lists that need outputting */
5831 static GTY(()) bool have_location_lists;
5833 /* Unique label counter. */
5834 static GTY(()) unsigned int loclabel_num;
5836 /* Unique label counter for point-of-call tables. */
5837 static GTY(()) unsigned int poc_label_num;
5839 /* The direct call table structure. */
5841 typedef struct GTY(()) dcall_struct {
5842 unsigned int poc_label_num;
5844 dw_die_ref targ_die;
5848 DEF_VEC_O(dcall_entry);
5849 DEF_VEC_ALLOC_O(dcall_entry, gc);
5851 /* The virtual call table structure. */
5853 typedef struct GTY(()) vcall_struct {
5854 unsigned int poc_label_num;
5855 unsigned int vtable_slot;
5859 DEF_VEC_O(vcall_entry);
5860 DEF_VEC_ALLOC_O(vcall_entry, gc);
5862 /* Pointers to the direct and virtual call tables. */
5863 static GTY (()) VEC (dcall_entry, gc) * dcall_table = NULL;
5864 static GTY (()) VEC (vcall_entry, gc) * vcall_table = NULL;
5866 /* A hash table to map INSN_UIDs to vtable slot indexes. */
5868 struct GTY (()) vcall_insn {
5870 unsigned int vtable_slot;
5873 static GTY ((param_is (struct vcall_insn))) htab_t vcall_insn_table;
5875 #ifdef DWARF2_DEBUGGING_INFO
5876 /* Record whether the function being analyzed contains inlined functions. */
5877 static int current_function_has_inlines;
5879 #if 0 && defined (MIPS_DEBUGGING_INFO)
5880 static int comp_unit_has_inlines;
5883 /* The last file entry emitted by maybe_emit_file(). */
5884 static GTY(()) struct dwarf_file_data * last_emitted_file;
5886 /* Number of internal labels generated by gen_internal_sym(). */
5887 static GTY(()) int label_num;
5889 /* Cached result of previous call to lookup_filename. */
5890 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
5892 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
5894 #ifdef DWARF2_DEBUGGING_INFO
5896 /* Offset from the "steady-state frame pointer" to the frame base,
5897 within the current function. */
5898 static HOST_WIDE_INT frame_pointer_fb_offset;
5900 /* Forward declarations for functions defined in this file. */
5902 static int is_pseudo_reg (const_rtx);
5903 static tree type_main_variant (tree);
5904 static int is_tagged_type (const_tree);
5905 static const char *dwarf_tag_name (unsigned);
5906 static const char *dwarf_attr_name (unsigned);
5907 static const char *dwarf_form_name (unsigned);
5908 static tree decl_ultimate_origin (const_tree);
5909 static tree decl_class_context (tree);
5910 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
5911 static inline enum dw_val_class AT_class (dw_attr_ref);
5912 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
5913 static inline unsigned AT_flag (dw_attr_ref);
5914 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
5915 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
5916 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
5917 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
5918 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
5919 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
5920 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
5921 unsigned int, unsigned char *);
5922 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
5923 static hashval_t debug_str_do_hash (const void *);
5924 static int debug_str_eq (const void *, const void *);
5925 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
5926 static inline const char *AT_string (dw_attr_ref);
5927 static enum dwarf_form AT_string_form (dw_attr_ref);
5928 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
5929 static void add_AT_specification (dw_die_ref, dw_die_ref);
5930 static inline dw_die_ref AT_ref (dw_attr_ref);
5931 static inline int AT_ref_external (dw_attr_ref);
5932 static inline void set_AT_ref_external (dw_attr_ref, int);
5933 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
5934 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
5935 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
5936 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
5938 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
5939 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
5940 static inline rtx AT_addr (dw_attr_ref);
5941 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
5942 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
5943 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
5944 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
5945 unsigned HOST_WIDE_INT);
5946 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
5948 static inline const char *AT_lbl (dw_attr_ref);
5949 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
5950 static const char *get_AT_low_pc (dw_die_ref);
5951 static const char *get_AT_hi_pc (dw_die_ref);
5952 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
5953 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
5954 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
5955 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
5956 static bool is_c_family (void);
5957 static bool is_cxx (void);
5958 static bool is_java (void);
5959 static bool is_fortran (void);
5960 static bool is_ada (void);
5961 static void remove_AT (dw_die_ref, enum dwarf_attribute);
5962 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
5963 static void add_child_die (dw_die_ref, dw_die_ref);
5964 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
5965 static dw_die_ref lookup_type_die (tree);
5966 static void equate_type_number_to_die (tree, dw_die_ref);
5967 static hashval_t decl_die_table_hash (const void *);
5968 static int decl_die_table_eq (const void *, const void *);
5969 static dw_die_ref lookup_decl_die (tree);
5970 static hashval_t common_block_die_table_hash (const void *);
5971 static int common_block_die_table_eq (const void *, const void *);
5972 static hashval_t decl_loc_table_hash (const void *);
5973 static int decl_loc_table_eq (const void *, const void *);
5974 static var_loc_list *lookup_decl_loc (const_tree);
5975 static void equate_decl_number_to_die (tree, dw_die_ref);
5976 static struct var_loc_node *add_var_loc_to_decl (tree, rtx);
5977 static void print_spaces (FILE *);
5978 static void print_die (dw_die_ref, FILE *);
5979 static void print_dwarf_line_table (FILE *);
5980 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
5981 static dw_die_ref pop_compile_unit (dw_die_ref);
5982 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
5983 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
5984 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
5985 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
5986 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
5987 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
5988 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
5989 struct md5_ctx *, int *);
5990 struct checksum_attributes;
5991 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
5992 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
5993 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
5994 static void generate_type_signature (dw_die_ref, comdat_type_node *);
5995 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
5996 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
5997 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
5998 static int same_die_p (dw_die_ref, dw_die_ref, int *);
5999 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
6000 static void compute_section_prefix (dw_die_ref);
6001 static int is_type_die (dw_die_ref);
6002 static int is_comdat_die (dw_die_ref);
6003 static int is_symbol_die (dw_die_ref);
6004 static void assign_symbol_names (dw_die_ref);
6005 static void break_out_includes (dw_die_ref);
6006 static int is_declaration_die (dw_die_ref);
6007 static int should_move_die_to_comdat (dw_die_ref);
6008 static dw_die_ref clone_as_declaration (dw_die_ref);
6009 static dw_die_ref clone_die (dw_die_ref);
6010 static dw_die_ref clone_tree (dw_die_ref);
6011 static void copy_declaration_context (dw_die_ref, dw_die_ref);
6012 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
6013 static void generate_skeleton_bottom_up (skeleton_chain_node *);
6014 static dw_die_ref generate_skeleton (dw_die_ref);
6015 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
6017 static void break_out_comdat_types (dw_die_ref);
6018 static dw_die_ref copy_ancestor_tree (dw_die_ref, dw_die_ref, htab_t);
6019 static void copy_decls_walk (dw_die_ref, dw_die_ref, htab_t);
6020 static void copy_decls_for_unworthy_types (dw_die_ref);
6022 static hashval_t htab_cu_hash (const void *);
6023 static int htab_cu_eq (const void *, const void *);
6024 static void htab_cu_del (void *);
6025 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
6026 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
6027 static void add_sibling_attributes (dw_die_ref);
6028 static void build_abbrev_table (dw_die_ref);
6029 static void output_location_lists (dw_die_ref);
6030 static int constant_size (unsigned HOST_WIDE_INT);
6031 static unsigned long size_of_die (dw_die_ref);
6032 static void calc_die_sizes (dw_die_ref);
6033 static void mark_dies (dw_die_ref);
6034 static void unmark_dies (dw_die_ref);
6035 static void unmark_all_dies (dw_die_ref);
6036 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
6037 static unsigned long size_of_aranges (void);
6038 static enum dwarf_form value_format (dw_attr_ref);
6039 static void output_value_format (dw_attr_ref);
6040 static void output_abbrev_section (void);
6041 static void output_die_symbol (dw_die_ref);
6042 static void output_die (dw_die_ref);
6043 static void output_compilation_unit_header (void);
6044 static void output_comp_unit (dw_die_ref, int);
6045 static void output_comdat_type_unit (comdat_type_node *);
6046 static const char *dwarf2_name (tree, int);
6047 static void add_pubname (tree, dw_die_ref);
6048 static void add_pubname_string (const char *, dw_die_ref);
6049 static void add_pubtype (tree, dw_die_ref);
6050 static void output_pubnames (VEC (pubname_entry,gc) *);
6051 static void add_arange (tree, dw_die_ref);
6052 static void output_aranges (void);
6053 static unsigned int add_ranges_num (int);
6054 static unsigned int add_ranges (const_tree);
6055 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
6057 static void output_ranges (void);
6058 static void output_line_info (void);
6059 static void output_file_names (void);
6060 static dw_die_ref base_type_die (tree);
6061 static int is_base_type (tree);
6062 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
6063 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
6064 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
6065 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
6066 static int type_is_enum (const_tree);
6067 static unsigned int dbx_reg_number (const_rtx);
6068 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
6069 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
6070 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
6071 enum var_init_status);
6072 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
6073 enum var_init_status);
6074 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
6075 enum var_init_status);
6076 static int is_based_loc (const_rtx);
6077 static int resolve_one_addr (rtx *, void *);
6078 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
6079 enum var_init_status);
6080 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
6081 enum var_init_status);
6082 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
6083 enum var_init_status);
6084 static dw_loc_list_ref loc_list_from_tree (tree, int);
6085 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
6086 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
6087 static tree field_type (const_tree);
6088 static unsigned int simple_type_align_in_bits (const_tree);
6089 static unsigned int simple_decl_align_in_bits (const_tree);
6090 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
6091 static HOST_WIDE_INT field_byte_offset (const_tree);
6092 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
6094 static void add_data_member_location_attribute (dw_die_ref, tree);
6095 static bool add_const_value_attribute (dw_die_ref, rtx);
6096 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
6097 static void insert_float (const_rtx, unsigned char *);
6098 static rtx rtl_for_decl_location (tree);
6099 static bool add_location_or_const_value_attribute (dw_die_ref, tree,
6100 enum dwarf_attribute);
6101 static bool tree_add_const_value_attribute (dw_die_ref, tree);
6102 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
6103 static void add_name_attribute (dw_die_ref, const char *);
6104 static void add_comp_dir_attribute (dw_die_ref);
6105 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
6106 static void add_subscript_info (dw_die_ref, tree, bool);
6107 static void add_byte_size_attribute (dw_die_ref, tree);
6108 static void add_bit_offset_attribute (dw_die_ref, tree);
6109 static void add_bit_size_attribute (dw_die_ref, tree);
6110 static void add_prototyped_attribute (dw_die_ref, tree);
6111 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
6112 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
6113 static void add_src_coords_attributes (dw_die_ref, tree);
6114 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
6115 static void push_decl_scope (tree);
6116 static void pop_decl_scope (void);
6117 static dw_die_ref scope_die_for (tree, dw_die_ref);
6118 static inline int local_scope_p (dw_die_ref);
6119 static inline int class_scope_p (dw_die_ref);
6120 static inline int class_or_namespace_scope_p (dw_die_ref);
6121 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
6122 static void add_calling_convention_attribute (dw_die_ref, tree);
6123 static const char *type_tag (const_tree);
6124 static tree member_declared_type (const_tree);
6126 static const char *decl_start_label (tree);
6128 static void gen_array_type_die (tree, dw_die_ref);
6129 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
6131 static void gen_entry_point_die (tree, dw_die_ref);
6133 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
6134 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
6135 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
6136 static void gen_unspecified_parameters_die (tree, dw_die_ref);
6137 static void gen_formal_types_die (tree, dw_die_ref);
6138 static void gen_subprogram_die (tree, dw_die_ref);
6139 static void gen_variable_die (tree, tree, dw_die_ref);
6140 static void gen_const_die (tree, dw_die_ref);
6141 static void gen_label_die (tree, dw_die_ref);
6142 static void gen_lexical_block_die (tree, dw_die_ref, int);
6143 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
6144 static void gen_field_die (tree, dw_die_ref);
6145 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
6146 static dw_die_ref gen_compile_unit_die (const char *);
6147 static void gen_inheritance_die (tree, tree, dw_die_ref);
6148 static void gen_member_die (tree, dw_die_ref);
6149 static void gen_struct_or_union_type_die (tree, dw_die_ref,
6150 enum debug_info_usage);
6151 static void gen_subroutine_type_die (tree, dw_die_ref);
6152 static void gen_typedef_die (tree, dw_die_ref);
6153 static void gen_type_die (tree, dw_die_ref);
6154 static void gen_block_die (tree, dw_die_ref, int);
6155 static void decls_for_scope (tree, dw_die_ref, int);
6156 static int is_redundant_typedef (const_tree);
6157 static inline dw_die_ref get_context_die (tree);
6158 static void gen_namespace_die (tree, dw_die_ref);
6159 static void gen_decl_die (tree, tree, dw_die_ref);
6160 static dw_die_ref force_decl_die (tree);
6161 static dw_die_ref force_type_die (tree);
6162 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
6163 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
6164 static struct dwarf_file_data * lookup_filename (const char *);
6165 static void retry_incomplete_types (void);
6166 static void gen_type_die_for_member (tree, tree, dw_die_ref);
6167 static void gen_generic_params_dies (tree);
6168 static void splice_child_die (dw_die_ref, dw_die_ref);
6169 static int file_info_cmp (const void *, const void *);
6170 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
6171 const char *, const char *);
6172 static void output_loc_list (dw_loc_list_ref);
6173 static char *gen_internal_sym (const char *);
6175 static void prune_unmark_dies (dw_die_ref);
6176 static void prune_unused_types_mark (dw_die_ref, int);
6177 static void prune_unused_types_walk (dw_die_ref);
6178 static void prune_unused_types_walk_attribs (dw_die_ref);
6179 static void prune_unused_types_prune (dw_die_ref);
6180 static void prune_unused_types (void);
6181 static int maybe_emit_file (struct dwarf_file_data *fd);
6182 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
6183 static void gen_remaining_tmpl_value_param_die_attribute (void);
6185 /* Section names used to hold DWARF debugging information. */
6186 #ifndef DEBUG_INFO_SECTION
6187 #define DEBUG_INFO_SECTION ".debug_info"
6189 #ifndef DEBUG_ABBREV_SECTION
6190 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
6192 #ifndef DEBUG_ARANGES_SECTION
6193 #define DEBUG_ARANGES_SECTION ".debug_aranges"
6195 #ifndef DEBUG_MACINFO_SECTION
6196 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
6198 #ifndef DEBUG_LINE_SECTION
6199 #define DEBUG_LINE_SECTION ".debug_line"
6201 #ifndef DEBUG_LOC_SECTION
6202 #define DEBUG_LOC_SECTION ".debug_loc"
6204 #ifndef DEBUG_PUBNAMES_SECTION
6205 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
6207 #ifndef DEBUG_PUBTYPES_SECTION
6208 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
6210 #ifndef DEBUG_DCALL_SECTION
6211 #define DEBUG_DCALL_SECTION ".debug_dcall"
6213 #ifndef DEBUG_VCALL_SECTION
6214 #define DEBUG_VCALL_SECTION ".debug_vcall"
6216 #ifndef DEBUG_STR_SECTION
6217 #define DEBUG_STR_SECTION ".debug_str"
6219 #ifndef DEBUG_RANGES_SECTION
6220 #define DEBUG_RANGES_SECTION ".debug_ranges"
6223 /* Standard ELF section names for compiled code and data. */
6224 #ifndef TEXT_SECTION_NAME
6225 #define TEXT_SECTION_NAME ".text"
6228 /* Section flags for .debug_str section. */
6229 #define DEBUG_STR_SECTION_FLAGS \
6230 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
6231 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
6234 /* Labels we insert at beginning sections we can reference instead of
6235 the section names themselves. */
6237 #ifndef TEXT_SECTION_LABEL
6238 #define TEXT_SECTION_LABEL "Ltext"
6240 #ifndef COLD_TEXT_SECTION_LABEL
6241 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
6243 #ifndef DEBUG_LINE_SECTION_LABEL
6244 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
6246 #ifndef DEBUG_INFO_SECTION_LABEL
6247 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
6249 #ifndef DEBUG_ABBREV_SECTION_LABEL
6250 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
6252 #ifndef DEBUG_LOC_SECTION_LABEL
6253 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
6255 #ifndef DEBUG_RANGES_SECTION_LABEL
6256 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
6258 #ifndef DEBUG_MACINFO_SECTION_LABEL
6259 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
6262 /* Definitions of defaults for formats and names of various special
6263 (artificial) labels which may be generated within this file (when the -g
6264 options is used and DWARF2_DEBUGGING_INFO is in effect.
6265 If necessary, these may be overridden from within the tm.h file, but
6266 typically, overriding these defaults is unnecessary. */
6268 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6269 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6270 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6271 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6272 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6273 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6274 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6275 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6276 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6277 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
6279 #ifndef TEXT_END_LABEL
6280 #define TEXT_END_LABEL "Letext"
6282 #ifndef COLD_END_LABEL
6283 #define COLD_END_LABEL "Letext_cold"
6285 #ifndef BLOCK_BEGIN_LABEL
6286 #define BLOCK_BEGIN_LABEL "LBB"
6288 #ifndef BLOCK_END_LABEL
6289 #define BLOCK_END_LABEL "LBE"
6291 #ifndef LINE_CODE_LABEL
6292 #define LINE_CODE_LABEL "LM"
6294 #ifndef SEPARATE_LINE_CODE_LABEL
6295 #define SEPARATE_LINE_CODE_LABEL "LSM"
6299 /* We allow a language front-end to designate a function that is to be
6300 called to "demangle" any name before it is put into a DIE. */
6302 static const char *(*demangle_name_func) (const char *);
6305 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
6307 demangle_name_func = func;
6310 /* Test if rtl node points to a pseudo register. */
6313 is_pseudo_reg (const_rtx rtl)
6315 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
6316 || (GET_CODE (rtl) == SUBREG
6317 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
6320 /* Return a reference to a type, with its const and volatile qualifiers
6324 type_main_variant (tree type)
6326 type = TYPE_MAIN_VARIANT (type);
6328 /* ??? There really should be only one main variant among any group of
6329 variants of a given type (and all of the MAIN_VARIANT values for all
6330 members of the group should point to that one type) but sometimes the C
6331 front-end messes this up for array types, so we work around that bug
6333 if (TREE_CODE (type) == ARRAY_TYPE)
6334 while (type != TYPE_MAIN_VARIANT (type))
6335 type = TYPE_MAIN_VARIANT (type);
6340 /* Return nonzero if the given type node represents a tagged type. */
6343 is_tagged_type (const_tree type)
6345 enum tree_code code = TREE_CODE (type);
6347 return (code == RECORD_TYPE || code == UNION_TYPE
6348 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
6351 /* Convert a DIE tag into its string name. */
6354 dwarf_tag_name (unsigned int tag)
6358 case DW_TAG_padding:
6359 return "DW_TAG_padding";
6360 case DW_TAG_array_type:
6361 return "DW_TAG_array_type";
6362 case DW_TAG_class_type:
6363 return "DW_TAG_class_type";
6364 case DW_TAG_entry_point:
6365 return "DW_TAG_entry_point";
6366 case DW_TAG_enumeration_type:
6367 return "DW_TAG_enumeration_type";
6368 case DW_TAG_formal_parameter:
6369 return "DW_TAG_formal_parameter";
6370 case DW_TAG_imported_declaration:
6371 return "DW_TAG_imported_declaration";
6373 return "DW_TAG_label";
6374 case DW_TAG_lexical_block:
6375 return "DW_TAG_lexical_block";
6377 return "DW_TAG_member";
6378 case DW_TAG_pointer_type:
6379 return "DW_TAG_pointer_type";
6380 case DW_TAG_reference_type:
6381 return "DW_TAG_reference_type";
6382 case DW_TAG_compile_unit:
6383 return "DW_TAG_compile_unit";
6384 case DW_TAG_string_type:
6385 return "DW_TAG_string_type";
6386 case DW_TAG_structure_type:
6387 return "DW_TAG_structure_type";
6388 case DW_TAG_subroutine_type:
6389 return "DW_TAG_subroutine_type";
6390 case DW_TAG_typedef:
6391 return "DW_TAG_typedef";
6392 case DW_TAG_union_type:
6393 return "DW_TAG_union_type";
6394 case DW_TAG_unspecified_parameters:
6395 return "DW_TAG_unspecified_parameters";
6396 case DW_TAG_variant:
6397 return "DW_TAG_variant";
6398 case DW_TAG_common_block:
6399 return "DW_TAG_common_block";
6400 case DW_TAG_common_inclusion:
6401 return "DW_TAG_common_inclusion";
6402 case DW_TAG_inheritance:
6403 return "DW_TAG_inheritance";
6404 case DW_TAG_inlined_subroutine:
6405 return "DW_TAG_inlined_subroutine";
6407 return "DW_TAG_module";
6408 case DW_TAG_ptr_to_member_type:
6409 return "DW_TAG_ptr_to_member_type";
6410 case DW_TAG_set_type:
6411 return "DW_TAG_set_type";
6412 case DW_TAG_subrange_type:
6413 return "DW_TAG_subrange_type";
6414 case DW_TAG_with_stmt:
6415 return "DW_TAG_with_stmt";
6416 case DW_TAG_access_declaration:
6417 return "DW_TAG_access_declaration";
6418 case DW_TAG_base_type:
6419 return "DW_TAG_base_type";
6420 case DW_TAG_catch_block:
6421 return "DW_TAG_catch_block";
6422 case DW_TAG_const_type:
6423 return "DW_TAG_const_type";
6424 case DW_TAG_constant:
6425 return "DW_TAG_constant";
6426 case DW_TAG_enumerator:
6427 return "DW_TAG_enumerator";
6428 case DW_TAG_file_type:
6429 return "DW_TAG_file_type";
6431 return "DW_TAG_friend";
6432 case DW_TAG_namelist:
6433 return "DW_TAG_namelist";
6434 case DW_TAG_namelist_item:
6435 return "DW_TAG_namelist_item";
6436 case DW_TAG_packed_type:
6437 return "DW_TAG_packed_type";
6438 case DW_TAG_subprogram:
6439 return "DW_TAG_subprogram";
6440 case DW_TAG_template_type_param:
6441 return "DW_TAG_template_type_param";
6442 case DW_TAG_template_value_param:
6443 return "DW_TAG_template_value_param";
6444 case DW_TAG_thrown_type:
6445 return "DW_TAG_thrown_type";
6446 case DW_TAG_try_block:
6447 return "DW_TAG_try_block";
6448 case DW_TAG_variant_part:
6449 return "DW_TAG_variant_part";
6450 case DW_TAG_variable:
6451 return "DW_TAG_variable";
6452 case DW_TAG_volatile_type:
6453 return "DW_TAG_volatile_type";
6454 case DW_TAG_dwarf_procedure:
6455 return "DW_TAG_dwarf_procedure";
6456 case DW_TAG_restrict_type:
6457 return "DW_TAG_restrict_type";
6458 case DW_TAG_interface_type:
6459 return "DW_TAG_interface_type";
6460 case DW_TAG_namespace:
6461 return "DW_TAG_namespace";
6462 case DW_TAG_imported_module:
6463 return "DW_TAG_imported_module";
6464 case DW_TAG_unspecified_type:
6465 return "DW_TAG_unspecified_type";
6466 case DW_TAG_partial_unit:
6467 return "DW_TAG_partial_unit";
6468 case DW_TAG_imported_unit:
6469 return "DW_TAG_imported_unit";
6470 case DW_TAG_condition:
6471 return "DW_TAG_condition";
6472 case DW_TAG_shared_type:
6473 return "DW_TAG_shared_type";
6474 case DW_TAG_type_unit:
6475 return "DW_TAG_type_unit";
6476 case DW_TAG_rvalue_reference_type:
6477 return "DW_TAG_rvalue_reference_type";
6478 case DW_TAG_template_alias:
6479 return "DW_TAG_template_alias";
6480 case DW_TAG_GNU_template_parameter_pack:
6481 return "DW_TAG_GNU_template_parameter_pack";
6482 case DW_TAG_GNU_formal_parameter_pack:
6483 return "DW_TAG_GNU_formal_parameter_pack";
6484 case DW_TAG_MIPS_loop:
6485 return "DW_TAG_MIPS_loop";
6486 case DW_TAG_format_label:
6487 return "DW_TAG_format_label";
6488 case DW_TAG_function_template:
6489 return "DW_TAG_function_template";
6490 case DW_TAG_class_template:
6491 return "DW_TAG_class_template";
6492 case DW_TAG_GNU_BINCL:
6493 return "DW_TAG_GNU_BINCL";
6494 case DW_TAG_GNU_EINCL:
6495 return "DW_TAG_GNU_EINCL";
6496 case DW_TAG_GNU_template_template_param:
6497 return "DW_TAG_GNU_template_template_param";
6499 return "DW_TAG_<unknown>";
6503 /* Convert a DWARF attribute code into its string name. */
6506 dwarf_attr_name (unsigned int attr)
6511 return "DW_AT_sibling";
6512 case DW_AT_location:
6513 return "DW_AT_location";
6515 return "DW_AT_name";
6516 case DW_AT_ordering:
6517 return "DW_AT_ordering";
6518 case DW_AT_subscr_data:
6519 return "DW_AT_subscr_data";
6520 case DW_AT_byte_size:
6521 return "DW_AT_byte_size";
6522 case DW_AT_bit_offset:
6523 return "DW_AT_bit_offset";
6524 case DW_AT_bit_size:
6525 return "DW_AT_bit_size";
6526 case DW_AT_element_list:
6527 return "DW_AT_element_list";
6528 case DW_AT_stmt_list:
6529 return "DW_AT_stmt_list";
6531 return "DW_AT_low_pc";
6533 return "DW_AT_high_pc";
6534 case DW_AT_language:
6535 return "DW_AT_language";
6537 return "DW_AT_member";
6539 return "DW_AT_discr";
6540 case DW_AT_discr_value:
6541 return "DW_AT_discr_value";
6542 case DW_AT_visibility:
6543 return "DW_AT_visibility";
6545 return "DW_AT_import";
6546 case DW_AT_string_length:
6547 return "DW_AT_string_length";
6548 case DW_AT_common_reference:
6549 return "DW_AT_common_reference";
6550 case DW_AT_comp_dir:
6551 return "DW_AT_comp_dir";
6552 case DW_AT_const_value:
6553 return "DW_AT_const_value";
6554 case DW_AT_containing_type:
6555 return "DW_AT_containing_type";
6556 case DW_AT_default_value:
6557 return "DW_AT_default_value";
6559 return "DW_AT_inline";
6560 case DW_AT_is_optional:
6561 return "DW_AT_is_optional";
6562 case DW_AT_lower_bound:
6563 return "DW_AT_lower_bound";
6564 case DW_AT_producer:
6565 return "DW_AT_producer";
6566 case DW_AT_prototyped:
6567 return "DW_AT_prototyped";
6568 case DW_AT_return_addr:
6569 return "DW_AT_return_addr";
6570 case DW_AT_start_scope:
6571 return "DW_AT_start_scope";
6572 case DW_AT_bit_stride:
6573 return "DW_AT_bit_stride";
6574 case DW_AT_upper_bound:
6575 return "DW_AT_upper_bound";
6576 case DW_AT_abstract_origin:
6577 return "DW_AT_abstract_origin";
6578 case DW_AT_accessibility:
6579 return "DW_AT_accessibility";
6580 case DW_AT_address_class:
6581 return "DW_AT_address_class";
6582 case DW_AT_artificial:
6583 return "DW_AT_artificial";
6584 case DW_AT_base_types:
6585 return "DW_AT_base_types";
6586 case DW_AT_calling_convention:
6587 return "DW_AT_calling_convention";
6589 return "DW_AT_count";
6590 case DW_AT_data_member_location:
6591 return "DW_AT_data_member_location";
6592 case DW_AT_decl_column:
6593 return "DW_AT_decl_column";
6594 case DW_AT_decl_file:
6595 return "DW_AT_decl_file";
6596 case DW_AT_decl_line:
6597 return "DW_AT_decl_line";
6598 case DW_AT_declaration:
6599 return "DW_AT_declaration";
6600 case DW_AT_discr_list:
6601 return "DW_AT_discr_list";
6602 case DW_AT_encoding:
6603 return "DW_AT_encoding";
6604 case DW_AT_external:
6605 return "DW_AT_external";
6606 case DW_AT_explicit:
6607 return "DW_AT_explicit";
6608 case DW_AT_frame_base:
6609 return "DW_AT_frame_base";
6611 return "DW_AT_friend";
6612 case DW_AT_identifier_case:
6613 return "DW_AT_identifier_case";
6614 case DW_AT_macro_info:
6615 return "DW_AT_macro_info";
6616 case DW_AT_namelist_items:
6617 return "DW_AT_namelist_items";
6618 case DW_AT_priority:
6619 return "DW_AT_priority";
6621 return "DW_AT_segment";
6622 case DW_AT_specification:
6623 return "DW_AT_specification";
6624 case DW_AT_static_link:
6625 return "DW_AT_static_link";
6627 return "DW_AT_type";
6628 case DW_AT_use_location:
6629 return "DW_AT_use_location";
6630 case DW_AT_variable_parameter:
6631 return "DW_AT_variable_parameter";
6632 case DW_AT_virtuality:
6633 return "DW_AT_virtuality";
6634 case DW_AT_vtable_elem_location:
6635 return "DW_AT_vtable_elem_location";
6637 case DW_AT_allocated:
6638 return "DW_AT_allocated";
6639 case DW_AT_associated:
6640 return "DW_AT_associated";
6641 case DW_AT_data_location:
6642 return "DW_AT_data_location";
6643 case DW_AT_byte_stride:
6644 return "DW_AT_byte_stride";
6645 case DW_AT_entry_pc:
6646 return "DW_AT_entry_pc";
6647 case DW_AT_use_UTF8:
6648 return "DW_AT_use_UTF8";
6649 case DW_AT_extension:
6650 return "DW_AT_extension";
6652 return "DW_AT_ranges";
6653 case DW_AT_trampoline:
6654 return "DW_AT_trampoline";
6655 case DW_AT_call_column:
6656 return "DW_AT_call_column";
6657 case DW_AT_call_file:
6658 return "DW_AT_call_file";
6659 case DW_AT_call_line:
6660 return "DW_AT_call_line";
6662 case DW_AT_signature:
6663 return "DW_AT_signature";
6664 case DW_AT_main_subprogram:
6665 return "DW_AT_main_subprogram";
6666 case DW_AT_data_bit_offset:
6667 return "DW_AT_data_bit_offset";
6668 case DW_AT_const_expr:
6669 return "DW_AT_const_expr";
6670 case DW_AT_enum_class:
6671 return "DW_AT_enum_class";
6672 case DW_AT_linkage_name:
6673 return "DW_AT_linkage_name";
6675 case DW_AT_MIPS_fde:
6676 return "DW_AT_MIPS_fde";
6677 case DW_AT_MIPS_loop_begin:
6678 return "DW_AT_MIPS_loop_begin";
6679 case DW_AT_MIPS_tail_loop_begin:
6680 return "DW_AT_MIPS_tail_loop_begin";
6681 case DW_AT_MIPS_epilog_begin:
6682 return "DW_AT_MIPS_epilog_begin";
6683 case DW_AT_MIPS_loop_unroll_factor:
6684 return "DW_AT_MIPS_loop_unroll_factor";
6685 case DW_AT_MIPS_software_pipeline_depth:
6686 return "DW_AT_MIPS_software_pipeline_depth";
6687 case DW_AT_MIPS_linkage_name:
6688 return "DW_AT_MIPS_linkage_name";
6689 case DW_AT_MIPS_stride:
6690 return "DW_AT_MIPS_stride";
6691 case DW_AT_MIPS_abstract_name:
6692 return "DW_AT_MIPS_abstract_name";
6693 case DW_AT_MIPS_clone_origin:
6694 return "DW_AT_MIPS_clone_origin";
6695 case DW_AT_MIPS_has_inlines:
6696 return "DW_AT_MIPS_has_inlines";
6698 case DW_AT_sf_names:
6699 return "DW_AT_sf_names";
6700 case DW_AT_src_info:
6701 return "DW_AT_src_info";
6702 case DW_AT_mac_info:
6703 return "DW_AT_mac_info";
6704 case DW_AT_src_coords:
6705 return "DW_AT_src_coords";
6706 case DW_AT_body_begin:
6707 return "DW_AT_body_begin";
6708 case DW_AT_body_end:
6709 return "DW_AT_body_end";
6710 case DW_AT_GNU_vector:
6711 return "DW_AT_GNU_vector";
6712 case DW_AT_GNU_guarded_by:
6713 return "DW_AT_GNU_guarded_by";
6714 case DW_AT_GNU_pt_guarded_by:
6715 return "DW_AT_GNU_pt_guarded_by";
6716 case DW_AT_GNU_guarded:
6717 return "DW_AT_GNU_guarded";
6718 case DW_AT_GNU_pt_guarded:
6719 return "DW_AT_GNU_pt_guarded";
6720 case DW_AT_GNU_locks_excluded:
6721 return "DW_AT_GNU_locks_excluded";
6722 case DW_AT_GNU_exclusive_locks_required:
6723 return "DW_AT_GNU_exclusive_locks_required";
6724 case DW_AT_GNU_shared_locks_required:
6725 return "DW_AT_GNU_shared_locks_required";
6726 case DW_AT_GNU_odr_signature:
6727 return "DW_AT_GNU_odr_signature";
6728 case DW_AT_GNU_template_name:
6729 return "DW_AT_GNU_template_name";
6731 case DW_AT_VMS_rtnbeg_pd_address:
6732 return "DW_AT_VMS_rtnbeg_pd_address";
6735 return "DW_AT_<unknown>";
6739 /* Convert a DWARF value form code into its string name. */
6742 dwarf_form_name (unsigned int form)
6747 return "DW_FORM_addr";
6748 case DW_FORM_block2:
6749 return "DW_FORM_block2";
6750 case DW_FORM_block4:
6751 return "DW_FORM_block4";
6753 return "DW_FORM_data2";
6755 return "DW_FORM_data4";
6757 return "DW_FORM_data8";
6758 case DW_FORM_string:
6759 return "DW_FORM_string";
6761 return "DW_FORM_block";
6762 case DW_FORM_block1:
6763 return "DW_FORM_block1";
6765 return "DW_FORM_data1";
6767 return "DW_FORM_flag";
6769 return "DW_FORM_sdata";
6771 return "DW_FORM_strp";
6773 return "DW_FORM_udata";
6774 case DW_FORM_ref_addr:
6775 return "DW_FORM_ref_addr";
6777 return "DW_FORM_ref1";
6779 return "DW_FORM_ref2";
6781 return "DW_FORM_ref4";
6783 return "DW_FORM_ref8";
6784 case DW_FORM_ref_udata:
6785 return "DW_FORM_ref_udata";
6786 case DW_FORM_indirect:
6787 return "DW_FORM_indirect";
6788 case DW_FORM_sec_offset:
6789 return "DW_FORM_sec_offset";
6790 case DW_FORM_exprloc:
6791 return "DW_FORM_exprloc";
6792 case DW_FORM_flag_present:
6793 return "DW_FORM_flag_present";
6794 case DW_FORM_ref_sig8:
6795 return "DW_FORM_ref_sig8";
6797 return "DW_FORM_<unknown>";
6801 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
6802 instance of an inlined instance of a decl which is local to an inline
6803 function, so we have to trace all of the way back through the origin chain
6804 to find out what sort of node actually served as the original seed for the
6808 decl_ultimate_origin (const_tree decl)
6810 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
6813 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
6814 nodes in the function to point to themselves; ignore that if
6815 we're trying to output the abstract instance of this function. */
6816 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
6819 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
6820 most distant ancestor, this should never happen. */
6821 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
6823 return DECL_ABSTRACT_ORIGIN (decl);
6826 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
6827 of a virtual function may refer to a base class, so we check the 'this'
6831 decl_class_context (tree decl)
6833 tree context = NULL_TREE;
6835 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
6836 context = DECL_CONTEXT (decl);
6838 context = TYPE_MAIN_VARIANT
6839 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
6841 if (context && !TYPE_P (context))
6842 context = NULL_TREE;
6847 /* Add an attribute/value pair to a DIE. */
6850 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
6852 /* Maybe this should be an assert? */
6856 if (die->die_attr == NULL)
6857 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
6858 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
6861 static inline enum dw_val_class
6862 AT_class (dw_attr_ref a)
6864 return a->dw_attr_val.val_class;
6867 /* Add a flag value attribute to a DIE. */
6870 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
6874 attr.dw_attr = attr_kind;
6875 attr.dw_attr_val.val_class = dw_val_class_flag;
6876 attr.dw_attr_val.v.val_flag = flag;
6877 add_dwarf_attr (die, &attr);
6880 static inline unsigned
6881 AT_flag (dw_attr_ref a)
6883 gcc_assert (a && AT_class (a) == dw_val_class_flag);
6884 return a->dw_attr_val.v.val_flag;
6887 /* Add a signed integer attribute value to a DIE. */
6890 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
6894 attr.dw_attr = attr_kind;
6895 attr.dw_attr_val.val_class = dw_val_class_const;
6896 attr.dw_attr_val.v.val_int = int_val;
6897 add_dwarf_attr (die, &attr);
6900 static inline HOST_WIDE_INT
6901 AT_int (dw_attr_ref a)
6903 gcc_assert (a && AT_class (a) == dw_val_class_const);
6904 return a->dw_attr_val.v.val_int;
6907 /* Add an unsigned integer attribute value to a DIE. */
6910 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
6911 unsigned HOST_WIDE_INT unsigned_val)
6915 attr.dw_attr = attr_kind;
6916 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
6917 attr.dw_attr_val.v.val_unsigned = unsigned_val;
6918 add_dwarf_attr (die, &attr);
6921 static inline unsigned HOST_WIDE_INT
6922 AT_unsigned (dw_attr_ref a)
6924 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
6925 return a->dw_attr_val.v.val_unsigned;
6928 /* Add an unsigned double integer attribute value to a DIE. */
6931 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
6932 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
6936 attr.dw_attr = attr_kind;
6937 attr.dw_attr_val.val_class = dw_val_class_const_double;
6938 attr.dw_attr_val.v.val_double.high = high;
6939 attr.dw_attr_val.v.val_double.low = low;
6940 add_dwarf_attr (die, &attr);
6943 /* Add a floating point attribute value to a DIE and return it. */
6946 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
6947 unsigned int length, unsigned int elt_size, unsigned char *array)
6951 attr.dw_attr = attr_kind;
6952 attr.dw_attr_val.val_class = dw_val_class_vec;
6953 attr.dw_attr_val.v.val_vec.length = length;
6954 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
6955 attr.dw_attr_val.v.val_vec.array = array;
6956 add_dwarf_attr (die, &attr);
6959 /* Add an 8-byte data attribute value to a DIE. */
6962 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
6963 unsigned char data8[8])
6967 attr.dw_attr = attr_kind;
6968 attr.dw_attr_val.val_class = dw_val_class_data8;
6969 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
6970 add_dwarf_attr (die, &attr);
6973 /* Hash and equality functions for debug_str_hash. */
6976 debug_str_do_hash (const void *x)
6978 return htab_hash_string (((const struct indirect_string_node *)x)->str);
6982 debug_str_eq (const void *x1, const void *x2)
6984 return strcmp ((((const struct indirect_string_node *)x1)->str),
6985 (const char *)x2) == 0;
6988 /* Add STR to the indirect string hash table. */
6990 static struct indirect_string_node *
6991 find_AT_string (const char *str)
6993 struct indirect_string_node *node;
6996 if (! debug_str_hash)
6997 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
6998 debug_str_eq, NULL);
7000 slot = htab_find_slot_with_hash (debug_str_hash, str,
7001 htab_hash_string (str), INSERT);
7004 node = (struct indirect_string_node *)
7005 ggc_alloc_cleared (sizeof (struct indirect_string_node));
7006 node->str = ggc_strdup (str);
7010 node = (struct indirect_string_node *) *slot;
7016 /* Add a string attribute value to a DIE. */
7019 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
7022 struct indirect_string_node *node;
7024 node = find_AT_string (str);
7026 attr.dw_attr = attr_kind;
7027 attr.dw_attr_val.val_class = dw_val_class_str;
7028 attr.dw_attr_val.v.val_str = node;
7029 add_dwarf_attr (die, &attr);
7032 /* Create a label for an indirect string node, ensuring it is going to
7033 be output, unless its reference count goes down to zero. */
7036 gen_label_for_indirect_string (struct indirect_string_node *node)
7043 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
7044 ++dw2_string_counter;
7045 node->label = xstrdup (label);
7048 /* Create a SYMBOL_REF rtx whose value is the initial address of a
7049 debug string STR. */
7052 get_debug_string_label (const char *str)
7054 struct indirect_string_node *node = find_AT_string (str);
7056 debug_str_hash_forced = true;
7058 gen_label_for_indirect_string (node);
7060 return gen_rtx_SYMBOL_REF (Pmode, node->label);
7063 static inline const char *
7064 AT_string (dw_attr_ref a)
7066 gcc_assert (a && AT_class (a) == dw_val_class_str);
7067 return a->dw_attr_val.v.val_str->str;
7070 /* Find out whether a string should be output inline in DIE
7071 or out-of-line in .debug_str section. */
7073 static enum dwarf_form
7074 AT_string_form (dw_attr_ref a)
7076 struct indirect_string_node *node;
7079 gcc_assert (a && AT_class (a) == dw_val_class_str);
7081 node = a->dw_attr_val.v.val_str;
7085 len = strlen (node->str) + 1;
7087 /* If the string is shorter or equal to the size of the reference, it is
7088 always better to put it inline. */
7089 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
7090 return node->form = DW_FORM_string;
7092 /* If we cannot expect the linker to merge strings in .debug_str
7093 section, only put it into .debug_str if it is worth even in this
7095 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
7096 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
7097 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
7098 return node->form = DW_FORM_string;
7100 gen_label_for_indirect_string (node);
7102 return node->form = DW_FORM_strp;
7105 /* Add a DIE reference attribute value to a DIE. */
7108 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
7112 attr.dw_attr = attr_kind;
7113 attr.dw_attr_val.val_class = dw_val_class_die_ref;
7114 attr.dw_attr_val.v.val_die_ref.die = targ_die;
7115 attr.dw_attr_val.v.val_die_ref.external = 0;
7116 add_dwarf_attr (die, &attr);
7119 /* Add an AT_specification attribute to a DIE, and also make the back
7120 pointer from the specification to the definition. */
7123 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
7125 add_AT_die_ref (die, DW_AT_specification, targ_die);
7126 gcc_assert (!targ_die->die_definition);
7127 targ_die->die_definition = die;
7130 static inline dw_die_ref
7131 AT_ref (dw_attr_ref a)
7133 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7134 return a->dw_attr_val.v.val_die_ref.die;
7138 AT_ref_external (dw_attr_ref a)
7140 if (a && AT_class (a) == dw_val_class_die_ref)
7141 return a->dw_attr_val.v.val_die_ref.external;
7147 set_AT_ref_external (dw_attr_ref a, int i)
7149 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7150 a->dw_attr_val.v.val_die_ref.external = i;
7153 /* Add an FDE reference attribute value to a DIE. */
7156 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
7160 attr.dw_attr = attr_kind;
7161 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
7162 attr.dw_attr_val.v.val_fde_index = targ_fde;
7163 add_dwarf_attr (die, &attr);
7166 /* Add a location description attribute value to a DIE. */
7169 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
7173 attr.dw_attr = attr_kind;
7174 attr.dw_attr_val.val_class = dw_val_class_loc;
7175 attr.dw_attr_val.v.val_loc = loc;
7176 add_dwarf_attr (die, &attr);
7179 static inline dw_loc_descr_ref
7180 AT_loc (dw_attr_ref a)
7182 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7183 return a->dw_attr_val.v.val_loc;
7187 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
7191 attr.dw_attr = attr_kind;
7192 attr.dw_attr_val.val_class = dw_val_class_loc_list;
7193 attr.dw_attr_val.v.val_loc_list = loc_list;
7194 add_dwarf_attr (die, &attr);
7195 have_location_lists = true;
7198 static inline dw_loc_list_ref
7199 AT_loc_list (dw_attr_ref a)
7201 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7202 return a->dw_attr_val.v.val_loc_list;
7205 static inline dw_loc_list_ref *
7206 AT_loc_list_ptr (dw_attr_ref a)
7208 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7209 return &a->dw_attr_val.v.val_loc_list;
7212 /* Add an address constant attribute value to a DIE. */
7215 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
7219 attr.dw_attr = attr_kind;
7220 attr.dw_attr_val.val_class = dw_val_class_addr;
7221 attr.dw_attr_val.v.val_addr = addr;
7222 add_dwarf_attr (die, &attr);
7225 /* Get the RTX from to an address DIE attribute. */
7228 AT_addr (dw_attr_ref a)
7230 gcc_assert (a && AT_class (a) == dw_val_class_addr);
7231 return a->dw_attr_val.v.val_addr;
7234 /* Add a file attribute value to a DIE. */
7237 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
7238 struct dwarf_file_data *fd)
7242 attr.dw_attr = attr_kind;
7243 attr.dw_attr_val.val_class = dw_val_class_file;
7244 attr.dw_attr_val.v.val_file = fd;
7245 add_dwarf_attr (die, &attr);
7248 /* Get the dwarf_file_data from a file DIE attribute. */
7250 static inline struct dwarf_file_data *
7251 AT_file (dw_attr_ref a)
7253 gcc_assert (a && AT_class (a) == dw_val_class_file);
7254 return a->dw_attr_val.v.val_file;
7257 /* Add a label identifier attribute value to a DIE. */
7260 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
7264 attr.dw_attr = attr_kind;
7265 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
7266 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
7267 add_dwarf_attr (die, &attr);
7270 /* Add a section offset attribute value to a DIE, an offset into the
7271 debug_line section. */
7274 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7279 attr.dw_attr = attr_kind;
7280 attr.dw_attr_val.val_class = dw_val_class_lineptr;
7281 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7282 add_dwarf_attr (die, &attr);
7285 /* Add a section offset attribute value to a DIE, an offset into the
7286 debug_macinfo section. */
7289 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7294 attr.dw_attr = attr_kind;
7295 attr.dw_attr_val.val_class = dw_val_class_macptr;
7296 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7297 add_dwarf_attr (die, &attr);
7300 /* Add an offset attribute value to a DIE. */
7303 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
7304 unsigned HOST_WIDE_INT offset)
7308 attr.dw_attr = attr_kind;
7309 attr.dw_attr_val.val_class = dw_val_class_offset;
7310 attr.dw_attr_val.v.val_offset = offset;
7311 add_dwarf_attr (die, &attr);
7314 /* Add an range_list attribute value to a DIE. */
7317 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
7318 long unsigned int offset)
7322 attr.dw_attr = attr_kind;
7323 attr.dw_attr_val.val_class = dw_val_class_range_list;
7324 attr.dw_attr_val.v.val_offset = offset;
7325 add_dwarf_attr (die, &attr);
7328 static inline const char *
7329 AT_lbl (dw_attr_ref a)
7331 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
7332 || AT_class (a) == dw_val_class_lineptr
7333 || AT_class (a) == dw_val_class_macptr));
7334 return a->dw_attr_val.v.val_lbl_id;
7337 /* Get the attribute of type attr_kind. */
7340 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7344 dw_die_ref spec = NULL;
7349 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7350 if (a->dw_attr == attr_kind)
7352 else if (a->dw_attr == DW_AT_specification
7353 || a->dw_attr == DW_AT_abstract_origin)
7357 return get_AT (spec, attr_kind);
7362 /* Return the "low pc" attribute value, typically associated with a subprogram
7363 DIE. Return null if the "low pc" attribute is either not present, or if it
7364 cannot be represented as an assembler label identifier. */
7366 static inline const char *
7367 get_AT_low_pc (dw_die_ref die)
7369 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
7371 return a ? AT_lbl (a) : NULL;
7374 /* Return the "high pc" attribute value, typically associated with a subprogram
7375 DIE. Return null if the "high pc" attribute is either not present, or if it
7376 cannot be represented as an assembler label identifier. */
7378 static inline const char *
7379 get_AT_hi_pc (dw_die_ref die)
7381 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
7383 return a ? AT_lbl (a) : NULL;
7386 /* Return the value of the string attribute designated by ATTR_KIND, or
7387 NULL if it is not present. */
7389 static inline const char *
7390 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
7392 dw_attr_ref a = get_AT (die, attr_kind);
7394 return a ? AT_string (a) : NULL;
7397 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
7398 if it is not present. */
7401 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
7403 dw_attr_ref a = get_AT (die, attr_kind);
7405 return a ? AT_flag (a) : 0;
7408 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
7409 if it is not present. */
7411 static inline unsigned
7412 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
7414 dw_attr_ref a = get_AT (die, attr_kind);
7416 return a ? AT_unsigned (a) : 0;
7419 static inline dw_die_ref
7420 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
7422 dw_attr_ref a = get_AT (die, attr_kind);
7424 return a ? AT_ref (a) : NULL;
7427 static inline struct dwarf_file_data *
7428 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
7430 dw_attr_ref a = get_AT (die, attr_kind);
7432 return a ? AT_file (a) : NULL;
7435 /* Return TRUE if the language is C or C++. */
7440 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7442 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
7443 || lang == DW_LANG_C99
7444 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
7447 /* Return TRUE if the language is C++. */
7452 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7454 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
7457 /* Return TRUE if the language is Fortran. */
7462 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7464 return (lang == DW_LANG_Fortran77
7465 || lang == DW_LANG_Fortran90
7466 || lang == DW_LANG_Fortran95);
7469 /* Return TRUE if the language is Java. */
7474 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7476 return lang == DW_LANG_Java;
7479 /* Return TRUE if the language is Ada. */
7484 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7486 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
7489 /* Remove the specified attribute if present. */
7492 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7500 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7501 if (a->dw_attr == attr_kind)
7503 if (AT_class (a) == dw_val_class_str)
7504 if (a->dw_attr_val.v.val_str->refcount)
7505 a->dw_attr_val.v.val_str->refcount--;
7507 /* VEC_ordered_remove should help reduce the number of abbrevs
7509 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
7514 /* Remove CHILD from its parent. PREV must have the property that
7515 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
7518 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
7520 gcc_assert (child->die_parent == prev->die_parent);
7521 gcc_assert (prev->die_sib == child);
7524 gcc_assert (child->die_parent->die_child == child);
7528 prev->die_sib = child->die_sib;
7529 if (child->die_parent->die_child == child)
7530 child->die_parent->die_child = prev;
7533 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
7534 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
7537 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
7539 dw_die_ref parent = old_child->die_parent;
7541 gcc_assert (parent == prev->die_parent);
7542 gcc_assert (prev->die_sib == old_child);
7544 new_child->die_parent = parent;
7545 if (prev == old_child)
7547 gcc_assert (parent->die_child == old_child);
7548 new_child->die_sib = new_child;
7552 prev->die_sib = new_child;
7553 new_child->die_sib = old_child->die_sib;
7555 if (old_child->die_parent->die_child == old_child)
7556 old_child->die_parent->die_child = new_child;
7559 /* Move all children from OLD_PARENT to NEW_PARENT. */
7562 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
7565 new_parent->die_child = old_parent->die_child;
7566 old_parent->die_child = NULL;
7567 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
7570 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
7574 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
7580 dw_die_ref prev = c;
7582 while (c->die_tag == tag)
7584 remove_child_with_prev (c, prev);
7585 /* Might have removed every child. */
7586 if (c == c->die_sib)
7590 } while (c != die->die_child);
7593 /* Add a CHILD_DIE as the last child of DIE. */
7596 add_child_die (dw_die_ref die, dw_die_ref child_die)
7598 /* FIXME this should probably be an assert. */
7599 if (! die || ! child_die)
7601 gcc_assert (die != child_die);
7603 child_die->die_parent = die;
7606 child_die->die_sib = die->die_child->die_sib;
7607 die->die_child->die_sib = child_die;
7610 child_die->die_sib = child_die;
7611 die->die_child = child_die;
7614 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
7615 is the specification, to the end of PARENT's list of children.
7616 This is done by removing and re-adding it. */
7619 splice_child_die (dw_die_ref parent, dw_die_ref child)
7623 /* We want the declaration DIE from inside the class, not the
7624 specification DIE at toplevel. */
7625 if (child->die_parent != parent)
7627 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
7633 gcc_assert (child->die_parent == parent
7634 || (child->die_parent
7635 == get_AT_ref (parent, DW_AT_specification)));
7637 for (p = child->die_parent->die_child; ; p = p->die_sib)
7638 if (p->die_sib == child)
7640 remove_child_with_prev (child, p);
7644 add_child_die (parent, child);
7647 /* Return a pointer to a newly created DIE node. */
7649 static inline dw_die_ref
7650 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
7652 dw_die_ref die = GGC_CNEW (die_node);
7654 die->die_tag = tag_value;
7656 if (parent_die != NULL)
7657 add_child_die (parent_die, die);
7660 limbo_die_node *limbo_node;
7662 limbo_node = GGC_CNEW (limbo_die_node);
7663 limbo_node->die = die;
7664 limbo_node->created_for = t;
7665 limbo_node->next = limbo_die_list;
7666 limbo_die_list = limbo_node;
7672 /* Return the DIE associated with the given type specifier. */
7674 static inline dw_die_ref
7675 lookup_type_die (tree type)
7677 return TYPE_SYMTAB_DIE (type);
7680 /* Equate a DIE to a given type specifier. */
7683 equate_type_number_to_die (tree type, dw_die_ref type_die)
7685 TYPE_SYMTAB_DIE (type) = type_die;
7688 /* Returns a hash value for X (which really is a die_struct). */
7691 decl_die_table_hash (const void *x)
7693 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
7696 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
7699 decl_die_table_eq (const void *x, const void *y)
7701 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
7704 /* Return the DIE associated with a given declaration. */
7706 static inline dw_die_ref
7707 lookup_decl_die (tree decl)
7709 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
7712 /* Returns a hash value for X (which really is a var_loc_list). */
7715 decl_loc_table_hash (const void *x)
7717 return (hashval_t) ((const var_loc_list *) x)->decl_id;
7720 /* Return nonzero if decl_id of var_loc_list X is the same as
7724 decl_loc_table_eq (const void *x, const void *y)
7726 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
7729 /* Return the var_loc list associated with a given declaration. */
7731 static inline var_loc_list *
7732 lookup_decl_loc (const_tree decl)
7734 if (!decl_loc_table)
7736 return (var_loc_list *)
7737 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
7740 /* Equate a DIE to a particular declaration. */
7743 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
7745 unsigned int decl_id = DECL_UID (decl);
7748 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
7750 decl_die->decl_id = decl_id;
7753 /* Add a variable location node to the linked list for DECL. */
7755 static struct var_loc_node *
7756 add_var_loc_to_decl (tree decl, rtx loc_note)
7758 unsigned int decl_id = DECL_UID (decl);
7761 struct var_loc_node *loc = NULL;
7763 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
7766 temp = GGC_CNEW (var_loc_list);
7767 temp->decl_id = decl_id;
7771 temp = (var_loc_list *) *slot;
7775 /* If the current location is the same as the end of the list,
7776 and either both or neither of the locations is uninitialized,
7777 we have nothing to do. */
7778 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
7779 NOTE_VAR_LOCATION_LOC (loc_note)))
7780 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7781 != NOTE_VAR_LOCATION_STATUS (loc_note))
7782 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7783 == VAR_INIT_STATUS_UNINITIALIZED)
7784 || (NOTE_VAR_LOCATION_STATUS (loc_note)
7785 == VAR_INIT_STATUS_UNINITIALIZED))))
7787 /* Add LOC to the end of list and update LAST. */
7788 loc = GGC_CNEW (struct var_loc_node);
7789 temp->last->next = loc;
7795 loc = GGC_CNEW (struct var_loc_node);
7802 /* Keep track of the number of spaces used to indent the
7803 output of the debugging routines that print the structure of
7804 the DIE internal representation. */
7805 static int print_indent;
7807 /* Indent the line the number of spaces given by print_indent. */
7810 print_spaces (FILE *outfile)
7812 fprintf (outfile, "%*s", print_indent, "");
7815 /* Print a type signature in hex. */
7818 print_signature (FILE *outfile, char *sig)
7822 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
7823 fprintf (outfile, "%02x", sig[i] & 0xff);
7826 /* Print the information associated with a given DIE, and its children.
7827 This routine is a debugging aid only. */
7830 print_die (dw_die_ref die, FILE *outfile)
7836 print_spaces (outfile);
7837 fprintf (outfile, "DIE %4ld: %s\n",
7838 die->die_offset, dwarf_tag_name (die->die_tag));
7839 print_spaces (outfile);
7840 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
7841 fprintf (outfile, " offset: %ld\n", die->die_offset);
7842 if (dwarf_version >= 4 && die->die_id.die_type_node)
7844 print_spaces (outfile);
7845 fprintf (outfile, " signature: ");
7846 print_signature (outfile, die->die_id.die_type_node->signature);
7847 fprintf (outfile, "\n");
7850 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7852 print_spaces (outfile);
7853 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
7855 switch (AT_class (a))
7857 case dw_val_class_addr:
7858 fprintf (outfile, "address");
7860 case dw_val_class_offset:
7861 fprintf (outfile, "offset");
7863 case dw_val_class_loc:
7864 fprintf (outfile, "location descriptor");
7866 case dw_val_class_loc_list:
7867 fprintf (outfile, "location list -> label:%s",
7868 AT_loc_list (a)->ll_symbol);
7870 case dw_val_class_range_list:
7871 fprintf (outfile, "range list");
7873 case dw_val_class_const:
7874 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
7876 case dw_val_class_unsigned_const:
7877 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
7879 case dw_val_class_const_double:
7880 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
7881 HOST_WIDE_INT_PRINT_UNSIGNED")",
7882 a->dw_attr_val.v.val_double.high,
7883 a->dw_attr_val.v.val_double.low);
7885 case dw_val_class_vec:
7886 fprintf (outfile, "floating-point or vector constant");
7888 case dw_val_class_flag:
7889 fprintf (outfile, "%u", AT_flag (a));
7891 case dw_val_class_die_ref:
7892 if (AT_ref (a) != NULL)
7894 if (dwarf_version >= 4 && AT_ref (a)->die_id.die_type_node)
7896 fprintf (outfile, "die -> signature: ");
7897 print_signature (outfile,
7898 AT_ref (a)->die_id.die_type_node->signature);
7900 else if (dwarf_version < 4 && AT_ref (a)->die_id.die_symbol)
7901 fprintf (outfile, "die -> label: %s",
7902 AT_ref (a)->die_id.die_symbol);
7904 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
7907 fprintf (outfile, "die -> <null>");
7909 case dw_val_class_lbl_id:
7910 case dw_val_class_lineptr:
7911 case dw_val_class_macptr:
7912 fprintf (outfile, "label: %s", AT_lbl (a));
7914 case dw_val_class_str:
7915 if (AT_string (a) != NULL)
7916 fprintf (outfile, "\"%s\"", AT_string (a));
7918 fprintf (outfile, "<null>");
7920 case dw_val_class_file:
7921 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
7922 AT_file (a)->emitted_number);
7924 case dw_val_class_data8:
7928 for (i = 0; i < 8; i++)
7929 fprintf (outfile, "%02x", a->dw_attr_val.v.val_data8[i]);
7936 fprintf (outfile, "\n");
7939 if (die->die_child != NULL)
7942 FOR_EACH_CHILD (die, c, print_die (c, outfile));
7945 if (print_indent == 0)
7946 fprintf (outfile, "\n");
7949 /* Print the contents of the source code line number correspondence table.
7950 This routine is a debugging aid only. */
7953 print_dwarf_line_table (FILE *outfile)
7956 dw_line_info_ref line_info;
7958 fprintf (outfile, "\n\nDWARF source line information\n");
7959 for (i = 1; i < line_info_table_in_use; i++)
7961 line_info = &line_info_table[i];
7962 fprintf (outfile, "%5d: %4ld %6ld\n", i,
7963 line_info->dw_file_num,
7964 line_info->dw_line_num);
7967 fprintf (outfile, "\n\n");
7970 /* Print the information collected for a given DIE. */
7973 debug_dwarf_die (dw_die_ref die)
7975 print_die (die, stderr);
7978 /* Print all DWARF information collected for the compilation unit.
7979 This routine is a debugging aid only. */
7985 print_die (comp_unit_die, stderr);
7986 if (! DWARF2_ASM_LINE_DEBUG_INFO)
7987 print_dwarf_line_table (stderr);
7990 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
7991 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
7992 DIE that marks the start of the DIEs for this include file. */
7995 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
7997 const char *filename = get_AT_string (bincl_die, DW_AT_name);
7998 dw_die_ref new_unit = gen_compile_unit_die (filename);
8000 new_unit->die_sib = old_unit;
8004 /* Close an include-file CU and reopen the enclosing one. */
8007 pop_compile_unit (dw_die_ref old_unit)
8009 dw_die_ref new_unit = old_unit->die_sib;
8011 old_unit->die_sib = NULL;
8015 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8016 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
8018 /* Calculate the checksum of a location expression. */
8021 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
8025 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
8027 CHECKSUM (loc->dw_loc_oprnd1);
8028 CHECKSUM (loc->dw_loc_oprnd2);
8031 /* Calculate the checksum of an attribute. */
8034 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
8036 dw_loc_descr_ref loc;
8039 CHECKSUM (at->dw_attr);
8041 /* We don't care that this was compiled with a different compiler
8042 snapshot; if the output is the same, that's what matters. */
8043 if (at->dw_attr == DW_AT_producer)
8046 switch (AT_class (at))
8048 case dw_val_class_const:
8049 CHECKSUM (at->dw_attr_val.v.val_int);
8051 case dw_val_class_unsigned_const:
8052 CHECKSUM (at->dw_attr_val.v.val_unsigned);
8054 case dw_val_class_const_double:
8055 CHECKSUM (at->dw_attr_val.v.val_double);
8057 case dw_val_class_vec:
8058 CHECKSUM (at->dw_attr_val.v.val_vec);
8060 case dw_val_class_flag:
8061 CHECKSUM (at->dw_attr_val.v.val_flag);
8063 case dw_val_class_str:
8064 CHECKSUM_STRING (AT_string (at));
8067 case dw_val_class_addr:
8069 gcc_assert (GET_CODE (r) == SYMBOL_REF);
8070 CHECKSUM_STRING (XSTR (r, 0));
8073 case dw_val_class_offset:
8074 CHECKSUM (at->dw_attr_val.v.val_offset);
8077 case dw_val_class_loc:
8078 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
8079 loc_checksum (loc, ctx);
8082 case dw_val_class_die_ref:
8083 die_checksum (AT_ref (at), ctx, mark);
8086 case dw_val_class_fde_ref:
8087 case dw_val_class_lbl_id:
8088 case dw_val_class_lineptr:
8089 case dw_val_class_macptr:
8092 case dw_val_class_file:
8093 CHECKSUM_STRING (AT_file (at)->filename);
8096 case dw_val_class_data8:
8097 CHECKSUM (at->dw_attr_val.v.val_data8);
8105 /* Calculate the checksum of a DIE. */
8108 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
8114 /* To avoid infinite recursion. */
8117 CHECKSUM (die->die_mark);
8120 die->die_mark = ++(*mark);
8122 CHECKSUM (die->die_tag);
8124 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8125 attr_checksum (a, ctx, mark);
8127 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
8131 #undef CHECKSUM_STRING
8133 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
8134 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8135 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
8136 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
8137 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
8138 #define CHECKSUM_ATTR(FOO) \
8139 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
8141 /* Calculate the checksum of a number in signed LEB128 format. */
8144 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
8151 byte = (value & 0x7f);
8153 more = !((value == 0 && (byte & 0x40) == 0)
8154 || (value == -1 && (byte & 0x40) != 0));
8163 /* Calculate the checksum of a number in unsigned LEB128 format. */
8166 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
8170 unsigned char byte = (value & 0x7f);
8173 /* More bytes to follow. */
8181 /* Checksum the context of the DIE. This adds the names of any
8182 surrounding namespaces or structures to the checksum. */
8185 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
8189 int tag = die->die_tag;
8191 if (tag != DW_TAG_namespace
8192 && tag != DW_TAG_structure_type
8193 && tag != DW_TAG_class_type)
8196 name = get_AT_string (die, DW_AT_name);
8198 spec = get_AT_ref (die, DW_AT_specification);
8202 if (die->die_parent != NULL)
8203 checksum_die_context (die->die_parent, ctx);
8205 CHECKSUM_ULEB128 ('C');
8206 CHECKSUM_ULEB128 (tag);
8208 CHECKSUM_STRING (name);
8211 /* Calculate the checksum of a location expression. */
8214 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
8216 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
8217 were emitted as a DW_FORM_sdata instead of a location expression. */
8218 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
8220 CHECKSUM_ULEB128 (DW_FORM_sdata);
8221 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
8225 /* Otherwise, just checksum the raw location expression. */
8228 CHECKSUM_ULEB128 (loc->dw_loc_opc);
8229 CHECKSUM (loc->dw_loc_oprnd1);
8230 CHECKSUM (loc->dw_loc_oprnd2);
8231 loc = loc->dw_loc_next;
8235 /* Calculate the checksum of an attribute. */
8238 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
8239 struct md5_ctx *ctx, int *mark)
8241 dw_loc_descr_ref loc;
8244 if (AT_class (at) == dw_val_class_die_ref)
8246 dw_die_ref target_die = AT_ref (at);
8248 /* For pointer and reference types, we checksum only the (qualified)
8249 name of the target type (if there is a name). For friend entries,
8250 we checksum only the (qualified) name of the target type or function.
8251 This allows the checksum to remain the same whether the target type
8252 is complete or not. */
8253 if ((at->dw_attr == DW_AT_type
8254 && (tag == DW_TAG_pointer_type
8255 || tag == DW_TAG_reference_type
8256 || tag == DW_TAG_ptr_to_member_type))
8257 || (at->dw_attr == DW_AT_friend
8258 && tag == DW_TAG_friend))
8260 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
8262 if (name_attr != NULL)
8264 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
8268 CHECKSUM_ULEB128 ('N');
8269 CHECKSUM_ULEB128 (at->dw_attr);
8270 if (decl->die_parent != NULL)
8271 checksum_die_context (decl->die_parent, ctx);
8272 CHECKSUM_ULEB128 ('E');
8273 CHECKSUM_STRING (AT_string (name_attr));
8278 /* For all other references to another DIE, we check to see if the
8279 target DIE has already been visited. If it has, we emit a
8280 backward reference; if not, we descend recursively. */
8281 if (target_die->die_mark > 0)
8283 CHECKSUM_ULEB128 ('R');
8284 CHECKSUM_ULEB128 (at->dw_attr);
8285 CHECKSUM_ULEB128 (target_die->die_mark);
8289 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
8293 target_die->die_mark = ++(*mark);
8294 CHECKSUM_ULEB128 ('T');
8295 CHECKSUM_ULEB128 (at->dw_attr);
8296 if (decl->die_parent != NULL)
8297 checksum_die_context (decl->die_parent, ctx);
8298 die_checksum_ordered (target_die, ctx, mark);
8303 CHECKSUM_ULEB128 ('A');
8304 CHECKSUM_ULEB128 (at->dw_attr);
8306 switch (AT_class (at))
8308 case dw_val_class_const:
8309 CHECKSUM_ULEB128 (DW_FORM_sdata);
8310 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
8313 case dw_val_class_unsigned_const:
8314 CHECKSUM_ULEB128 (DW_FORM_sdata);
8315 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
8318 case dw_val_class_const_double:
8319 CHECKSUM_ULEB128 (DW_FORM_block);
8320 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
8321 CHECKSUM (at->dw_attr_val.v.val_double);
8324 case dw_val_class_vec:
8325 CHECKSUM_ULEB128 (DW_FORM_block);
8326 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_vec));
8327 CHECKSUM (at->dw_attr_val.v.val_vec);
8330 case dw_val_class_flag:
8331 CHECKSUM_ULEB128 (DW_FORM_flag);
8332 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
8335 case dw_val_class_str:
8336 CHECKSUM_ULEB128 (DW_FORM_string);
8337 CHECKSUM_STRING (AT_string (at));
8340 case dw_val_class_addr:
8342 gcc_assert (GET_CODE (r) == SYMBOL_REF);
8343 CHECKSUM_ULEB128 (DW_FORM_string);
8344 CHECKSUM_STRING (XSTR (r, 0));
8347 case dw_val_class_offset:
8348 CHECKSUM_ULEB128 (DW_FORM_sdata);
8349 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
8352 case dw_val_class_loc:
8353 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
8354 loc_checksum_ordered (loc, ctx);
8357 case dw_val_class_fde_ref:
8358 case dw_val_class_lbl_id:
8359 case dw_val_class_lineptr:
8360 case dw_val_class_macptr:
8363 case dw_val_class_file:
8364 CHECKSUM_ULEB128 (DW_FORM_string);
8365 CHECKSUM_STRING (AT_file (at)->filename);
8368 case dw_val_class_data8:
8369 CHECKSUM (at->dw_attr_val.v.val_data8);
8377 struct checksum_attributes
8379 dw_attr_ref at_name;
8380 dw_attr_ref at_type;
8381 dw_attr_ref at_friend;
8382 dw_attr_ref at_accessibility;
8383 dw_attr_ref at_address_class;
8384 dw_attr_ref at_allocated;
8385 dw_attr_ref at_artificial;
8386 dw_attr_ref at_associated;
8387 dw_attr_ref at_binary_scale;
8388 dw_attr_ref at_bit_offset;
8389 dw_attr_ref at_bit_size;
8390 dw_attr_ref at_bit_stride;
8391 dw_attr_ref at_byte_size;
8392 dw_attr_ref at_byte_stride;
8393 dw_attr_ref at_const_value;
8394 dw_attr_ref at_containing_type;
8395 dw_attr_ref at_count;
8396 dw_attr_ref at_data_location;
8397 dw_attr_ref at_data_member_location;
8398 dw_attr_ref at_decimal_scale;
8399 dw_attr_ref at_decimal_sign;
8400 dw_attr_ref at_default_value;
8401 dw_attr_ref at_digit_count;
8402 dw_attr_ref at_discr;
8403 dw_attr_ref at_discr_list;
8404 dw_attr_ref at_discr_value;
8405 dw_attr_ref at_encoding;
8406 dw_attr_ref at_endianity;
8407 dw_attr_ref at_explicit;
8408 dw_attr_ref at_is_optional;
8409 dw_attr_ref at_location;
8410 dw_attr_ref at_lower_bound;
8411 dw_attr_ref at_mutable;
8412 dw_attr_ref at_ordering;
8413 dw_attr_ref at_picture_string;
8414 dw_attr_ref at_prototyped;
8415 dw_attr_ref at_small;
8416 dw_attr_ref at_segment;
8417 dw_attr_ref at_string_length;
8418 dw_attr_ref at_threads_scaled;
8419 dw_attr_ref at_upper_bound;
8420 dw_attr_ref at_use_location;
8421 dw_attr_ref at_use_UTF8;
8422 dw_attr_ref at_variable_parameter;
8423 dw_attr_ref at_virtuality;
8424 dw_attr_ref at_visibility;
8425 dw_attr_ref at_vtable_elem_location;
8428 /* Collect the attributes that we will want to use for the checksum. */
8431 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
8436 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8447 attrs->at_friend = a;
8449 case DW_AT_accessibility:
8450 attrs->at_accessibility = a;
8452 case DW_AT_address_class:
8453 attrs->at_address_class = a;
8455 case DW_AT_allocated:
8456 attrs->at_allocated = a;
8458 case DW_AT_artificial:
8459 attrs->at_artificial = a;
8461 case DW_AT_associated:
8462 attrs->at_associated = a;
8464 case DW_AT_binary_scale:
8465 attrs->at_binary_scale = a;
8467 case DW_AT_bit_offset:
8468 attrs->at_bit_offset = a;
8470 case DW_AT_bit_size:
8471 attrs->at_bit_size = a;
8473 case DW_AT_bit_stride:
8474 attrs->at_bit_stride = a;
8476 case DW_AT_byte_size:
8477 attrs->at_byte_size = a;
8479 case DW_AT_byte_stride:
8480 attrs->at_byte_stride = a;
8482 case DW_AT_const_value:
8483 attrs->at_const_value = a;
8485 case DW_AT_containing_type:
8486 attrs->at_containing_type = a;
8489 attrs->at_count = a;
8491 case DW_AT_data_location:
8492 attrs->at_data_location = a;
8494 case DW_AT_data_member_location:
8495 attrs->at_data_member_location = a;
8497 case DW_AT_decimal_scale:
8498 attrs->at_decimal_scale = a;
8500 case DW_AT_decimal_sign:
8501 attrs->at_decimal_sign = a;
8503 case DW_AT_default_value:
8504 attrs->at_default_value = a;
8506 case DW_AT_digit_count:
8507 attrs->at_digit_count = a;
8510 attrs->at_discr = a;
8512 case DW_AT_discr_list:
8513 attrs->at_discr_list = a;
8515 case DW_AT_discr_value:
8516 attrs->at_discr_value = a;
8518 case DW_AT_encoding:
8519 attrs->at_encoding = a;
8521 case DW_AT_endianity:
8522 attrs->at_endianity = a;
8524 case DW_AT_explicit:
8525 attrs->at_explicit = a;
8527 case DW_AT_is_optional:
8528 attrs->at_is_optional = a;
8530 case DW_AT_location:
8531 attrs->at_location = a;
8533 case DW_AT_lower_bound:
8534 attrs->at_lower_bound = a;
8537 attrs->at_mutable = a;
8539 case DW_AT_ordering:
8540 attrs->at_ordering = a;
8542 case DW_AT_picture_string:
8543 attrs->at_picture_string = a;
8545 case DW_AT_prototyped:
8546 attrs->at_prototyped = a;
8549 attrs->at_small = a;
8552 attrs->at_segment = a;
8554 case DW_AT_string_length:
8555 attrs->at_string_length = a;
8557 case DW_AT_threads_scaled:
8558 attrs->at_threads_scaled = a;
8560 case DW_AT_upper_bound:
8561 attrs->at_upper_bound = a;
8563 case DW_AT_use_location:
8564 attrs->at_use_location = a;
8566 case DW_AT_use_UTF8:
8567 attrs->at_use_UTF8 = a;
8569 case DW_AT_variable_parameter:
8570 attrs->at_variable_parameter = a;
8572 case DW_AT_virtuality:
8573 attrs->at_virtuality = a;
8575 case DW_AT_visibility:
8576 attrs->at_visibility = a;
8578 case DW_AT_vtable_elem_location:
8579 attrs->at_vtable_elem_location = a;
8587 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
8590 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
8594 struct checksum_attributes attrs;
8596 CHECKSUM_ULEB128 ('D');
8597 CHECKSUM_ULEB128 (die->die_tag);
8599 memset (&attrs, 0, sizeof (attrs));
8601 decl = get_AT_ref (die, DW_AT_specification);
8603 collect_checksum_attributes (&attrs, decl);
8604 collect_checksum_attributes (&attrs, die);
8606 CHECKSUM_ATTR (attrs.at_name);
8607 CHECKSUM_ATTR (attrs.at_accessibility);
8608 CHECKSUM_ATTR (attrs.at_address_class);
8609 CHECKSUM_ATTR (attrs.at_allocated);
8610 CHECKSUM_ATTR (attrs.at_artificial);
8611 CHECKSUM_ATTR (attrs.at_associated);
8612 CHECKSUM_ATTR (attrs.at_binary_scale);
8613 CHECKSUM_ATTR (attrs.at_bit_offset);
8614 CHECKSUM_ATTR (attrs.at_bit_size);
8615 CHECKSUM_ATTR (attrs.at_bit_stride);
8616 CHECKSUM_ATTR (attrs.at_byte_size);
8617 CHECKSUM_ATTR (attrs.at_byte_stride);
8618 CHECKSUM_ATTR (attrs.at_const_value);
8619 CHECKSUM_ATTR (attrs.at_containing_type);
8620 CHECKSUM_ATTR (attrs.at_count);
8621 CHECKSUM_ATTR (attrs.at_data_location);
8622 CHECKSUM_ATTR (attrs.at_data_member_location);
8623 CHECKSUM_ATTR (attrs.at_decimal_scale);
8624 CHECKSUM_ATTR (attrs.at_decimal_sign);
8625 CHECKSUM_ATTR (attrs.at_default_value);
8626 CHECKSUM_ATTR (attrs.at_digit_count);
8627 CHECKSUM_ATTR (attrs.at_discr);
8628 CHECKSUM_ATTR (attrs.at_discr_list);
8629 CHECKSUM_ATTR (attrs.at_discr_value);
8630 CHECKSUM_ATTR (attrs.at_encoding);
8631 CHECKSUM_ATTR (attrs.at_endianity);
8632 CHECKSUM_ATTR (attrs.at_explicit);
8633 CHECKSUM_ATTR (attrs.at_is_optional);
8634 CHECKSUM_ATTR (attrs.at_location);
8635 CHECKSUM_ATTR (attrs.at_lower_bound);
8636 CHECKSUM_ATTR (attrs.at_mutable);
8637 CHECKSUM_ATTR (attrs.at_ordering);
8638 CHECKSUM_ATTR (attrs.at_picture_string);
8639 CHECKSUM_ATTR (attrs.at_prototyped);
8640 CHECKSUM_ATTR (attrs.at_small);
8641 CHECKSUM_ATTR (attrs.at_segment);
8642 CHECKSUM_ATTR (attrs.at_string_length);
8643 CHECKSUM_ATTR (attrs.at_threads_scaled);
8644 CHECKSUM_ATTR (attrs.at_upper_bound);
8645 CHECKSUM_ATTR (attrs.at_use_location);
8646 CHECKSUM_ATTR (attrs.at_use_UTF8);
8647 CHECKSUM_ATTR (attrs.at_variable_parameter);
8648 CHECKSUM_ATTR (attrs.at_virtuality);
8649 CHECKSUM_ATTR (attrs.at_visibility);
8650 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
8651 CHECKSUM_ATTR (attrs.at_type);
8652 CHECKSUM_ATTR (attrs.at_friend);
8654 /* Checksum the child DIEs, except for nested types and member functions. */
8657 dw_attr_ref name_attr;
8660 name_attr = get_AT (c, DW_AT_name);
8661 if ((is_type_die (c) || c->die_tag == DW_TAG_subprogram)
8662 && name_attr != NULL)
8664 CHECKSUM_ULEB128 ('S');
8665 CHECKSUM_ULEB128 (c->die_tag);
8666 CHECKSUM_STRING (AT_string (name_attr));
8670 /* Mark this DIE so it gets processed when unmarking. */
8671 if (c->die_mark == 0)
8673 die_checksum_ordered (c, ctx, mark);
8675 } while (c != die->die_child);
8677 CHECKSUM_ULEB128 (0);
8681 #undef CHECKSUM_STRING
8682 #undef CHECKSUM_ATTR
8683 #undef CHECKSUM_LEB128
8684 #undef CHECKSUM_ULEB128
8686 /* Generate the type signature for DIE. This is computed by generating an
8687 MD5 checksum over the DIE's tag, its relevant attributes, and its
8688 children. Attributes that are references to other DIEs are processed
8689 by recursion, using the MARK field to prevent infinite recursion.
8690 If the DIE is nested inside a namespace or another type, we also
8691 need to include that context in the signature. The lower 64 bits
8692 of the resulting MD5 checksum comprise the signature. */
8695 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
8699 unsigned char checksum[16];
8703 name = get_AT_string (die, DW_AT_name);
8704 decl = get_AT_ref (die, DW_AT_specification);
8706 /* First, compute a signature for just the type name (and its surrounding
8707 context, if any. This is stored in the type unit DIE for link-time
8708 ODR (one-definition rule) checking. */
8710 if (is_cxx() && name != NULL)
8712 md5_init_ctx (&ctx);
8714 /* Checksum the names of surrounding namespaces and structures. */
8715 if (decl != NULL && decl->die_parent != NULL)
8716 checksum_die_context (decl->die_parent, &ctx);
8718 md5_process_bytes (&die->die_tag, sizeof (die->die_tag), &ctx);
8719 md5_process_bytes (name, strlen (name) + 1, &ctx);
8720 md5_finish_ctx (&ctx, checksum);
8722 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
8725 /* Next, compute the complete type signature. */
8727 md5_init_ctx (&ctx);
8729 die->die_mark = mark;
8731 /* Checksum the names of surrounding namespaces and structures. */
8732 if (decl != NULL && decl->die_parent != NULL)
8733 checksum_die_context (decl->die_parent, &ctx);
8735 /* Checksum the DIE and its children. */
8736 die_checksum_ordered (die, &ctx, &mark);
8737 unmark_all_dies (die);
8738 md5_finish_ctx (&ctx, checksum);
8740 /* Store the signature in the type node and link the type DIE and the
8741 type node together. */
8742 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
8743 DWARF_TYPE_SIGNATURE_SIZE);
8744 die->die_id.die_type_node = type_node;
8745 type_node->type_die = die;
8747 /* If the DIE is a specification, link its declaration to the type node
8750 decl->die_id.die_type_node = type_node;
8753 /* Do the location expressions look same? */
8755 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
8757 return loc1->dw_loc_opc == loc2->dw_loc_opc
8758 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
8759 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
8762 /* Do the values look the same? */
8764 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
8766 dw_loc_descr_ref loc1, loc2;
8769 if (v1->val_class != v2->val_class)
8772 switch (v1->val_class)
8774 case dw_val_class_const:
8775 return v1->v.val_int == v2->v.val_int;
8776 case dw_val_class_unsigned_const:
8777 return v1->v.val_unsigned == v2->v.val_unsigned;
8778 case dw_val_class_const_double:
8779 return v1->v.val_double.high == v2->v.val_double.high
8780 && v1->v.val_double.low == v2->v.val_double.low;
8781 case dw_val_class_vec:
8782 if (v1->v.val_vec.length != v2->v.val_vec.length
8783 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
8785 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
8786 v1->v.val_vec.length * v1->v.val_vec.elt_size))
8789 case dw_val_class_flag:
8790 return v1->v.val_flag == v2->v.val_flag;
8791 case dw_val_class_str:
8792 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
8794 case dw_val_class_addr:
8795 r1 = v1->v.val_addr;
8796 r2 = v2->v.val_addr;
8797 if (GET_CODE (r1) != GET_CODE (r2))
8799 return !rtx_equal_p (r1, r2);
8801 case dw_val_class_offset:
8802 return v1->v.val_offset == v2->v.val_offset;
8804 case dw_val_class_loc:
8805 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
8807 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
8808 if (!same_loc_p (loc1, loc2, mark))
8810 return !loc1 && !loc2;
8812 case dw_val_class_die_ref:
8813 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
8815 case dw_val_class_fde_ref:
8816 case dw_val_class_lbl_id:
8817 case dw_val_class_lineptr:
8818 case dw_val_class_macptr:
8821 case dw_val_class_file:
8822 return v1->v.val_file == v2->v.val_file;
8824 case dw_val_class_data8:
8825 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
8832 /* Do the attributes look the same? */
8835 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
8837 if (at1->dw_attr != at2->dw_attr)
8840 /* We don't care that this was compiled with a different compiler
8841 snapshot; if the output is the same, that's what matters. */
8842 if (at1->dw_attr == DW_AT_producer)
8845 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
8848 /* Do the dies look the same? */
8851 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
8857 /* To avoid infinite recursion. */
8859 return die1->die_mark == die2->die_mark;
8860 die1->die_mark = die2->die_mark = ++(*mark);
8862 if (die1->die_tag != die2->die_tag)
8865 if (VEC_length (dw_attr_node, die1->die_attr)
8866 != VEC_length (dw_attr_node, die2->die_attr))
8869 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
8870 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
8873 c1 = die1->die_child;
8874 c2 = die2->die_child;
8883 if (!same_die_p (c1, c2, mark))
8887 if (c1 == die1->die_child)
8889 if (c2 == die2->die_child)
8899 /* Do the dies look the same? Wrapper around same_die_p. */
8902 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
8905 int ret = same_die_p (die1, die2, &mark);
8907 unmark_all_dies (die1);
8908 unmark_all_dies (die2);
8913 /* The prefix to attach to symbols on DIEs in the current comdat debug
8915 static char *comdat_symbol_id;
8917 /* The index of the current symbol within the current comdat CU. */
8918 static unsigned int comdat_symbol_number;
8920 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
8921 children, and set comdat_symbol_id accordingly. */
8924 compute_section_prefix (dw_die_ref unit_die)
8926 const char *die_name = get_AT_string (unit_die, DW_AT_name);
8927 const char *base = die_name ? lbasename (die_name) : "anonymous";
8928 char *name = XALLOCAVEC (char, strlen (base) + 64);
8931 unsigned char checksum[16];
8934 /* Compute the checksum of the DIE, then append part of it as hex digits to
8935 the name filename of the unit. */
8937 md5_init_ctx (&ctx);
8939 die_checksum (unit_die, &ctx, &mark);
8940 unmark_all_dies (unit_die);
8941 md5_finish_ctx (&ctx, checksum);
8943 sprintf (name, "%s.", base);
8944 clean_symbol_name (name);
8946 p = name + strlen (name);
8947 for (i = 0; i < 4; i++)
8949 sprintf (p, "%.2x", checksum[i]);
8953 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
8954 comdat_symbol_number = 0;
8957 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
8960 is_type_die (dw_die_ref die)
8962 switch (die->die_tag)
8964 case DW_TAG_array_type:
8965 case DW_TAG_class_type:
8966 case DW_TAG_interface_type:
8967 case DW_TAG_enumeration_type:
8968 case DW_TAG_pointer_type:
8969 case DW_TAG_reference_type:
8970 case DW_TAG_string_type:
8971 case DW_TAG_structure_type:
8972 case DW_TAG_subroutine_type:
8973 case DW_TAG_union_type:
8974 case DW_TAG_ptr_to_member_type:
8975 case DW_TAG_set_type:
8976 case DW_TAG_subrange_type:
8977 case DW_TAG_base_type:
8978 case DW_TAG_const_type:
8979 case DW_TAG_file_type:
8980 case DW_TAG_packed_type:
8981 case DW_TAG_volatile_type:
8982 case DW_TAG_typedef:
8989 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
8990 Basically, we want to choose the bits that are likely to be shared between
8991 compilations (types) and leave out the bits that are specific to individual
8992 compilations (functions). */
8995 is_comdat_die (dw_die_ref c)
8997 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
8998 we do for stabs. The advantage is a greater likelihood of sharing between
8999 objects that don't include headers in the same order (and therefore would
9000 put the base types in a different comdat). jason 8/28/00 */
9002 if (c->die_tag == DW_TAG_base_type)
9005 if (c->die_tag == DW_TAG_pointer_type
9006 || c->die_tag == DW_TAG_reference_type
9007 || c->die_tag == DW_TAG_const_type
9008 || c->die_tag == DW_TAG_volatile_type)
9010 dw_die_ref t = get_AT_ref (c, DW_AT_type);
9012 return t ? is_comdat_die (t) : 0;
9015 return is_type_die (c);
9018 /* Returns 1 iff C is the sort of DIE that might be referred to from another
9019 compilation unit. */
9022 is_symbol_die (dw_die_ref c)
9024 return (is_type_die (c)
9025 || is_declaration_die (c)
9026 || c->die_tag == DW_TAG_namespace
9027 || c->die_tag == DW_TAG_module);
9031 gen_internal_sym (const char *prefix)
9035 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
9036 return xstrdup (buf);
9039 /* Assign symbols to all worthy DIEs under DIE. */
9042 assign_symbol_names (dw_die_ref die)
9046 if (is_symbol_die (die))
9048 if (comdat_symbol_id)
9050 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
9052 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
9053 comdat_symbol_id, comdat_symbol_number++);
9054 die->die_id.die_symbol = xstrdup (p);
9057 die->die_id.die_symbol = gen_internal_sym ("LDIE");
9060 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
9063 struct cu_hash_table_entry
9066 unsigned min_comdat_num, max_comdat_num;
9067 struct cu_hash_table_entry *next;
9070 /* Routines to manipulate hash table of CUs. */
9072 htab_cu_hash (const void *of)
9074 const struct cu_hash_table_entry *const entry =
9075 (const struct cu_hash_table_entry *) of;
9077 return htab_hash_string (entry->cu->die_id.die_symbol);
9081 htab_cu_eq (const void *of1, const void *of2)
9083 const struct cu_hash_table_entry *const entry1 =
9084 (const struct cu_hash_table_entry *) of1;
9085 const struct die_struct *const entry2 = (const struct die_struct *) of2;
9087 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
9091 htab_cu_del (void *what)
9093 struct cu_hash_table_entry *next,
9094 *entry = (struct cu_hash_table_entry *) what;
9104 /* Check whether we have already seen this CU and set up SYM_NUM
9107 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
9109 struct cu_hash_table_entry dummy;
9110 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
9112 dummy.max_comdat_num = 0;
9114 slot = (struct cu_hash_table_entry **)
9115 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
9119 for (; entry; last = entry, entry = entry->next)
9121 if (same_die_p_wrap (cu, entry->cu))
9127 *sym_num = entry->min_comdat_num;
9131 entry = XCNEW (struct cu_hash_table_entry);
9133 entry->min_comdat_num = *sym_num = last->max_comdat_num;
9134 entry->next = *slot;
9140 /* Record SYM_NUM to record of CU in HTABLE. */
9142 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
9144 struct cu_hash_table_entry **slot, *entry;
9146 slot = (struct cu_hash_table_entry **)
9147 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
9151 entry->max_comdat_num = sym_num;
9154 /* Traverse the DIE (which is always comp_unit_die), and set up
9155 additional compilation units for each of the include files we see
9156 bracketed by BINCL/EINCL. */
9159 break_out_includes (dw_die_ref die)
9162 dw_die_ref unit = NULL;
9163 limbo_die_node *node, **pnode;
9164 htab_t cu_hash_table;
9168 dw_die_ref prev = c;
9170 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
9171 || (unit && is_comdat_die (c)))
9173 dw_die_ref next = c->die_sib;
9175 /* This DIE is for a secondary CU; remove it from the main one. */
9176 remove_child_with_prev (c, prev);
9178 if (c->die_tag == DW_TAG_GNU_BINCL)
9179 unit = push_new_compile_unit (unit, c);
9180 else if (c->die_tag == DW_TAG_GNU_EINCL)
9181 unit = pop_compile_unit (unit);
9183 add_child_die (unit, c);
9185 if (c == die->die_child)
9188 } while (c != die->die_child);
9191 /* We can only use this in debugging, since the frontend doesn't check
9192 to make sure that we leave every include file we enter. */
9196 assign_symbol_names (die);
9197 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
9198 for (node = limbo_die_list, pnode = &limbo_die_list;
9204 compute_section_prefix (node->die);
9205 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
9206 &comdat_symbol_number);
9207 assign_symbol_names (node->die);
9209 *pnode = node->next;
9212 pnode = &node->next;
9213 record_comdat_symbol_number (node->die, cu_hash_table,
9214 comdat_symbol_number);
9217 htab_delete (cu_hash_table);
9220 /* Return non-zero if this DIE is a declaration. */
9223 is_declaration_die (dw_die_ref die)
9228 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9229 if (a->dw_attr == DW_AT_declaration)
9235 /* Return non-zero if this is a type DIE that should be moved to a
9236 COMDAT .debug_types section. */
9239 should_move_die_to_comdat (dw_die_ref die)
9241 switch (die->die_tag)
9243 case DW_TAG_class_type:
9244 case DW_TAG_structure_type:
9245 case DW_TAG_enumeration_type:
9246 case DW_TAG_union_type:
9247 /* Don't move declarations or inlined instances. */
9248 if (is_declaration_die (die) || get_AT (die, DW_AT_abstract_origin))
9251 case DW_TAG_array_type:
9252 case DW_TAG_interface_type:
9253 case DW_TAG_pointer_type:
9254 case DW_TAG_reference_type:
9255 case DW_TAG_string_type:
9256 case DW_TAG_subroutine_type:
9257 case DW_TAG_ptr_to_member_type:
9258 case DW_TAG_set_type:
9259 case DW_TAG_subrange_type:
9260 case DW_TAG_base_type:
9261 case DW_TAG_const_type:
9262 case DW_TAG_file_type:
9263 case DW_TAG_packed_type:
9264 case DW_TAG_volatile_type:
9265 case DW_TAG_typedef:
9271 /* Make a clone of DIE. */
9274 clone_die (dw_die_ref die)
9280 clone = GGC_CNEW (die_node);
9281 clone->die_tag = die->die_tag;
9283 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9284 add_dwarf_attr (clone, a);
9289 /* Make a clone of the tree rooted at DIE. */
9292 clone_tree (dw_die_ref die)
9295 dw_die_ref clone = clone_die (die);
9297 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree(c)));
9302 /* Make a clone of DIE as a declaration. */
9305 clone_as_declaration (dw_die_ref die)
9312 /* If the DIE is already a declaration, just clone it. */
9313 if (is_declaration_die (die))
9314 return clone_die (die);
9316 /* If the DIE is a specification, just clone its declaration DIE. */
9317 decl = get_AT_ref (die, DW_AT_specification);
9319 return clone_die (decl);
9321 clone = GGC_CNEW (die_node);
9322 clone->die_tag = die->die_tag;
9324 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9326 /* We don't want to copy over all attributes.
9327 For example we don't want DW_AT_byte_size because otherwise we will no
9328 longer have a declaration and GDB will treat it as a definition. */
9332 case DW_AT_artificial:
9333 case DW_AT_containing_type:
9334 case DW_AT_external:
9337 case DW_AT_virtuality:
9338 case DW_AT_MIPS_linkage_name:
9339 add_dwarf_attr (clone, a);
9341 case DW_AT_byte_size:
9347 if (die->die_id.die_type_node)
9348 add_AT_die_ref (clone, DW_AT_signature, die);
9350 add_AT_flag (clone, DW_AT_declaration, 1);
9354 /* Copy the declaration context to the new compile unit DIE. This includes
9355 any surrounding namespace or type declarations. If the DIE has an
9356 AT_specification attribute, it also includes attributes and children
9357 attached to the specification. */
9360 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
9363 dw_die_ref new_decl;
9365 decl = get_AT_ref (die, DW_AT_specification);
9374 /* Copy the type node pointer from the new DIE to the original
9375 declaration DIE so we can forward references later. */
9376 decl->die_id.die_type_node = die->die_id.die_type_node;
9378 remove_AT (die, DW_AT_specification);
9380 for (ix = 0; VEC_iterate (dw_attr_node, decl->die_attr, ix, a); ix++)
9382 if (a->dw_attr != DW_AT_name
9383 && a->dw_attr != DW_AT_declaration
9384 && a->dw_attr != DW_AT_external)
9385 add_dwarf_attr (die, a);
9388 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree(c)));
9391 if (decl->die_parent != NULL
9392 && decl->die_parent->die_tag != DW_TAG_compile_unit
9393 && decl->die_parent->die_tag != DW_TAG_type_unit)
9395 new_decl = copy_ancestor_tree (unit, decl, NULL);
9396 if (new_decl != NULL)
9398 remove_AT (new_decl, DW_AT_signature);
9399 add_AT_specification (die, new_decl);
9404 /* Generate the skeleton ancestor tree for the given NODE, then clone
9405 the DIE and add the clone into the tree. */
9408 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
9410 if (node->new_die != NULL)
9413 node->new_die = clone_as_declaration (node->old_die);
9415 if (node->parent != NULL)
9417 generate_skeleton_ancestor_tree (node->parent);
9418 add_child_die (node->parent->new_die, node->new_die);
9422 /* Generate a skeleton tree of DIEs containing any declarations that are
9423 found in the original tree. We traverse the tree looking for declaration
9424 DIEs, and construct the skeleton from the bottom up whenever we find one. */
9427 generate_skeleton_bottom_up (skeleton_chain_node *parent)
9429 skeleton_chain_node node;
9432 dw_die_ref prev = NULL;
9433 dw_die_ref next = NULL;
9435 node.parent = parent;
9437 first = c = parent->old_die->die_child;
9441 if (prev == NULL || prev->die_sib == c)
9444 next = (c == first ? NULL : c->die_sib);
9446 node.new_die = NULL;
9447 if (is_declaration_die (c))
9449 /* Clone the existing DIE, move the original to the skeleton
9450 tree (which is in the main CU), and put the clone, with
9451 all the original's children, where the original came from. */
9452 dw_die_ref clone = clone_die (c);
9453 move_all_children (c, clone);
9455 replace_child (c, clone, prev);
9456 generate_skeleton_ancestor_tree (parent);
9457 add_child_die (parent->new_die, c);
9461 generate_skeleton_bottom_up (&node);
9462 } while (next != NULL);
9465 /* Wrapper function for generate_skeleton_bottom_up. */
9468 generate_skeleton (dw_die_ref die)
9470 skeleton_chain_node node;
9473 node.new_die = NULL;
9476 /* If this type definition is nested inside another type,
9477 always leave at least a declaration in its place. */
9478 if (die->die_parent != NULL && is_type_die (die->die_parent))
9479 node.new_die = clone_as_declaration (die);
9481 generate_skeleton_bottom_up (&node);
9482 return node.new_die;
9485 /* Remove the DIE from its parent, possibly replacing it with a cloned
9486 declaration. The original DIE will be moved to a new compile unit
9487 so that existing references to it follow it to the new location. If
9488 any of the original DIE's descendants is a declaration, we need to
9489 replace the original DIE with a skeleton tree and move the
9490 declarations back into the skeleton tree. */
9493 remove_child_or_replace_with_skeleton (dw_die_ref child, dw_die_ref prev)
9495 dw_die_ref skeleton;
9497 skeleton = generate_skeleton (child);
9498 if (skeleton == NULL)
9499 remove_child_with_prev (child, prev);
9502 skeleton->die_id.die_type_node = child->die_id.die_type_node;
9503 replace_child (child, skeleton, prev);
9509 /* Traverse the DIE and set up additional .debug_types sections for each
9510 type worthy of being placed in a COMDAT section. */
9513 break_out_comdat_types (dw_die_ref die)
9517 dw_die_ref prev = NULL;
9518 dw_die_ref next = NULL;
9519 dw_die_ref unit = NULL;
9521 first = c = die->die_child;
9525 if (prev == NULL || prev->die_sib == c)
9528 next = (c == first ? NULL : c->die_sib);
9529 if (should_move_die_to_comdat (c))
9531 dw_die_ref replacement;
9532 comdat_type_node_ref type_node;
9534 /* Create a new type unit DIE as the root for the new tree, and
9535 add it to the list of comdat types. */
9536 unit = new_die (DW_TAG_type_unit, NULL, NULL);
9537 add_AT_unsigned (unit, DW_AT_language,
9538 get_AT_unsigned (comp_unit_die, DW_AT_language));
9539 type_node = GGC_CNEW (comdat_type_node);
9540 type_node->root_die = unit;
9541 type_node->next = comdat_type_list;
9542 comdat_type_list = type_node;
9544 /* Generate the type signature. */
9545 generate_type_signature (c, type_node);
9547 /* Copy the declaration context, attributes, and children of the
9548 declaration into the new compile unit DIE. */
9549 copy_declaration_context (unit, c);
9551 /* Remove this DIE from the main CU. */
9552 replacement = remove_child_or_replace_with_skeleton (c, prev);
9554 /* Break out nested types into their own type units. */
9555 break_out_comdat_types (c);
9557 /* Add the DIE to the new compunit. */
9558 add_child_die (unit, c);
9560 if (replacement != NULL)
9563 else if (c->die_tag == DW_TAG_namespace
9564 || c->die_tag == DW_TAG_class_type
9565 || c->die_tag == DW_TAG_structure_type
9566 || c->die_tag == DW_TAG_union_type)
9568 /* Look for nested types that can be broken out. */
9569 break_out_comdat_types (c);
9571 } while (next != NULL);
9574 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
9576 struct decl_table_entry
9582 /* Routines to manipulate hash table of copied declarations. */
9585 htab_decl_hash (const void *of)
9587 const struct decl_table_entry *const entry =
9588 (const struct decl_table_entry *) of;
9590 return htab_hash_pointer (entry->orig);
9594 htab_decl_eq (const void *of1, const void *of2)
9596 const struct decl_table_entry *const entry1 =
9597 (const struct decl_table_entry *) of1;
9598 const struct die_struct *const entry2 = (const struct die_struct *) of2;
9600 return entry1->orig == entry2;
9604 htab_decl_del (void *what)
9606 struct decl_table_entry *entry = (struct decl_table_entry *) what;
9611 /* Copy DIE and its ancestors, up to, but not including, the compile unit
9612 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
9613 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
9614 to check if the ancestor has already been copied into UNIT. */
9617 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
9619 dw_die_ref parent = die->die_parent;
9620 dw_die_ref new_parent = unit;
9623 struct decl_table_entry *entry = NULL;
9627 /* Check if the entry has already been copied to UNIT. */
9628 slot = htab_find_slot_with_hash (decl_table, die,
9629 htab_hash_pointer (die), INSERT);
9630 if (*slot != HTAB_EMPTY_ENTRY)
9632 entry = (struct decl_table_entry *) *slot;
9636 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
9637 entry = XCNEW (struct decl_table_entry);
9645 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
9648 if (parent->die_tag != DW_TAG_compile_unit
9649 && parent->die_tag != DW_TAG_type_unit)
9650 new_parent = copy_ancestor_tree (unit, parent, decl_table);
9653 copy = clone_as_declaration (die);
9654 add_child_die (new_parent, copy);
9656 if (decl_table != NULL)
9658 /* Make sure the copy is marked as part of the type unit. */
9660 /* Record the pointer to the copy. */
9667 /* Walk the DIE and its children, looking for references to incomplete
9668 or trivial types that are unmarked (i.e., that are not in the current
9672 copy_decls_walk (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
9678 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9680 if (AT_class (a) == dw_val_class_die_ref)
9682 dw_die_ref targ = AT_ref (a);
9683 comdat_type_node_ref type_node = targ->die_id.die_type_node;
9685 struct decl_table_entry *entry;
9687 if (targ->die_mark != 0 || type_node != NULL)
9690 slot = htab_find_slot_with_hash (decl_table, targ,
9691 htab_hash_pointer (targ), INSERT);
9693 if (*slot != HTAB_EMPTY_ENTRY)
9695 /* TARG has already been copied, so we just need to
9696 modify the reference to point to the copy. */
9697 entry = (struct decl_table_entry *) *slot;
9698 a->dw_attr_val.v.val_die_ref.die = entry->copy;
9702 dw_die_ref parent = unit;
9703 dw_die_ref copy = clone_tree (targ);
9705 /* Make sure the cloned tree is marked as part of the
9709 /* Record in DECL_TABLE that TARG has been copied.
9710 Need to do this now, before the recursive call,
9711 because DECL_TABLE may be expanded and SLOT
9712 would no longer be a valid pointer. */
9713 entry = XCNEW (struct decl_table_entry);
9718 /* If TARG has surrounding context, copy its ancestor tree
9719 into the new type unit. */
9720 if (targ->die_parent != NULL
9721 && targ->die_parent->die_tag != DW_TAG_compile_unit
9722 && targ->die_parent->die_tag != DW_TAG_type_unit)
9723 parent = copy_ancestor_tree (unit, targ->die_parent,
9726 add_child_die (parent, copy);
9727 a->dw_attr_val.v.val_die_ref.die = copy;
9729 /* Make sure the newly-copied DIE is walked. If it was
9730 installed in a previously-added context, it won't
9731 get visited otherwise. */
9733 copy_decls_walk (unit, parent, decl_table);
9738 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
9741 /* Copy declarations for "unworthy" types into the new comdat section.
9742 Incomplete types, modified types, and certain other types aren't broken
9743 out into comdat sections of their own, so they don't have a signature,
9744 and we need to copy the declaration into the same section so that we
9745 don't have an external reference. */
9748 copy_decls_for_unworthy_types (dw_die_ref unit)
9753 decl_table = htab_create (10, htab_decl_hash, htab_decl_eq, htab_decl_del);
9754 copy_decls_walk (unit, unit, decl_table);
9755 htab_delete (decl_table);
9759 /* Traverse the DIE and add a sibling attribute if it may have the
9760 effect of speeding up access to siblings. To save some space,
9761 avoid generating sibling attributes for DIE's without children. */
9764 add_sibling_attributes (dw_die_ref die)
9768 if (! die->die_child)
9771 if (die->die_parent && die != die->die_parent->die_child)
9772 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
9774 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
9777 /* Output all location lists for the DIE and its children. */
9780 output_location_lists (dw_die_ref die)
9786 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9787 if (AT_class (a) == dw_val_class_loc_list)
9788 output_loc_list (AT_loc_list (a));
9790 FOR_EACH_CHILD (die, c, output_location_lists (c));
9793 /* The format of each DIE (and its attribute value pairs) is encoded in an
9794 abbreviation table. This routine builds the abbreviation table and assigns
9795 a unique abbreviation id for each abbreviation entry. The children of each
9796 die are visited recursively. */
9799 build_abbrev_table (dw_die_ref die)
9801 unsigned long abbrev_id;
9802 unsigned int n_alloc;
9807 /* Scan the DIE references, and mark as external any that refer to
9808 DIEs from other CUs (i.e. those which are not marked). */
9809 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9810 if (AT_class (a) == dw_val_class_die_ref
9811 && AT_ref (a)->die_mark == 0)
9813 gcc_assert (dwarf_version >= 4 || AT_ref (a)->die_id.die_symbol);
9814 set_AT_ref_external (a, 1);
9817 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
9819 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
9820 dw_attr_ref die_a, abbrev_a;
9824 if (abbrev->die_tag != die->die_tag)
9826 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
9829 if (VEC_length (dw_attr_node, abbrev->die_attr)
9830 != VEC_length (dw_attr_node, die->die_attr))
9833 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
9835 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
9836 if ((abbrev_a->dw_attr != die_a->dw_attr)
9837 || (value_format (abbrev_a) != value_format (die_a)))
9847 if (abbrev_id >= abbrev_die_table_in_use)
9849 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
9851 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
9852 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
9855 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
9856 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
9857 abbrev_die_table_allocated = n_alloc;
9860 ++abbrev_die_table_in_use;
9861 abbrev_die_table[abbrev_id] = die;
9864 die->die_abbrev = abbrev_id;
9865 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
9868 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9871 constant_size (unsigned HOST_WIDE_INT value)
9878 log = floor_log2 (value);
9881 log = 1 << (floor_log2 (log) + 1);
9886 /* Return the size of a DIE as it is represented in the
9887 .debug_info section. */
9889 static unsigned long
9890 size_of_die (dw_die_ref die)
9892 unsigned long size = 0;
9896 size += size_of_uleb128 (die->die_abbrev);
9897 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9899 switch (AT_class (a))
9901 case dw_val_class_addr:
9902 size += DWARF2_ADDR_SIZE;
9904 case dw_val_class_offset:
9905 size += DWARF_OFFSET_SIZE;
9907 case dw_val_class_loc:
9909 unsigned long lsize = size_of_locs (AT_loc (a));
9912 size += constant_size (lsize);
9916 case dw_val_class_loc_list:
9917 size += DWARF_OFFSET_SIZE;
9919 case dw_val_class_range_list:
9920 size += DWARF_OFFSET_SIZE;
9922 case dw_val_class_const:
9923 size += size_of_sleb128 (AT_int (a));
9925 case dw_val_class_unsigned_const:
9926 size += constant_size (AT_unsigned (a));
9928 case dw_val_class_const_double:
9929 size += 2 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
9930 if (HOST_BITS_PER_WIDE_INT >= 64)
9933 case dw_val_class_vec:
9934 size += constant_size (a->dw_attr_val.v.val_vec.length
9935 * a->dw_attr_val.v.val_vec.elt_size)
9936 + a->dw_attr_val.v.val_vec.length
9937 * a->dw_attr_val.v.val_vec.elt_size; /* block */
9939 case dw_val_class_flag:
9942 case dw_val_class_die_ref:
9943 if (AT_ref_external (a))
9945 /* In DWARF4, we use DW_FORM_sig8; for earlier versions
9946 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9947 is sized by target address length, whereas in DWARF3
9948 it's always sized as an offset. */
9949 if (dwarf_version >= 4)
9950 size += DWARF_TYPE_SIGNATURE_SIZE;
9951 else if (dwarf_version == 2)
9952 size += DWARF2_ADDR_SIZE;
9954 size += DWARF_OFFSET_SIZE;
9957 size += DWARF_OFFSET_SIZE;
9959 case dw_val_class_fde_ref:
9960 size += DWARF_OFFSET_SIZE;
9962 case dw_val_class_lbl_id:
9963 size += DWARF2_ADDR_SIZE;
9965 case dw_val_class_lineptr:
9966 case dw_val_class_macptr:
9967 size += DWARF_OFFSET_SIZE;
9969 case dw_val_class_str:
9970 if (AT_string_form (a) == DW_FORM_strp)
9971 size += DWARF_OFFSET_SIZE;
9973 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
9975 case dw_val_class_file:
9976 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
9978 case dw_val_class_data8:
9989 /* Size the debugging information associated with a given DIE. Visits the
9990 DIE's children recursively. Updates the global variable next_die_offset, on
9991 each time through. Uses the current value of next_die_offset to update the
9992 die_offset field in each DIE. */
9995 calc_die_sizes (dw_die_ref die)
9999 die->die_offset = next_die_offset;
10000 next_die_offset += size_of_die (die);
10002 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
10004 if (die->die_child != NULL)
10005 /* Count the null byte used to terminate sibling lists. */
10006 next_die_offset += 1;
10009 /* Set the marks for a die and its children. We do this so
10010 that we know whether or not a reference needs to use FORM_ref_addr; only
10011 DIEs in the same CU will be marked. We used to clear out the offset
10012 and use that as the flag, but ran into ordering problems. */
10015 mark_dies (dw_die_ref die)
10019 gcc_assert (!die->die_mark);
10022 FOR_EACH_CHILD (die, c, mark_dies (c));
10025 /* Clear the marks for a die and its children. */
10028 unmark_dies (dw_die_ref die)
10032 if (dwarf_version < 4)
10033 gcc_assert (die->die_mark);
10036 FOR_EACH_CHILD (die, c, unmark_dies (c));
10039 /* Clear the marks for a die, its children and referred dies. */
10042 unmark_all_dies (dw_die_ref die)
10048 if (!die->die_mark)
10052 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
10054 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10055 if (AT_class (a) == dw_val_class_die_ref)
10056 unmark_all_dies (AT_ref (a));
10059 /* Return the size of the .debug_pubnames or .debug_pubtypes table
10060 generated for the compilation unit. */
10062 static unsigned long
10063 size_of_pubnames (VEC (pubname_entry, gc) * names)
10065 unsigned long size;
10069 size = DWARF_PUBNAMES_HEADER_SIZE;
10070 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
10071 if (names != pubtype_table
10072 || p->die->die_offset != 0
10073 || !flag_eliminate_unused_debug_types)
10074 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
10076 size += DWARF_OFFSET_SIZE;
10080 /* Return the size of the information in the .debug_aranges section. */
10082 static unsigned long
10083 size_of_aranges (void)
10085 unsigned long size;
10087 size = DWARF_ARANGES_HEADER_SIZE;
10089 /* Count the address/length pair for this compilation unit. */
10090 if (text_section_used)
10091 size += 2 * DWARF2_ADDR_SIZE;
10092 if (cold_text_section_used)
10093 size += 2 * DWARF2_ADDR_SIZE;
10094 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
10096 /* Count the two zero words used to terminated the address range table. */
10097 size += 2 * DWARF2_ADDR_SIZE;
10101 /* Select the encoding of an attribute value. */
10103 static enum dwarf_form
10104 value_format (dw_attr_ref a)
10106 switch (a->dw_attr_val.val_class)
10108 case dw_val_class_addr:
10109 /* Only very few attributes allow DW_FORM_addr. */
10110 switch (a->dw_attr)
10113 case DW_AT_high_pc:
10114 case DW_AT_entry_pc:
10115 case DW_AT_trampoline:
10116 return DW_FORM_addr;
10120 switch (DWARF2_ADDR_SIZE)
10123 return DW_FORM_data1;
10125 return DW_FORM_data2;
10127 return DW_FORM_data4;
10129 return DW_FORM_data8;
10131 gcc_unreachable ();
10133 case dw_val_class_range_list:
10134 case dw_val_class_offset:
10135 case dw_val_class_loc_list:
10136 switch (DWARF_OFFSET_SIZE)
10139 return DW_FORM_data4;
10141 return DW_FORM_data8;
10143 gcc_unreachable ();
10145 case dw_val_class_loc:
10146 switch (constant_size (size_of_locs (AT_loc (a))))
10149 return DW_FORM_block1;
10151 return DW_FORM_block2;
10153 gcc_unreachable ();
10155 case dw_val_class_const:
10156 return DW_FORM_sdata;
10157 case dw_val_class_unsigned_const:
10158 switch (constant_size (AT_unsigned (a)))
10161 return DW_FORM_data1;
10163 return DW_FORM_data2;
10165 return DW_FORM_data4;
10167 return DW_FORM_data8;
10169 gcc_unreachable ();
10171 case dw_val_class_const_double:
10172 switch (HOST_BITS_PER_WIDE_INT)
10175 return DW_FORM_data2;
10177 return DW_FORM_data4;
10179 return DW_FORM_data8;
10182 return DW_FORM_block1;
10184 case dw_val_class_vec:
10185 switch (constant_size (a->dw_attr_val.v.val_vec.length
10186 * a->dw_attr_val.v.val_vec.elt_size))
10189 return DW_FORM_block1;
10191 return DW_FORM_block2;
10193 return DW_FORM_block4;
10195 gcc_unreachable ();
10197 case dw_val_class_flag:
10198 return DW_FORM_flag;
10199 case dw_val_class_die_ref:
10200 if (AT_ref_external (a))
10201 return dwarf_version >= 4 ? DW_FORM_sig8 : DW_FORM_ref_addr;
10203 return DW_FORM_ref;
10204 case dw_val_class_fde_ref:
10205 return DW_FORM_data;
10206 case dw_val_class_lbl_id:
10207 return DW_FORM_addr;
10208 case dw_val_class_lineptr:
10209 case dw_val_class_macptr:
10210 return DW_FORM_data;
10211 case dw_val_class_str:
10212 return AT_string_form (a);
10213 case dw_val_class_file:
10214 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
10217 return DW_FORM_data1;
10219 return DW_FORM_data2;
10221 return DW_FORM_data4;
10223 gcc_unreachable ();
10226 case dw_val_class_data8:
10227 return DW_FORM_data8;
10230 gcc_unreachable ();
10234 /* Output the encoding of an attribute value. */
10237 output_value_format (dw_attr_ref a)
10239 enum dwarf_form form = value_format (a);
10241 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
10244 /* Output the .debug_abbrev section which defines the DIE abbreviation
10248 output_abbrev_section (void)
10250 unsigned long abbrev_id;
10252 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
10254 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
10256 dw_attr_ref a_attr;
10258 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
10259 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
10260 dwarf_tag_name (abbrev->die_tag));
10262 if (abbrev->die_child != NULL)
10263 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
10265 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
10267 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
10270 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
10271 dwarf_attr_name (a_attr->dw_attr));
10272 output_value_format (a_attr);
10275 dw2_asm_output_data (1, 0, NULL);
10276 dw2_asm_output_data (1, 0, NULL);
10279 /* Terminate the table. */
10280 dw2_asm_output_data (1, 0, NULL);
10283 /* Output a symbol we can use to refer to this DIE from another CU. */
10286 output_die_symbol (dw_die_ref die)
10288 char *sym = die->die_id.die_symbol;
10293 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
10294 /* We make these global, not weak; if the target doesn't support
10295 .linkonce, it doesn't support combining the sections, so debugging
10297 targetm.asm_out.globalize_label (asm_out_file, sym);
10299 ASM_OUTPUT_LABEL (asm_out_file, sym);
10302 /* Return a new location list, given the begin and end range, and the
10305 static inline dw_loc_list_ref
10306 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
10307 const char *section)
10309 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
10311 retlist->begin = begin;
10312 retlist->end = end;
10313 retlist->expr = expr;
10314 retlist->section = section;
10319 /* Generate a new internal symbol for this location list node, if it
10320 hasn't got one yet. */
10323 gen_llsym (dw_loc_list_ref list)
10325 gcc_assert (!list->ll_symbol);
10326 list->ll_symbol = gen_internal_sym ("LLST");
10329 /* Output the location list given to us. */
10332 output_loc_list (dw_loc_list_ref list_head)
10334 dw_loc_list_ref curr = list_head;
10336 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
10338 /* Walk the location list, and output each range + expression. */
10339 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
10341 unsigned long size;
10342 /* Don't output an entry that starts and ends at the same address. */
10343 if (strcmp (curr->begin, curr->end) == 0)
10345 if (!have_multiple_function_sections)
10347 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
10348 "Location list begin address (%s)",
10349 list_head->ll_symbol);
10350 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
10351 "Location list end address (%s)",
10352 list_head->ll_symbol);
10356 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
10357 "Location list begin address (%s)",
10358 list_head->ll_symbol);
10359 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
10360 "Location list end address (%s)",
10361 list_head->ll_symbol);
10363 size = size_of_locs (curr->expr);
10365 /* Output the block length for this list of location operations. */
10366 gcc_assert (size <= 0xffff);
10367 dw2_asm_output_data (2, size, "%s", "Location expression size");
10369 output_loc_sequence (curr->expr);
10372 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10373 "Location list terminator begin (%s)",
10374 list_head->ll_symbol);
10375 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10376 "Location list terminator end (%s)",
10377 list_head->ll_symbol);
10380 /* Output a type signature. */
10383 output_signature (const char *sig, const char *name)
10387 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
10388 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
10391 /* Output the DIE and its attributes. Called recursively to generate
10392 the definitions of each child DIE. */
10395 output_die (dw_die_ref die)
10399 unsigned long size;
10402 /* If someone in another CU might refer to us, set up a symbol for
10403 them to point to. */
10404 if (dwarf_version < 4 && die->die_id.die_symbol)
10405 output_die_symbol (die);
10407 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
10408 (unsigned long)die->die_offset,
10409 dwarf_tag_name (die->die_tag));
10411 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10413 const char *name = dwarf_attr_name (a->dw_attr);
10415 switch (AT_class (a))
10417 case dw_val_class_addr:
10418 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
10421 case dw_val_class_offset:
10422 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
10426 case dw_val_class_range_list:
10428 char *p = strchr (ranges_section_label, '\0');
10430 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
10431 a->dw_attr_val.v.val_offset);
10432 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
10433 debug_ranges_section, "%s", name);
10438 case dw_val_class_loc:
10439 size = size_of_locs (AT_loc (a));
10441 /* Output the block length for this list of location operations. */
10442 dw2_asm_output_data (constant_size (size), size, "%s", name);
10444 output_loc_sequence (AT_loc (a));
10447 case dw_val_class_const:
10448 /* ??? It would be slightly more efficient to use a scheme like is
10449 used for unsigned constants below, but gdb 4.x does not sign
10450 extend. Gdb 5.x does sign extend. */
10451 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
10454 case dw_val_class_unsigned_const:
10455 dw2_asm_output_data (constant_size (AT_unsigned (a)),
10456 AT_unsigned (a), "%s", name);
10459 case dw_val_class_const_double:
10461 unsigned HOST_WIDE_INT first, second;
10463 if (HOST_BITS_PER_WIDE_INT >= 64)
10464 dw2_asm_output_data (1,
10465 2 * HOST_BITS_PER_WIDE_INT
10466 / HOST_BITS_PER_CHAR,
10469 if (WORDS_BIG_ENDIAN)
10471 first = a->dw_attr_val.v.val_double.high;
10472 second = a->dw_attr_val.v.val_double.low;
10476 first = a->dw_attr_val.v.val_double.low;
10477 second = a->dw_attr_val.v.val_double.high;
10480 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
10482 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
10487 case dw_val_class_vec:
10489 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
10490 unsigned int len = a->dw_attr_val.v.val_vec.length;
10494 dw2_asm_output_data (constant_size (len * elt_size),
10495 len * elt_size, "%s", name);
10496 if (elt_size > sizeof (HOST_WIDE_INT))
10501 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
10503 i++, p += elt_size)
10504 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
10505 "fp or vector constant word %u", i);
10509 case dw_val_class_flag:
10510 dw2_asm_output_data (1, AT_flag (a), "%s", name);
10513 case dw_val_class_loc_list:
10515 char *sym = AT_loc_list (a)->ll_symbol;
10518 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
10523 case dw_val_class_die_ref:
10524 if (AT_ref_external (a))
10526 if (dwarf_version >= 4)
10528 comdat_type_node_ref type_node =
10529 AT_ref (a)->die_id.die_type_node;
10531 gcc_assert (type_node);
10532 output_signature (type_node->signature, name);
10536 char *sym = AT_ref (a)->die_id.die_symbol;
10540 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10541 length, whereas in DWARF3 it's always sized as an
10543 if (dwarf_version == 2)
10544 size = DWARF2_ADDR_SIZE;
10546 size = DWARF_OFFSET_SIZE;
10547 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
10553 gcc_assert (AT_ref (a)->die_offset);
10554 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
10559 case dw_val_class_fde_ref:
10563 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
10564 a->dw_attr_val.v.val_fde_index * 2);
10565 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
10570 case dw_val_class_lbl_id:
10571 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
10574 case dw_val_class_lineptr:
10575 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
10576 debug_line_section, "%s", name);
10579 case dw_val_class_macptr:
10580 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
10581 debug_macinfo_section, "%s", name);
10584 case dw_val_class_str:
10585 if (AT_string_form (a) == DW_FORM_strp)
10586 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
10587 a->dw_attr_val.v.val_str->label,
10589 "%s: \"%s\"", name, AT_string (a));
10591 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
10594 case dw_val_class_file:
10596 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
10598 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
10599 a->dw_attr_val.v.val_file->filename);
10603 case dw_val_class_data8:
10607 for (i = 0; i < 8; i++)
10608 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
10609 i == 0 ? "%s" : NULL, name);
10614 gcc_unreachable ();
10618 FOR_EACH_CHILD (die, c, output_die (c));
10620 /* Add null byte to terminate sibling list. */
10621 if (die->die_child != NULL)
10622 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
10623 (unsigned long) die->die_offset);
10626 /* Output the compilation unit that appears at the beginning of the
10627 .debug_info section, and precedes the DIE descriptions. */
10630 output_compilation_unit_header (void)
10632 int ver = dwarf_version;
10634 /* Don't mark the output as DWARF-4 until we make full use of the
10635 version 4 extensions, and gdb supports them. For now, -gdwarf-4
10636 selects only a few extensions from the DWARF-4 spec. */
10639 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
10640 dw2_asm_output_data (4, 0xffffffff,
10641 "Initial length escape value indicating 64-bit DWARF extension");
10642 dw2_asm_output_data (DWARF_OFFSET_SIZE,
10643 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
10644 "Length of Compilation Unit Info");
10645 dw2_asm_output_data (2, ver, "DWARF version number");
10646 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
10647 debug_abbrev_section,
10648 "Offset Into Abbrev. Section");
10649 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
10652 /* Output the compilation unit DIE and its children. */
10655 output_comp_unit (dw_die_ref die, int output_if_empty)
10657 const char *secname;
10658 char *oldsym, *tmp;
10660 /* Unless we are outputting main CU, we may throw away empty ones. */
10661 if (!output_if_empty && die->die_child == NULL)
10664 /* Even if there are no children of this DIE, we must output the information
10665 about the compilation unit. Otherwise, on an empty translation unit, we
10666 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
10667 will then complain when examining the file. First mark all the DIEs in
10668 this CU so we know which get local refs. */
10671 build_abbrev_table (die);
10673 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10674 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10675 calc_die_sizes (die);
10677 oldsym = die->die_id.die_symbol;
10680 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
10682 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
10684 die->die_id.die_symbol = NULL;
10685 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
10688 switch_to_section (debug_info_section);
10690 /* Output debugging information. */
10691 output_compilation_unit_header ();
10694 /* Leave the marks on the main CU, so we can check them in
10695 output_pubnames. */
10699 die->die_id.die_symbol = oldsym;
10703 /* Output a comdat type unit DIE and its children. */
10706 output_comdat_type_unit (comdat_type_node *node)
10708 const char *secname;
10711 #if defined (OBJECT_FORMAT_ELF)
10715 /* First mark all the DIEs in this CU so we know which get local refs. */
10716 mark_dies (node->root_die);
10718 build_abbrev_table (node->root_die);
10720 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10721 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
10722 calc_die_sizes (node->root_die);
10724 #if defined (OBJECT_FORMAT_ELF)
10725 secname = ".debug_types";
10726 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
10727 sprintf (tmp, "wt.");
10728 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
10729 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
10730 comdat_key = get_identifier (tmp);
10731 targetm.asm_out.named_section (secname,
10732 SECTION_DEBUG | SECTION_LINKONCE,
10735 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
10736 sprintf (tmp, ".gnu.linkonce.wt.");
10737 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
10738 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
10740 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
10743 /* Output debugging information. */
10744 output_compilation_unit_header ();
10745 output_signature (node->signature, "Type Signature");
10746 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
10747 "Offset to Type DIE");
10748 output_die (node->root_die);
10750 unmark_dies (node->root_die);
10753 /* Return the DWARF2/3 pubname associated with a decl. */
10755 static const char *
10756 dwarf2_name (tree decl, int scope)
10758 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
10761 /* Add a new entry to .debug_pubnames if appropriate. */
10764 add_pubname_string (const char *str, dw_die_ref die)
10769 e.name = xstrdup (str);
10770 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
10774 add_pubname (tree decl, dw_die_ref die)
10776 if (TREE_PUBLIC (decl))
10778 const char *name = dwarf2_name (decl, 1);
10780 add_pubname_string (name, die);
10784 /* Add a new entry to .debug_pubtypes if appropriate. */
10787 add_pubtype (tree decl, dw_die_ref die)
10792 if ((TREE_PUBLIC (decl)
10793 || die->die_parent == comp_unit_die)
10794 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
10799 if (TYPE_NAME (decl))
10801 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
10802 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
10803 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
10804 && DECL_NAME (TYPE_NAME (decl)))
10805 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
10807 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
10812 e.name = dwarf2_name (decl, 1);
10814 e.name = xstrdup (e.name);
10817 /* If we don't have a name for the type, there's no point in adding
10818 it to the table. */
10819 if (e.name && e.name[0] != '\0')
10820 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
10824 /* Output the public names table used to speed up access to externally
10825 visible names; or the public types table used to find type definitions. */
10828 output_pubnames (VEC (pubname_entry, gc) * names)
10831 unsigned long pubnames_length = size_of_pubnames (names);
10834 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
10835 dw2_asm_output_data (4, 0xffffffff,
10836 "Initial length escape value indicating 64-bit DWARF extension");
10837 if (names == pubname_table)
10838 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
10839 "Length of Public Names Info");
10841 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
10842 "Length of Public Type Names Info");
10843 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
10844 dw2_asm_output_data (2, 2, "DWARF Version");
10845 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
10846 debug_info_section,
10847 "Offset of Compilation Unit Info");
10848 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
10849 "Compilation Unit Length");
10851 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
10853 /* We shouldn't see pubnames for DIEs outside of the main CU. */
10854 if (names == pubname_table)
10855 gcc_assert (pub->die->die_mark);
10857 if (names != pubtype_table
10858 || pub->die->die_offset != 0
10859 || !flag_eliminate_unused_debug_types)
10861 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
10864 dw2_asm_output_nstring (pub->name, -1, "external name");
10868 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
10871 /* Add a new entry to .debug_aranges if appropriate. */
10874 add_arange (tree decl, dw_die_ref die)
10876 if (! DECL_SECTION_NAME (decl))
10879 if (arange_table_in_use == arange_table_allocated)
10881 arange_table_allocated += ARANGE_TABLE_INCREMENT;
10882 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
10883 arange_table_allocated);
10884 memset (arange_table + arange_table_in_use, 0,
10885 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
10888 arange_table[arange_table_in_use++] = die;
10891 /* Output the information that goes into the .debug_aranges table.
10892 Namely, define the beginning and ending address range of the
10893 text section generated for this compilation unit. */
10896 output_aranges (void)
10899 unsigned long aranges_length = size_of_aranges ();
10901 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
10902 dw2_asm_output_data (4, 0xffffffff,
10903 "Initial length escape value indicating 64-bit DWARF extension");
10904 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
10905 "Length of Address Ranges Info");
10906 /* Version number for aranges is still 2, even in DWARF3. */
10907 dw2_asm_output_data (2, 2, "DWARF Version");
10908 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
10909 debug_info_section,
10910 "Offset of Compilation Unit Info");
10911 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
10912 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
10914 /* We need to align to twice the pointer size here. */
10915 if (DWARF_ARANGES_PAD_SIZE)
10917 /* Pad using a 2 byte words so that padding is correct for any
10919 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
10920 2 * DWARF2_ADDR_SIZE);
10921 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
10922 dw2_asm_output_data (2, 0, NULL);
10925 /* It is necessary not to output these entries if the sections were
10926 not used; if the sections were not used, the length will be 0 and
10927 the address may end up as 0 if the section is discarded by ld
10928 --gc-sections, leaving an invalid (0, 0) entry that can be
10929 confused with the terminator. */
10930 if (text_section_used)
10932 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
10933 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
10934 text_section_label, "Length");
10936 if (cold_text_section_used)
10938 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
10940 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
10941 cold_text_section_label, "Length");
10944 for (i = 0; i < arange_table_in_use; i++)
10946 dw_die_ref die = arange_table[i];
10948 /* We shouldn't see aranges for DIEs outside of the main CU. */
10949 gcc_assert (die->die_mark);
10951 if (die->die_tag == DW_TAG_subprogram)
10953 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
10955 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
10956 get_AT_low_pc (die), "Length");
10960 /* A static variable; extract the symbol from DW_AT_location.
10961 Note that this code isn't currently hit, as we only emit
10962 aranges for functions (jason 9/23/99). */
10963 dw_attr_ref a = get_AT (die, DW_AT_location);
10964 dw_loc_descr_ref loc;
10966 gcc_assert (a && AT_class (a) == dw_val_class_loc);
10969 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
10971 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
10972 loc->dw_loc_oprnd1.v.val_addr, "Address");
10973 dw2_asm_output_data (DWARF2_ADDR_SIZE,
10974 get_AT_unsigned (die, DW_AT_byte_size),
10979 /* Output the terminator words. */
10980 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
10981 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
10984 /* Add a new entry to .debug_ranges. Return the offset at which it
10987 static unsigned int
10988 add_ranges_num (int num)
10990 unsigned int in_use = ranges_table_in_use;
10992 if (in_use == ranges_table_allocated)
10994 ranges_table_allocated += RANGES_TABLE_INCREMENT;
10995 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
10996 ranges_table_allocated);
10997 memset (ranges_table + ranges_table_in_use, 0,
10998 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
11001 ranges_table[in_use].num = num;
11002 ranges_table_in_use = in_use + 1;
11004 return in_use * 2 * DWARF2_ADDR_SIZE;
11007 /* Add a new entry to .debug_ranges corresponding to a block, or a
11008 range terminator if BLOCK is NULL. */
11010 static unsigned int
11011 add_ranges (const_tree block)
11013 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
11016 /* Add a new entry to .debug_ranges corresponding to a pair of
11020 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
11023 unsigned int in_use = ranges_by_label_in_use;
11024 unsigned int offset;
11026 if (in_use == ranges_by_label_allocated)
11028 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
11029 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
11031 ranges_by_label_allocated);
11032 memset (ranges_by_label + ranges_by_label_in_use, 0,
11033 RANGES_TABLE_INCREMENT
11034 * sizeof (struct dw_ranges_by_label_struct));
11037 ranges_by_label[in_use].begin = begin;
11038 ranges_by_label[in_use].end = end;
11039 ranges_by_label_in_use = in_use + 1;
11041 offset = add_ranges_num (-(int)in_use - 1);
11044 add_AT_range_list (die, DW_AT_ranges, offset);
11050 output_ranges (void)
11053 static const char *const start_fmt = "Offset 0x%x";
11054 const char *fmt = start_fmt;
11056 for (i = 0; i < ranges_table_in_use; i++)
11058 int block_num = ranges_table[i].num;
11062 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
11063 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
11065 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
11066 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
11068 /* If all code is in the text section, then the compilation
11069 unit base address defaults to DW_AT_low_pc, which is the
11070 base of the text section. */
11071 if (!have_multiple_function_sections)
11073 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
11074 text_section_label,
11075 fmt, i * 2 * DWARF2_ADDR_SIZE);
11076 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
11077 text_section_label, NULL);
11080 /* Otherwise, the compilation unit base address is zero,
11081 which allows us to use absolute addresses, and not worry
11082 about whether the target supports cross-section
11086 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11087 fmt, i * 2 * DWARF2_ADDR_SIZE);
11088 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
11094 /* Negative block_num stands for an index into ranges_by_label. */
11095 else if (block_num < 0)
11097 int lab_idx = - block_num - 1;
11099 if (!have_multiple_function_sections)
11101 gcc_unreachable ();
11103 /* If we ever use add_ranges_by_labels () for a single
11104 function section, all we have to do is to take out
11105 the #if 0 above. */
11106 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11107 ranges_by_label[lab_idx].begin,
11108 text_section_label,
11109 fmt, i * 2 * DWARF2_ADDR_SIZE);
11110 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11111 ranges_by_label[lab_idx].end,
11112 text_section_label, NULL);
11117 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11118 ranges_by_label[lab_idx].begin,
11119 fmt, i * 2 * DWARF2_ADDR_SIZE);
11120 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11121 ranges_by_label[lab_idx].end,
11127 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11128 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11134 /* Data structure containing information about input files. */
11137 const char *path; /* Complete file name. */
11138 const char *fname; /* File name part. */
11139 int length; /* Length of entire string. */
11140 struct dwarf_file_data * file_idx; /* Index in input file table. */
11141 int dir_idx; /* Index in directory table. */
11144 /* Data structure containing information about directories with source
11148 const char *path; /* Path including directory name. */
11149 int length; /* Path length. */
11150 int prefix; /* Index of directory entry which is a prefix. */
11151 int count; /* Number of files in this directory. */
11152 int dir_idx; /* Index of directory used as base. */
11155 /* Callback function for file_info comparison. We sort by looking at
11156 the directories in the path. */
11159 file_info_cmp (const void *p1, const void *p2)
11161 const struct file_info *const s1 = (const struct file_info *) p1;
11162 const struct file_info *const s2 = (const struct file_info *) p2;
11163 const unsigned char *cp1;
11164 const unsigned char *cp2;
11166 /* Take care of file names without directories. We need to make sure that
11167 we return consistent values to qsort since some will get confused if
11168 we return the same value when identical operands are passed in opposite
11169 orders. So if neither has a directory, return 0 and otherwise return
11170 1 or -1 depending on which one has the directory. */
11171 if ((s1->path == s1->fname || s2->path == s2->fname))
11172 return (s2->path == s2->fname) - (s1->path == s1->fname);
11174 cp1 = (const unsigned char *) s1->path;
11175 cp2 = (const unsigned char *) s2->path;
11181 /* Reached the end of the first path? If so, handle like above. */
11182 if ((cp1 == (const unsigned char *) s1->fname)
11183 || (cp2 == (const unsigned char *) s2->fname))
11184 return ((cp2 == (const unsigned char *) s2->fname)
11185 - (cp1 == (const unsigned char *) s1->fname));
11187 /* Character of current path component the same? */
11188 else if (*cp1 != *cp2)
11189 return *cp1 - *cp2;
11193 struct file_name_acquire_data
11195 struct file_info *files;
11200 /* Traversal function for the hash table. */
11203 file_name_acquire (void ** slot, void *data)
11205 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
11206 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
11207 struct file_info *fi;
11210 gcc_assert (fnad->max_files >= d->emitted_number);
11212 if (! d->emitted_number)
11215 gcc_assert (fnad->max_files != fnad->used_files);
11217 fi = fnad->files + fnad->used_files++;
11219 /* Skip all leading "./". */
11221 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
11224 /* Create a new array entry. */
11226 fi->length = strlen (f);
11229 /* Search for the file name part. */
11230 f = strrchr (f, DIR_SEPARATOR);
11231 #if defined (DIR_SEPARATOR_2)
11233 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
11237 if (f == NULL || f < g)
11243 fi->fname = f == NULL ? fi->path : f + 1;
11247 /* Output the directory table and the file name table. We try to minimize
11248 the total amount of memory needed. A heuristic is used to avoid large
11249 slowdowns with many input files. */
11252 output_file_names (void)
11254 struct file_name_acquire_data fnad;
11256 struct file_info *files;
11257 struct dir_info *dirs;
11265 if (!last_emitted_file)
11267 dw2_asm_output_data (1, 0, "End directory table");
11268 dw2_asm_output_data (1, 0, "End file name table");
11272 numfiles = last_emitted_file->emitted_number;
11274 /* Allocate the various arrays we need. */
11275 files = XALLOCAVEC (struct file_info, numfiles);
11276 dirs = XALLOCAVEC (struct dir_info, numfiles);
11278 fnad.files = files;
11279 fnad.used_files = 0;
11280 fnad.max_files = numfiles;
11281 htab_traverse (file_table, file_name_acquire, &fnad);
11282 gcc_assert (fnad.used_files == fnad.max_files);
11284 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
11286 /* Find all the different directories used. */
11287 dirs[0].path = files[0].path;
11288 dirs[0].length = files[0].fname - files[0].path;
11289 dirs[0].prefix = -1;
11291 dirs[0].dir_idx = 0;
11292 files[0].dir_idx = 0;
11295 for (i = 1; i < numfiles; i++)
11296 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
11297 && memcmp (dirs[ndirs - 1].path, files[i].path,
11298 dirs[ndirs - 1].length) == 0)
11300 /* Same directory as last entry. */
11301 files[i].dir_idx = ndirs - 1;
11302 ++dirs[ndirs - 1].count;
11308 /* This is a new directory. */
11309 dirs[ndirs].path = files[i].path;
11310 dirs[ndirs].length = files[i].fname - files[i].path;
11311 dirs[ndirs].count = 1;
11312 dirs[ndirs].dir_idx = ndirs;
11313 files[i].dir_idx = ndirs;
11315 /* Search for a prefix. */
11316 dirs[ndirs].prefix = -1;
11317 for (j = 0; j < ndirs; j++)
11318 if (dirs[j].length < dirs[ndirs].length
11319 && dirs[j].length > 1
11320 && (dirs[ndirs].prefix == -1
11321 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
11322 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
11323 dirs[ndirs].prefix = j;
11328 /* Now to the actual work. We have to find a subset of the directories which
11329 allow expressing the file name using references to the directory table
11330 with the least amount of characters. We do not do an exhaustive search
11331 where we would have to check out every combination of every single
11332 possible prefix. Instead we use a heuristic which provides nearly optimal
11333 results in most cases and never is much off. */
11334 saved = XALLOCAVEC (int, ndirs);
11335 savehere = XALLOCAVEC (int, ndirs);
11337 memset (saved, '\0', ndirs * sizeof (saved[0]));
11338 for (i = 0; i < ndirs; i++)
11343 /* We can always save some space for the current directory. But this
11344 does not mean it will be enough to justify adding the directory. */
11345 savehere[i] = dirs[i].length;
11346 total = (savehere[i] - saved[i]) * dirs[i].count;
11348 for (j = i + 1; j < ndirs; j++)
11351 if (saved[j] < dirs[i].length)
11353 /* Determine whether the dirs[i] path is a prefix of the
11357 k = dirs[j].prefix;
11358 while (k != -1 && k != (int) i)
11359 k = dirs[k].prefix;
11363 /* Yes it is. We can possibly save some memory by
11364 writing the filenames in dirs[j] relative to
11366 savehere[j] = dirs[i].length;
11367 total += (savehere[j] - saved[j]) * dirs[j].count;
11372 /* Check whether we can save enough to justify adding the dirs[i]
11374 if (total > dirs[i].length + 1)
11376 /* It's worthwhile adding. */
11377 for (j = i; j < ndirs; j++)
11378 if (savehere[j] > 0)
11380 /* Remember how much we saved for this directory so far. */
11381 saved[j] = savehere[j];
11383 /* Remember the prefix directory. */
11384 dirs[j].dir_idx = i;
11389 /* Emit the directory name table. */
11390 idx_offset = dirs[0].length > 0 ? 1 : 0;
11391 for (i = 1 - idx_offset; i < ndirs; i++)
11392 dw2_asm_output_nstring (dirs[i].path,
11394 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
11395 "Directory Entry: 0x%x", i + idx_offset);
11397 dw2_asm_output_data (1, 0, "End directory table");
11399 /* We have to emit them in the order of emitted_number since that's
11400 used in the debug info generation. To do this efficiently we
11401 generate a back-mapping of the indices first. */
11402 backmap = XALLOCAVEC (int, numfiles);
11403 for (i = 0; i < numfiles; i++)
11404 backmap[files[i].file_idx->emitted_number - 1] = i;
11406 /* Now write all the file names. */
11407 for (i = 0; i < numfiles; i++)
11409 int file_idx = backmap[i];
11410 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
11412 #ifdef VMS_DEBUGGING_INFO
11413 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
11415 /* Setting these fields can lead to debugger miscomparisons,
11416 but VMS Debug requires them to be set correctly. */
11421 int maxfilelen = strlen (files[file_idx].path)
11422 + dirs[dir_idx].length
11423 + MAX_VMS_VERSION_LEN + 1;
11424 char *filebuf = XALLOCAVEC (char, maxfilelen);
11426 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
11427 snprintf (filebuf, maxfilelen, "%s;%d",
11428 files[file_idx].path + dirs[dir_idx].length, ver);
11430 dw2_asm_output_nstring
11431 (filebuf, -1, "File Entry: 0x%x", (unsigned) i + 1);
11433 /* Include directory index. */
11434 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
11436 /* Modification time. */
11437 dw2_asm_output_data_uleb128
11438 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
11442 /* File length in bytes. */
11443 dw2_asm_output_data_uleb128
11444 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
11448 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
11449 "File Entry: 0x%x", (unsigned) i + 1);
11451 /* Include directory index. */
11452 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
11454 /* Modification time. */
11455 dw2_asm_output_data_uleb128 (0, NULL);
11457 /* File length in bytes. */
11458 dw2_asm_output_data_uleb128 (0, NULL);
11462 dw2_asm_output_data (1, 0, "End file name table");
11466 /* Output the source line number correspondence information. This
11467 information goes into the .debug_line section. */
11470 output_line_info (void)
11472 char l1[20], l2[20], p1[20], p2[20];
11473 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
11474 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
11476 unsigned n_op_args;
11477 unsigned long lt_index;
11478 unsigned long current_line;
11481 unsigned long current_file;
11482 unsigned long function;
11483 int ver = dwarf_version;
11485 /* Don't mark the output as DWARF-4 until we make full use of the
11486 version 4 extensions, and gdb supports them. For now, -gdwarf-4
11487 selects only a few extensions from the DWARF-4 spec. */
11491 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
11492 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
11493 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
11494 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
11496 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11497 dw2_asm_output_data (4, 0xffffffff,
11498 "Initial length escape value indicating 64-bit DWARF extension");
11499 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
11500 "Length of Source Line Info");
11501 ASM_OUTPUT_LABEL (asm_out_file, l1);
11503 dw2_asm_output_data (2, ver, "DWARF Version");
11504 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
11505 ASM_OUTPUT_LABEL (asm_out_file, p1);
11507 /* Define the architecture-dependent minimum instruction length (in
11508 bytes). In this implementation of DWARF, this field is used for
11509 information purposes only. Since GCC generates assembly language,
11510 we have no a priori knowledge of how many instruction bytes are
11511 generated for each source line, and therefore can use only the
11512 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
11513 commands. Accordingly, we fix this as `1', which is "correct
11514 enough" for all architectures, and don't let the target override. */
11515 dw2_asm_output_data (1, 1,
11516 "Minimum Instruction Length");
11518 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
11519 "Default is_stmt_start flag");
11520 dw2_asm_output_data (1, DWARF_LINE_BASE,
11521 "Line Base Value (Special Opcodes)");
11522 dw2_asm_output_data (1, DWARF_LINE_RANGE,
11523 "Line Range Value (Special Opcodes)");
11524 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
11525 "Special Opcode Base");
11527 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
11531 case DW_LNS_advance_pc:
11532 case DW_LNS_advance_line:
11533 case DW_LNS_set_file:
11534 case DW_LNS_set_column:
11535 case DW_LNS_fixed_advance_pc:
11543 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
11547 /* Write out the information about the files we use. */
11548 output_file_names ();
11549 ASM_OUTPUT_LABEL (asm_out_file, p2);
11551 /* We used to set the address register to the first location in the text
11552 section here, but that didn't accomplish anything since we already
11553 have a line note for the opening brace of the first function. */
11555 /* Generate the line number to PC correspondence table, encoded as
11556 a series of state machine operations. */
11560 if (cfun && in_cold_section_p)
11561 strcpy (prev_line_label, crtl->subsections.cold_section_label);
11563 strcpy (prev_line_label, text_section_label);
11564 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
11566 dw_line_info_ref line_info = &line_info_table[lt_index];
11569 /* Disable this optimization for now; GDB wants to see two line notes
11570 at the beginning of a function so it can find the end of the
11573 /* Don't emit anything for redundant notes. Just updating the
11574 address doesn't accomplish anything, because we already assume
11575 that anything after the last address is this line. */
11576 if (line_info->dw_line_num == current_line
11577 && line_info->dw_file_num == current_file)
11581 /* Emit debug info for the address of the current line.
11583 Unfortunately, we have little choice here currently, and must always
11584 use the most general form. GCC does not know the address delta
11585 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
11586 attributes which will give an upper bound on the address range. We
11587 could perhaps use length attributes to determine when it is safe to
11588 use DW_LNS_fixed_advance_pc. */
11590 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
11593 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
11594 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
11595 "DW_LNS_fixed_advance_pc");
11596 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
11600 /* This can handle any delta. This takes
11601 4+DWARF2_ADDR_SIZE bytes. */
11602 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
11603 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
11604 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
11605 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
11608 strcpy (prev_line_label, line_label);
11610 /* Emit debug info for the source file of the current line, if
11611 different from the previous line. */
11612 if (line_info->dw_file_num != current_file)
11614 current_file = line_info->dw_file_num;
11615 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
11616 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
11619 /* Emit debug info for the current line number, choosing the encoding
11620 that uses the least amount of space. */
11621 if (line_info->dw_line_num != current_line)
11623 line_offset = line_info->dw_line_num - current_line;
11624 line_delta = line_offset - DWARF_LINE_BASE;
11625 current_line = line_info->dw_line_num;
11626 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
11627 /* This can handle deltas from -10 to 234, using the current
11628 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
11630 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
11631 "line %lu", current_line);
11634 /* This can handle any delta. This takes at least 4 bytes,
11635 depending on the value being encoded. */
11636 dw2_asm_output_data (1, DW_LNS_advance_line,
11637 "advance to line %lu", current_line);
11638 dw2_asm_output_data_sleb128 (line_offset, NULL);
11639 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
11643 /* We still need to start a new row, so output a copy insn. */
11644 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
11647 /* Emit debug info for the address of the end of the function. */
11650 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
11651 "DW_LNS_fixed_advance_pc");
11652 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
11656 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
11657 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
11658 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
11659 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
11662 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
11663 dw2_asm_output_data_uleb128 (1, NULL);
11664 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
11669 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
11671 dw_separate_line_info_ref line_info
11672 = &separate_line_info_table[lt_index];
11675 /* Don't emit anything for redundant notes. */
11676 if (line_info->dw_line_num == current_line
11677 && line_info->dw_file_num == current_file
11678 && line_info->function == function)
11682 /* Emit debug info for the address of the current line. If this is
11683 a new function, or the first line of a function, then we need
11684 to handle it differently. */
11685 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
11687 if (function != line_info->function)
11689 function = line_info->function;
11691 /* Set the address register to the first line in the function. */
11692 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
11693 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
11694 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
11695 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
11699 /* ??? See the DW_LNS_advance_pc comment above. */
11702 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
11703 "DW_LNS_fixed_advance_pc");
11704 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
11708 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
11709 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
11710 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
11711 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
11715 strcpy (prev_line_label, line_label);
11717 /* Emit debug info for the source file of the current line, if
11718 different from the previous line. */
11719 if (line_info->dw_file_num != current_file)
11721 current_file = line_info->dw_file_num;
11722 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
11723 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
11726 /* Emit debug info for the current line number, choosing the encoding
11727 that uses the least amount of space. */
11728 if (line_info->dw_line_num != current_line)
11730 line_offset = line_info->dw_line_num - current_line;
11731 line_delta = line_offset - DWARF_LINE_BASE;
11732 current_line = line_info->dw_line_num;
11733 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
11734 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
11735 "line %lu", current_line);
11738 dw2_asm_output_data (1, DW_LNS_advance_line,
11739 "advance to line %lu", current_line);
11740 dw2_asm_output_data_sleb128 (line_offset, NULL);
11741 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
11745 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
11753 /* If we're done with a function, end its sequence. */
11754 if (lt_index == separate_line_info_table_in_use
11755 || separate_line_info_table[lt_index].function != function)
11760 /* Emit debug info for the address of the end of the function. */
11761 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
11764 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
11765 "DW_LNS_fixed_advance_pc");
11766 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
11770 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
11771 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
11772 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
11773 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
11776 /* Output the marker for the end of this sequence. */
11777 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
11778 dw2_asm_output_data_uleb128 (1, NULL);
11779 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
11783 /* Output the marker for the end of the line number info. */
11784 ASM_OUTPUT_LABEL (asm_out_file, l2);
11787 /* Return the size of the .debug_dcall table for the compilation unit. */
11789 static unsigned long
11790 size_of_dcall_table (void)
11792 unsigned long size;
11795 tree last_poc_decl = NULL;
11797 /* Header: version + debug info section pointer + pointer size. */
11798 size = 2 + DWARF_OFFSET_SIZE + 1;
11800 /* Each entry: code label + DIE offset. */
11801 for (i = 0; VEC_iterate (dcall_entry, dcall_table, i, p); i++)
11803 gcc_assert (p->targ_die != NULL);
11804 /* Insert a "from" entry when the point-of-call DIE offset changes. */
11805 if (p->poc_decl != last_poc_decl)
11807 dw_die_ref poc_die = lookup_decl_die (p->poc_decl);
11808 gcc_assert (poc_die);
11809 last_poc_decl = p->poc_decl;
11811 size += (DWARF_OFFSET_SIZE
11812 + size_of_uleb128 (poc_die->die_offset));
11814 size += DWARF_OFFSET_SIZE + size_of_uleb128 (p->targ_die->die_offset);
11820 /* Output the direct call table used to disambiguate PC values when
11821 identical function have been merged. */
11824 output_dcall_table (void)
11827 unsigned long dcall_length = size_of_dcall_table ();
11829 char poc_label[MAX_ARTIFICIAL_LABEL_BYTES];
11830 tree last_poc_decl = NULL;
11832 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11833 dw2_asm_output_data (4, 0xffffffff,
11834 "Initial length escape value indicating 64-bit DWARF extension");
11835 dw2_asm_output_data (DWARF_OFFSET_SIZE, dcall_length,
11836 "Length of Direct Call Table");
11837 dw2_asm_output_data (2, 4, "Version number");
11838 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11839 debug_info_section,
11840 "Offset of Compilation Unit Info");
11841 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11843 for (i = 0; VEC_iterate (dcall_entry, dcall_table, i, p); i++)
11845 /* Insert a "from" entry when the point-of-call DIE offset changes. */
11846 if (p->poc_decl != last_poc_decl)
11848 dw_die_ref poc_die = lookup_decl_die (p->poc_decl);
11849 last_poc_decl = p->poc_decl;
11852 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, "New caller");
11853 dw2_asm_output_data_uleb128 (poc_die->die_offset,
11854 "Caller DIE offset");
11857 ASM_GENERATE_INTERNAL_LABEL (poc_label, "LPOC", p->poc_label_num);
11858 dw2_asm_output_addr (DWARF_OFFSET_SIZE, poc_label, "Point of call");
11859 dw2_asm_output_data_uleb128 (p->targ_die->die_offset,
11860 "Callee DIE offset");
11864 /* Return the size of the .debug_vcall table for the compilation unit. */
11866 static unsigned long
11867 size_of_vcall_table (void)
11869 unsigned long size;
11873 /* Header: version + pointer size. */
11876 /* Each entry: code label + vtable slot index. */
11877 for (i = 0; VEC_iterate (vcall_entry, vcall_table, i, p); i++)
11878 size += DWARF_OFFSET_SIZE + size_of_uleb128 (p->vtable_slot);
11883 /* Output the virtual call table used to disambiguate PC values when
11884 identical function have been merged. */
11887 output_vcall_table (void)
11890 unsigned long vcall_length = size_of_vcall_table ();
11892 char poc_label[MAX_ARTIFICIAL_LABEL_BYTES];
11894 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11895 dw2_asm_output_data (4, 0xffffffff,
11896 "Initial length escape value indicating 64-bit DWARF extension");
11897 dw2_asm_output_data (DWARF_OFFSET_SIZE, vcall_length,
11898 "Length of Virtual Call Table");
11899 dw2_asm_output_data (2, 4, "Version number");
11900 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11902 for (i = 0; VEC_iterate (vcall_entry, vcall_table, i, p); i++)
11904 ASM_GENERATE_INTERNAL_LABEL (poc_label, "LPOC", p->poc_label_num);
11905 dw2_asm_output_addr (DWARF_OFFSET_SIZE, poc_label, "Point of call");
11906 dw2_asm_output_data_uleb128 (p->vtable_slot, "Vtable slot");
11910 /* Given a pointer to a tree node for some base type, return a pointer to
11911 a DIE that describes the given type.
11913 This routine must only be called for GCC type nodes that correspond to
11914 Dwarf base (fundamental) types. */
11917 base_type_die (tree type)
11919 dw_die_ref base_type_result;
11920 enum dwarf_type encoding;
11922 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
11925 /* If this is a subtype that should not be emitted as a subrange type,
11926 use the base type. See subrange_type_for_debug_p. */
11927 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
11928 type = TREE_TYPE (type);
11930 switch (TREE_CODE (type))
11933 if (TYPE_STRING_FLAG (type))
11935 if (TYPE_UNSIGNED (type))
11936 encoding = DW_ATE_unsigned_char;
11938 encoding = DW_ATE_signed_char;
11940 else if (TYPE_UNSIGNED (type))
11941 encoding = DW_ATE_unsigned;
11943 encoding = DW_ATE_signed;
11947 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
11949 if (dwarf_version >= 3 || !dwarf_strict)
11950 encoding = DW_ATE_decimal_float;
11952 encoding = DW_ATE_lo_user;
11955 encoding = DW_ATE_float;
11958 case FIXED_POINT_TYPE:
11959 if (!(dwarf_version >= 3 || !dwarf_strict))
11960 encoding = DW_ATE_lo_user;
11961 else if (TYPE_UNSIGNED (type))
11962 encoding = DW_ATE_unsigned_fixed;
11964 encoding = DW_ATE_signed_fixed;
11967 /* Dwarf2 doesn't know anything about complex ints, so use
11968 a user defined type for it. */
11970 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
11971 encoding = DW_ATE_complex_float;
11973 encoding = DW_ATE_lo_user;
11977 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
11978 encoding = DW_ATE_boolean;
11982 /* No other TREE_CODEs are Dwarf fundamental types. */
11983 gcc_unreachable ();
11986 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
11988 /* This probably indicates a bug. */
11989 if (! TYPE_NAME (type))
11990 add_name_attribute (base_type_result, "__unknown__");
11992 add_AT_unsigned (base_type_result, DW_AT_byte_size,
11993 int_size_in_bytes (type));
11994 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
11996 return base_type_result;
11999 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12000 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12003 is_base_type (tree type)
12005 switch (TREE_CODE (type))
12011 case FIXED_POINT_TYPE:
12019 case QUAL_UNION_TYPE:
12020 case ENUMERAL_TYPE:
12021 case FUNCTION_TYPE:
12024 case REFERENCE_TYPE:
12031 gcc_unreachable ();
12037 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12038 node, return the size in bits for the type if it is a constant, or else
12039 return the alignment for the type if the type's size is not constant, or
12040 else return BITS_PER_WORD if the type actually turns out to be an
12041 ERROR_MARK node. */
12043 static inline unsigned HOST_WIDE_INT
12044 simple_type_size_in_bits (const_tree type)
12046 if (TREE_CODE (type) == ERROR_MARK)
12047 return BITS_PER_WORD;
12048 else if (TYPE_SIZE (type) == NULL_TREE)
12050 else if (host_integerp (TYPE_SIZE (type), 1))
12051 return tree_low_cst (TYPE_SIZE (type), 1);
12053 return TYPE_ALIGN (type);
12056 /* Given a pointer to a tree node for a subrange type, return a pointer
12057 to a DIE that describes the given type. */
12060 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
12062 dw_die_ref subrange_die;
12063 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
12065 if (context_die == NULL)
12066 context_die = comp_unit_die;
12068 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
12070 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
12072 /* The size of the subrange type and its base type do not match,
12073 so we need to generate a size attribute for the subrange type. */
12074 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
12078 add_bound_info (subrange_die, DW_AT_lower_bound, low);
12080 add_bound_info (subrange_die, DW_AT_upper_bound, high);
12082 return subrange_die;
12085 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
12086 entry that chains various modifiers in front of the given type. */
12089 modified_type_die (tree type, int is_const_type, int is_volatile_type,
12090 dw_die_ref context_die)
12092 enum tree_code code = TREE_CODE (type);
12093 dw_die_ref mod_type_die;
12094 dw_die_ref sub_die = NULL;
12095 tree item_type = NULL;
12096 tree qualified_type;
12097 tree name, low, high;
12099 if (code == ERROR_MARK)
12102 /* See if we already have the appropriately qualified variant of
12105 = get_qualified_type (type,
12106 ((is_const_type ? TYPE_QUAL_CONST : 0)
12107 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
12109 /* If we do, then we can just use its DIE, if it exists. */
12110 if (qualified_type)
12112 mod_type_die = lookup_type_die (qualified_type);
12114 return mod_type_die;
12117 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
12119 /* Handle C typedef types. */
12120 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
12122 tree dtype = TREE_TYPE (name);
12124 if (qualified_type == dtype)
12126 /* For a named type, use the typedef. */
12127 gen_type_die (qualified_type, context_die);
12128 return lookup_type_die (qualified_type);
12130 else if (is_const_type < TYPE_READONLY (dtype)
12131 || is_volatile_type < TYPE_VOLATILE (dtype)
12132 || (is_const_type <= TYPE_READONLY (dtype)
12133 && is_volatile_type <= TYPE_VOLATILE (dtype)
12134 && DECL_ORIGINAL_TYPE (name) != type))
12135 /* cv-unqualified version of named type. Just use the unnamed
12136 type to which it refers. */
12137 return modified_type_die (DECL_ORIGINAL_TYPE (name),
12138 is_const_type, is_volatile_type,
12140 /* Else cv-qualified version of named type; fall through. */
12145 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
12146 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
12148 else if (is_volatile_type)
12150 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
12151 sub_die = modified_type_die (type, 0, 0, context_die);
12153 else if (code == POINTER_TYPE)
12155 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
12156 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
12157 simple_type_size_in_bits (type) / BITS_PER_UNIT);
12158 item_type = TREE_TYPE (type);
12159 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
12160 add_AT_unsigned (mod_type_die, DW_AT_address_class,
12161 TYPE_ADDR_SPACE (item_type));
12163 else if (code == REFERENCE_TYPE)
12165 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
12166 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
12167 simple_type_size_in_bits (type) / BITS_PER_UNIT);
12168 item_type = TREE_TYPE (type);
12169 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
12170 add_AT_unsigned (mod_type_die, DW_AT_address_class,
12171 TYPE_ADDR_SPACE (item_type));
12173 else if (code == INTEGER_TYPE
12174 && TREE_TYPE (type) != NULL_TREE
12175 && subrange_type_for_debug_p (type, &low, &high))
12177 mod_type_die = subrange_type_die (type, low, high, context_die);
12178 item_type = TREE_TYPE (type);
12180 else if (is_base_type (type))
12181 mod_type_die = base_type_die (type);
12184 gen_type_die (type, context_die);
12186 /* We have to get the type_main_variant here (and pass that to the
12187 `lookup_type_die' routine) because the ..._TYPE node we have
12188 might simply be a *copy* of some original type node (where the
12189 copy was created to help us keep track of typedef names) and
12190 that copy might have a different TYPE_UID from the original
12192 if (TREE_CODE (type) != VECTOR_TYPE)
12193 return lookup_type_die (type_main_variant (type));
12195 /* Vectors have the debugging information in the type,
12196 not the main variant. */
12197 return lookup_type_die (type);
12200 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
12201 don't output a DW_TAG_typedef, since there isn't one in the
12202 user's program; just attach a DW_AT_name to the type.
12203 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
12204 if the base type already has the same name. */
12206 && ((TREE_CODE (name) != TYPE_DECL
12207 && (qualified_type == TYPE_MAIN_VARIANT (type)
12208 || (!is_const_type && !is_volatile_type)))
12209 || (TREE_CODE (name) == TYPE_DECL
12210 && TREE_TYPE (name) == qualified_type
12211 && DECL_NAME (name))))
12213 if (TREE_CODE (name) == TYPE_DECL)
12214 /* Could just call add_name_and_src_coords_attributes here,
12215 but since this is a builtin type it doesn't have any
12216 useful source coordinates anyway. */
12217 name = DECL_NAME (name);
12218 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
12221 if (qualified_type)
12222 equate_type_number_to_die (qualified_type, mod_type_die);
12225 /* We must do this after the equate_type_number_to_die call, in case
12226 this is a recursive type. This ensures that the modified_type_die
12227 recursion will terminate even if the type is recursive. Recursive
12228 types are possible in Ada. */
12229 sub_die = modified_type_die (item_type,
12230 TYPE_READONLY (item_type),
12231 TYPE_VOLATILE (item_type),
12234 if (sub_die != NULL)
12235 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
12237 return mod_type_die;
12240 /* Generate DIEs for the generic parameters of T.
12241 T must be either a generic type or a generic function.
12242 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
12245 gen_generic_params_dies (tree t)
12249 dw_die_ref die = NULL;
12251 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
12255 die = lookup_type_die (t);
12256 else if (DECL_P (t))
12257 die = lookup_decl_die (t);
12261 parms = lang_hooks.get_innermost_generic_parms (t);
12263 /* T has no generic parameter. It means T is neither a generic type
12264 or function. End of story. */
12267 parms_num = TREE_VEC_LENGTH (parms);
12268 args = lang_hooks.get_innermost_generic_args (t);
12269 for (i = 0; i < parms_num; i++)
12271 tree parm, arg, arg_pack_elems;
12273 parm = TREE_VEC_ELT (parms, i);
12274 arg = TREE_VEC_ELT (args, i);
12275 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
12276 gcc_assert (parm && TREE_VALUE (parm) && arg);
12278 if (parm && TREE_VALUE (parm) && arg)
12280 /* If PARM represents a template parameter pack,
12281 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
12282 by DW_TAG_template_*_parameter DIEs for the argument
12283 pack elements of ARG. Note that ARG would then be
12284 an argument pack. */
12285 if (arg_pack_elems)
12286 template_parameter_pack_die (TREE_VALUE (parm),
12290 generic_parameter_die (TREE_VALUE (parm), arg,
12291 true /* Emit DW_AT_name */, die);
12296 /* Create and return a DIE for PARM which should be
12297 the representation of a generic type parameter.
12298 For instance, in the C++ front end, PARM would be a template parameter.
12299 ARG is the argument to PARM.
12300 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
12302 PARENT_DIE is the parent DIE which the new created DIE should be added to,
12303 as a child node. */
12306 generic_parameter_die (tree parm, tree arg,
12308 dw_die_ref parent_die)
12310 dw_die_ref tmpl_die = NULL;
12311 const char *name = NULL;
12313 if (!parm || !DECL_NAME (parm) || !arg)
12316 /* We support non-type generic parameters and arguments,
12317 type generic parameters and arguments, as well as
12318 generic generic parameters (a.k.a. template template parameters in C++)
12320 if (TREE_CODE (parm) == PARM_DECL)
12321 /* PARM is a nontype generic parameter */
12322 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
12323 else if (TREE_CODE (parm) == TYPE_DECL)
12324 /* PARM is a type generic parameter. */
12325 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
12326 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
12327 /* PARM is a generic generic parameter.
12328 Its DIE is a GNU extension. It shall have a
12329 DW_AT_name attribute to represent the name of the template template
12330 parameter, and a DW_AT_GNU_template_name attribute to represent the
12331 name of the template template argument. */
12332 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
12335 gcc_unreachable ();
12341 /* If PARM is a generic parameter pack, it means we are
12342 emitting debug info for a template argument pack element.
12343 In other terms, ARG is a template argument pack element.
12344 In that case, we don't emit any DW_AT_name attribute for
12348 name = IDENTIFIER_POINTER (DECL_NAME (parm));
12350 add_AT_string (tmpl_die, DW_AT_name, name);
12353 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
12355 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
12356 TMPL_DIE should have a child DW_AT_type attribute that is set
12357 to the type of the argument to PARM, which is ARG.
12358 If PARM is a type generic parameter, TMPL_DIE should have a
12359 child DW_AT_type that is set to ARG. */
12360 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
12361 add_type_attribute (tmpl_die, tmpl_type, 0,
12362 TREE_THIS_VOLATILE (tmpl_type),
12367 /* So TMPL_DIE is a DIE representing a
12368 a generic generic template parameter, a.k.a template template
12369 parameter in C++ and arg is a template. */
12371 /* The DW_AT_GNU_template_name attribute of the DIE must be set
12372 to the name of the argument. */
12373 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
12375 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
12378 if (TREE_CODE (parm) == PARM_DECL)
12379 /* So PARM is a non-type generic parameter.
12380 DWARF3 5.6.8 says we must set a DW_AT_const_value child
12381 attribute of TMPL_DIE which value represents the value
12383 We must be careful here:
12384 The value of ARG might reference some function decls.
12385 We might currently be emitting debug info for a generic
12386 type and types are emitted before function decls, we don't
12387 know if the function decls referenced by ARG will actually be
12388 emitted after cgraph computations.
12389 So must defer the generation of the DW_AT_const_value to
12390 after cgraph is ready. */
12391 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
12397 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
12398 PARM_PACK must be a template parameter pack. The returned DIE
12399 will be child DIE of PARENT_DIE. */
12402 template_parameter_pack_die (tree parm_pack,
12403 tree parm_pack_args,
12404 dw_die_ref parent_die)
12409 gcc_assert (parent_die && parm_pack);
12411 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
12412 add_name_and_src_coords_attributes (die, parm_pack);
12413 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
12414 generic_parameter_die (parm_pack,
12415 TREE_VEC_ELT (parm_pack_args, j),
12416 false /* Don't emit DW_AT_name */,
12421 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
12422 an enumerated type. */
12425 type_is_enum (const_tree type)
12427 return TREE_CODE (type) == ENUMERAL_TYPE;
12430 /* Return the DBX register number described by a given RTL node. */
12432 static unsigned int
12433 dbx_reg_number (const_rtx rtl)
12435 unsigned regno = REGNO (rtl);
12437 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
12439 #ifdef LEAF_REG_REMAP
12440 if (current_function_uses_only_leaf_regs)
12442 int leaf_reg = LEAF_REG_REMAP (regno);
12443 if (leaf_reg != -1)
12444 regno = (unsigned) leaf_reg;
12448 return DBX_REGISTER_NUMBER (regno);
12451 /* Optionally add a DW_OP_piece term to a location description expression.
12452 DW_OP_piece is only added if the location description expression already
12453 doesn't end with DW_OP_piece. */
12456 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
12458 dw_loc_descr_ref loc;
12460 if (*list_head != NULL)
12462 /* Find the end of the chain. */
12463 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
12466 if (loc->dw_loc_opc != DW_OP_piece)
12467 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
12471 /* Return a location descriptor that designates a machine register or
12472 zero if there is none. */
12474 static dw_loc_descr_ref
12475 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
12479 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
12482 regs = targetm.dwarf_register_span (rtl);
12484 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
12485 return multiple_reg_loc_descriptor (rtl, regs, initialized);
12487 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
12490 /* Return a location descriptor that designates a machine register for
12491 a given hard register number. */
12493 static dw_loc_descr_ref
12494 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
12496 dw_loc_descr_ref reg_loc_descr;
12500 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
12502 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
12504 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
12505 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
12507 return reg_loc_descr;
12510 /* Given an RTL of a register, return a location descriptor that
12511 designates a value that spans more than one register. */
12513 static dw_loc_descr_ref
12514 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
12515 enum var_init_status initialized)
12517 int nregs, size, i;
12519 dw_loc_descr_ref loc_result = NULL;
12522 #ifdef LEAF_REG_REMAP
12523 if (current_function_uses_only_leaf_regs)
12525 int leaf_reg = LEAF_REG_REMAP (reg);
12526 if (leaf_reg != -1)
12527 reg = (unsigned) leaf_reg;
12530 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
12531 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
12533 /* Simple, contiguous registers. */
12534 if (regs == NULL_RTX)
12536 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
12541 dw_loc_descr_ref t;
12543 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
12544 VAR_INIT_STATUS_INITIALIZED);
12545 add_loc_descr (&loc_result, t);
12546 add_loc_descr_op_piece (&loc_result, size);
12552 /* Now onto stupid register sets in non contiguous locations. */
12554 gcc_assert (GET_CODE (regs) == PARALLEL);
12556 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
12559 for (i = 0; i < XVECLEN (regs, 0); ++i)
12561 dw_loc_descr_ref t;
12563 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
12564 VAR_INIT_STATUS_INITIALIZED);
12565 add_loc_descr (&loc_result, t);
12566 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
12567 add_loc_descr_op_piece (&loc_result, size);
12570 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
12571 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
12575 #endif /* DWARF2_DEBUGGING_INFO */
12577 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
12579 /* Return a location descriptor that designates a constant. */
12581 static dw_loc_descr_ref
12582 int_loc_descriptor (HOST_WIDE_INT i)
12584 enum dwarf_location_atom op;
12586 /* Pick the smallest representation of a constant, rather than just
12587 defaulting to the LEB encoding. */
12591 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
12592 else if (i <= 0xff)
12593 op = DW_OP_const1u;
12594 else if (i <= 0xffff)
12595 op = DW_OP_const2u;
12596 else if (HOST_BITS_PER_WIDE_INT == 32
12597 || i <= 0xffffffff)
12598 op = DW_OP_const4u;
12605 op = DW_OP_const1s;
12606 else if (i >= -0x8000)
12607 op = DW_OP_const2s;
12608 else if (HOST_BITS_PER_WIDE_INT == 32
12609 || i >= -0x80000000)
12610 op = DW_OP_const4s;
12615 return new_loc_descr (op, i, 0);
12619 #ifdef DWARF2_DEBUGGING_INFO
12620 /* Return loc description representing "address" of integer value.
12621 This can appear only as toplevel expression. */
12623 static dw_loc_descr_ref
12624 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
12627 dw_loc_descr_ref loc_result = NULL;
12629 if (!(dwarf_version >= 4 || !dwarf_strict))
12636 else if (i <= 0xff)
12638 else if (i <= 0xffff)
12640 else if (HOST_BITS_PER_WIDE_INT == 32
12641 || i <= 0xffffffff)
12644 litsize = 1 + size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
12650 else if (i >= -0x8000)
12652 else if (HOST_BITS_PER_WIDE_INT == 32
12653 || i >= -0x80000000)
12656 litsize = 1 + size_of_sleb128 (i);
12658 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
12659 is more compact. For DW_OP_stack_value we need:
12660 litsize + 1 (DW_OP_stack_value)
12661 and for DW_OP_implicit_value:
12662 1 (DW_OP_implicit_value) + 1 (length) + size. */
12663 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
12665 loc_result = int_loc_descriptor (i);
12666 add_loc_descr (&loc_result,
12667 new_loc_descr (DW_OP_stack_value, 0, 0));
12671 loc_result = new_loc_descr (DW_OP_implicit_value,
12673 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
12674 loc_result->dw_loc_oprnd2.v.val_int = i;
12678 /* Return a location descriptor that designates a base+offset location. */
12680 static dw_loc_descr_ref
12681 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
12682 enum var_init_status initialized)
12684 unsigned int regno;
12685 dw_loc_descr_ref result;
12686 dw_fde_ref fde = current_fde ();
12688 /* We only use "frame base" when we're sure we're talking about the
12689 post-prologue local stack frame. We do this by *not* running
12690 register elimination until this point, and recognizing the special
12691 argument pointer and soft frame pointer rtx's. */
12692 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
12694 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
12698 if (GET_CODE (elim) == PLUS)
12700 offset += INTVAL (XEXP (elim, 1));
12701 elim = XEXP (elim, 0);
12703 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12704 && (elim == hard_frame_pointer_rtx
12705 || elim == stack_pointer_rtx))
12706 || elim == (frame_pointer_needed
12707 ? hard_frame_pointer_rtx
12708 : stack_pointer_rtx));
12710 /* If drap register is used to align stack, use frame
12711 pointer + offset to access stack variables. If stack
12712 is aligned without drap, use stack pointer + offset to
12713 access stack variables. */
12714 if (crtl->stack_realign_tried
12715 && reg == frame_pointer_rtx)
12718 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
12719 ? HARD_FRAME_POINTER_REGNUM
12720 : STACK_POINTER_REGNUM);
12721 return new_reg_loc_descr (base_reg, offset);
12724 offset += frame_pointer_fb_offset;
12725 return new_loc_descr (DW_OP_fbreg, offset, 0);
12730 && (fde->drap_reg == REGNO (reg)
12731 || fde->vdrap_reg == REGNO (reg)))
12733 /* Use cfa+offset to represent the location of arguments passed
12734 on the stack when drap is used to align stack.
12735 Only do this when not optimizing, for optimized code var-tracking
12736 is supposed to track where the arguments live and the register
12737 used as vdrap or drap in some spot might be used for something
12738 else in other part of the routine. */
12739 return new_loc_descr (DW_OP_fbreg, offset, 0);
12742 regno = dbx_reg_number (reg);
12744 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
12747 result = new_loc_descr (DW_OP_bregx, regno, offset);
12749 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
12750 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
12755 /* Return true if this RTL expression describes a base+offset calculation. */
12758 is_based_loc (const_rtx rtl)
12760 return (GET_CODE (rtl) == PLUS
12761 && ((REG_P (XEXP (rtl, 0))
12762 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
12763 && CONST_INT_P (XEXP (rtl, 1)))));
12766 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
12769 static dw_loc_descr_ref
12770 tls_mem_loc_descriptor (rtx mem)
12773 dw_loc_descr_ref loc_result;
12775 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
12778 base = get_base_address (MEM_EXPR (mem));
12780 || TREE_CODE (base) != VAR_DECL
12781 || !DECL_THREAD_LOCAL_P (base))
12784 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1);
12785 if (loc_result == NULL)
12788 if (INTVAL (MEM_OFFSET (mem)))
12789 loc_descr_plus_const (&loc_result, INTVAL (MEM_OFFSET (mem)));
12794 /* Output debug info about reason why we failed to expand expression as dwarf
12798 expansion_failed (tree expr, rtx rtl, char const *reason)
12800 if (dump_file && (dump_flags & TDF_DETAILS))
12802 fprintf (dump_file, "Failed to expand as dwarf: ");
12804 print_generic_expr (dump_file, expr, dump_flags);
12807 fprintf (dump_file, "\n");
12808 print_rtl (dump_file, rtl);
12810 fprintf (dump_file, "\nReason: %s\n", reason);
12814 /* Helper function for const_ok_for_output, called either directly
12815 or via for_each_rtx. */
12818 const_ok_for_output_1 (rtx *rtlp, void *data ATTRIBUTE_UNUSED)
12822 if (GET_CODE (rtl) == UNSPEC)
12824 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
12825 we can't express it in the debug info. */
12826 #ifdef ENABLE_CHECKING
12827 inform (current_function_decl
12828 ? DECL_SOURCE_LOCATION (current_function_decl)
12829 : UNKNOWN_LOCATION,
12830 "non-delegitimized UNSPEC %d found in variable location",
12833 expansion_failed (NULL_TREE, rtl,
12834 "UNSPEC hasn't been delegitimized.\n");
12838 if (GET_CODE (rtl) != SYMBOL_REF)
12841 if (CONSTANT_POOL_ADDRESS_P (rtl))
12844 get_pool_constant_mark (rtl, &marked);
12845 /* If all references to this pool constant were optimized away,
12846 it was not output and thus we can't represent it. */
12849 expansion_failed (NULL_TREE, rtl,
12850 "Constant was removed from constant pool.\n");
12855 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
12858 /* Avoid references to external symbols in debug info, on several targets
12859 the linker might even refuse to link when linking a shared library,
12860 and in many other cases the relocations for .debug_info/.debug_loc are
12861 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
12862 to be defined within the same shared library or executable are fine. */
12863 if (SYMBOL_REF_EXTERNAL_P (rtl))
12865 tree decl = SYMBOL_REF_DECL (rtl);
12867 if (decl == NULL || !targetm.binds_local_p (decl))
12869 expansion_failed (NULL_TREE, rtl,
12870 "Symbol not defined in current TU.\n");
12878 /* Return true if constant RTL can be emitted in DW_OP_addr or
12879 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
12880 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
12883 const_ok_for_output (rtx rtl)
12885 if (GET_CODE (rtl) == SYMBOL_REF)
12886 return const_ok_for_output_1 (&rtl, NULL) == 0;
12888 if (GET_CODE (rtl) == CONST)
12889 return for_each_rtx (&XEXP (rtl, 0), const_ok_for_output_1, NULL) == 0;
12894 /* The following routine converts the RTL for a variable or parameter
12895 (resident in memory) into an equivalent Dwarf representation of a
12896 mechanism for getting the address of that same variable onto the top of a
12897 hypothetical "address evaluation" stack.
12899 When creating memory location descriptors, we are effectively transforming
12900 the RTL for a memory-resident object into its Dwarf postfix expression
12901 equivalent. This routine recursively descends an RTL tree, turning
12902 it into Dwarf postfix code as it goes.
12904 MODE is the mode of the memory reference, needed to handle some
12905 autoincrement addressing modes.
12907 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
12908 location list for RTL.
12910 Return 0 if we can't represent the location. */
12912 static dw_loc_descr_ref
12913 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
12914 enum var_init_status initialized)
12916 dw_loc_descr_ref mem_loc_result = NULL;
12917 enum dwarf_location_atom op;
12918 dw_loc_descr_ref op0, op1;
12920 /* Note that for a dynamically sized array, the location we will generate a
12921 description of here will be the lowest numbered location which is
12922 actually within the array. That's *not* necessarily the same as the
12923 zeroth element of the array. */
12925 rtl = targetm.delegitimize_address (rtl);
12927 switch (GET_CODE (rtl))
12932 return mem_loc_descriptor (XEXP (rtl, 0), mode, initialized);
12935 /* The case of a subreg may arise when we have a local (register)
12936 variable or a formal (register) parameter which doesn't quite fill
12937 up an entire register. For now, just assume that it is
12938 legitimate to make the Dwarf info refer to the whole register which
12939 contains the given subreg. */
12940 if (!subreg_lowpart_p (rtl))
12942 rtl = SUBREG_REG (rtl);
12943 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
12945 if (GET_MODE_CLASS (GET_MODE (rtl)) != MODE_INT)
12947 mem_loc_result = mem_loc_descriptor (rtl, mode, initialized);
12951 /* Whenever a register number forms a part of the description of the
12952 method for calculating the (dynamic) address of a memory resident
12953 object, DWARF rules require the register number be referred to as
12954 a "base register". This distinction is not based in any way upon
12955 what category of register the hardware believes the given register
12956 belongs to. This is strictly DWARF terminology we're dealing with
12957 here. Note that in cases where the location of a memory-resident
12958 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
12959 OP_CONST (0)) the actual DWARF location descriptor that we generate
12960 may just be OP_BASEREG (basereg). This may look deceptively like
12961 the object in question was allocated to a register (rather than in
12962 memory) so DWARF consumers need to be aware of the subtle
12963 distinction between OP_REG and OP_BASEREG. */
12964 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
12965 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
12966 else if (stack_realign_drap
12968 && crtl->args.internal_arg_pointer == rtl
12969 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
12971 /* If RTL is internal_arg_pointer, which has been optimized
12972 out, use DRAP instead. */
12973 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
12974 VAR_INIT_STATUS_INITIALIZED);
12980 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
12981 VAR_INIT_STATUS_INITIALIZED);
12986 int shift = DWARF2_ADDR_SIZE
12987 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
12988 shift *= BITS_PER_UNIT;
12989 if (GET_CODE (rtl) == SIGN_EXTEND)
12993 mem_loc_result = op0;
12994 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12995 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
12996 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
12997 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13002 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
13003 VAR_INIT_STATUS_INITIALIZED);
13004 if (mem_loc_result == NULL)
13005 mem_loc_result = tls_mem_loc_descriptor (rtl);
13006 if (mem_loc_result != 0)
13008 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
13010 expansion_failed (NULL_TREE, rtl, "DWARF address size mismatch");
13013 else if (GET_MODE_SIZE (GET_MODE (rtl)) == DWARF2_ADDR_SIZE)
13014 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
13016 add_loc_descr (&mem_loc_result,
13017 new_loc_descr (DW_OP_deref_size,
13018 GET_MODE_SIZE (GET_MODE (rtl)), 0));
13022 rtx new_rtl = avoid_constant_pool_reference (rtl);
13023 if (new_rtl != rtl)
13024 return mem_loc_descriptor (new_rtl, mode, initialized);
13029 rtl = XEXP (rtl, 1);
13031 /* ... fall through ... */
13034 /* Some ports can transform a symbol ref into a label ref, because
13035 the symbol ref is too far away and has to be dumped into a constant
13039 if (GET_CODE (rtl) == SYMBOL_REF
13040 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
13042 dw_loc_descr_ref temp;
13044 /* If this is not defined, we have no way to emit the data. */
13045 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
13048 temp = new_loc_descr (DW_OP_addr, 0, 0);
13049 temp->dw_loc_oprnd1.val_class = dw_val_class_addr;
13050 temp->dw_loc_oprnd1.v.val_addr = rtl;
13051 temp->dtprel = true;
13053 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
13054 add_loc_descr (&mem_loc_result, temp);
13059 if (!const_ok_for_output (rtl))
13063 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
13064 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
13065 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
13066 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
13072 expansion_failed (NULL_TREE, rtl,
13073 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
13077 /* Extract the PLUS expression nested inside and fall into
13078 PLUS code below. */
13079 rtl = XEXP (rtl, 1);
13084 /* Turn these into a PLUS expression and fall into the PLUS code
13086 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
13087 GEN_INT (GET_CODE (rtl) == PRE_INC
13088 ? GET_MODE_UNIT_SIZE (mode)
13089 : -GET_MODE_UNIT_SIZE (mode)));
13091 /* ... fall through ... */
13095 if (is_based_loc (rtl))
13096 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
13097 INTVAL (XEXP (rtl, 1)),
13098 VAR_INIT_STATUS_INITIALIZED);
13101 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
13102 VAR_INIT_STATUS_INITIALIZED);
13103 if (mem_loc_result == 0)
13106 if (CONST_INT_P (XEXP (rtl, 1)))
13107 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
13110 dw_loc_descr_ref mem_loc_result2
13111 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13112 VAR_INIT_STATUS_INITIALIZED);
13113 if (mem_loc_result2 == 0)
13115 add_loc_descr (&mem_loc_result, mem_loc_result2);
13116 add_loc_descr (&mem_loc_result,
13117 new_loc_descr (DW_OP_plus, 0, 0));
13122 /* If a pseudo-reg is optimized away, it is possible for it to
13123 be replaced with a MEM containing a multiply or shift. */
13165 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13166 VAR_INIT_STATUS_INITIALIZED);
13167 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13168 VAR_INIT_STATUS_INITIALIZED);
13170 if (op0 == 0 || op1 == 0)
13173 mem_loc_result = op0;
13174 add_loc_descr (&mem_loc_result, op1);
13175 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13179 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13180 VAR_INIT_STATUS_INITIALIZED);
13181 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13182 VAR_INIT_STATUS_INITIALIZED);
13184 if (op0 == 0 || op1 == 0)
13187 mem_loc_result = op0;
13188 add_loc_descr (&mem_loc_result, op1);
13189 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13190 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13191 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
13192 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13193 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
13209 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13210 VAR_INIT_STATUS_INITIALIZED);
13215 mem_loc_result = op0;
13216 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13220 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13248 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
13249 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 1))) > DWARF2_ADDR_SIZE)
13253 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
13255 if (op_mode == VOIDmode)
13256 op_mode = GET_MODE (XEXP (rtl, 1));
13257 if (op_mode != VOIDmode && GET_MODE_CLASS (op_mode) != MODE_INT)
13260 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13261 VAR_INIT_STATUS_INITIALIZED);
13262 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13263 VAR_INIT_STATUS_INITIALIZED);
13265 if (op0 == 0 || op1 == 0)
13268 if (op_mode != VOIDmode
13269 && GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
13271 int shift = DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode);
13272 shift *= BITS_PER_UNIT;
13273 /* For eq/ne, if the operands are known to be zero-extended,
13274 there is no need to do the fancy shifting up. */
13275 if (op == DW_OP_eq || op == DW_OP_ne)
13277 dw_loc_descr_ref last0, last1;
13279 last0->dw_loc_next != NULL;
13280 last0 = last0->dw_loc_next)
13283 last1->dw_loc_next != NULL;
13284 last1 = last1->dw_loc_next)
13286 /* deref_size zero extends, and for constants we can check
13287 whether they are zero extended or not. */
13288 if (((last0->dw_loc_opc == DW_OP_deref_size
13289 && last0->dw_loc_oprnd1.v.val_int
13290 <= GET_MODE_SIZE (op_mode))
13291 || (CONST_INT_P (XEXP (rtl, 0))
13292 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
13293 == (INTVAL (XEXP (rtl, 0))
13294 & GET_MODE_MASK (op_mode))))
13295 && ((last1->dw_loc_opc == DW_OP_deref_size
13296 && last1->dw_loc_oprnd1.v.val_int
13297 <= GET_MODE_SIZE (op_mode))
13298 || (CONST_INT_P (XEXP (rtl, 1))
13299 && (unsigned HOST_WIDE_INT)
13300 INTVAL (XEXP (rtl, 1))
13301 == (INTVAL (XEXP (rtl, 1))
13302 & GET_MODE_MASK (op_mode)))))
13305 add_loc_descr (&op0, int_loc_descriptor (shift));
13306 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
13307 if (CONST_INT_P (XEXP (rtl, 1)))
13308 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
13311 add_loc_descr (&op1, int_loc_descriptor (shift));
13312 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
13318 mem_loc_result = op0;
13319 add_loc_descr (&mem_loc_result, op1);
13320 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13321 if (STORE_FLAG_VALUE != 1)
13323 add_loc_descr (&mem_loc_result,
13324 int_loc_descriptor (STORE_FLAG_VALUE));
13325 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13346 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
13347 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 1))) > DWARF2_ADDR_SIZE)
13351 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
13353 if (op_mode == VOIDmode)
13354 op_mode = GET_MODE (XEXP (rtl, 1));
13355 if (op_mode != VOIDmode && GET_MODE_CLASS (op_mode) != MODE_INT)
13358 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13359 VAR_INIT_STATUS_INITIALIZED);
13360 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13361 VAR_INIT_STATUS_INITIALIZED);
13363 if (op0 == 0 || op1 == 0)
13366 if (op_mode != VOIDmode
13367 && GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
13369 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
13370 dw_loc_descr_ref last0, last1;
13372 last0->dw_loc_next != NULL;
13373 last0 = last0->dw_loc_next)
13376 last1->dw_loc_next != NULL;
13377 last1 = last1->dw_loc_next)
13379 if (CONST_INT_P (XEXP (rtl, 0)))
13380 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
13381 /* deref_size zero extends, so no need to mask it again. */
13382 else if (last0->dw_loc_opc != DW_OP_deref_size
13383 || last0->dw_loc_oprnd1.v.val_int
13384 > GET_MODE_SIZE (op_mode))
13386 add_loc_descr (&op0, int_loc_descriptor (mask));
13387 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
13389 if (CONST_INT_P (XEXP (rtl, 1)))
13390 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
13391 /* deref_size zero extends, so no need to mask it again. */
13392 else if (last1->dw_loc_opc != DW_OP_deref_size
13393 || last1->dw_loc_oprnd1.v.val_int
13394 > GET_MODE_SIZE (op_mode))
13396 add_loc_descr (&op1, int_loc_descriptor (mask));
13397 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
13402 HOST_WIDE_INT bias = 1;
13403 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
13404 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
13405 if (CONST_INT_P (XEXP (rtl, 1)))
13406 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
13407 + INTVAL (XEXP (rtl, 1)));
13409 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
13419 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
13420 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
13421 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
13424 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13425 VAR_INIT_STATUS_INITIALIZED);
13426 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13427 VAR_INIT_STATUS_INITIALIZED);
13429 if (op0 == 0 || op1 == 0)
13432 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
13433 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
13434 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
13435 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
13437 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
13439 HOST_WIDE_INT mask = GET_MODE_MASK (GET_MODE (XEXP (rtl, 0)));
13440 add_loc_descr (&op0, int_loc_descriptor (mask));
13441 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
13442 add_loc_descr (&op1, int_loc_descriptor (mask));
13443 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
13447 HOST_WIDE_INT bias = 1;
13448 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
13449 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
13450 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
13453 else if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
13455 int shift = DWARF2_ADDR_SIZE
13456 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
13457 shift *= BITS_PER_UNIT;
13458 add_loc_descr (&op0, int_loc_descriptor (shift));
13459 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
13460 add_loc_descr (&op1, int_loc_descriptor (shift));
13461 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
13464 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
13468 mem_loc_result = op0;
13469 add_loc_descr (&mem_loc_result, op1);
13470 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13472 dw_loc_descr_ref bra_node, drop_node;
13474 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
13475 add_loc_descr (&mem_loc_result, bra_node);
13476 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
13477 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
13478 add_loc_descr (&mem_loc_result, drop_node);
13479 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
13480 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
13486 if (CONST_INT_P (XEXP (rtl, 1))
13487 && CONST_INT_P (XEXP (rtl, 2))
13488 && ((unsigned) INTVAL (XEXP (rtl, 1))
13489 + (unsigned) INTVAL (XEXP (rtl, 2))
13490 <= GET_MODE_BITSIZE (GET_MODE (rtl)))
13491 && GET_MODE_BITSIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
13492 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
13495 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13496 VAR_INIT_STATUS_INITIALIZED);
13499 if (GET_CODE (rtl) == SIGN_EXTRACT)
13503 mem_loc_result = op0;
13504 size = INTVAL (XEXP (rtl, 1));
13505 shift = INTVAL (XEXP (rtl, 2));
13506 if (BITS_BIG_ENDIAN)
13507 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
13509 if (shift + size != (int) DWARF2_ADDR_SIZE)
13511 add_loc_descr (&mem_loc_result,
13512 int_loc_descriptor (DWARF2_ADDR_SIZE
13514 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
13516 if (size != (int) DWARF2_ADDR_SIZE)
13518 add_loc_descr (&mem_loc_result,
13519 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
13520 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13530 /* In theory, we could implement the above. */
13531 /* DWARF cannot represent the unsigned compare operations
13558 case FLOAT_TRUNCATE:
13560 case UNSIGNED_FLOAT:
13563 case FRACT_CONVERT:
13564 case UNSIGNED_FRACT_CONVERT:
13566 case UNSIGNED_SAT_FRACT:
13577 /* If delegitimize_address couldn't do anything with the UNSPEC, we
13578 can't express it in the debug info. This can happen e.g. with some
13583 resolve_one_addr (&rtl, NULL);
13587 #ifdef ENABLE_CHECKING
13588 print_rtl (stderr, rtl);
13589 gcc_unreachable ();
13595 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13596 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13598 return mem_loc_result;
13601 /* Return a descriptor that describes the concatenation of two locations.
13602 This is typically a complex variable. */
13604 static dw_loc_descr_ref
13605 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
13607 dw_loc_descr_ref cc_loc_result = NULL;
13608 dw_loc_descr_ref x0_ref
13609 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13610 dw_loc_descr_ref x1_ref
13611 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13613 if (x0_ref == 0 || x1_ref == 0)
13616 cc_loc_result = x0_ref;
13617 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
13619 add_loc_descr (&cc_loc_result, x1_ref);
13620 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
13622 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13623 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13625 return cc_loc_result;
13628 /* Return a descriptor that describes the concatenation of N
13631 static dw_loc_descr_ref
13632 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
13635 dw_loc_descr_ref cc_loc_result = NULL;
13636 unsigned int n = XVECLEN (concatn, 0);
13638 for (i = 0; i < n; ++i)
13640 dw_loc_descr_ref ref;
13641 rtx x = XVECEXP (concatn, 0, i);
13643 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
13647 add_loc_descr (&cc_loc_result, ref);
13648 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
13651 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13652 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13654 return cc_loc_result;
13657 /* Output a proper Dwarf location descriptor for a variable or parameter
13658 which is either allocated in a register or in a memory location. For a
13659 register, we just generate an OP_REG and the register number. For a
13660 memory location we provide a Dwarf postfix expression describing how to
13661 generate the (dynamic) address of the object onto the address stack.
13663 MODE is mode of the decl if this loc_descriptor is going to be used in
13664 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
13665 allowed, VOIDmode otherwise.
13667 If we don't know how to describe it, return 0. */
13669 static dw_loc_descr_ref
13670 loc_descriptor (rtx rtl, enum machine_mode mode,
13671 enum var_init_status initialized)
13673 dw_loc_descr_ref loc_result = NULL;
13675 switch (GET_CODE (rtl))
13678 /* The case of a subreg may arise when we have a local (register)
13679 variable or a formal (register) parameter which doesn't quite fill
13680 up an entire register. For now, just assume that it is
13681 legitimate to make the Dwarf info refer to the whole register which
13682 contains the given subreg. */
13683 loc_result = loc_descriptor (SUBREG_REG (rtl), mode, initialized);
13687 loc_result = reg_loc_descriptor (rtl, initialized);
13692 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
13696 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
13698 if (loc_result == NULL)
13699 loc_result = tls_mem_loc_descriptor (rtl);
13700 if (loc_result == NULL)
13702 rtx new_rtl = avoid_constant_pool_reference (rtl);
13703 if (new_rtl != rtl)
13704 loc_result = loc_descriptor (new_rtl, mode, initialized);
13709 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
13714 loc_result = concatn_loc_descriptor (rtl, initialized);
13719 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
13721 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), mode,
13726 rtl = XEXP (rtl, 1);
13731 rtvec par_elems = XVEC (rtl, 0);
13732 int num_elem = GET_NUM_ELEM (par_elems);
13733 enum machine_mode mode;
13736 /* Create the first one, so we have something to add to. */
13737 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
13738 VOIDmode, initialized);
13739 if (loc_result == NULL)
13741 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
13742 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13743 for (i = 1; i < num_elem; i++)
13745 dw_loc_descr_ref temp;
13747 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
13748 VOIDmode, initialized);
13751 add_loc_descr (&loc_result, temp);
13752 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
13753 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
13759 if (mode != VOIDmode && mode != BLKmode)
13760 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
13765 if (mode == VOIDmode)
13766 mode = GET_MODE (rtl);
13768 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13770 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13772 /* Note that a CONST_DOUBLE rtx could represent either an integer
13773 or a floating-point constant. A CONST_DOUBLE is used whenever
13774 the constant requires more than one word in order to be
13775 adequately represented. We output CONST_DOUBLEs as blocks. */
13776 loc_result = new_loc_descr (DW_OP_implicit_value,
13777 GET_MODE_SIZE (mode), 0);
13778 if (SCALAR_FLOAT_MODE_P (mode))
13780 unsigned int length = GET_MODE_SIZE (mode);
13781 unsigned char *array = GGC_NEWVEC (unsigned char, length);
13783 insert_float (rtl, array);
13784 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13785 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
13786 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
13787 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13791 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
13792 loc_result->dw_loc_oprnd2.v.val_double.high
13793 = CONST_DOUBLE_HIGH (rtl);
13794 loc_result->dw_loc_oprnd2.v.val_double.low
13795 = CONST_DOUBLE_LOW (rtl);
13801 if (mode == VOIDmode)
13802 mode = GET_MODE (rtl);
13804 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
13806 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
13807 unsigned int length = CONST_VECTOR_NUNITS (rtl);
13808 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
13812 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
13813 switch (GET_MODE_CLASS (mode))
13815 case MODE_VECTOR_INT:
13816 for (i = 0, p = array; i < length; i++, p += elt_size)
13818 rtx elt = CONST_VECTOR_ELT (rtl, i);
13819 HOST_WIDE_INT lo, hi;
13821 switch (GET_CODE (elt))
13829 lo = CONST_DOUBLE_LOW (elt);
13830 hi = CONST_DOUBLE_HIGH (elt);
13834 gcc_unreachable ();
13837 if (elt_size <= sizeof (HOST_WIDE_INT))
13838 insert_int (lo, elt_size, p);
13841 unsigned char *p0 = p;
13842 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
13844 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
13845 if (WORDS_BIG_ENDIAN)
13850 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
13851 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
13856 case MODE_VECTOR_FLOAT:
13857 for (i = 0, p = array; i < length; i++, p += elt_size)
13859 rtx elt = CONST_VECTOR_ELT (rtl, i);
13860 insert_float (elt, p);
13865 gcc_unreachable ();
13868 loc_result = new_loc_descr (DW_OP_implicit_value,
13869 length * elt_size, 0);
13870 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
13871 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
13872 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
13873 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
13878 if (mode == VOIDmode
13879 || GET_CODE (XEXP (rtl, 0)) == CONST_INT
13880 || GET_CODE (XEXP (rtl, 0)) == CONST_DOUBLE
13881 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
13883 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
13888 if (!const_ok_for_output (rtl))
13891 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
13892 && (dwarf_version >= 4 || !dwarf_strict))
13894 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
13895 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
13896 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
13897 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
13898 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
13903 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
13904 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
13905 && (dwarf_version >= 4 || !dwarf_strict))
13907 /* Value expression. */
13908 loc_result = mem_loc_descriptor (rtl, VOIDmode, initialized);
13910 add_loc_descr (&loc_result,
13911 new_loc_descr (DW_OP_stack_value, 0, 0));
13919 /* We need to figure out what section we should use as the base for the
13920 address ranges where a given location is valid.
13921 1. If this particular DECL has a section associated with it, use that.
13922 2. If this function has a section associated with it, use that.
13923 3. Otherwise, use the text section.
13924 XXX: If you split a variable across multiple sections, we won't notice. */
13926 static const char *
13927 secname_for_decl (const_tree decl)
13929 const char *secname;
13931 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
13933 tree sectree = DECL_SECTION_NAME (decl);
13934 secname = TREE_STRING_POINTER (sectree);
13936 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
13938 tree sectree = DECL_SECTION_NAME (current_function_decl);
13939 secname = TREE_STRING_POINTER (sectree);
13941 else if (cfun && in_cold_section_p)
13942 secname = crtl->subsections.cold_section_label;
13944 secname = text_section_label;
13949 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
13952 decl_by_reference_p (tree decl)
13954 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
13955 || TREE_CODE (decl) == VAR_DECL)
13956 && DECL_BY_REFERENCE (decl));
13959 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
13962 static dw_loc_descr_ref
13963 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
13964 enum var_init_status initialized)
13966 int have_address = 0;
13967 dw_loc_descr_ref descr;
13968 enum machine_mode mode;
13970 if (want_address != 2)
13972 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
13974 if (GET_CODE (XEXP (varloc, 1)) != PARALLEL)
13976 varloc = XEXP (XEXP (varloc, 1), 0);
13977 mode = GET_MODE (varloc);
13978 if (MEM_P (varloc))
13980 rtx addr = XEXP (varloc, 0);
13981 descr = mem_loc_descriptor (addr, mode, initialized);
13986 rtx x = avoid_constant_pool_reference (varloc);
13988 descr = mem_loc_descriptor (x, mode, initialized);
13992 descr = mem_loc_descriptor (varloc, mode, initialized);
13999 descr = loc_descriptor (varloc, DECL_MODE (loc), initialized);
14006 if (want_address == 2 && !have_address
14007 && (dwarf_version >= 4 || !dwarf_strict))
14009 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
14011 expansion_failed (loc, NULL_RTX,
14012 "DWARF address size mismatch");
14015 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
14018 /* Show if we can't fill the request for an address. */
14019 if (want_address && !have_address)
14021 expansion_failed (loc, NULL_RTX,
14022 "Want address and only have value");
14026 /* If we've got an address and don't want one, dereference. */
14027 if (!want_address && have_address)
14029 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
14030 enum dwarf_location_atom op;
14032 if (size > DWARF2_ADDR_SIZE || size == -1)
14034 expansion_failed (loc, NULL_RTX,
14035 "DWARF address size mismatch");
14038 else if (size == DWARF2_ADDR_SIZE)
14041 op = DW_OP_deref_size;
14043 add_loc_descr (&descr, new_loc_descr (op, size, 0));
14049 /* Return the dwarf representation of the location list LOC_LIST of
14050 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14053 static dw_loc_list_ref
14054 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
14056 const char *endname, *secname;
14058 enum var_init_status initialized;
14059 struct var_loc_node *node;
14060 dw_loc_descr_ref descr;
14061 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
14062 dw_loc_list_ref list = NULL;
14063 dw_loc_list_ref *listp = &list;
14065 /* Now that we know what section we are using for a base,
14066 actually construct the list of locations.
14067 The first location information is what is passed to the
14068 function that creates the location list, and the remaining
14069 locations just get added on to that list.
14070 Note that we only know the start address for a location
14071 (IE location changes), so to build the range, we use
14072 the range [current location start, next location start].
14073 This means we have to special case the last node, and generate
14074 a range of [last location start, end of function label]. */
14076 secname = secname_for_decl (decl);
14078 for (node = loc_list->first; node->next; node = node->next)
14079 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
14081 /* The variable has a location between NODE->LABEL and
14082 NODE->NEXT->LABEL. */
14083 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
14084 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
14085 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
14088 *listp = new_loc_list (descr, node->label, node->next->label,
14090 listp = &(*listp)->dw_loc_next;
14094 /* If the variable has a location at the last label
14095 it keeps its location until the end of function. */
14096 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
14098 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
14099 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
14100 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
14103 if (!current_function_decl)
14104 endname = text_end_label;
14107 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
14108 current_function_funcdef_no);
14109 endname = ggc_strdup (label_id);
14112 *listp = new_loc_list (descr, node->label, endname, secname);
14113 listp = &(*listp)->dw_loc_next;
14117 /* Try to avoid the overhead of a location list emitting a location
14118 expression instead, but only if we didn't have more than one
14119 location entry in the first place. If some entries were not
14120 representable, we don't want to pretend a single entry that was
14121 applies to the entire scope in which the variable is
14123 if (list && loc_list->first->next)
14129 /* Return if the loc_list has only single element and thus can be represented
14130 as location description. */
14133 single_element_loc_list_p (dw_loc_list_ref list)
14135 gcc_assert (!list->dw_loc_next || list->ll_symbol);
14136 return !list->ll_symbol;
14139 /* To each location in list LIST add loc descr REF. */
14142 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
14144 dw_loc_descr_ref copy;
14145 add_loc_descr (&list->expr, ref);
14146 list = list->dw_loc_next;
14149 copy = GGC_CNEW (dw_loc_descr_node);
14150 memcpy (copy, ref, sizeof (dw_loc_descr_node));
14151 add_loc_descr (&list->expr, copy);
14152 while (copy->dw_loc_next)
14154 dw_loc_descr_ref new_copy = GGC_CNEW (dw_loc_descr_node);
14155 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
14156 copy->dw_loc_next = new_copy;
14159 list = list->dw_loc_next;
14163 /* Given two lists RET and LIST
14164 produce location list that is result of adding expression in LIST
14165 to expression in RET on each possition in program.
14166 Might be destructive on both RET and LIST.
14168 TODO: We handle only simple cases of RET or LIST having at most one
14169 element. General case would inolve sorting the lists in program order
14170 and merging them that will need some additional work.
14171 Adding that will improve quality of debug info especially for SRA-ed
14175 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
14184 if (!list->dw_loc_next)
14186 add_loc_descr_to_each (*ret, list->expr);
14189 if (!(*ret)->dw_loc_next)
14191 add_loc_descr_to_each (list, (*ret)->expr);
14195 expansion_failed (NULL_TREE, NULL_RTX,
14196 "Don't know how to merge two non-trivial"
14197 " location lists.\n");
14202 /* LOC is constant expression. Try a luck, look it up in constant
14203 pool and return its loc_descr of its address. */
14205 static dw_loc_descr_ref
14206 cst_pool_loc_descr (tree loc)
14208 /* Get an RTL for this, if something has been emitted. */
14209 rtx rtl = lookup_constant_def (loc);
14210 enum machine_mode mode;
14212 if (!rtl || !MEM_P (rtl))
14217 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
14219 /* TODO: We might get more coverage if we was actually delaying expansion
14220 of all expressions till end of compilation when constant pools are fully
14222 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
14224 expansion_failed (loc, NULL_RTX,
14225 "CST value in contant pool but not marked.");
14228 mode = GET_MODE (rtl);
14229 rtl = XEXP (rtl, 0);
14230 return mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
14233 /* Return dw_loc_list representing address of addr_expr LOC
14234 by looking for innder INDIRECT_REF expression and turing it
14235 into simple arithmetics. */
14237 static dw_loc_list_ref
14238 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev)
14241 HOST_WIDE_INT bitsize, bitpos, bytepos;
14242 enum machine_mode mode;
14244 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
14245 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14247 obj = get_inner_reference (TREE_OPERAND (loc, 0),
14248 &bitsize, &bitpos, &offset, &mode,
14249 &unsignedp, &volatilep, false);
14251 if (bitpos % BITS_PER_UNIT)
14253 expansion_failed (loc, NULL_RTX, "bitfield access");
14256 if (!INDIRECT_REF_P (obj))
14258 expansion_failed (obj,
14259 NULL_RTX, "no indirect ref in inner refrence");
14262 if (!offset && !bitpos)
14263 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1);
14265 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
14266 && (dwarf_version >= 4 || !dwarf_strict))
14268 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0);
14273 /* Variable offset. */
14274 list_ret1 = loc_list_from_tree (offset, 0);
14275 if (list_ret1 == 0)
14277 add_loc_list (&list_ret, list_ret1);
14280 add_loc_descr_to_each (list_ret,
14281 new_loc_descr (DW_OP_plus, 0, 0));
14283 bytepos = bitpos / BITS_PER_UNIT;
14285 add_loc_descr_to_each (list_ret,
14286 new_loc_descr (DW_OP_plus_uconst,
14288 else if (bytepos < 0)
14289 loc_list_plus_const (list_ret, bytepos);
14290 add_loc_descr_to_each (list_ret,
14291 new_loc_descr (DW_OP_stack_value, 0, 0));
14297 /* Generate Dwarf location list representing LOC.
14298 If WANT_ADDRESS is false, expression computing LOC will be computed
14299 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14300 if WANT_ADDRESS is 2, expression computing address useable in location
14301 will be returned (i.e. DW_OP_reg can be used
14302 to refer to register values). */
14304 static dw_loc_list_ref
14305 loc_list_from_tree (tree loc, int want_address)
14307 dw_loc_descr_ref ret = NULL, ret1 = NULL;
14308 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14309 int have_address = 0;
14310 enum dwarf_location_atom op;
14312 /* ??? Most of the time we do not take proper care for sign/zero
14313 extending the values properly. Hopefully this won't be a real
14316 switch (TREE_CODE (loc))
14319 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
14322 case PLACEHOLDER_EXPR:
14323 /* This case involves extracting fields from an object to determine the
14324 position of other fields. We don't try to encode this here. The
14325 only user of this is Ada, which encodes the needed information using
14326 the names of types. */
14327 expansion_failed (loc, NULL_RTX, "PLACEHOLDER_EXPR");
14331 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
14332 /* There are no opcodes for these operations. */
14335 case PREINCREMENT_EXPR:
14336 case PREDECREMENT_EXPR:
14337 case POSTINCREMENT_EXPR:
14338 case POSTDECREMENT_EXPR:
14339 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
14340 /* There are no opcodes for these operations. */
14344 /* If we already want an address, see if there is INDIRECT_REF inside
14345 e.g. for &this->field. */
14348 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
14349 (loc, want_address == 2);
14352 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
14353 && (ret = cst_pool_loc_descr (loc)))
14356 /* Otherwise, process the argument and look for the address. */
14357 if (!list_ret && !ret)
14358 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1);
14362 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
14368 if (DECL_THREAD_LOCAL_P (loc))
14371 enum dwarf_location_atom first_op;
14372 enum dwarf_location_atom second_op;
14373 bool dtprel = false;
14375 if (targetm.have_tls)
14377 /* If this is not defined, we have no way to emit the
14379 if (!targetm.asm_out.output_dwarf_dtprel)
14382 /* The way DW_OP_GNU_push_tls_address is specified, we
14383 can only look up addresses of objects in the current
14385 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
14387 first_op = DW_OP_addr;
14389 second_op = DW_OP_GNU_push_tls_address;
14393 if (!targetm.emutls.debug_form_tls_address
14394 || !(dwarf_version >= 3 || !dwarf_strict))
14396 loc = emutls_decl (loc);
14397 first_op = DW_OP_addr;
14398 second_op = DW_OP_form_tls_address;
14401 rtl = rtl_for_decl_location (loc);
14402 if (rtl == NULL_RTX)
14407 rtl = XEXP (rtl, 0);
14408 if (! CONSTANT_P (rtl))
14411 ret = new_loc_descr (first_op, 0, 0);
14412 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
14413 ret->dw_loc_oprnd1.v.val_addr = rtl;
14414 ret->dtprel = dtprel;
14416 ret1 = new_loc_descr (second_op, 0, 0);
14417 add_loc_descr (&ret, ret1);
14425 if (DECL_HAS_VALUE_EXPR_P (loc))
14426 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
14431 case FUNCTION_DECL:
14434 var_loc_list *loc_list = lookup_decl_loc (loc);
14436 if (loc_list && loc_list->first)
14438 list_ret = dw_loc_list (loc_list, loc, want_address);
14439 have_address = want_address != 0;
14442 rtl = rtl_for_decl_location (loc);
14443 if (rtl == NULL_RTX)
14445 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
14448 else if (CONST_INT_P (rtl))
14450 HOST_WIDE_INT val = INTVAL (rtl);
14451 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14452 val &= GET_MODE_MASK (DECL_MODE (loc));
14453 ret = int_loc_descriptor (val);
14455 else if (GET_CODE (rtl) == CONST_STRING)
14457 expansion_failed (loc, NULL_RTX, "CONST_STRING");
14460 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
14462 ret = new_loc_descr (DW_OP_addr, 0, 0);
14463 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
14464 ret->dw_loc_oprnd1.v.val_addr = rtl;
14468 enum machine_mode mode;
14470 /* Certain constructs can only be represented at top-level. */
14471 if (want_address == 2)
14473 ret = loc_descriptor (rtl, VOIDmode,
14474 VAR_INIT_STATUS_INITIALIZED);
14479 mode = GET_MODE (rtl);
14482 rtl = XEXP (rtl, 0);
14485 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
14488 expansion_failed (loc, rtl,
14489 "failed to produce loc descriptor for rtl");
14495 case ALIGN_INDIRECT_REF:
14496 case MISALIGNED_INDIRECT_REF:
14497 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
14501 case COMPOUND_EXPR:
14502 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address);
14505 case VIEW_CONVERT_EXPR:
14508 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address);
14510 case COMPONENT_REF:
14511 case BIT_FIELD_REF:
14513 case ARRAY_RANGE_REF:
14514 case REALPART_EXPR:
14515 case IMAGPART_EXPR:
14518 HOST_WIDE_INT bitsize, bitpos, bytepos;
14519 enum machine_mode mode;
14521 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
14523 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
14524 &unsignedp, &volatilep, false);
14526 gcc_assert (obj != loc);
14528 list_ret = loc_list_from_tree (obj,
14530 && !bitpos && !offset ? 2 : 1);
14531 /* TODO: We can extract value of the small expression via shifting even
14532 for nonzero bitpos. */
14535 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
14537 expansion_failed (loc, NULL_RTX,
14538 "bitfield access");
14542 if (offset != NULL_TREE)
14544 /* Variable offset. */
14545 list_ret1 = loc_list_from_tree (offset, 0);
14546 if (list_ret1 == 0)
14548 add_loc_list (&list_ret, list_ret1);
14551 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
14554 bytepos = bitpos / BITS_PER_UNIT;
14556 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
14557 else if (bytepos < 0)
14558 loc_list_plus_const (list_ret, bytepos);
14565 if ((want_address || !host_integerp (loc, 0))
14566 && (ret = cst_pool_loc_descr (loc)))
14568 else if (want_address == 2
14569 && host_integerp (loc, 0)
14570 && (ret = address_of_int_loc_descriptor
14571 (int_size_in_bytes (TREE_TYPE (loc)),
14572 tree_low_cst (loc, 0))))
14574 else if (host_integerp (loc, 0))
14575 ret = int_loc_descriptor (tree_low_cst (loc, 0));
14578 expansion_failed (loc, NULL_RTX,
14579 "Integer operand is not host integer");
14588 if ((ret = cst_pool_loc_descr (loc)))
14591 /* We can construct small constants here using int_loc_descriptor. */
14592 expansion_failed (loc, NULL_RTX,
14593 "constructor or constant not in constant pool");
14596 case TRUTH_AND_EXPR:
14597 case TRUTH_ANDIF_EXPR:
14602 case TRUTH_XOR_EXPR:
14607 case TRUTH_OR_EXPR:
14608 case TRUTH_ORIF_EXPR:
14613 case FLOOR_DIV_EXPR:
14614 case CEIL_DIV_EXPR:
14615 case ROUND_DIV_EXPR:
14616 case TRUNC_DIV_EXPR:
14617 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14626 case FLOOR_MOD_EXPR:
14627 case CEIL_MOD_EXPR:
14628 case ROUND_MOD_EXPR:
14629 case TRUNC_MOD_EXPR:
14630 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
14635 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
14636 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
14637 if (list_ret == 0 || list_ret1 == 0)
14640 add_loc_list (&list_ret, list_ret1);
14643 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
14644 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
14645 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
14646 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
14647 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
14659 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
14662 case POINTER_PLUS_EXPR:
14664 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
14665 && host_integerp (TREE_OPERAND (loc, 1), 0))
14667 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
14671 loc_list_plus_const (list_ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
14679 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14686 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14693 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14700 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
14715 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
14716 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
14717 if (list_ret == 0 || list_ret1 == 0)
14720 add_loc_list (&list_ret, list_ret1);
14723 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14726 case TRUTH_NOT_EXPR:
14740 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
14744 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
14750 const enum tree_code code =
14751 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
14753 loc = build3 (COND_EXPR, TREE_TYPE (loc),
14754 build2 (code, integer_type_node,
14755 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
14756 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
14759 /* ... fall through ... */
14763 dw_loc_descr_ref lhs
14764 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
14765 dw_loc_list_ref rhs
14766 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0);
14767 dw_loc_descr_ref bra_node, jump_node, tmp;
14769 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
14770 if (list_ret == 0 || lhs == 0 || rhs == 0)
14773 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14774 add_loc_descr_to_each (list_ret, bra_node);
14776 add_loc_list (&list_ret, rhs);
14777 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
14778 add_loc_descr_to_each (list_ret, jump_node);
14780 add_loc_descr_to_each (list_ret, lhs);
14781 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14782 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
14784 /* ??? Need a node to point the skip at. Use a nop. */
14785 tmp = new_loc_descr (DW_OP_nop, 0, 0);
14786 add_loc_descr_to_each (list_ret, tmp);
14787 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14788 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
14792 case FIX_TRUNC_EXPR:
14796 /* Leave front-end specific codes as simply unknown. This comes
14797 up, for instance, with the C STMT_EXPR. */
14798 if ((unsigned int) TREE_CODE (loc)
14799 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
14801 expansion_failed (loc, NULL_RTX,
14802 "language specific tree node");
14806 #ifdef ENABLE_CHECKING
14807 /* Otherwise this is a generic code; we should just lists all of
14808 these explicitly. We forgot one. */
14809 gcc_unreachable ();
14811 /* In a release build, we want to degrade gracefully: better to
14812 generate incomplete debugging information than to crash. */
14817 if (!ret && !list_ret)
14820 if (want_address == 2 && !have_address
14821 && (dwarf_version >= 4 || !dwarf_strict))
14823 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
14825 expansion_failed (loc, NULL_RTX,
14826 "DWARF address size mismatch");
14830 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
14832 add_loc_descr_to_each (list_ret,
14833 new_loc_descr (DW_OP_stack_value, 0, 0));
14836 /* Show if we can't fill the request for an address. */
14837 if (want_address && !have_address)
14839 expansion_failed (loc, NULL_RTX,
14840 "Want address and only have value");
14844 gcc_assert (!ret || !list_ret);
14846 /* If we've got an address and don't want one, dereference. */
14847 if (!want_address && have_address)
14849 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
14851 if (size > DWARF2_ADDR_SIZE || size == -1)
14853 expansion_failed (loc, NULL_RTX,
14854 "DWARF address size mismatch");
14857 else if (size == DWARF2_ADDR_SIZE)
14860 op = DW_OP_deref_size;
14863 add_loc_descr (&ret, new_loc_descr (op, size, 0));
14865 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
14868 list_ret = new_loc_list (ret, NULL, NULL, NULL);
14873 /* Same as above but return only single location expression. */
14874 static dw_loc_descr_ref
14875 loc_descriptor_from_tree (tree loc, int want_address)
14877 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address);
14880 if (ret->dw_loc_next)
14882 expansion_failed (loc, NULL_RTX,
14883 "Location list where only loc descriptor needed");
14889 /* Given a value, round it up to the lowest multiple of `boundary'
14890 which is not less than the value itself. */
14892 static inline HOST_WIDE_INT
14893 ceiling (HOST_WIDE_INT value, unsigned int boundary)
14895 return (((value + boundary - 1) / boundary) * boundary);
14898 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
14899 pointer to the declared type for the relevant field variable, or return
14900 `integer_type_node' if the given node turns out to be an
14901 ERROR_MARK node. */
14904 field_type (const_tree decl)
14908 if (TREE_CODE (decl) == ERROR_MARK)
14909 return integer_type_node;
14911 type = DECL_BIT_FIELD_TYPE (decl);
14912 if (type == NULL_TREE)
14913 type = TREE_TYPE (decl);
14918 /* Given a pointer to a tree node, return the alignment in bits for
14919 it, or else return BITS_PER_WORD if the node actually turns out to
14920 be an ERROR_MARK node. */
14922 static inline unsigned
14923 simple_type_align_in_bits (const_tree type)
14925 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
14928 static inline unsigned
14929 simple_decl_align_in_bits (const_tree decl)
14931 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
14934 /* Return the result of rounding T up to ALIGN. */
14936 static inline HOST_WIDE_INT
14937 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
14939 /* We must be careful if T is negative because HOST_WIDE_INT can be
14940 either "above" or "below" unsigned int as per the C promotion
14941 rules, depending on the host, thus making the signedness of the
14942 direct multiplication and division unpredictable. */
14943 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
14949 return (HOST_WIDE_INT) u;
14952 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
14953 lowest addressed byte of the "containing object" for the given FIELD_DECL,
14954 or return 0 if we are unable to determine what that offset is, either
14955 because the argument turns out to be a pointer to an ERROR_MARK node, or
14956 because the offset is actually variable. (We can't handle the latter case
14959 static HOST_WIDE_INT
14960 field_byte_offset (const_tree decl)
14962 HOST_WIDE_INT object_offset_in_bits;
14963 HOST_WIDE_INT bitpos_int;
14965 if (TREE_CODE (decl) == ERROR_MARK)
14968 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
14970 /* We cannot yet cope with fields whose positions are variable, so
14971 for now, when we see such things, we simply return 0. Someday, we may
14972 be able to handle such cases, but it will be damn difficult. */
14973 if (! host_integerp (bit_position (decl), 0))
14976 bitpos_int = int_bit_position (decl);
14978 #ifdef PCC_BITFIELD_TYPE_MATTERS
14979 if (PCC_BITFIELD_TYPE_MATTERS)
14982 tree field_size_tree;
14983 HOST_WIDE_INT deepest_bitpos;
14984 unsigned HOST_WIDE_INT field_size_in_bits;
14985 unsigned int type_align_in_bits;
14986 unsigned int decl_align_in_bits;
14987 unsigned HOST_WIDE_INT type_size_in_bits;
14989 type = field_type (decl);
14990 type_size_in_bits = simple_type_size_in_bits (type);
14991 type_align_in_bits = simple_type_align_in_bits (type);
14993 field_size_tree = DECL_SIZE (decl);
14995 /* The size could be unspecified if there was an error, or for
14996 a flexible array member. */
14997 if (!field_size_tree)
14998 field_size_tree = bitsize_zero_node;
15000 /* If the size of the field is not constant, use the type size. */
15001 if (host_integerp (field_size_tree, 1))
15002 field_size_in_bits = tree_low_cst (field_size_tree, 1);
15004 field_size_in_bits = type_size_in_bits;
15006 decl_align_in_bits = simple_decl_align_in_bits (decl);
15008 /* The GCC front-end doesn't make any attempt to keep track of the
15009 starting bit offset (relative to the start of the containing
15010 structure type) of the hypothetical "containing object" for a
15011 bit-field. Thus, when computing the byte offset value for the
15012 start of the "containing object" of a bit-field, we must deduce
15013 this information on our own. This can be rather tricky to do in
15014 some cases. For example, handling the following structure type
15015 definition when compiling for an i386/i486 target (which only
15016 aligns long long's to 32-bit boundaries) can be very tricky:
15018 struct S { int field1; long long field2:31; };
15020 Fortunately, there is a simple rule-of-thumb which can be used
15021 in such cases. When compiling for an i386/i486, GCC will
15022 allocate 8 bytes for the structure shown above. It decides to
15023 do this based upon one simple rule for bit-field allocation.
15024 GCC allocates each "containing object" for each bit-field at
15025 the first (i.e. lowest addressed) legitimate alignment boundary
15026 (based upon the required minimum alignment for the declared
15027 type of the field) which it can possibly use, subject to the
15028 condition that there is still enough available space remaining
15029 in the containing object (when allocated at the selected point)
15030 to fully accommodate all of the bits of the bit-field itself.
15032 This simple rule makes it obvious why GCC allocates 8 bytes for
15033 each object of the structure type shown above. When looking
15034 for a place to allocate the "containing object" for `field2',
15035 the compiler simply tries to allocate a 64-bit "containing
15036 object" at each successive 32-bit boundary (starting at zero)
15037 until it finds a place to allocate that 64- bit field such that
15038 at least 31 contiguous (and previously unallocated) bits remain
15039 within that selected 64 bit field. (As it turns out, for the
15040 example above, the compiler finds it is OK to allocate the
15041 "containing object" 64-bit field at bit-offset zero within the
15044 Here we attempt to work backwards from the limited set of facts
15045 we're given, and we try to deduce from those facts, where GCC
15046 must have believed that the containing object started (within
15047 the structure type). The value we deduce is then used (by the
15048 callers of this routine) to generate DW_AT_location and
15049 DW_AT_bit_offset attributes for fields (both bit-fields and, in
15050 the case of DW_AT_location, regular fields as well). */
15052 /* Figure out the bit-distance from the start of the structure to
15053 the "deepest" bit of the bit-field. */
15054 deepest_bitpos = bitpos_int + field_size_in_bits;
15056 /* This is the tricky part. Use some fancy footwork to deduce
15057 where the lowest addressed bit of the containing object must
15059 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15061 /* Round up to type_align by default. This works best for
15063 object_offset_in_bits
15064 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
15066 if (object_offset_in_bits > bitpos_int)
15068 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
15070 /* Round up to decl_align instead. */
15071 object_offset_in_bits
15072 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
15077 object_offset_in_bits = bitpos_int;
15079 return object_offset_in_bits / BITS_PER_UNIT;
15082 /* The following routines define various Dwarf attributes and any data
15083 associated with them. */
15085 /* Add a location description attribute value to a DIE.
15087 This emits location attributes suitable for whole variables and
15088 whole parameters. Note that the location attributes for struct fields are
15089 generated by the routine `data_member_location_attribute' below. */
15092 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
15093 dw_loc_list_ref descr)
15097 if (single_element_loc_list_p (descr))
15098 add_AT_loc (die, attr_kind, descr->expr);
15100 add_AT_loc_list (die, attr_kind, descr);
15103 /* Attach the specialized form of location attribute used for data members of
15104 struct and union types. In the special case of a FIELD_DECL node which
15105 represents a bit-field, the "offset" part of this special location
15106 descriptor must indicate the distance in bytes from the lowest-addressed
15107 byte of the containing struct or union type to the lowest-addressed byte of
15108 the "containing object" for the bit-field. (See the `field_byte_offset'
15111 For any given bit-field, the "containing object" is a hypothetical object
15112 (of some integral or enum type) within which the given bit-field lives. The
15113 type of this hypothetical "containing object" is always the same as the
15114 declared type of the individual bit-field itself (for GCC anyway... the
15115 DWARF spec doesn't actually mandate this). Note that it is the size (in
15116 bytes) of the hypothetical "containing object" which will be given in the
15117 DW_AT_byte_size attribute for this bit-field. (See the
15118 `byte_size_attribute' function below.) It is also used when calculating the
15119 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15120 function below.) */
15123 add_data_member_location_attribute (dw_die_ref die, tree decl)
15125 HOST_WIDE_INT offset;
15126 dw_loc_descr_ref loc_descr = 0;
15128 if (TREE_CODE (decl) == TREE_BINFO)
15130 /* We're working on the TAG_inheritance for a base class. */
15131 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
15133 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15134 aren't at a fixed offset from all (sub)objects of the same
15135 type. We need to extract the appropriate offset from our
15136 vtable. The following dwarf expression means
15138 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15140 This is specific to the V3 ABI, of course. */
15142 dw_loc_descr_ref tmp;
15144 /* Make a copy of the object address. */
15145 tmp = new_loc_descr (DW_OP_dup, 0, 0);
15146 add_loc_descr (&loc_descr, tmp);
15148 /* Extract the vtable address. */
15149 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15150 add_loc_descr (&loc_descr, tmp);
15152 /* Calculate the address of the offset. */
15153 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
15154 gcc_assert (offset < 0);
15156 tmp = int_loc_descriptor (-offset);
15157 add_loc_descr (&loc_descr, tmp);
15158 tmp = new_loc_descr (DW_OP_minus, 0, 0);
15159 add_loc_descr (&loc_descr, tmp);
15161 /* Extract the offset. */
15162 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15163 add_loc_descr (&loc_descr, tmp);
15165 /* Add it to the object address. */
15166 tmp = new_loc_descr (DW_OP_plus, 0, 0);
15167 add_loc_descr (&loc_descr, tmp);
15170 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
15173 offset = field_byte_offset (decl);
15177 if (dwarf_version > 2)
15179 /* Don't need to output a location expression, just the constant. */
15180 add_AT_int (die, DW_AT_data_member_location, offset);
15185 enum dwarf_location_atom op;
15187 /* The DWARF2 standard says that we should assume that the structure
15188 address is already on the stack, so we can specify a structure
15189 field address by using DW_OP_plus_uconst. */
15191 #ifdef MIPS_DEBUGGING_INFO
15192 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
15193 operator correctly. It works only if we leave the offset on the
15197 op = DW_OP_plus_uconst;
15200 loc_descr = new_loc_descr (op, offset, 0);
15204 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
15207 /* Writes integer values to dw_vec_const array. */
15210 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
15214 *dest++ = val & 0xff;
15220 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15222 static HOST_WIDE_INT
15223 extract_int (const unsigned char *src, unsigned int size)
15225 HOST_WIDE_INT val = 0;
15231 val |= *--src & 0xff;
15237 /* Writes floating point values to dw_vec_const array. */
15240 insert_float (const_rtx rtl, unsigned char *array)
15242 REAL_VALUE_TYPE rv;
15246 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
15247 real_to_target (val, &rv, GET_MODE (rtl));
15249 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15250 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
15252 insert_int (val[i], 4, array);
15257 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15258 does not have a "location" either in memory or in a register. These
15259 things can arise in GNU C when a constant is passed as an actual parameter
15260 to an inlined function. They can also arise in C++ where declared
15261 constants do not necessarily get memory "homes". */
15264 add_const_value_attribute (dw_die_ref die, rtx rtl)
15266 switch (GET_CODE (rtl))
15270 HOST_WIDE_INT val = INTVAL (rtl);
15273 add_AT_int (die, DW_AT_const_value, val);
15275 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
15280 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
15281 floating-point constant. A CONST_DOUBLE is used whenever the
15282 constant requires more than one word in order to be adequately
15285 enum machine_mode mode = GET_MODE (rtl);
15287 if (SCALAR_FLOAT_MODE_P (mode))
15289 unsigned int length = GET_MODE_SIZE (mode);
15290 unsigned char *array = GGC_NEWVEC (unsigned char, length);
15292 insert_float (rtl, array);
15293 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
15296 add_AT_double (die, DW_AT_const_value,
15297 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
15303 enum machine_mode mode = GET_MODE (rtl);
15304 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
15305 unsigned int length = CONST_VECTOR_NUNITS (rtl);
15306 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
15310 switch (GET_MODE_CLASS (mode))
15312 case MODE_VECTOR_INT:
15313 for (i = 0, p = array; i < length; i++, p += elt_size)
15315 rtx elt = CONST_VECTOR_ELT (rtl, i);
15316 HOST_WIDE_INT lo, hi;
15318 switch (GET_CODE (elt))
15326 lo = CONST_DOUBLE_LOW (elt);
15327 hi = CONST_DOUBLE_HIGH (elt);
15331 gcc_unreachable ();
15334 if (elt_size <= sizeof (HOST_WIDE_INT))
15335 insert_int (lo, elt_size, p);
15338 unsigned char *p0 = p;
15339 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
15341 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
15342 if (WORDS_BIG_ENDIAN)
15347 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
15348 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
15353 case MODE_VECTOR_FLOAT:
15354 for (i = 0, p = array; i < length; i++, p += elt_size)
15356 rtx elt = CONST_VECTOR_ELT (rtl, i);
15357 insert_float (elt, p);
15362 gcc_unreachable ();
15365 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
15370 if (dwarf_version >= 4 || !dwarf_strict)
15372 dw_loc_descr_ref loc_result;
15373 resolve_one_addr (&rtl, NULL);
15375 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
15376 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
15377 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
15378 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
15379 add_AT_loc (die, DW_AT_location, loc_result);
15380 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
15386 if (CONSTANT_P (XEXP (rtl, 0)))
15387 return add_const_value_attribute (die, XEXP (rtl, 0));
15390 if (!const_ok_for_output (rtl))
15393 if (dwarf_version >= 4 || !dwarf_strict)
15398 /* In cases where an inlined instance of an inline function is passed
15399 the address of an `auto' variable (which is local to the caller) we
15400 can get a situation where the DECL_RTL of the artificial local
15401 variable (for the inlining) which acts as a stand-in for the
15402 corresponding formal parameter (of the inline function) will look
15403 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
15404 exactly a compile-time constant expression, but it isn't the address
15405 of the (artificial) local variable either. Rather, it represents the
15406 *value* which the artificial local variable always has during its
15407 lifetime. We currently have no way to represent such quasi-constant
15408 values in Dwarf, so for now we just punt and generate nothing. */
15416 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
15417 && MEM_READONLY_P (rtl)
15418 && GET_MODE (rtl) == BLKmode)
15420 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
15426 /* No other kinds of rtx should be possible here. */
15427 gcc_unreachable ();
15432 /* Determine whether the evaluation of EXPR references any variables
15433 or functions which aren't otherwise used (and therefore may not be
15436 reference_to_unused (tree * tp, int * walk_subtrees,
15437 void * data ATTRIBUTE_UNUSED)
15439 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
15440 *walk_subtrees = 0;
15442 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
15443 && ! TREE_ASM_WRITTEN (*tp))
15445 /* ??? The C++ FE emits debug information for using decls, so
15446 putting gcc_unreachable here falls over. See PR31899. For now
15447 be conservative. */
15448 else if (!cgraph_global_info_ready
15449 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
15451 else if (TREE_CODE (*tp) == VAR_DECL)
15453 struct varpool_node *node = varpool_node (*tp);
15457 else if (TREE_CODE (*tp) == FUNCTION_DECL
15458 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
15460 /* The call graph machinery must have finished analyzing,
15461 optimizing and gimplifying the CU by now.
15462 So if *TP has no call graph node associated
15463 to it, it means *TP will not be emitted. */
15464 if (!cgraph_get_node (*tp))
15467 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
15473 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
15474 for use in a later add_const_value_attribute call. */
15477 rtl_for_decl_init (tree init, tree type)
15479 rtx rtl = NULL_RTX;
15481 /* If a variable is initialized with a string constant without embedded
15482 zeros, build CONST_STRING. */
15483 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
15485 tree enttype = TREE_TYPE (type);
15486 tree domain = TYPE_DOMAIN (type);
15487 enum machine_mode mode = TYPE_MODE (enttype);
15489 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
15491 && integer_zerop (TYPE_MIN_VALUE (domain))
15492 && compare_tree_int (TYPE_MAX_VALUE (domain),
15493 TREE_STRING_LENGTH (init) - 1) == 0
15494 && ((size_t) TREE_STRING_LENGTH (init)
15495 == strlen (TREE_STRING_POINTER (init)) + 1))
15497 rtl = gen_rtx_CONST_STRING (VOIDmode,
15498 ggc_strdup (TREE_STRING_POINTER (init)));
15499 rtl = gen_rtx_MEM (BLKmode, rtl);
15500 MEM_READONLY_P (rtl) = 1;
15503 /* Other aggregates, and complex values, could be represented using
15505 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
15507 /* Vectors only work if their mode is supported by the target.
15508 FIXME: generic vectors ought to work too. */
15509 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
15511 /* If the initializer is something that we know will expand into an
15512 immediate RTL constant, expand it now. We must be careful not to
15513 reference variables which won't be output. */
15514 else if (initializer_constant_valid_p (init, type)
15515 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
15517 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
15519 if (TREE_CODE (type) == VECTOR_TYPE)
15520 switch (TREE_CODE (init))
15525 if (TREE_CONSTANT (init))
15527 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
15528 bool constant_p = true;
15530 unsigned HOST_WIDE_INT ix;
15532 /* Even when ctor is constant, it might contain non-*_CST
15533 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
15534 belong into VECTOR_CST nodes. */
15535 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
15536 if (!CONSTANT_CLASS_P (value))
15538 constant_p = false;
15544 init = build_vector_from_ctor (type, elts);
15554 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
15556 /* If expand_expr returns a MEM, it wasn't immediate. */
15557 gcc_assert (!rtl || !MEM_P (rtl));
15563 /* Generate RTL for the variable DECL to represent its location. */
15566 rtl_for_decl_location (tree decl)
15570 /* Here we have to decide where we are going to say the parameter "lives"
15571 (as far as the debugger is concerned). We only have a couple of
15572 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
15574 DECL_RTL normally indicates where the parameter lives during most of the
15575 activation of the function. If optimization is enabled however, this
15576 could be either NULL or else a pseudo-reg. Both of those cases indicate
15577 that the parameter doesn't really live anywhere (as far as the code
15578 generation parts of GCC are concerned) during most of the function's
15579 activation. That will happen (for example) if the parameter is never
15580 referenced within the function.
15582 We could just generate a location descriptor here for all non-NULL
15583 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
15584 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
15585 where DECL_RTL is NULL or is a pseudo-reg.
15587 Note however that we can only get away with using DECL_INCOMING_RTL as
15588 a backup substitute for DECL_RTL in certain limited cases. In cases
15589 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
15590 we can be sure that the parameter was passed using the same type as it is
15591 declared to have within the function, and that its DECL_INCOMING_RTL
15592 points us to a place where a value of that type is passed.
15594 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
15595 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
15596 because in these cases DECL_INCOMING_RTL points us to a value of some
15597 type which is *different* from the type of the parameter itself. Thus,
15598 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
15599 such cases, the debugger would end up (for example) trying to fetch a
15600 `float' from a place which actually contains the first part of a
15601 `double'. That would lead to really incorrect and confusing
15602 output at debug-time.
15604 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
15605 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
15606 are a couple of exceptions however. On little-endian machines we can
15607 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
15608 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
15609 an integral type that is smaller than TREE_TYPE (decl). These cases arise
15610 when (on a little-endian machine) a non-prototyped function has a
15611 parameter declared to be of type `short' or `char'. In such cases,
15612 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
15613 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
15614 passed `int' value. If the debugger then uses that address to fetch
15615 a `short' or a `char' (on a little-endian machine) the result will be
15616 the correct data, so we allow for such exceptional cases below.
15618 Note that our goal here is to describe the place where the given formal
15619 parameter lives during most of the function's activation (i.e. between the
15620 end of the prologue and the start of the epilogue). We'll do that as best
15621 as we can. Note however that if the given formal parameter is modified
15622 sometime during the execution of the function, then a stack backtrace (at
15623 debug-time) will show the function as having been called with the *new*
15624 value rather than the value which was originally passed in. This happens
15625 rarely enough that it is not a major problem, but it *is* a problem, and
15626 I'd like to fix it.
15628 A future version of dwarf2out.c may generate two additional attributes for
15629 any given DW_TAG_formal_parameter DIE which will describe the "passed
15630 type" and the "passed location" for the given formal parameter in addition
15631 to the attributes we now generate to indicate the "declared type" and the
15632 "active location" for each parameter. This additional set of attributes
15633 could be used by debuggers for stack backtraces. Separately, note that
15634 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
15635 This happens (for example) for inlined-instances of inline function formal
15636 parameters which are never referenced. This really shouldn't be
15637 happening. All PARM_DECL nodes should get valid non-NULL
15638 DECL_INCOMING_RTL values. FIXME. */
15640 /* Use DECL_RTL as the "location" unless we find something better. */
15641 rtl = DECL_RTL_IF_SET (decl);
15643 /* When generating abstract instances, ignore everything except
15644 constants, symbols living in memory, and symbols living in
15645 fixed registers. */
15646 if (! reload_completed)
15649 && (CONSTANT_P (rtl)
15651 && CONSTANT_P (XEXP (rtl, 0)))
15653 && TREE_CODE (decl) == VAR_DECL
15654 && TREE_STATIC (decl))))
15656 rtl = targetm.delegitimize_address (rtl);
15661 else if (TREE_CODE (decl) == PARM_DECL)
15663 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
15665 tree declared_type = TREE_TYPE (decl);
15666 tree passed_type = DECL_ARG_TYPE (decl);
15667 enum machine_mode dmode = TYPE_MODE (declared_type);
15668 enum machine_mode pmode = TYPE_MODE (passed_type);
15670 /* This decl represents a formal parameter which was optimized out.
15671 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
15672 all cases where (rtl == NULL_RTX) just below. */
15673 if (dmode == pmode)
15674 rtl = DECL_INCOMING_RTL (decl);
15675 else if (SCALAR_INT_MODE_P (dmode)
15676 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
15677 && DECL_INCOMING_RTL (decl))
15679 rtx inc = DECL_INCOMING_RTL (decl);
15682 else if (MEM_P (inc))
15684 if (BYTES_BIG_ENDIAN)
15685 rtl = adjust_address_nv (inc, dmode,
15686 GET_MODE_SIZE (pmode)
15687 - GET_MODE_SIZE (dmode));
15694 /* If the parm was passed in registers, but lives on the stack, then
15695 make a big endian correction if the mode of the type of the
15696 parameter is not the same as the mode of the rtl. */
15697 /* ??? This is the same series of checks that are made in dbxout.c before
15698 we reach the big endian correction code there. It isn't clear if all
15699 of these checks are necessary here, but keeping them all is the safe
15701 else if (MEM_P (rtl)
15702 && XEXP (rtl, 0) != const0_rtx
15703 && ! CONSTANT_P (XEXP (rtl, 0))
15704 /* Not passed in memory. */
15705 && !MEM_P (DECL_INCOMING_RTL (decl))
15706 /* Not passed by invisible reference. */
15707 && (!REG_P (XEXP (rtl, 0))
15708 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
15709 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
15710 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
15711 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
15714 /* Big endian correction check. */
15715 && BYTES_BIG_ENDIAN
15716 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
15717 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
15720 int offset = (UNITS_PER_WORD
15721 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
15723 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15724 plus_constant (XEXP (rtl, 0), offset));
15727 else if (TREE_CODE (decl) == VAR_DECL
15730 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
15731 && BYTES_BIG_ENDIAN)
15733 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
15734 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
15736 /* If a variable is declared "register" yet is smaller than
15737 a register, then if we store the variable to memory, it
15738 looks like we're storing a register-sized value, when in
15739 fact we are not. We need to adjust the offset of the
15740 storage location to reflect the actual value's bytes,
15741 else gdb will not be able to display it. */
15743 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
15744 plus_constant (XEXP (rtl, 0), rsize-dsize));
15747 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
15748 and will have been substituted directly into all expressions that use it.
15749 C does not have such a concept, but C++ and other languages do. */
15750 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
15751 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
15754 rtl = targetm.delegitimize_address (rtl);
15756 /* If we don't look past the constant pool, we risk emitting a
15757 reference to a constant pool entry that isn't referenced from
15758 code, and thus is not emitted. */
15760 rtl = avoid_constant_pool_reference (rtl);
15762 /* Try harder to get a rtl. If this symbol ends up not being emitted
15763 in the current CU, resolve_addr will remove the expression referencing
15765 if (rtl == NULL_RTX
15766 && TREE_CODE (decl) == VAR_DECL
15767 && !DECL_EXTERNAL (decl)
15768 && TREE_STATIC (decl)
15769 && DECL_NAME (decl)
15770 && !DECL_HARD_REGISTER (decl)
15771 && DECL_MODE (decl) != VOIDmode)
15773 rtl = DECL_RTL (decl);
15774 /* Reset DECL_RTL back, as various parts of the compiler expects
15775 DECL_RTL set meaning it is actually going to be output. */
15776 SET_DECL_RTL (decl, NULL);
15778 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
15779 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
15786 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
15787 returned. If so, the decl for the COMMON block is returned, and the
15788 value is the offset into the common block for the symbol. */
15791 fortran_common (tree decl, HOST_WIDE_INT *value)
15793 tree val_expr, cvar;
15794 enum machine_mode mode;
15795 HOST_WIDE_INT bitsize, bitpos;
15797 int volatilep = 0, unsignedp = 0;
15799 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
15800 it does not have a value (the offset into the common area), or if it
15801 is thread local (as opposed to global) then it isn't common, and shouldn't
15802 be handled as such. */
15803 if (TREE_CODE (decl) != VAR_DECL
15804 || !TREE_STATIC (decl)
15805 || !DECL_HAS_VALUE_EXPR_P (decl)
15809 val_expr = DECL_VALUE_EXPR (decl);
15810 if (TREE_CODE (val_expr) != COMPONENT_REF)
15813 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
15814 &mode, &unsignedp, &volatilep, true);
15816 if (cvar == NULL_TREE
15817 || TREE_CODE (cvar) != VAR_DECL
15818 || DECL_ARTIFICIAL (cvar)
15819 || !TREE_PUBLIC (cvar))
15823 if (offset != NULL)
15825 if (!host_integerp (offset, 0))
15827 *value = tree_low_cst (offset, 0);
15830 *value += bitpos / BITS_PER_UNIT;
15835 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
15836 data attribute for a variable or a parameter. We generate the
15837 DW_AT_const_value attribute only in those cases where the given variable
15838 or parameter does not have a true "location" either in memory or in a
15839 register. This can happen (for example) when a constant is passed as an
15840 actual argument in a call to an inline function. (It's possible that
15841 these things can crop up in other ways also.) Note that one type of
15842 constant value which can be passed into an inlined function is a constant
15843 pointer. This can happen for example if an actual argument in an inlined
15844 function call evaluates to a compile-time constant address. */
15847 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
15848 enum dwarf_attribute attr)
15851 dw_loc_list_ref list;
15852 var_loc_list *loc_list;
15854 if (TREE_CODE (decl) == ERROR_MARK)
15857 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
15858 || TREE_CODE (decl) == RESULT_DECL);
15860 /* Try to get some constant RTL for this decl, and use that as the value of
15863 rtl = rtl_for_decl_location (decl);
15864 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
15865 && add_const_value_attribute (die, rtl))
15868 /* See if we have single element location list that is equivalent to
15869 a constant value. That way we are better to use add_const_value_attribute
15870 rather than expanding constant value equivalent. */
15871 loc_list = lookup_decl_loc (decl);
15874 && loc_list->first == loc_list->last
15875 && NOTE_VAR_LOCATION (loc_list->first->var_loc_note)
15876 && NOTE_VAR_LOCATION_LOC (loc_list->first->var_loc_note))
15878 struct var_loc_node *node;
15880 node = loc_list->first;
15881 rtl = NOTE_VAR_LOCATION_LOC (node->var_loc_note);
15882 if (GET_CODE (rtl) != PARALLEL)
15883 rtl = XEXP (rtl, 0);
15884 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
15885 && add_const_value_attribute (die, rtl))
15888 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2);
15891 add_AT_location_description (die, attr, list);
15894 /* None of that worked, so it must not really have a location;
15895 try adding a constant value attribute from the DECL_INITIAL. */
15896 return tree_add_const_value_attribute_for_decl (die, decl);
15899 /* Add VARIABLE and DIE into deferred locations list. */
15902 defer_location (tree variable, dw_die_ref die)
15904 deferred_locations entry;
15905 entry.variable = variable;
15907 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
15910 /* Helper function for tree_add_const_value_attribute. Natively encode
15911 initializer INIT into an array. Return true if successful. */
15914 native_encode_initializer (tree init, unsigned char *array, int size)
15918 if (init == NULL_TREE)
15922 switch (TREE_CODE (init))
15925 type = TREE_TYPE (init);
15926 if (TREE_CODE (type) == ARRAY_TYPE)
15928 tree enttype = TREE_TYPE (type);
15929 enum machine_mode mode = TYPE_MODE (enttype);
15931 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
15933 if (int_size_in_bytes (type) != size)
15935 if (size > TREE_STRING_LENGTH (init))
15937 memcpy (array, TREE_STRING_POINTER (init),
15938 TREE_STRING_LENGTH (init));
15939 memset (array + TREE_STRING_LENGTH (init),
15940 '\0', size - TREE_STRING_LENGTH (init));
15943 memcpy (array, TREE_STRING_POINTER (init), size);
15948 type = TREE_TYPE (init);
15949 if (int_size_in_bytes (type) != size)
15951 if (TREE_CODE (type) == ARRAY_TYPE)
15953 HOST_WIDE_INT min_index;
15954 unsigned HOST_WIDE_INT cnt;
15955 int curpos = 0, fieldsize;
15956 constructor_elt *ce;
15958 if (TYPE_DOMAIN (type) == NULL_TREE
15959 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
15962 fieldsize = int_size_in_bytes (TREE_TYPE (type));
15963 if (fieldsize <= 0)
15966 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
15967 memset (array, '\0', size);
15969 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
15972 tree val = ce->value;
15973 tree index = ce->index;
15975 if (index && TREE_CODE (index) == RANGE_EXPR)
15976 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
15979 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
15984 if (!native_encode_initializer (val, array + pos, fieldsize))
15987 curpos = pos + fieldsize;
15988 if (index && TREE_CODE (index) == RANGE_EXPR)
15990 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
15991 - tree_low_cst (TREE_OPERAND (index, 0), 0);
15995 memcpy (array + curpos, array + pos, fieldsize);
15996 curpos += fieldsize;
15999 gcc_assert (curpos <= size);
16003 else if (TREE_CODE (type) == RECORD_TYPE
16004 || TREE_CODE (type) == UNION_TYPE)
16006 tree field = NULL_TREE;
16007 unsigned HOST_WIDE_INT cnt;
16008 constructor_elt *ce;
16010 if (int_size_in_bytes (type) != size)
16013 if (TREE_CODE (type) == RECORD_TYPE)
16014 field = TYPE_FIELDS (type);
16017 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
16018 cnt++, field = field ? TREE_CHAIN (field) : 0)
16020 tree val = ce->value;
16021 int pos, fieldsize;
16023 if (ce->index != 0)
16029 if (field == NULL_TREE || DECL_BIT_FIELD (field))
16032 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
16033 && TYPE_DOMAIN (TREE_TYPE (field))
16034 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
16036 else if (DECL_SIZE_UNIT (field) == NULL_TREE
16037 || !host_integerp (DECL_SIZE_UNIT (field), 0))
16039 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
16040 pos = int_byte_position (field);
16041 gcc_assert (pos + fieldsize <= size);
16043 && !native_encode_initializer (val, array + pos, fieldsize))
16049 case VIEW_CONVERT_EXPR:
16050 case NON_LVALUE_EXPR:
16051 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
16053 return native_encode_expr (init, array, size) == size;
16057 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16058 attribute is the const value T. */
16061 tree_add_const_value_attribute (dw_die_ref die, tree t)
16064 tree type = TREE_TYPE (t);
16067 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
16071 gcc_assert (!DECL_P (init));
16073 rtl = rtl_for_decl_init (init, type);
16075 return add_const_value_attribute (die, rtl);
16076 /* If the host and target are sane, try harder. */
16077 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
16078 && initializer_constant_valid_p (init, type))
16080 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
16081 if (size > 0 && (int) size == size)
16083 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
16085 if (native_encode_initializer (init, array, size))
16087 add_AT_vec (die, DW_AT_const_value, size, 1, array);
16095 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16096 attribute is the const value of T, where T is an integral constant
16097 variable with static storage duration
16098 (so it can't be a PARM_DECL or a RESULT_DECL). */
16101 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
16105 || (TREE_CODE (decl) != VAR_DECL
16106 && TREE_CODE (decl) != CONST_DECL))
16109 if (TREE_READONLY (decl)
16110 && ! TREE_THIS_VOLATILE (decl)
16111 && DECL_INITIAL (decl))
16116 /* Don't add DW_AT_const_value if abstract origin already has one. */
16117 if (get_AT (var_die, DW_AT_const_value))
16120 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
16123 /* Convert the CFI instructions for the current function into a
16124 location list. This is used for DW_AT_frame_base when we targeting
16125 a dwarf2 consumer that does not support the dwarf3
16126 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16129 static dw_loc_list_ref
16130 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
16133 dw_loc_list_ref list, *list_tail;
16135 dw_cfa_location last_cfa, next_cfa;
16136 const char *start_label, *last_label, *section;
16137 dw_cfa_location remember;
16139 fde = current_fde ();
16140 gcc_assert (fde != NULL);
16142 section = secname_for_decl (current_function_decl);
16146 memset (&next_cfa, 0, sizeof (next_cfa));
16147 next_cfa.reg = INVALID_REGNUM;
16148 remember = next_cfa;
16150 start_label = fde->dw_fde_begin;
16152 /* ??? Bald assumption that the CIE opcode list does not contain
16153 advance opcodes. */
16154 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
16155 lookup_cfa_1 (cfi, &next_cfa, &remember);
16157 last_cfa = next_cfa;
16158 last_label = start_label;
16160 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
16161 switch (cfi->dw_cfi_opc)
16163 case DW_CFA_set_loc:
16164 case DW_CFA_advance_loc1:
16165 case DW_CFA_advance_loc2:
16166 case DW_CFA_advance_loc4:
16167 if (!cfa_equal_p (&last_cfa, &next_cfa))
16169 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16170 start_label, last_label, section);
16172 list_tail = &(*list_tail)->dw_loc_next;
16173 last_cfa = next_cfa;
16174 start_label = last_label;
16176 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
16179 case DW_CFA_advance_loc:
16180 /* The encoding is complex enough that we should never emit this. */
16181 gcc_unreachable ();
16184 lookup_cfa_1 (cfi, &next_cfa, &remember);
16188 if (!cfa_equal_p (&last_cfa, &next_cfa))
16190 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16191 start_label, last_label, section);
16192 list_tail = &(*list_tail)->dw_loc_next;
16193 start_label = last_label;
16196 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
16197 start_label, fde->dw_fde_end, section);
16199 if (list && list->dw_loc_next)
16205 /* Compute a displacement from the "steady-state frame pointer" to the
16206 frame base (often the same as the CFA), and store it in
16207 frame_pointer_fb_offset. OFFSET is added to the displacement
16208 before the latter is negated. */
16211 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
16215 #ifdef FRAME_POINTER_CFA_OFFSET
16216 reg = frame_pointer_rtx;
16217 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
16219 reg = arg_pointer_rtx;
16220 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
16223 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
16224 if (GET_CODE (elim) == PLUS)
16226 offset += INTVAL (XEXP (elim, 1));
16227 elim = XEXP (elim, 0);
16230 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
16231 && (elim == hard_frame_pointer_rtx
16232 || elim == stack_pointer_rtx))
16233 || elim == (frame_pointer_needed
16234 ? hard_frame_pointer_rtx
16235 : stack_pointer_rtx));
16237 frame_pointer_fb_offset = -offset;
16240 /* Generate a DW_AT_name attribute given some string value to be included as
16241 the value of the attribute. */
16244 add_name_attribute (dw_die_ref die, const char *name_string)
16246 if (name_string != NULL && *name_string != 0)
16248 if (demangle_name_func)
16249 name_string = (*demangle_name_func) (name_string);
16251 add_AT_string (die, DW_AT_name, name_string);
16255 /* Generate a DW_AT_comp_dir attribute for DIE. */
16258 add_comp_dir_attribute (dw_die_ref die)
16260 const char *wd = get_src_pwd ();
16266 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
16270 wdlen = strlen (wd);
16271 wd1 = GGC_NEWVEC (char, wdlen + 2);
16273 wd1 [wdlen] = DIR_SEPARATOR;
16274 wd1 [wdlen + 1] = 0;
16278 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
16281 /* Given a tree node describing an array bound (either lower or upper) output
16282 a representation for that bound. */
16285 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
16287 int want_address = 2;
16289 switch (TREE_CODE (bound))
16294 /* All fixed-bounds are represented by INTEGER_CST nodes. */
16297 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (bound));
16299 /* Use the default if possible. */
16300 if (bound_attr == DW_AT_lower_bound
16301 && (((is_c_family () || is_java ()) && integer_zerop (bound))
16302 || (is_fortran () && integer_onep (bound))))
16305 /* Otherwise represent the bound as an unsigned value with the
16306 precision of its type. The precision and signedness of the
16307 type will be necessary to re-interpret it unambiguously. */
16308 else if (prec < HOST_BITS_PER_WIDE_INT)
16310 unsigned HOST_WIDE_INT mask
16311 = ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
16312 add_AT_unsigned (subrange_die, bound_attr,
16313 TREE_INT_CST_LOW (bound) & mask);
16315 else if (prec == HOST_BITS_PER_WIDE_INT
16316 || TREE_INT_CST_HIGH (bound) == 0)
16317 add_AT_unsigned (subrange_die, bound_attr,
16318 TREE_INT_CST_LOW (bound));
16320 add_AT_double (subrange_die, bound_attr, TREE_INT_CST_HIGH (bound),
16321 TREE_INT_CST_LOW (bound));
16326 case VIEW_CONVERT_EXPR:
16327 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
16337 dw_die_ref decl_die = lookup_decl_die (bound);
16339 /* ??? Can this happen, or should the variable have been bound
16340 first? Probably it can, since I imagine that we try to create
16341 the types of parameters in the order in which they exist in
16342 the list, and won't have created a forward reference to a
16343 later parameter. */
16344 if (decl_die != NULL)
16346 add_AT_die_ref (subrange_die, bound_attr, decl_die);
16355 /* Otherwise try to create a stack operation procedure to
16356 evaluate the value of the array bound. */
16358 dw_die_ref ctx, decl_die;
16359 dw_loc_list_ref list;
16361 list = loc_list_from_tree (bound, want_address);
16365 if (single_element_loc_list_p (list))
16367 add_AT_loc (subrange_die, bound_attr, list->expr);
16371 if (current_function_decl == 0)
16372 ctx = comp_unit_die;
16374 ctx = lookup_decl_die (current_function_decl);
16376 decl_die = new_die (DW_TAG_variable, ctx, bound);
16377 add_AT_flag (decl_die, DW_AT_artificial, 1);
16378 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
16379 add_AT_location_description (decl_die, DW_AT_location, list);
16380 add_AT_die_ref (subrange_die, bound_attr, decl_die);
16386 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
16387 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
16388 Note that the block of subscript information for an array type also
16389 includes information about the element type of the given array type. */
16392 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
16394 unsigned dimension_number;
16396 dw_die_ref subrange_die;
16398 for (dimension_number = 0;
16399 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
16400 type = TREE_TYPE (type), dimension_number++)
16402 tree domain = TYPE_DOMAIN (type);
16404 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
16407 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
16408 and (in GNU C only) variable bounds. Handle all three forms
16410 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
16413 /* We have an array type with specified bounds. */
16414 lower = TYPE_MIN_VALUE (domain);
16415 upper = TYPE_MAX_VALUE (domain);
16417 /* Define the index type. */
16418 if (TREE_TYPE (domain))
16420 /* ??? This is probably an Ada unnamed subrange type. Ignore the
16421 TREE_TYPE field. We can't emit debug info for this
16422 because it is an unnamed integral type. */
16423 if (TREE_CODE (domain) == INTEGER_TYPE
16424 && TYPE_NAME (domain) == NULL_TREE
16425 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
16426 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
16429 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
16433 /* ??? If upper is NULL, the array has unspecified length,
16434 but it does have a lower bound. This happens with Fortran
16436 Since the debugger is definitely going to need to know N
16437 to produce useful results, go ahead and output the lower
16438 bound solo, and hope the debugger can cope. */
16440 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
16442 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
16445 /* Otherwise we have an array type with an unspecified length. The
16446 DWARF-2 spec does not say how to handle this; let's just leave out the
16452 add_byte_size_attribute (dw_die_ref die, tree tree_node)
16456 switch (TREE_CODE (tree_node))
16461 case ENUMERAL_TYPE:
16464 case QUAL_UNION_TYPE:
16465 size = int_size_in_bytes (tree_node);
16468 /* For a data member of a struct or union, the DW_AT_byte_size is
16469 generally given as the number of bytes normally allocated for an
16470 object of the *declared* type of the member itself. This is true
16471 even for bit-fields. */
16472 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
16475 gcc_unreachable ();
16478 /* Note that `size' might be -1 when we get to this point. If it is, that
16479 indicates that the byte size of the entity in question is variable. We
16480 have no good way of expressing this fact in Dwarf at the present time,
16481 so just let the -1 pass on through. */
16482 add_AT_unsigned (die, DW_AT_byte_size, size);
16485 /* For a FIELD_DECL node which represents a bit-field, output an attribute
16486 which specifies the distance in bits from the highest order bit of the
16487 "containing object" for the bit-field to the highest order bit of the
16490 For any given bit-field, the "containing object" is a hypothetical object
16491 (of some integral or enum type) within which the given bit-field lives. The
16492 type of this hypothetical "containing object" is always the same as the
16493 declared type of the individual bit-field itself. The determination of the
16494 exact location of the "containing object" for a bit-field is rather
16495 complicated. It's handled by the `field_byte_offset' function (above).
16497 Note that it is the size (in bytes) of the hypothetical "containing object"
16498 which will be given in the DW_AT_byte_size attribute for this bit-field.
16499 (See `byte_size_attribute' above). */
16502 add_bit_offset_attribute (dw_die_ref die, tree decl)
16504 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
16505 tree type = DECL_BIT_FIELD_TYPE (decl);
16506 HOST_WIDE_INT bitpos_int;
16507 HOST_WIDE_INT highest_order_object_bit_offset;
16508 HOST_WIDE_INT highest_order_field_bit_offset;
16509 HOST_WIDE_INT unsigned bit_offset;
16511 /* Must be a field and a bit field. */
16512 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
16514 /* We can't yet handle bit-fields whose offsets are variable, so if we
16515 encounter such things, just return without generating any attribute
16516 whatsoever. Likewise for variable or too large size. */
16517 if (! host_integerp (bit_position (decl), 0)
16518 || ! host_integerp (DECL_SIZE (decl), 1))
16521 bitpos_int = int_bit_position (decl);
16523 /* Note that the bit offset is always the distance (in bits) from the
16524 highest-order bit of the "containing object" to the highest-order bit of
16525 the bit-field itself. Since the "high-order end" of any object or field
16526 is different on big-endian and little-endian machines, the computation
16527 below must take account of these differences. */
16528 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
16529 highest_order_field_bit_offset = bitpos_int;
16531 if (! BYTES_BIG_ENDIAN)
16533 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
16534 highest_order_object_bit_offset += simple_type_size_in_bits (type);
16538 = (! BYTES_BIG_ENDIAN
16539 ? highest_order_object_bit_offset - highest_order_field_bit_offset
16540 : highest_order_field_bit_offset - highest_order_object_bit_offset);
16542 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
16545 /* For a FIELD_DECL node which represents a bit field, output an attribute
16546 which specifies the length in bits of the given field. */
16549 add_bit_size_attribute (dw_die_ref die, tree decl)
16551 /* Must be a field and a bit field. */
16552 gcc_assert (TREE_CODE (decl) == FIELD_DECL
16553 && DECL_BIT_FIELD_TYPE (decl));
16555 if (host_integerp (DECL_SIZE (decl), 1))
16556 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
16559 /* If the compiled language is ANSI C, then add a 'prototyped'
16560 attribute, if arg types are given for the parameters of a function. */
16563 add_prototyped_attribute (dw_die_ref die, tree func_type)
16565 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
16566 && TYPE_ARG_TYPES (func_type) != NULL)
16567 add_AT_flag (die, DW_AT_prototyped, 1);
16570 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
16571 by looking in either the type declaration or object declaration
16574 static inline dw_die_ref
16575 add_abstract_origin_attribute (dw_die_ref die, tree origin)
16577 dw_die_ref origin_die = NULL;
16579 if (TREE_CODE (origin) != FUNCTION_DECL)
16581 /* We may have gotten separated from the block for the inlined
16582 function, if we're in an exception handler or some such; make
16583 sure that the abstract function has been written out.
16585 Doing this for nested functions is wrong, however; functions are
16586 distinct units, and our context might not even be inline. */
16590 fn = TYPE_STUB_DECL (fn);
16592 fn = decl_function_context (fn);
16594 dwarf2out_abstract_function (fn);
16597 if (DECL_P (origin))
16598 origin_die = lookup_decl_die (origin);
16599 else if (TYPE_P (origin))
16600 origin_die = lookup_type_die (origin);
16602 /* XXX: Functions that are never lowered don't always have correct block
16603 trees (in the case of java, they simply have no block tree, in some other
16604 languages). For these functions, there is nothing we can really do to
16605 output correct debug info for inlined functions in all cases. Rather
16606 than die, we'll just produce deficient debug info now, in that we will
16607 have variables without a proper abstract origin. In the future, when all
16608 functions are lowered, we should re-add a gcc_assert (origin_die)
16612 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
16616 /* We do not currently support the pure_virtual attribute. */
16619 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
16621 if (DECL_VINDEX (func_decl))
16623 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
16625 if (host_integerp (DECL_VINDEX (func_decl), 0))
16626 add_AT_loc (die, DW_AT_vtable_elem_location,
16627 new_loc_descr (DW_OP_constu,
16628 tree_low_cst (DECL_VINDEX (func_decl), 0),
16631 /* GNU extension: Record what type this method came from originally. */
16632 if (debug_info_level > DINFO_LEVEL_TERSE
16633 && DECL_CONTEXT (func_decl))
16634 add_AT_die_ref (die, DW_AT_containing_type,
16635 lookup_type_die (DECL_CONTEXT (func_decl)));
16639 /* Add source coordinate attributes for the given decl. */
16642 add_src_coords_attributes (dw_die_ref die, tree decl)
16644 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
16646 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
16647 add_AT_unsigned (die, DW_AT_decl_line, s.line);
16650 /* Add a DW_AT_name attribute and source coordinate attribute for the
16651 given decl, but only if it actually has a name. */
16654 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
16658 decl_name = DECL_NAME (decl);
16659 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
16661 const char *name = dwarf2_name (decl, 0);
16663 add_name_attribute (die, name);
16664 if (! DECL_ARTIFICIAL (decl))
16665 add_src_coords_attributes (die, decl);
16667 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
16668 && TREE_PUBLIC (decl)
16669 && !DECL_ABSTRACT (decl)
16670 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
16673 /* Defer until we have an assembler name set. */
16674 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
16676 limbo_die_node *asm_name;
16678 asm_name = GGC_CNEW (limbo_die_node);
16679 asm_name->die = die;
16680 asm_name->created_for = decl;
16681 asm_name->next = deferred_asm_name;
16682 deferred_asm_name = asm_name;
16684 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
16685 add_AT_string (die, DW_AT_MIPS_linkage_name,
16686 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
16690 #ifdef VMS_DEBUGGING_INFO
16691 /* Get the function's name, as described by its RTL. This may be different
16692 from the DECL_NAME name used in the source file. */
16693 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
16695 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
16696 XEXP (DECL_RTL (decl), 0));
16697 VEC_safe_push (rtx, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
16702 /* Push a new declaration scope. */
16705 push_decl_scope (tree scope)
16707 VEC_safe_push (tree, gc, decl_scope_table, scope);
16710 /* Pop a declaration scope. */
16713 pop_decl_scope (void)
16715 VEC_pop (tree, decl_scope_table);
16718 /* Return the DIE for the scope that immediately contains this type.
16719 Non-named types get global scope. Named types nested in other
16720 types get their containing scope if it's open, or global scope
16721 otherwise. All other types (i.e. function-local named types) get
16722 the current active scope. */
16725 scope_die_for (tree t, dw_die_ref context_die)
16727 dw_die_ref scope_die = NULL;
16728 tree containing_scope;
16731 /* Non-types always go in the current scope. */
16732 gcc_assert (TYPE_P (t));
16734 containing_scope = TYPE_CONTEXT (t);
16736 /* Use the containing namespace if it was passed in (for a declaration). */
16737 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
16739 if (context_die == lookup_decl_die (containing_scope))
16742 containing_scope = NULL_TREE;
16745 /* Ignore function type "scopes" from the C frontend. They mean that
16746 a tagged type is local to a parmlist of a function declarator, but
16747 that isn't useful to DWARF. */
16748 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
16749 containing_scope = NULL_TREE;
16751 if (containing_scope == NULL_TREE)
16752 scope_die = comp_unit_die;
16753 else if (TYPE_P (containing_scope))
16755 /* For types, we can just look up the appropriate DIE. But
16756 first we check to see if we're in the middle of emitting it
16757 so we know where the new DIE should go. */
16758 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
16759 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
16764 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
16765 || TREE_ASM_WRITTEN (containing_scope));
16767 /* If none of the current dies are suitable, we get file scope. */
16768 scope_die = comp_unit_die;
16771 scope_die = lookup_type_die (containing_scope);
16774 scope_die = context_die;
16779 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
16782 local_scope_p (dw_die_ref context_die)
16784 for (; context_die; context_die = context_die->die_parent)
16785 if (context_die->die_tag == DW_TAG_inlined_subroutine
16786 || context_die->die_tag == DW_TAG_subprogram)
16792 /* Returns nonzero if CONTEXT_DIE is a class. */
16795 class_scope_p (dw_die_ref context_die)
16797 return (context_die
16798 && (context_die->die_tag == DW_TAG_structure_type
16799 || context_die->die_tag == DW_TAG_class_type
16800 || context_die->die_tag == DW_TAG_interface_type
16801 || context_die->die_tag == DW_TAG_union_type));
16804 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
16805 whether or not to treat a DIE in this context as a declaration. */
16808 class_or_namespace_scope_p (dw_die_ref context_die)
16810 return (class_scope_p (context_die)
16811 || (context_die && context_die->die_tag == DW_TAG_namespace));
16814 /* Many forms of DIEs require a "type description" attribute. This
16815 routine locates the proper "type descriptor" die for the type given
16816 by 'type', and adds a DW_AT_type attribute below the given die. */
16819 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
16820 int decl_volatile, dw_die_ref context_die)
16822 enum tree_code code = TREE_CODE (type);
16823 dw_die_ref type_die = NULL;
16825 /* ??? If this type is an unnamed subrange type of an integral, floating-point
16826 or fixed-point type, use the inner type. This is because we have no
16827 support for unnamed types in base_type_die. This can happen if this is
16828 an Ada subrange type. Correct solution is emit a subrange type die. */
16829 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
16830 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
16831 type = TREE_TYPE (type), code = TREE_CODE (type);
16833 if (code == ERROR_MARK
16834 /* Handle a special case. For functions whose return type is void, we
16835 generate *no* type attribute. (Note that no object may have type
16836 `void', so this only applies to function return types). */
16837 || code == VOID_TYPE)
16840 type_die = modified_type_die (type,
16841 decl_const || TYPE_READONLY (type),
16842 decl_volatile || TYPE_VOLATILE (type),
16845 if (type_die != NULL)
16846 add_AT_die_ref (object_die, DW_AT_type, type_die);
16849 /* Given an object die, add the calling convention attribute for the
16850 function call type. */
16852 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
16854 enum dwarf_calling_convention value = DW_CC_normal;
16856 value = ((enum dwarf_calling_convention)
16857 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
16859 /* DWARF doesn't provide a way to identify a program's source-level
16860 entry point. DW_AT_calling_convention attributes are only meant
16861 to describe functions' calling conventions. However, lacking a
16862 better way to signal the Fortran main program, we use this for the
16863 time being, following existing custom. */
16865 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
16866 value = DW_CC_program;
16868 /* Only add the attribute if the backend requests it, and
16869 is not DW_CC_normal. */
16870 if (value && (value != DW_CC_normal))
16871 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
16874 /* Given a tree pointer to a struct, class, union, or enum type node, return
16875 a pointer to the (string) tag name for the given type, or zero if the type
16876 was declared without a tag. */
16878 static const char *
16879 type_tag (const_tree type)
16881 const char *name = 0;
16883 if (TYPE_NAME (type) != 0)
16887 /* Find the IDENTIFIER_NODE for the type name. */
16888 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
16889 t = TYPE_NAME (type);
16891 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
16892 a TYPE_DECL node, regardless of whether or not a `typedef' was
16894 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
16895 && ! DECL_IGNORED_P (TYPE_NAME (type)))
16897 /* We want to be extra verbose. Don't call dwarf_name if
16898 DECL_NAME isn't set. The default hook for decl_printable_name
16899 doesn't like that, and in this context it's correct to return
16900 0, instead of "<anonymous>" or the like. */
16901 if (DECL_NAME (TYPE_NAME (type)))
16902 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
16905 /* Now get the name as a string, or invent one. */
16906 if (!name && t != 0)
16907 name = IDENTIFIER_POINTER (t);
16910 return (name == 0 || *name == '\0') ? 0 : name;
16913 /* Return the type associated with a data member, make a special check
16914 for bit field types. */
16917 member_declared_type (const_tree member)
16919 return (DECL_BIT_FIELD_TYPE (member)
16920 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
16923 /* Get the decl's label, as described by its RTL. This may be different
16924 from the DECL_NAME name used in the source file. */
16927 static const char *
16928 decl_start_label (tree decl)
16931 const char *fnname;
16933 x = DECL_RTL (decl);
16934 gcc_assert (MEM_P (x));
16937 gcc_assert (GET_CODE (x) == SYMBOL_REF);
16939 fnname = XSTR (x, 0);
16944 /* These routines generate the internal representation of the DIE's for
16945 the compilation unit. Debugging information is collected by walking
16946 the declaration trees passed in from dwarf2out_decl(). */
16949 gen_array_type_die (tree type, dw_die_ref context_die)
16951 dw_die_ref scope_die = scope_die_for (type, context_die);
16952 dw_die_ref array_die;
16954 /* GNU compilers represent multidimensional array types as sequences of one
16955 dimensional array types whose element types are themselves array types.
16956 We sometimes squish that down to a single array_type DIE with multiple
16957 subscripts in the Dwarf debugging info. The draft Dwarf specification
16958 say that we are allowed to do this kind of compression in C, because
16959 there is no difference between an array of arrays and a multidimensional
16960 array. We don't do this for Ada to remain as close as possible to the
16961 actual representation, which is especially important against the language
16962 flexibilty wrt arrays of variable size. */
16964 bool collapse_nested_arrays = !is_ada ();
16967 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
16968 DW_TAG_string_type doesn't have DW_AT_type attribute). */
16969 if (TYPE_STRING_FLAG (type)
16970 && TREE_CODE (type) == ARRAY_TYPE
16972 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
16974 HOST_WIDE_INT size;
16976 array_die = new_die (DW_TAG_string_type, scope_die, type);
16977 add_name_attribute (array_die, type_tag (type));
16978 equate_type_number_to_die (type, array_die);
16979 size = int_size_in_bytes (type);
16981 add_AT_unsigned (array_die, DW_AT_byte_size, size);
16982 else if (TYPE_DOMAIN (type) != NULL_TREE
16983 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
16984 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
16986 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
16987 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2);
16989 size = int_size_in_bytes (TREE_TYPE (szdecl));
16990 if (loc && size > 0)
16992 add_AT_location_description (array_die, DW_AT_string_length, loc);
16993 if (size != DWARF2_ADDR_SIZE)
16994 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17000 /* ??? The SGI dwarf reader fails for array of array of enum types
17001 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
17002 array type comes before the outer array type. We thus call gen_type_die
17003 before we new_die and must prevent nested array types collapsing for this
17006 #ifdef MIPS_DEBUGGING_INFO
17007 gen_type_die (TREE_TYPE (type), context_die);
17008 collapse_nested_arrays = false;
17011 array_die = new_die (DW_TAG_array_type, scope_die, type);
17012 add_name_attribute (array_die, type_tag (type));
17013 equate_type_number_to_die (type, array_die);
17015 if (TREE_CODE (type) == VECTOR_TYPE)
17017 /* The frontend feeds us a representation for the vector as a struct
17018 containing an array. Pull out the array type. */
17019 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
17020 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
17023 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17025 && TREE_CODE (type) == ARRAY_TYPE
17026 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
17027 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
17028 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17031 /* We default the array ordering. SDB will probably do
17032 the right things even if DW_AT_ordering is not present. It's not even
17033 an issue until we start to get into multidimensional arrays anyway. If
17034 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17035 then we'll have to put the DW_AT_ordering attribute back in. (But if
17036 and when we find out that we need to put these in, we will only do so
17037 for multidimensional arrays. */
17038 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17041 #ifdef MIPS_DEBUGGING_INFO
17042 /* The SGI compilers handle arrays of unknown bound by setting
17043 AT_declaration and not emitting any subrange DIEs. */
17044 if (! TYPE_DOMAIN (type))
17045 add_AT_flag (array_die, DW_AT_declaration, 1);
17048 add_subscript_info (array_die, type, collapse_nested_arrays);
17050 /* Add representation of the type of the elements of this array type and
17051 emit the corresponding DIE if we haven't done it already. */
17052 element_type = TREE_TYPE (type);
17053 if (collapse_nested_arrays)
17054 while (TREE_CODE (element_type) == ARRAY_TYPE)
17056 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
17058 element_type = TREE_TYPE (element_type);
17061 #ifndef MIPS_DEBUGGING_INFO
17062 gen_type_die (element_type, context_die);
17065 add_type_attribute (array_die, element_type, 0, 0, context_die);
17067 if (get_AT (array_die, DW_AT_name))
17068 add_pubtype (type, array_die);
17071 static dw_loc_descr_ref
17072 descr_info_loc (tree val, tree base_decl)
17074 HOST_WIDE_INT size;
17075 dw_loc_descr_ref loc, loc2;
17076 enum dwarf_location_atom op;
17078 if (val == base_decl)
17079 return new_loc_descr (DW_OP_push_object_address, 0, 0);
17081 switch (TREE_CODE (val))
17084 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17086 return loc_descriptor_from_tree (val, 0);
17088 if (host_integerp (val, 0))
17089 return int_loc_descriptor (tree_low_cst (val, 0));
17092 size = int_size_in_bytes (TREE_TYPE (val));
17095 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17098 if (size == DWARF2_ADDR_SIZE)
17099 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
17101 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
17103 case POINTER_PLUS_EXPR:
17105 if (host_integerp (TREE_OPERAND (val, 1), 1)
17106 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
17109 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17112 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
17118 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17121 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
17124 add_loc_descr (&loc, loc2);
17125 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
17147 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
17148 tree val, tree base_decl)
17150 dw_loc_descr_ref loc;
17152 if (host_integerp (val, 0))
17154 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
17158 loc = descr_info_loc (val, base_decl);
17162 add_AT_loc (die, attr, loc);
17165 /* This routine generates DIE for array with hidden descriptor, details
17166 are filled into *info by a langhook. */
17169 gen_descr_array_type_die (tree type, struct array_descr_info *info,
17170 dw_die_ref context_die)
17172 dw_die_ref scope_die = scope_die_for (type, context_die);
17173 dw_die_ref array_die;
17176 array_die = new_die (DW_TAG_array_type, scope_die, type);
17177 add_name_attribute (array_die, type_tag (type));
17178 equate_type_number_to_die (type, array_die);
17180 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17182 && info->ndimensions >= 2)
17183 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17185 if (info->data_location)
17186 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
17188 if (info->associated)
17189 add_descr_info_field (array_die, DW_AT_associated, info->associated,
17191 if (info->allocated)
17192 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
17195 for (dim = 0; dim < info->ndimensions; dim++)
17197 dw_die_ref subrange_die
17198 = new_die (DW_TAG_subrange_type, array_die, NULL);
17200 if (info->dimen[dim].lower_bound)
17202 /* If it is the default value, omit it. */
17203 if ((is_c_family () || is_java ())
17204 && integer_zerop (info->dimen[dim].lower_bound))
17206 else if (is_fortran ()
17207 && integer_onep (info->dimen[dim].lower_bound))
17210 add_descr_info_field (subrange_die, DW_AT_lower_bound,
17211 info->dimen[dim].lower_bound,
17214 if (info->dimen[dim].upper_bound)
17215 add_descr_info_field (subrange_die, DW_AT_upper_bound,
17216 info->dimen[dim].upper_bound,
17218 if (info->dimen[dim].stride)
17219 add_descr_info_field (subrange_die, DW_AT_byte_stride,
17220 info->dimen[dim].stride,
17224 gen_type_die (info->element_type, context_die);
17225 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
17227 if (get_AT (array_die, DW_AT_name))
17228 add_pubtype (type, array_die);
17233 gen_entry_point_die (tree decl, dw_die_ref context_die)
17235 tree origin = decl_ultimate_origin (decl);
17236 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
17238 if (origin != NULL)
17239 add_abstract_origin_attribute (decl_die, origin);
17242 add_name_and_src_coords_attributes (decl_die, decl);
17243 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
17244 0, 0, context_die);
17247 if (DECL_ABSTRACT (decl))
17248 equate_decl_number_to_die (decl, decl_die);
17250 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
17254 /* Walk through the list of incomplete types again, trying once more to
17255 emit full debugging info for them. */
17258 retry_incomplete_types (void)
17262 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
17263 if (should_emit_struct_debug (VEC_index (tree, incomplete_types, i),
17264 DINFO_USAGE_DIR_USE))
17265 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
17268 /* Determine what tag to use for a record type. */
17270 static enum dwarf_tag
17271 record_type_tag (tree type)
17273 if (! lang_hooks.types.classify_record)
17274 return DW_TAG_structure_type;
17276 switch (lang_hooks.types.classify_record (type))
17278 case RECORD_IS_STRUCT:
17279 return DW_TAG_structure_type;
17281 case RECORD_IS_CLASS:
17282 return DW_TAG_class_type;
17284 case RECORD_IS_INTERFACE:
17285 if (dwarf_version >= 3 || !dwarf_strict)
17286 return DW_TAG_interface_type;
17287 return DW_TAG_structure_type;
17290 gcc_unreachable ();
17294 /* Generate a DIE to represent an enumeration type. Note that these DIEs
17295 include all of the information about the enumeration values also. Each
17296 enumerated type name/value is listed as a child of the enumerated type
17300 gen_enumeration_type_die (tree type, dw_die_ref context_die)
17302 dw_die_ref type_die = lookup_type_die (type);
17304 if (type_die == NULL)
17306 type_die = new_die (DW_TAG_enumeration_type,
17307 scope_die_for (type, context_die), type);
17308 equate_type_number_to_die (type, type_die);
17309 add_name_attribute (type_die, type_tag (type));
17311 else if (! TYPE_SIZE (type))
17314 remove_AT (type_die, DW_AT_declaration);
17316 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
17317 given enum type is incomplete, do not generate the DW_AT_byte_size
17318 attribute or the DW_AT_element_list attribute. */
17319 if (TYPE_SIZE (type))
17323 TREE_ASM_WRITTEN (type) = 1;
17324 add_byte_size_attribute (type_die, type);
17325 if (TYPE_STUB_DECL (type) != NULL_TREE)
17326 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
17328 /* If the first reference to this type was as the return type of an
17329 inline function, then it may not have a parent. Fix this now. */
17330 if (type_die->die_parent == NULL)
17331 add_child_die (scope_die_for (type, context_die), type_die);
17333 for (link = TYPE_VALUES (type);
17334 link != NULL; link = TREE_CHAIN (link))
17336 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
17337 tree value = TREE_VALUE (link);
17339 add_name_attribute (enum_die,
17340 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
17342 if (TREE_CODE (value) == CONST_DECL)
17343 value = DECL_INITIAL (value);
17345 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
17346 /* DWARF2 does not provide a way of indicating whether or
17347 not enumeration constants are signed or unsigned. GDB
17348 always assumes the values are signed, so we output all
17349 values as if they were signed. That means that
17350 enumeration constants with very large unsigned values
17351 will appear to have negative values in the debugger. */
17352 add_AT_int (enum_die, DW_AT_const_value,
17353 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
17357 add_AT_flag (type_die, DW_AT_declaration, 1);
17359 if (get_AT (type_die, DW_AT_name))
17360 add_pubtype (type, type_die);
17365 /* Generate a DIE to represent either a real live formal parameter decl or to
17366 represent just the type of some formal parameter position in some function
17369 Note that this routine is a bit unusual because its argument may be a
17370 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
17371 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
17372 node. If it's the former then this function is being called to output a
17373 DIE to represent a formal parameter object (or some inlining thereof). If
17374 it's the latter, then this function is only being called to output a
17375 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
17376 argument type of some subprogram type.
17377 If EMIT_NAME_P is true, name and source coordinate attributes
17381 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
17382 dw_die_ref context_die)
17384 tree node_or_origin = node ? node : origin;
17385 tree ultimate_origin;
17386 dw_die_ref parm_die
17387 = new_die (DW_TAG_formal_parameter, context_die, node);
17389 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
17391 case tcc_declaration:
17392 ultimate_origin = decl_ultimate_origin (node_or_origin);
17393 if (node || ultimate_origin)
17394 origin = ultimate_origin;
17395 if (origin != NULL)
17396 add_abstract_origin_attribute (parm_die, origin);
17399 tree type = TREE_TYPE (node);
17401 add_name_and_src_coords_attributes (parm_die, node);
17402 if (decl_by_reference_p (node))
17403 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
17406 add_type_attribute (parm_die, type,
17407 TREE_READONLY (node),
17408 TREE_THIS_VOLATILE (node),
17410 if (DECL_ARTIFICIAL (node))
17411 add_AT_flag (parm_die, DW_AT_artificial, 1);
17414 if (node && node != origin)
17415 equate_decl_number_to_die (node, parm_die);
17416 if (! DECL_ABSTRACT (node_or_origin))
17417 add_location_or_const_value_attribute (parm_die, node_or_origin,
17423 /* We were called with some kind of a ..._TYPE node. */
17424 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
17428 gcc_unreachable ();
17434 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
17435 children DW_TAG_formal_parameter DIEs representing the arguments of the
17438 PARM_PACK must be a function parameter pack.
17439 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
17440 must point to the subsequent arguments of the function PACK_ARG belongs to.
17441 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
17442 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
17443 following the last one for which a DIE was generated. */
17446 gen_formal_parameter_pack_die (tree parm_pack,
17448 dw_die_ref subr_die,
17452 dw_die_ref parm_pack_die;
17454 gcc_assert (parm_pack
17455 && lang_hooks.function_parameter_pack_p (parm_pack)
17458 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
17459 add_src_coords_attributes (parm_pack_die, parm_pack);
17461 for (arg = pack_arg; arg; arg = TREE_CHAIN (arg))
17463 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
17466 gen_formal_parameter_die (arg, NULL,
17467 false /* Don't emit name attribute. */,
17472 return parm_pack_die;
17475 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
17476 at the end of an (ANSI prototyped) formal parameters list. */
17479 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
17481 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
17484 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
17485 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
17486 parameters as specified in some function type specification (except for
17487 those which appear as part of a function *definition*). */
17490 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
17493 tree formal_type = NULL;
17494 tree first_parm_type;
17497 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
17499 arg = DECL_ARGUMENTS (function_or_method_type);
17500 function_or_method_type = TREE_TYPE (function_or_method_type);
17505 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
17507 /* Make our first pass over the list of formal parameter types and output a
17508 DW_TAG_formal_parameter DIE for each one. */
17509 for (link = first_parm_type; link; )
17511 dw_die_ref parm_die;
17513 formal_type = TREE_VALUE (link);
17514 if (formal_type == void_type_node)
17517 /* Output a (nameless) DIE to represent the formal parameter itself. */
17518 parm_die = gen_formal_parameter_die (formal_type, NULL,
17519 true /* Emit name attribute. */,
17521 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
17522 && link == first_parm_type)
17523 || (arg && DECL_ARTIFICIAL (arg)))
17524 add_AT_flag (parm_die, DW_AT_artificial, 1);
17526 link = TREE_CHAIN (link);
17528 arg = TREE_CHAIN (arg);
17531 /* If this function type has an ellipsis, add a
17532 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
17533 if (formal_type != void_type_node)
17534 gen_unspecified_parameters_die (function_or_method_type, context_die);
17536 /* Make our second (and final) pass over the list of formal parameter types
17537 and output DIEs to represent those types (as necessary). */
17538 for (link = TYPE_ARG_TYPES (function_or_method_type);
17539 link && TREE_VALUE (link);
17540 link = TREE_CHAIN (link))
17541 gen_type_die (TREE_VALUE (link), context_die);
17544 /* We want to generate the DIE for TYPE so that we can generate the
17545 die for MEMBER, which has been defined; we will need to refer back
17546 to the member declaration nested within TYPE. If we're trying to
17547 generate minimal debug info for TYPE, processing TYPE won't do the
17548 trick; we need to attach the member declaration by hand. */
17551 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
17553 gen_type_die (type, context_die);
17555 /* If we're trying to avoid duplicate debug info, we may not have
17556 emitted the member decl for this function. Emit it now. */
17557 if (TYPE_STUB_DECL (type)
17558 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
17559 && ! lookup_decl_die (member))
17561 dw_die_ref type_die;
17562 gcc_assert (!decl_ultimate_origin (member));
17564 push_decl_scope (type);
17565 type_die = lookup_type_die (type);
17566 if (TREE_CODE (member) == FUNCTION_DECL)
17567 gen_subprogram_die (member, type_die);
17568 else if (TREE_CODE (member) == FIELD_DECL)
17570 /* Ignore the nameless fields that are used to skip bits but handle
17571 C++ anonymous unions and structs. */
17572 if (DECL_NAME (member) != NULL_TREE
17573 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
17574 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
17576 gen_type_die (member_declared_type (member), type_die);
17577 gen_field_die (member, type_die);
17581 gen_variable_die (member, NULL_TREE, type_die);
17587 /* Generate the DWARF2 info for the "abstract" instance of a function which we
17588 may later generate inlined and/or out-of-line instances of. */
17591 dwarf2out_abstract_function (tree decl)
17593 dw_die_ref old_die;
17597 htab_t old_decl_loc_table;
17599 /* Make sure we have the actual abstract inline, not a clone. */
17600 decl = DECL_ORIGIN (decl);
17602 old_die = lookup_decl_die (decl);
17603 if (old_die && get_AT (old_die, DW_AT_inline))
17604 /* We've already generated the abstract instance. */
17607 /* We can be called while recursively when seeing block defining inlined subroutine
17608 DIE. Be sure to not clobber the outer location table nor use it or we would
17609 get locations in abstract instantces. */
17610 old_decl_loc_table = decl_loc_table;
17611 decl_loc_table = NULL;
17613 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
17614 we don't get confused by DECL_ABSTRACT. */
17615 if (debug_info_level > DINFO_LEVEL_TERSE)
17617 context = decl_class_context (decl);
17619 gen_type_die_for_member
17620 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
17623 /* Pretend we've just finished compiling this function. */
17624 save_fn = current_function_decl;
17625 current_function_decl = decl;
17626 push_cfun (DECL_STRUCT_FUNCTION (decl));
17628 was_abstract = DECL_ABSTRACT (decl);
17629 set_decl_abstract_flags (decl, 1);
17630 dwarf2out_decl (decl);
17631 if (! was_abstract)
17632 set_decl_abstract_flags (decl, 0);
17634 current_function_decl = save_fn;
17635 decl_loc_table = old_decl_loc_table;
17639 /* Helper function of premark_used_types() which gets called through
17642 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17643 marked as unused by prune_unused_types. */
17646 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
17651 type = (tree) *slot;
17652 die = lookup_type_die (type);
17654 die->die_perennial_p = 1;
17658 /* Helper function of premark_types_used_by_global_vars which gets called
17659 through htab_traverse.
17661 Marks the DIE of a given type in *SLOT as perennial, so it never gets
17662 marked as unused by prune_unused_types. The DIE of the type is marked
17663 only if the global variable using the type will actually be emitted. */
17666 premark_types_used_by_global_vars_helper (void **slot,
17667 void *data ATTRIBUTE_UNUSED)
17669 struct types_used_by_vars_entry *entry;
17672 entry = (struct types_used_by_vars_entry *) *slot;
17673 gcc_assert (entry->type != NULL
17674 && entry->var_decl != NULL);
17675 die = lookup_type_die (entry->type);
17678 /* Ask cgraph if the global variable really is to be emitted.
17679 If yes, then we'll keep the DIE of ENTRY->TYPE. */
17680 struct varpool_node *node = varpool_node (entry->var_decl);
17683 die->die_perennial_p = 1;
17684 /* Keep the parent DIEs as well. */
17685 while ((die = die->die_parent) && die->die_perennial_p == 0)
17686 die->die_perennial_p = 1;
17692 /* Mark all members of used_types_hash as perennial. */
17695 premark_used_types (void)
17697 if (cfun && cfun->used_types_hash)
17698 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
17701 /* Mark all members of types_used_by_vars_entry as perennial. */
17704 premark_types_used_by_global_vars (void)
17706 if (types_used_by_vars_hash)
17707 htab_traverse (types_used_by_vars_hash,
17708 premark_types_used_by_global_vars_helper, NULL);
17711 /* Generate a DIE to represent a declared function (either file-scope or
17715 gen_subprogram_die (tree decl, dw_die_ref context_die)
17717 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
17718 tree origin = decl_ultimate_origin (decl);
17719 dw_die_ref subr_die;
17722 dw_die_ref old_die = lookup_decl_die (decl);
17723 int declaration = (current_function_decl != decl
17724 || class_or_namespace_scope_p (context_die));
17726 premark_used_types ();
17728 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
17729 started to generate the abstract instance of an inline, decided to output
17730 its containing class, and proceeded to emit the declaration of the inline
17731 from the member list for the class. If so, DECLARATION takes priority;
17732 we'll get back to the abstract instance when done with the class. */
17734 /* The class-scope declaration DIE must be the primary DIE. */
17735 if (origin && declaration && class_or_namespace_scope_p (context_die))
17738 gcc_assert (!old_die);
17741 /* Now that the C++ front end lazily declares artificial member fns, we
17742 might need to retrofit the declaration into its class. */
17743 if (!declaration && !origin && !old_die
17744 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
17745 && !class_or_namespace_scope_p (context_die)
17746 && debug_info_level > DINFO_LEVEL_TERSE)
17747 old_die = force_decl_die (decl);
17749 if (origin != NULL)
17751 gcc_assert (!declaration || local_scope_p (context_die));
17753 /* Fixup die_parent for the abstract instance of a nested
17754 inline function. */
17755 if (old_die && old_die->die_parent == NULL)
17756 add_child_die (context_die, old_die);
17758 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
17759 add_abstract_origin_attribute (subr_die, origin);
17763 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
17764 struct dwarf_file_data * file_index = lookup_filename (s.file);
17766 if (!get_AT_flag (old_die, DW_AT_declaration)
17767 /* We can have a normal definition following an inline one in the
17768 case of redefinition of GNU C extern inlines.
17769 It seems reasonable to use AT_specification in this case. */
17770 && !get_AT (old_die, DW_AT_inline))
17772 /* Detect and ignore this case, where we are trying to output
17773 something we have already output. */
17777 /* If the definition comes from the same place as the declaration,
17778 maybe use the old DIE. We always want the DIE for this function
17779 that has the *_pc attributes to be under comp_unit_die so the
17780 debugger can find it. We also need to do this for abstract
17781 instances of inlines, since the spec requires the out-of-line copy
17782 to have the same parent. For local class methods, this doesn't
17783 apply; we just use the old DIE. */
17784 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
17785 && (DECL_ARTIFICIAL (decl)
17786 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
17787 && (get_AT_unsigned (old_die, DW_AT_decl_line)
17788 == (unsigned) s.line))))
17790 subr_die = old_die;
17792 /* Clear out the declaration attribute and the formal parameters.
17793 Do not remove all children, because it is possible that this
17794 declaration die was forced using force_decl_die(). In such
17795 cases die that forced declaration die (e.g. TAG_imported_module)
17796 is one of the children that we do not want to remove. */
17797 remove_AT (subr_die, DW_AT_declaration);
17798 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
17802 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
17803 add_AT_specification (subr_die, old_die);
17804 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
17805 add_AT_file (subr_die, DW_AT_decl_file, file_index);
17806 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
17807 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
17812 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
17814 if (TREE_PUBLIC (decl))
17815 add_AT_flag (subr_die, DW_AT_external, 1);
17817 add_name_and_src_coords_attributes (subr_die, decl);
17818 if (debug_info_level > DINFO_LEVEL_TERSE)
17820 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
17821 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
17822 0, 0, context_die);
17825 add_pure_or_virtual_attribute (subr_die, decl);
17826 if (DECL_ARTIFICIAL (decl))
17827 add_AT_flag (subr_die, DW_AT_artificial, 1);
17829 if (TREE_PROTECTED (decl))
17830 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
17831 else if (TREE_PRIVATE (decl))
17832 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
17837 if (!old_die || !get_AT (old_die, DW_AT_inline))
17839 add_AT_flag (subr_die, DW_AT_declaration, 1);
17841 /* If this is an explicit function declaration then generate
17842 a DW_AT_explicit attribute. */
17843 if (lang_hooks.decls.function_decl_explicit_p (decl)
17844 && (dwarf_version >= 3 || !dwarf_strict))
17845 add_AT_flag (subr_die, DW_AT_explicit, 1);
17847 /* The first time we see a member function, it is in the context of
17848 the class to which it belongs. We make sure of this by emitting
17849 the class first. The next time is the definition, which is
17850 handled above. The two may come from the same source text.
17852 Note that force_decl_die() forces function declaration die. It is
17853 later reused to represent definition. */
17854 equate_decl_number_to_die (decl, subr_die);
17857 else if (DECL_ABSTRACT (decl))
17859 if (DECL_DECLARED_INLINE_P (decl))
17861 if (cgraph_function_possibly_inlined_p (decl))
17862 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
17864 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
17868 if (cgraph_function_possibly_inlined_p (decl))
17869 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
17871 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
17874 if (DECL_DECLARED_INLINE_P (decl)
17875 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
17876 add_AT_flag (subr_die, DW_AT_artificial, 1);
17878 equate_decl_number_to_die (decl, subr_die);
17880 else if (!DECL_EXTERNAL (decl))
17882 HOST_WIDE_INT cfa_fb_offset;
17884 if (!old_die || !get_AT (old_die, DW_AT_inline))
17885 equate_decl_number_to_die (decl, subr_die);
17887 if (!flag_reorder_blocks_and_partition)
17889 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
17890 current_function_funcdef_no);
17891 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
17892 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
17893 current_function_funcdef_no);
17894 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
17896 add_pubname (decl, subr_die);
17897 add_arange (decl, subr_die);
17900 { /* Do nothing for now; maybe need to duplicate die, one for
17901 hot section and one for cold section, then use the hot/cold
17902 section begin/end labels to generate the aranges... */
17904 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
17905 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
17906 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
17907 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
17909 add_pubname (decl, subr_die);
17910 add_arange (decl, subr_die);
17911 add_arange (decl, subr_die);
17915 #ifdef MIPS_DEBUGGING_INFO
17916 /* Add a reference to the FDE for this routine. */
17917 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
17920 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
17922 /* We define the "frame base" as the function's CFA. This is more
17923 convenient for several reasons: (1) It's stable across the prologue
17924 and epilogue, which makes it better than just a frame pointer,
17925 (2) With dwarf3, there exists a one-byte encoding that allows us
17926 to reference the .debug_frame data by proxy, but failing that,
17927 (3) We can at least reuse the code inspection and interpretation
17928 code that determines the CFA position at various points in the
17930 if (dwarf_version >= 3)
17932 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
17933 add_AT_loc (subr_die, DW_AT_frame_base, op);
17937 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
17938 if (list->dw_loc_next)
17939 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
17941 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
17944 /* Compute a displacement from the "steady-state frame pointer" to
17945 the CFA. The former is what all stack slots and argument slots
17946 will reference in the rtl; the later is what we've told the
17947 debugger about. We'll need to adjust all frame_base references
17948 by this displacement. */
17949 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
17951 if (cfun->static_chain_decl)
17952 add_AT_location_description (subr_die, DW_AT_static_link,
17953 loc_list_from_tree (cfun->static_chain_decl, 2));
17956 /* Generate child dies for template paramaters. */
17957 if (debug_info_level > DINFO_LEVEL_TERSE)
17958 gen_generic_params_dies (decl);
17960 /* Now output descriptions of the arguments for this function. This gets
17961 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
17962 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
17963 `...' at the end of the formal parameter list. In order to find out if
17964 there was a trailing ellipsis or not, we must instead look at the type
17965 associated with the FUNCTION_DECL. This will be a node of type
17966 FUNCTION_TYPE. If the chain of type nodes hanging off of this
17967 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
17968 an ellipsis at the end. */
17970 /* In the case where we are describing a mere function declaration, all we
17971 need to do here (and all we *can* do here) is to describe the *types* of
17972 its formal parameters. */
17973 if (debug_info_level <= DINFO_LEVEL_TERSE)
17975 else if (declaration)
17976 gen_formal_types_die (decl, subr_die);
17979 /* Generate DIEs to represent all known formal parameters. */
17980 tree parm = DECL_ARGUMENTS (decl);
17981 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
17982 tree generic_decl_parm = generic_decl
17983 ? DECL_ARGUMENTS (generic_decl)
17986 /* Now we want to walk the list of parameters of the function and
17987 emit their relevant DIEs.
17989 We consider the case of DECL being an instance of a generic function
17990 as well as it being a normal function.
17992 If DECL is an instance of a generic function we walk the
17993 parameters of the generic function declaration _and_ the parameters of
17994 DECL itself. This is useful because we want to emit specific DIEs for
17995 function parameter packs and those are declared as part of the
17996 generic function declaration. In that particular case,
17997 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
17998 That DIE has children DIEs representing the set of arguments
17999 of the pack. Note that the set of pack arguments can be empty.
18000 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18003 Otherwise, we just consider the parameters of DECL. */
18004 while (generic_decl_parm || parm)
18006 if (generic_decl_parm
18007 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
18008 gen_formal_parameter_pack_die (generic_decl_parm,
18013 gen_decl_die (parm, NULL, subr_die);
18014 parm = TREE_CHAIN (parm);
18017 if (generic_decl_parm)
18018 generic_decl_parm = TREE_CHAIN (generic_decl_parm);
18021 /* Decide whether we need an unspecified_parameters DIE at the end.
18022 There are 2 more cases to do this for: 1) the ansi ... declaration -
18023 this is detectable when the end of the arg list is not a
18024 void_type_node 2) an unprototyped function declaration (not a
18025 definition). This just means that we have no info about the
18026 parameters at all. */
18027 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
18028 if (fn_arg_types != NULL)
18030 /* This is the prototyped case, check for.... */
18031 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
18032 gen_unspecified_parameters_die (decl, subr_die);
18034 else if (DECL_INITIAL (decl) == NULL_TREE)
18035 gen_unspecified_parameters_die (decl, subr_die);
18038 /* Output Dwarf info for all of the stuff within the body of the function
18039 (if it has one - it may be just a declaration). */
18040 outer_scope = DECL_INITIAL (decl);
18042 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18043 a function. This BLOCK actually represents the outermost binding contour
18044 for the function, i.e. the contour in which the function's formal
18045 parameters and labels get declared. Curiously, it appears that the front
18046 end doesn't actually put the PARM_DECL nodes for the current function onto
18047 the BLOCK_VARS list for this outer scope, but are strung off of the
18048 DECL_ARGUMENTS list for the function instead.
18050 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18051 the LABEL_DECL nodes for the function however, and we output DWARF info
18052 for those in decls_for_scope. Just within the `outer_scope' there will be
18053 a BLOCK node representing the function's outermost pair of curly braces,
18054 and any blocks used for the base and member initializers of a C++
18055 constructor function. */
18056 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
18058 /* Emit a DW_TAG_variable DIE for a named return value. */
18059 if (DECL_NAME (DECL_RESULT (decl)))
18060 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
18062 current_function_has_inlines = 0;
18063 decls_for_scope (outer_scope, subr_die, 0);
18065 #if 0 && defined (MIPS_DEBUGGING_INFO)
18066 if (current_function_has_inlines)
18068 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
18069 if (! comp_unit_has_inlines)
18071 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
18072 comp_unit_has_inlines = 1;
18077 /* Add the calling convention attribute if requested. */
18078 add_calling_convention_attribute (subr_die, decl);
18082 /* Returns a hash value for X (which really is a die_struct). */
18085 common_block_die_table_hash (const void *x)
18087 const_dw_die_ref d = (const_dw_die_ref) x;
18088 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
18091 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18092 as decl_id and die_parent of die_struct Y. */
18095 common_block_die_table_eq (const void *x, const void *y)
18097 const_dw_die_ref d = (const_dw_die_ref) x;
18098 const_dw_die_ref e = (const_dw_die_ref) y;
18099 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
18102 /* Generate a DIE to represent a declared data object.
18103 Either DECL or ORIGIN must be non-null. */
18106 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
18110 tree decl_or_origin = decl ? decl : origin;
18111 tree ultimate_origin;
18112 dw_die_ref var_die;
18113 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
18114 dw_die_ref origin_die;
18115 int declaration = (DECL_EXTERNAL (decl_or_origin)
18116 || class_or_namespace_scope_p (context_die));
18118 ultimate_origin = decl_ultimate_origin (decl_or_origin);
18119 if (decl || ultimate_origin)
18120 origin = ultimate_origin;
18121 com_decl = fortran_common (decl_or_origin, &off);
18123 /* Symbol in common gets emitted as a child of the common block, in the form
18124 of a data member. */
18127 dw_die_ref com_die;
18128 dw_loc_list_ref loc;
18129 die_node com_die_arg;
18131 var_die = lookup_decl_die (decl_or_origin);
18134 if (get_AT (var_die, DW_AT_location) == NULL)
18136 loc = loc_list_from_tree (com_decl, off ? 1 : 2);
18141 /* Optimize the common case. */
18142 if (single_element_loc_list_p (loc)
18143 && loc->expr->dw_loc_opc == DW_OP_addr
18144 && loc->expr->dw_loc_next == NULL
18145 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
18147 loc->expr->dw_loc_oprnd1.v.val_addr
18148 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
18150 loc_list_plus_const (loc, off);
18152 add_AT_location_description (var_die, DW_AT_location, loc);
18153 remove_AT (var_die, DW_AT_declaration);
18159 if (common_block_die_table == NULL)
18160 common_block_die_table
18161 = htab_create_ggc (10, common_block_die_table_hash,
18162 common_block_die_table_eq, NULL);
18164 com_die_arg.decl_id = DECL_UID (com_decl);
18165 com_die_arg.die_parent = context_die;
18166 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
18167 loc = loc_list_from_tree (com_decl, 2);
18168 if (com_die == NULL)
18171 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
18174 com_die = new_die (DW_TAG_common_block, context_die, decl);
18175 add_name_and_src_coords_attributes (com_die, com_decl);
18178 add_AT_location_description (com_die, DW_AT_location, loc);
18179 /* Avoid sharing the same loc descriptor between
18180 DW_TAG_common_block and DW_TAG_variable. */
18181 loc = loc_list_from_tree (com_decl, 2);
18183 else if (DECL_EXTERNAL (decl))
18184 add_AT_flag (com_die, DW_AT_declaration, 1);
18185 add_pubname_string (cnam, com_die); /* ??? needed? */
18186 com_die->decl_id = DECL_UID (com_decl);
18187 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
18188 *slot = (void *) com_die;
18190 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
18192 add_AT_location_description (com_die, DW_AT_location, loc);
18193 loc = loc_list_from_tree (com_decl, 2);
18194 remove_AT (com_die, DW_AT_declaration);
18196 var_die = new_die (DW_TAG_variable, com_die, decl);
18197 add_name_and_src_coords_attributes (var_die, decl);
18198 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
18199 TREE_THIS_VOLATILE (decl), context_die);
18200 add_AT_flag (var_die, DW_AT_external, 1);
18205 /* Optimize the common case. */
18206 if (single_element_loc_list_p (loc)
18207 && loc->expr->dw_loc_opc == DW_OP_addr
18208 && loc->expr->dw_loc_next == NULL
18209 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
18210 loc->expr->dw_loc_oprnd1.v.val_addr
18211 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
18213 loc_list_plus_const (loc, off);
18215 add_AT_location_description (var_die, DW_AT_location, loc);
18217 else if (DECL_EXTERNAL (decl))
18218 add_AT_flag (var_die, DW_AT_declaration, 1);
18219 equate_decl_number_to_die (decl, var_die);
18223 /* If the compiler emitted a definition for the DECL declaration
18224 and if we already emitted a DIE for it, don't emit a second
18225 DIE for it again. */
18230 /* For static data members, the declaration in the class is supposed
18231 to have DW_TAG_member tag; the specification should still be
18232 DW_TAG_variable referencing the DW_TAG_member DIE. */
18233 if (declaration && class_scope_p (context_die))
18234 var_die = new_die (DW_TAG_member, context_die, decl);
18236 var_die = new_die (DW_TAG_variable, context_die, decl);
18239 if (origin != NULL)
18240 origin_die = add_abstract_origin_attribute (var_die, origin);
18242 /* Loop unrolling can create multiple blocks that refer to the same
18243 static variable, so we must test for the DW_AT_declaration flag.
18245 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
18246 copy decls and set the DECL_ABSTRACT flag on them instead of
18249 ??? Duplicated blocks have been rewritten to use .debug_ranges.
18251 ??? The declare_in_namespace support causes us to get two DIEs for one
18252 variable, both of which are declarations. We want to avoid considering
18253 one to be a specification, so we must test that this DIE is not a
18255 else if (old_die && TREE_STATIC (decl) && ! declaration
18256 && get_AT_flag (old_die, DW_AT_declaration) == 1)
18258 /* This is a definition of a C++ class level static. */
18259 add_AT_specification (var_die, old_die);
18260 if (DECL_NAME (decl))
18262 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
18263 struct dwarf_file_data * file_index = lookup_filename (s.file);
18265 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
18266 add_AT_file (var_die, DW_AT_decl_file, file_index);
18268 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
18269 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
18274 tree type = TREE_TYPE (decl);
18276 add_name_and_src_coords_attributes (var_die, decl);
18277 if (decl_by_reference_p (decl))
18278 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
18280 add_type_attribute (var_die, type, TREE_READONLY (decl),
18281 TREE_THIS_VOLATILE (decl), context_die);
18283 if (TREE_PUBLIC (decl))
18284 add_AT_flag (var_die, DW_AT_external, 1);
18286 if (DECL_ARTIFICIAL (decl))
18287 add_AT_flag (var_die, DW_AT_artificial, 1);
18289 if (TREE_PROTECTED (decl))
18290 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
18291 else if (TREE_PRIVATE (decl))
18292 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
18296 add_AT_flag (var_die, DW_AT_declaration, 1);
18298 if (decl && (DECL_ABSTRACT (decl) || declaration))
18299 equate_decl_number_to_die (decl, var_die);
18302 && (! DECL_ABSTRACT (decl_or_origin)
18303 /* Local static vars are shared between all clones/inlines,
18304 so emit DW_AT_location on the abstract DIE if DECL_RTL is
18306 || (TREE_CODE (decl_or_origin) == VAR_DECL
18307 && TREE_STATIC (decl_or_origin)
18308 && DECL_RTL_SET_P (decl_or_origin)))
18309 /* When abstract origin already has DW_AT_location attribute, no need
18310 to add it again. */
18311 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
18313 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
18314 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
18315 defer_location (decl_or_origin, var_die);
18317 add_location_or_const_value_attribute (var_die,
18320 add_pubname (decl_or_origin, var_die);
18323 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
18326 /* Generate a DIE to represent a named constant. */
18329 gen_const_die (tree decl, dw_die_ref context_die)
18331 dw_die_ref const_die;
18332 tree type = TREE_TYPE (decl);
18334 const_die = new_die (DW_TAG_constant, context_die, decl);
18335 add_name_and_src_coords_attributes (const_die, decl);
18336 add_type_attribute (const_die, type, 1, 0, context_die);
18337 if (TREE_PUBLIC (decl))
18338 add_AT_flag (const_die, DW_AT_external, 1);
18339 if (DECL_ARTIFICIAL (decl))
18340 add_AT_flag (const_die, DW_AT_artificial, 1);
18341 tree_add_const_value_attribute_for_decl (const_die, decl);
18344 /* Generate a DIE to represent a label identifier. */
18347 gen_label_die (tree decl, dw_die_ref context_die)
18349 tree origin = decl_ultimate_origin (decl);
18350 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
18352 char label[MAX_ARTIFICIAL_LABEL_BYTES];
18354 if (origin != NULL)
18355 add_abstract_origin_attribute (lbl_die, origin);
18357 add_name_and_src_coords_attributes (lbl_die, decl);
18359 if (DECL_ABSTRACT (decl))
18360 equate_decl_number_to_die (decl, lbl_die);
18363 insn = DECL_RTL_IF_SET (decl);
18365 /* Deleted labels are programmer specified labels which have been
18366 eliminated because of various optimizations. We still emit them
18367 here so that it is possible to put breakpoints on them. */
18371 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
18373 /* When optimization is enabled (via -O) some parts of the compiler
18374 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
18375 represent source-level labels which were explicitly declared by
18376 the user. This really shouldn't be happening though, so catch
18377 it if it ever does happen. */
18378 gcc_assert (!INSN_DELETED_P (insn));
18380 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
18381 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
18386 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
18387 attributes to the DIE for a block STMT, to describe where the inlined
18388 function was called from. This is similar to add_src_coords_attributes. */
18391 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
18393 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
18395 if (dwarf_version >= 3 || !dwarf_strict)
18397 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
18398 add_AT_unsigned (die, DW_AT_call_line, s.line);
18403 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
18404 Add low_pc and high_pc attributes to the DIE for a block STMT. */
18407 add_high_low_attributes (tree stmt, dw_die_ref die)
18409 char label[MAX_ARTIFICIAL_LABEL_BYTES];
18411 if (BLOCK_FRAGMENT_CHAIN (stmt)
18412 && (dwarf_version >= 3 || !dwarf_strict))
18416 if (inlined_function_outer_scope_p (stmt))
18418 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
18419 BLOCK_NUMBER (stmt));
18420 add_AT_lbl_id (die, DW_AT_entry_pc, label);
18423 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
18425 chain = BLOCK_FRAGMENT_CHAIN (stmt);
18428 add_ranges (chain);
18429 chain = BLOCK_FRAGMENT_CHAIN (chain);
18436 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
18437 BLOCK_NUMBER (stmt));
18438 add_AT_lbl_id (die, DW_AT_low_pc, label);
18439 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
18440 BLOCK_NUMBER (stmt));
18441 add_AT_lbl_id (die, DW_AT_high_pc, label);
18445 /* Generate a DIE for a lexical block. */
18448 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
18450 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
18452 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
18453 add_high_low_attributes (stmt, stmt_die);
18455 decls_for_scope (stmt, stmt_die, depth);
18458 /* Generate a DIE for an inlined subprogram. */
18461 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
18465 /* The instance of function that is effectively being inlined shall not
18467 gcc_assert (! BLOCK_ABSTRACT (stmt));
18469 decl = block_ultimate_origin (stmt);
18471 /* Emit info for the abstract instance first, if we haven't yet. We
18472 must emit this even if the block is abstract, otherwise when we
18473 emit the block below (or elsewhere), we may end up trying to emit
18474 a die whose origin die hasn't been emitted, and crashing. */
18475 dwarf2out_abstract_function (decl);
18477 if (! BLOCK_ABSTRACT (stmt))
18479 dw_die_ref subr_die
18480 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
18482 add_abstract_origin_attribute (subr_die, decl);
18483 if (TREE_ASM_WRITTEN (stmt))
18484 add_high_low_attributes (stmt, subr_die);
18485 add_call_src_coords_attributes (stmt, subr_die);
18487 decls_for_scope (stmt, subr_die, depth);
18488 current_function_has_inlines = 1;
18492 /* Generate a DIE for a field in a record, or structure. */
18495 gen_field_die (tree decl, dw_die_ref context_die)
18497 dw_die_ref decl_die;
18499 if (TREE_TYPE (decl) == error_mark_node)
18502 decl_die = new_die (DW_TAG_member, context_die, decl);
18503 add_name_and_src_coords_attributes (decl_die, decl);
18504 add_type_attribute (decl_die, member_declared_type (decl),
18505 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
18508 if (DECL_BIT_FIELD_TYPE (decl))
18510 add_byte_size_attribute (decl_die, decl);
18511 add_bit_size_attribute (decl_die, decl);
18512 add_bit_offset_attribute (decl_die, decl);
18515 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
18516 add_data_member_location_attribute (decl_die, decl);
18518 if (DECL_ARTIFICIAL (decl))
18519 add_AT_flag (decl_die, DW_AT_artificial, 1);
18521 if (TREE_PROTECTED (decl))
18522 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
18523 else if (TREE_PRIVATE (decl))
18524 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
18526 /* Equate decl number to die, so that we can look up this decl later on. */
18527 equate_decl_number_to_die (decl, decl_die);
18531 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
18532 Use modified_type_die instead.
18533 We keep this code here just in case these types of DIEs may be needed to
18534 represent certain things in other languages (e.g. Pascal) someday. */
18537 gen_pointer_type_die (tree type, dw_die_ref context_die)
18540 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
18542 equate_type_number_to_die (type, ptr_die);
18543 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
18544 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
18547 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
18548 Use modified_type_die instead.
18549 We keep this code here just in case these types of DIEs may be needed to
18550 represent certain things in other languages (e.g. Pascal) someday. */
18553 gen_reference_type_die (tree type, dw_die_ref context_die)
18556 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
18558 equate_type_number_to_die (type, ref_die);
18559 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
18560 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
18564 /* Generate a DIE for a pointer to a member type. */
18567 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
18570 = new_die (DW_TAG_ptr_to_member_type,
18571 scope_die_for (type, context_die), type);
18573 equate_type_number_to_die (type, ptr_die);
18574 add_AT_die_ref (ptr_die, DW_AT_containing_type,
18575 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
18576 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
18579 /* Generate the DIE for the compilation unit. */
18582 gen_compile_unit_die (const char *filename)
18585 char producer[250];
18586 const char *language_string = lang_hooks.name;
18589 die = new_die (DW_TAG_compile_unit, NULL, NULL);
18593 add_name_attribute (die, filename);
18594 /* Don't add cwd for <built-in>. */
18595 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
18596 add_comp_dir_attribute (die);
18599 sprintf (producer, "%s %s", language_string, version_string);
18601 #ifdef MIPS_DEBUGGING_INFO
18602 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
18603 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
18604 not appear in the producer string, the debugger reaches the conclusion
18605 that the object file is stripped and has no debugging information.
18606 To get the MIPS/SGI debugger to believe that there is debugging
18607 information in the object file, we add a -g to the producer string. */
18608 if (debug_info_level > DINFO_LEVEL_TERSE)
18609 strcat (producer, " -g");
18612 add_AT_string (die, DW_AT_producer, producer);
18614 language = DW_LANG_C89;
18615 if (strcmp (language_string, "GNU C++") == 0)
18616 language = DW_LANG_C_plus_plus;
18617 else if (strcmp (language_string, "GNU F77") == 0)
18618 language = DW_LANG_Fortran77;
18619 else if (strcmp (language_string, "GNU Pascal") == 0)
18620 language = DW_LANG_Pascal83;
18621 else if (dwarf_version >= 3 || !dwarf_strict)
18623 if (strcmp (language_string, "GNU Ada") == 0)
18624 language = DW_LANG_Ada95;
18625 else if (strcmp (language_string, "GNU Fortran") == 0)
18626 language = DW_LANG_Fortran95;
18627 else if (strcmp (language_string, "GNU Java") == 0)
18628 language = DW_LANG_Java;
18629 else if (strcmp (language_string, "GNU Objective-C") == 0)
18630 language = DW_LANG_ObjC;
18631 else if (strcmp (language_string, "GNU Objective-C++") == 0)
18632 language = DW_LANG_ObjC_plus_plus;
18635 add_AT_unsigned (die, DW_AT_language, language);
18639 /* Generate the DIE for a base class. */
18642 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
18644 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
18646 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
18647 add_data_member_location_attribute (die, binfo);
18649 if (BINFO_VIRTUAL_P (binfo))
18650 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
18652 if (access == access_public_node)
18653 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
18654 else if (access == access_protected_node)
18655 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
18658 /* Generate a DIE for a class member. */
18661 gen_member_die (tree type, dw_die_ref context_die)
18664 tree binfo = TYPE_BINFO (type);
18667 /* If this is not an incomplete type, output descriptions of each of its
18668 members. Note that as we output the DIEs necessary to represent the
18669 members of this record or union type, we will also be trying to output
18670 DIEs to represent the *types* of those members. However the `type'
18671 function (above) will specifically avoid generating type DIEs for member
18672 types *within* the list of member DIEs for this (containing) type except
18673 for those types (of members) which are explicitly marked as also being
18674 members of this (containing) type themselves. The g++ front- end can
18675 force any given type to be treated as a member of some other (containing)
18676 type by setting the TYPE_CONTEXT of the given (member) type to point to
18677 the TREE node representing the appropriate (containing) type. */
18679 /* First output info about the base classes. */
18682 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
18686 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
18687 gen_inheritance_die (base,
18688 (accesses ? VEC_index (tree, accesses, i)
18689 : access_public_node), context_die);
18692 /* Now output info about the data members and type members. */
18693 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
18695 /* If we thought we were generating minimal debug info for TYPE
18696 and then changed our minds, some of the member declarations
18697 may have already been defined. Don't define them again, but
18698 do put them in the right order. */
18700 child = lookup_decl_die (member);
18702 splice_child_die (context_die, child);
18704 gen_decl_die (member, NULL, context_die);
18707 /* Now output info about the function members (if any). */
18708 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
18710 /* Don't include clones in the member list. */
18711 if (DECL_ABSTRACT_ORIGIN (member))
18714 child = lookup_decl_die (member);
18716 splice_child_die (context_die, child);
18718 gen_decl_die (member, NULL, context_die);
18722 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
18723 is set, we pretend that the type was never defined, so we only get the
18724 member DIEs needed by later specification DIEs. */
18727 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
18728 enum debug_info_usage usage)
18730 dw_die_ref type_die = lookup_type_die (type);
18731 dw_die_ref scope_die = 0;
18733 int complete = (TYPE_SIZE (type)
18734 && (! TYPE_STUB_DECL (type)
18735 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
18736 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
18737 complete = complete && should_emit_struct_debug (type, usage);
18739 if (type_die && ! complete)
18742 if (TYPE_CONTEXT (type) != NULL_TREE
18743 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
18744 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
18747 scope_die = scope_die_for (type, context_die);
18749 if (! type_die || (nested && scope_die == comp_unit_die))
18750 /* First occurrence of type or toplevel definition of nested class. */
18752 dw_die_ref old_die = type_die;
18754 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
18755 ? record_type_tag (type) : DW_TAG_union_type,
18757 equate_type_number_to_die (type, type_die);
18759 add_AT_specification (type_die, old_die);
18761 add_name_attribute (type_die, type_tag (type));
18764 remove_AT (type_die, DW_AT_declaration);
18766 /* Generate child dies for template paramaters. */
18767 if (debug_info_level > DINFO_LEVEL_TERSE
18768 && COMPLETE_TYPE_P (type))
18769 gen_generic_params_dies (type);
18771 /* If this type has been completed, then give it a byte_size attribute and
18772 then give a list of members. */
18773 if (complete && !ns_decl)
18775 /* Prevent infinite recursion in cases where the type of some member of
18776 this type is expressed in terms of this type itself. */
18777 TREE_ASM_WRITTEN (type) = 1;
18778 add_byte_size_attribute (type_die, type);
18779 if (TYPE_STUB_DECL (type) != NULL_TREE)
18780 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
18782 /* If the first reference to this type was as the return type of an
18783 inline function, then it may not have a parent. Fix this now. */
18784 if (type_die->die_parent == NULL)
18785 add_child_die (scope_die, type_die);
18787 push_decl_scope (type);
18788 gen_member_die (type, type_die);
18791 /* GNU extension: Record what type our vtable lives in. */
18792 if (TYPE_VFIELD (type))
18794 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
18796 gen_type_die (vtype, context_die);
18797 add_AT_die_ref (type_die, DW_AT_containing_type,
18798 lookup_type_die (vtype));
18803 add_AT_flag (type_die, DW_AT_declaration, 1);
18805 /* We don't need to do this for function-local types. */
18806 if (TYPE_STUB_DECL (type)
18807 && ! decl_function_context (TYPE_STUB_DECL (type)))
18808 VEC_safe_push (tree, gc, incomplete_types, type);
18811 if (get_AT (type_die, DW_AT_name))
18812 add_pubtype (type, type_die);
18815 /* Generate a DIE for a subroutine _type_. */
18818 gen_subroutine_type_die (tree type, dw_die_ref context_die)
18820 tree return_type = TREE_TYPE (type);
18821 dw_die_ref subr_die
18822 = new_die (DW_TAG_subroutine_type,
18823 scope_die_for (type, context_die), type);
18825 equate_type_number_to_die (type, subr_die);
18826 add_prototyped_attribute (subr_die, type);
18827 add_type_attribute (subr_die, return_type, 0, 0, context_die);
18828 gen_formal_types_die (type, subr_die);
18830 if (get_AT (subr_die, DW_AT_name))
18831 add_pubtype (type, subr_die);
18834 /* Generate a DIE for a type definition. */
18837 gen_typedef_die (tree decl, dw_die_ref context_die)
18839 dw_die_ref type_die;
18842 if (TREE_ASM_WRITTEN (decl))
18845 TREE_ASM_WRITTEN (decl) = 1;
18846 type_die = new_die (DW_TAG_typedef, context_die, decl);
18847 origin = decl_ultimate_origin (decl);
18848 if (origin != NULL)
18849 add_abstract_origin_attribute (type_die, origin);
18854 add_name_and_src_coords_attributes (type_die, decl);
18855 if (DECL_ORIGINAL_TYPE (decl))
18857 type = DECL_ORIGINAL_TYPE (decl);
18859 gcc_assert (type != TREE_TYPE (decl));
18860 equate_type_number_to_die (TREE_TYPE (decl), type_die);
18863 type = TREE_TYPE (decl);
18865 add_type_attribute (type_die, type, TREE_READONLY (decl),
18866 TREE_THIS_VOLATILE (decl), context_die);
18869 if (DECL_ABSTRACT (decl))
18870 equate_decl_number_to_die (decl, type_die);
18872 if (get_AT (type_die, DW_AT_name))
18873 add_pubtype (decl, type_die);
18876 /* Generate a type description DIE. */
18879 gen_type_die_with_usage (tree type, dw_die_ref context_die,
18880 enum debug_info_usage usage)
18883 struct array_descr_info info;
18885 if (type == NULL_TREE || type == error_mark_node)
18888 /* If TYPE is a typedef type variant, let's generate debug info
18889 for the parent typedef which TYPE is a type of. */
18890 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
18891 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
18893 if (TREE_ASM_WRITTEN (type))
18896 /* Prevent broken recursion; we can't hand off to the same type. */
18897 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
18899 /* Use the DIE of the containing namespace as the parent DIE of
18900 the type description DIE we want to generate. */
18901 if (DECL_CONTEXT (TYPE_NAME (type))
18902 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
18903 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
18905 TREE_ASM_WRITTEN (type) = 1;
18906 gen_decl_die (TYPE_NAME (type), NULL, context_die);
18910 /* If this is an array type with hidden descriptor, handle it first. */
18911 if (!TREE_ASM_WRITTEN (type)
18912 && lang_hooks.types.get_array_descr_info
18913 && lang_hooks.types.get_array_descr_info (type, &info)
18914 && (dwarf_version >= 3 || !dwarf_strict))
18916 gen_descr_array_type_die (type, &info, context_die);
18917 TREE_ASM_WRITTEN (type) = 1;
18921 /* We are going to output a DIE to represent the unqualified version
18922 of this type (i.e. without any const or volatile qualifiers) so
18923 get the main variant (i.e. the unqualified version) of this type
18924 now. (Vectors are special because the debugging info is in the
18925 cloned type itself). */
18926 if (TREE_CODE (type) != VECTOR_TYPE)
18927 type = type_main_variant (type);
18929 if (TREE_ASM_WRITTEN (type))
18932 switch (TREE_CODE (type))
18938 case REFERENCE_TYPE:
18939 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
18940 ensures that the gen_type_die recursion will terminate even if the
18941 type is recursive. Recursive types are possible in Ada. */
18942 /* ??? We could perhaps do this for all types before the switch
18944 TREE_ASM_WRITTEN (type) = 1;
18946 /* For these types, all that is required is that we output a DIE (or a
18947 set of DIEs) to represent the "basis" type. */
18948 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18949 DINFO_USAGE_IND_USE);
18953 /* This code is used for C++ pointer-to-data-member types.
18954 Output a description of the relevant class type. */
18955 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
18956 DINFO_USAGE_IND_USE);
18958 /* Output a description of the type of the object pointed to. */
18959 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18960 DINFO_USAGE_IND_USE);
18962 /* Now output a DIE to represent this pointer-to-data-member type
18964 gen_ptr_to_mbr_type_die (type, context_die);
18967 case FUNCTION_TYPE:
18968 /* Force out return type (in case it wasn't forced out already). */
18969 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18970 DINFO_USAGE_DIR_USE);
18971 gen_subroutine_type_die (type, context_die);
18975 /* Force out return type (in case it wasn't forced out already). */
18976 gen_type_die_with_usage (TREE_TYPE (type), context_die,
18977 DINFO_USAGE_DIR_USE);
18978 gen_subroutine_type_die (type, context_die);
18982 gen_array_type_die (type, context_die);
18986 gen_array_type_die (type, context_die);
18989 case ENUMERAL_TYPE:
18992 case QUAL_UNION_TYPE:
18993 /* If this is a nested type whose containing class hasn't been written
18994 out yet, writing it out will cover this one, too. This does not apply
18995 to instantiations of member class templates; they need to be added to
18996 the containing class as they are generated. FIXME: This hurts the
18997 idea of combining type decls from multiple TUs, since we can't predict
18998 what set of template instantiations we'll get. */
18999 if (TYPE_CONTEXT (type)
19000 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
19001 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
19003 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
19005 if (TREE_ASM_WRITTEN (type))
19008 /* If that failed, attach ourselves to the stub. */
19009 push_decl_scope (TYPE_CONTEXT (type));
19010 context_die = lookup_type_die (TYPE_CONTEXT (type));
19013 else if (TYPE_CONTEXT (type) != NULL_TREE
19014 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
19016 /* If this type is local to a function that hasn't been written
19017 out yet, use a NULL context for now; it will be fixed up in
19018 decls_for_scope. */
19019 context_die = lookup_decl_die (TYPE_CONTEXT (type));
19024 context_die = declare_in_namespace (type, context_die);
19028 if (TREE_CODE (type) == ENUMERAL_TYPE)
19030 /* This might have been written out by the call to
19031 declare_in_namespace. */
19032 if (!TREE_ASM_WRITTEN (type))
19033 gen_enumeration_type_die (type, context_die);
19036 gen_struct_or_union_type_die (type, context_die, usage);
19041 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19042 it up if it is ever completed. gen_*_type_die will set it for us
19043 when appropriate. */
19049 case FIXED_POINT_TYPE:
19052 /* No DIEs needed for fundamental types. */
19056 /* No Dwarf representation currently defined. */
19060 gcc_unreachable ();
19063 TREE_ASM_WRITTEN (type) = 1;
19067 gen_type_die (tree type, dw_die_ref context_die)
19069 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
19072 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
19073 things which are local to the given block. */
19076 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
19078 int must_output_die = 0;
19081 /* Ignore blocks that are NULL. */
19082 if (stmt == NULL_TREE)
19085 inlined_func = inlined_function_outer_scope_p (stmt);
19087 /* If the block is one fragment of a non-contiguous block, do not
19088 process the variables, since they will have been done by the
19089 origin block. Do process subblocks. */
19090 if (BLOCK_FRAGMENT_ORIGIN (stmt))
19094 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
19095 gen_block_die (sub, context_die, depth + 1);
19100 /* Determine if we need to output any Dwarf DIEs at all to represent this
19103 /* The outer scopes for inlinings *must* always be represented. We
19104 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
19105 must_output_die = 1;
19108 /* Determine if this block directly contains any "significant"
19109 local declarations which we will need to output DIEs for. */
19110 if (debug_info_level > DINFO_LEVEL_TERSE)
19111 /* We are not in terse mode so *any* local declaration counts
19112 as being a "significant" one. */
19113 must_output_die = ((BLOCK_VARS (stmt) != NULL
19114 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
19115 && (TREE_USED (stmt)
19116 || TREE_ASM_WRITTEN (stmt)
19117 || BLOCK_ABSTRACT (stmt)));
19118 else if ((TREE_USED (stmt)
19119 || TREE_ASM_WRITTEN (stmt)
19120 || BLOCK_ABSTRACT (stmt))
19121 && !dwarf2out_ignore_block (stmt))
19122 must_output_die = 1;
19125 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
19126 DIE for any block which contains no significant local declarations at
19127 all. Rather, in such cases we just call `decls_for_scope' so that any
19128 needed Dwarf info for any sub-blocks will get properly generated. Note
19129 that in terse mode, our definition of what constitutes a "significant"
19130 local declaration gets restricted to include only inlined function
19131 instances and local (nested) function definitions. */
19132 if (must_output_die)
19136 /* If STMT block is abstract, that means we have been called
19137 indirectly from dwarf2out_abstract_function.
19138 That function rightfully marks the descendent blocks (of
19139 the abstract function it is dealing with) as being abstract,
19140 precisely to prevent us from emitting any
19141 DW_TAG_inlined_subroutine DIE as a descendent
19142 of an abstract function instance. So in that case, we should
19143 not call gen_inlined_subroutine_die.
19145 Later though, when cgraph asks dwarf2out to emit info
19146 for the concrete instance of the function decl into which
19147 the concrete instance of STMT got inlined, the later will lead
19148 to the generation of a DW_TAG_inlined_subroutine DIE. */
19149 if (! BLOCK_ABSTRACT (stmt))
19150 gen_inlined_subroutine_die (stmt, context_die, depth);
19153 gen_lexical_block_die (stmt, context_die, depth);
19156 decls_for_scope (stmt, context_die, depth);
19159 /* Process variable DECL (or variable with origin ORIGIN) within
19160 block STMT and add it to CONTEXT_DIE. */
19162 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
19165 tree decl_or_origin = decl ? decl : origin;
19167 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
19168 die = lookup_decl_die (decl_or_origin);
19169 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
19170 && TYPE_DECL_IS_STUB (decl_or_origin))
19171 die = lookup_type_die (TREE_TYPE (decl_or_origin));
19175 if (die != NULL && die->die_parent == NULL)
19176 add_child_die (context_die, die);
19177 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
19178 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
19179 stmt, context_die);
19181 gen_decl_die (decl, origin, context_die);
19184 /* Generate all of the decls declared within a given scope and (recursively)
19185 all of its sub-blocks. */
19188 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
19194 /* Ignore NULL blocks. */
19195 if (stmt == NULL_TREE)
19198 /* Output the DIEs to represent all of the data objects and typedefs
19199 declared directly within this block but not within any nested
19200 sub-blocks. Also, nested function and tag DIEs have been
19201 generated with a parent of NULL; fix that up now. */
19202 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
19203 process_scope_var (stmt, decl, NULL_TREE, context_die);
19204 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
19205 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
19208 /* If we're at -g1, we're not interested in subblocks. */
19209 if (debug_info_level <= DINFO_LEVEL_TERSE)
19212 /* Output the DIEs to represent all sub-blocks (and the items declared
19213 therein) of this block. */
19214 for (subblocks = BLOCK_SUBBLOCKS (stmt);
19216 subblocks = BLOCK_CHAIN (subblocks))
19217 gen_block_die (subblocks, context_die, depth + 1);
19220 /* Is this a typedef we can avoid emitting? */
19223 is_redundant_typedef (const_tree decl)
19225 if (TYPE_DECL_IS_STUB (decl))
19228 if (DECL_ARTIFICIAL (decl)
19229 && DECL_CONTEXT (decl)
19230 && is_tagged_type (DECL_CONTEXT (decl))
19231 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
19232 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
19233 /* Also ignore the artificial member typedef for the class name. */
19239 /* Returns the DIE for a context. */
19241 static inline dw_die_ref
19242 get_context_die (tree context)
19246 /* Find die that represents this context. */
19247 if (TYPE_P (context))
19248 return force_type_die (TYPE_MAIN_VARIANT (context));
19250 return force_decl_die (context);
19252 return comp_unit_die;
19255 /* Returns the DIE for decl. A DIE will always be returned. */
19258 force_decl_die (tree decl)
19260 dw_die_ref decl_die;
19261 unsigned saved_external_flag;
19262 tree save_fn = NULL_TREE;
19263 decl_die = lookup_decl_die (decl);
19266 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
19268 decl_die = lookup_decl_die (decl);
19272 switch (TREE_CODE (decl))
19274 case FUNCTION_DECL:
19275 /* Clear current_function_decl, so that gen_subprogram_die thinks
19276 that this is a declaration. At this point, we just want to force
19277 declaration die. */
19278 save_fn = current_function_decl;
19279 current_function_decl = NULL_TREE;
19280 gen_subprogram_die (decl, context_die);
19281 current_function_decl = save_fn;
19285 /* Set external flag to force declaration die. Restore it after
19286 gen_decl_die() call. */
19287 saved_external_flag = DECL_EXTERNAL (decl);
19288 DECL_EXTERNAL (decl) = 1;
19289 gen_decl_die (decl, NULL, context_die);
19290 DECL_EXTERNAL (decl) = saved_external_flag;
19293 case NAMESPACE_DECL:
19294 if (dwarf_version >= 3 || !dwarf_strict)
19295 dwarf2out_decl (decl);
19297 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
19298 decl_die = comp_unit_die;
19302 gcc_unreachable ();
19305 /* We should be able to find the DIE now. */
19307 decl_die = lookup_decl_die (decl);
19308 gcc_assert (decl_die);
19314 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
19315 always returned. */
19318 force_type_die (tree type)
19320 dw_die_ref type_die;
19322 type_die = lookup_type_die (type);
19325 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
19327 type_die = modified_type_die (type, TYPE_READONLY (type),
19328 TYPE_VOLATILE (type), context_die);
19329 gcc_assert (type_die);
19334 /* Force out any required namespaces to be able to output DECL,
19335 and return the new context_die for it, if it's changed. */
19338 setup_namespace_context (tree thing, dw_die_ref context_die)
19340 tree context = (DECL_P (thing)
19341 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
19342 if (context && TREE_CODE (context) == NAMESPACE_DECL)
19343 /* Force out the namespace. */
19344 context_die = force_decl_die (context);
19346 return context_die;
19349 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
19350 type) within its namespace, if appropriate.
19352 For compatibility with older debuggers, namespace DIEs only contain
19353 declarations; all definitions are emitted at CU scope. */
19356 declare_in_namespace (tree thing, dw_die_ref context_die)
19358 dw_die_ref ns_context;
19360 if (debug_info_level <= DINFO_LEVEL_TERSE)
19361 return context_die;
19363 /* If this decl is from an inlined function, then don't try to emit it in its
19364 namespace, as we will get confused. It would have already been emitted
19365 when the abstract instance of the inline function was emitted anyways. */
19366 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
19367 return context_die;
19369 ns_context = setup_namespace_context (thing, context_die);
19371 if (ns_context != context_die)
19375 if (DECL_P (thing))
19376 gen_decl_die (thing, NULL, ns_context);
19378 gen_type_die (thing, ns_context);
19380 return context_die;
19383 /* Generate a DIE for a namespace or namespace alias. */
19386 gen_namespace_die (tree decl, dw_die_ref context_die)
19388 dw_die_ref namespace_die;
19390 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
19391 they are an alias of. */
19392 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
19394 /* Output a real namespace or module. */
19395 context_die = setup_namespace_context (decl, comp_unit_die);
19396 namespace_die = new_die (is_fortran ()
19397 ? DW_TAG_module : DW_TAG_namespace,
19398 context_die, decl);
19399 /* For Fortran modules defined in different CU don't add src coords. */
19400 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
19402 const char *name = dwarf2_name (decl, 0);
19404 add_name_attribute (namespace_die, name);
19407 add_name_and_src_coords_attributes (namespace_die, decl);
19408 if (DECL_EXTERNAL (decl))
19409 add_AT_flag (namespace_die, DW_AT_declaration, 1);
19410 equate_decl_number_to_die (decl, namespace_die);
19414 /* Output a namespace alias. */
19416 /* Force out the namespace we are an alias of, if necessary. */
19417 dw_die_ref origin_die
19418 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
19420 if (DECL_CONTEXT (decl) == NULL_TREE
19421 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
19422 context_die = setup_namespace_context (decl, comp_unit_die);
19423 /* Now create the namespace alias DIE. */
19424 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
19425 add_name_and_src_coords_attributes (namespace_die, decl);
19426 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
19427 equate_decl_number_to_die (decl, namespace_die);
19431 /* Generate Dwarf debug information for a decl described by DECL. */
19434 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
19436 tree decl_or_origin = decl ? decl : origin;
19437 tree class_origin = NULL, ultimate_origin;
19439 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
19442 switch (TREE_CODE (decl_or_origin))
19448 if (!is_fortran ())
19450 /* The individual enumerators of an enum type get output when we output
19451 the Dwarf representation of the relevant enum type itself. */
19455 /* Emit its type. */
19456 gen_type_die (TREE_TYPE (decl), context_die);
19458 /* And its containing namespace. */
19459 context_die = declare_in_namespace (decl, context_die);
19461 gen_const_die (decl, context_die);
19464 case FUNCTION_DECL:
19465 /* Don't output any DIEs to represent mere function declarations,
19466 unless they are class members or explicit block externs. */
19467 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
19468 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
19469 && (current_function_decl == NULL_TREE
19470 || DECL_ARTIFICIAL (decl_or_origin)))
19475 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
19476 on local redeclarations of global functions. That seems broken. */
19477 if (current_function_decl != decl)
19478 /* This is only a declaration. */;
19481 /* If we're emitting a clone, emit info for the abstract instance. */
19482 if (origin || DECL_ORIGIN (decl) != decl)
19483 dwarf2out_abstract_function (origin
19484 ? DECL_ORIGIN (origin)
19485 : DECL_ABSTRACT_ORIGIN (decl));
19487 /* If we're emitting an out-of-line copy of an inline function,
19488 emit info for the abstract instance and set up to refer to it. */
19489 else if (cgraph_function_possibly_inlined_p (decl)
19490 && ! DECL_ABSTRACT (decl)
19491 && ! class_or_namespace_scope_p (context_die)
19492 /* dwarf2out_abstract_function won't emit a die if this is just
19493 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
19494 that case, because that works only if we have a die. */
19495 && DECL_INITIAL (decl) != NULL_TREE)
19497 dwarf2out_abstract_function (decl);
19498 set_decl_origin_self (decl);
19501 /* Otherwise we're emitting the primary DIE for this decl. */
19502 else if (debug_info_level > DINFO_LEVEL_TERSE)
19504 /* Before we describe the FUNCTION_DECL itself, make sure that we
19505 have described its return type. */
19506 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
19508 /* And its virtual context. */
19509 if (DECL_VINDEX (decl) != NULL_TREE)
19510 gen_type_die (DECL_CONTEXT (decl), context_die);
19512 /* And its containing type. */
19514 origin = decl_class_context (decl);
19515 if (origin != NULL_TREE)
19516 gen_type_die_for_member (origin, decl, context_die);
19518 /* And its containing namespace. */
19519 context_die = declare_in_namespace (decl, context_die);
19522 /* Now output a DIE to represent the function itself. */
19524 gen_subprogram_die (decl, context_die);
19528 /* If we are in terse mode, don't generate any DIEs to represent any
19529 actual typedefs. */
19530 if (debug_info_level <= DINFO_LEVEL_TERSE)
19533 /* In the special case of a TYPE_DECL node representing the declaration
19534 of some type tag, if the given TYPE_DECL is marked as having been
19535 instantiated from some other (original) TYPE_DECL node (e.g. one which
19536 was generated within the original definition of an inline function) we
19537 used to generate a special (abbreviated) DW_TAG_structure_type,
19538 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
19539 should be actually referencing those DIEs, as variable DIEs with that
19540 type would be emitted already in the abstract origin, so it was always
19541 removed during unused type prunning. Don't add anything in this
19543 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
19546 if (is_redundant_typedef (decl))
19547 gen_type_die (TREE_TYPE (decl), context_die);
19549 /* Output a DIE to represent the typedef itself. */
19550 gen_typedef_die (decl, context_die);
19554 if (debug_info_level >= DINFO_LEVEL_NORMAL)
19555 gen_label_die (decl, context_die);
19560 /* If we are in terse mode, don't generate any DIEs to represent any
19561 variable declarations or definitions. */
19562 if (debug_info_level <= DINFO_LEVEL_TERSE)
19565 /* Output any DIEs that are needed to specify the type of this data
19567 if (decl_by_reference_p (decl_or_origin))
19568 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
19570 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
19572 /* And its containing type. */
19573 class_origin = decl_class_context (decl_or_origin);
19574 if (class_origin != NULL_TREE)
19575 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
19577 /* And its containing namespace. */
19578 context_die = declare_in_namespace (decl_or_origin, context_die);
19580 /* Now output the DIE to represent the data object itself. This gets
19581 complicated because of the possibility that the VAR_DECL really
19582 represents an inlined instance of a formal parameter for an inline
19584 ultimate_origin = decl_ultimate_origin (decl_or_origin);
19585 if (ultimate_origin != NULL_TREE
19586 && TREE_CODE (ultimate_origin) == PARM_DECL)
19587 gen_formal_parameter_die (decl, origin,
19588 true /* Emit name attribute. */,
19591 gen_variable_die (decl, origin, context_die);
19595 /* Ignore the nameless fields that are used to skip bits but handle C++
19596 anonymous unions and structs. */
19597 if (DECL_NAME (decl) != NULL_TREE
19598 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
19599 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
19601 gen_type_die (member_declared_type (decl), context_die);
19602 gen_field_die (decl, context_die);
19607 if (DECL_BY_REFERENCE (decl_or_origin))
19608 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
19610 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
19611 gen_formal_parameter_die (decl, origin,
19612 true /* Emit name attribute. */,
19616 case NAMESPACE_DECL:
19617 case IMPORTED_DECL:
19618 if (dwarf_version >= 3 || !dwarf_strict)
19619 gen_namespace_die (decl, context_die);
19623 /* Probably some frontend-internal decl. Assume we don't care. */
19624 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
19629 /* Output debug information for global decl DECL. Called from toplev.c after
19630 compilation proper has finished. */
19633 dwarf2out_global_decl (tree decl)
19635 /* Output DWARF2 information for file-scope tentative data object
19636 declarations, file-scope (extern) function declarations (which
19637 had no corresponding body) and file-scope tagged type declarations
19638 and definitions which have not yet been forced out. */
19639 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
19640 dwarf2out_decl (decl);
19643 /* Output debug information for type decl DECL. Called from toplev.c
19644 and from language front ends (to record built-in types). */
19646 dwarf2out_type_decl (tree decl, int local)
19649 dwarf2out_decl (decl);
19652 /* Output debug information for imported module or decl DECL.
19653 NAME is non-NULL name in the lexical block if the decl has been renamed.
19654 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
19655 that DECL belongs to.
19656 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
19658 dwarf2out_imported_module_or_decl_1 (tree decl,
19660 tree lexical_block,
19661 dw_die_ref lexical_block_die)
19663 expanded_location xloc;
19664 dw_die_ref imported_die = NULL;
19665 dw_die_ref at_import_die;
19667 if (TREE_CODE (decl) == IMPORTED_DECL)
19669 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
19670 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
19674 xloc = expand_location (input_location);
19676 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
19678 if (is_base_type (TREE_TYPE (decl)))
19679 at_import_die = base_type_die (TREE_TYPE (decl));
19681 at_import_die = force_type_die (TREE_TYPE (decl));
19682 /* For namespace N { typedef void T; } using N::T; base_type_die
19683 returns NULL, but DW_TAG_imported_declaration requires
19684 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
19685 if (!at_import_die)
19687 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
19688 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
19689 at_import_die = lookup_type_die (TREE_TYPE (decl));
19690 gcc_assert (at_import_die);
19695 at_import_die = lookup_decl_die (decl);
19696 if (!at_import_die)
19698 /* If we're trying to avoid duplicate debug info, we may not have
19699 emitted the member decl for this field. Emit it now. */
19700 if (TREE_CODE (decl) == FIELD_DECL)
19702 tree type = DECL_CONTEXT (decl);
19704 if (TYPE_CONTEXT (type)
19705 && TYPE_P (TYPE_CONTEXT (type))
19706 && !should_emit_struct_debug (TYPE_CONTEXT (type),
19707 DINFO_USAGE_DIR_USE))
19709 gen_type_die_for_member (type, decl,
19710 get_context_die (TYPE_CONTEXT (type)));
19712 at_import_die = force_decl_die (decl);
19716 if (TREE_CODE (decl) == NAMESPACE_DECL)
19718 if (dwarf_version >= 3 || !dwarf_strict)
19719 imported_die = new_die (DW_TAG_imported_module,
19726 imported_die = new_die (DW_TAG_imported_declaration,
19730 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
19731 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
19733 add_AT_string (imported_die, DW_AT_name,
19734 IDENTIFIER_POINTER (name));
19735 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
19738 /* Output debug information for imported module or decl DECL.
19739 NAME is non-NULL name in context if the decl has been renamed.
19740 CHILD is true if decl is one of the renamed decls as part of
19741 importing whole module. */
19744 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
19747 /* dw_die_ref at_import_die; */
19748 dw_die_ref scope_die;
19750 if (debug_info_level <= DINFO_LEVEL_TERSE)
19755 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
19756 We need decl DIE for reference and scope die. First, get DIE for the decl
19759 /* Get the scope die for decl context. Use comp_unit_die for global module
19760 or decl. If die is not found for non globals, force new die. */
19762 && TYPE_P (context)
19763 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
19766 if (!(dwarf_version >= 3 || !dwarf_strict))
19769 scope_die = get_context_die (context);
19773 gcc_assert (scope_die->die_child);
19774 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
19775 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
19776 scope_die = scope_die->die_child;
19779 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
19780 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
19784 /* Write the debugging output for DECL. */
19787 dwarf2out_decl (tree decl)
19789 dw_die_ref context_die = comp_unit_die;
19791 switch (TREE_CODE (decl))
19796 case FUNCTION_DECL:
19797 /* What we would really like to do here is to filter out all mere
19798 file-scope declarations of file-scope functions which are never
19799 referenced later within this translation unit (and keep all of ones
19800 that *are* referenced later on) but we aren't clairvoyant, so we have
19801 no idea which functions will be referenced in the future (i.e. later
19802 on within the current translation unit). So here we just ignore all
19803 file-scope function declarations which are not also definitions. If
19804 and when the debugger needs to know something about these functions,
19805 it will have to hunt around and find the DWARF information associated
19806 with the definition of the function.
19808 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
19809 nodes represent definitions and which ones represent mere
19810 declarations. We have to check DECL_INITIAL instead. That's because
19811 the C front-end supports some weird semantics for "extern inline"
19812 function definitions. These can get inlined within the current
19813 translation unit (and thus, we need to generate Dwarf info for their
19814 abstract instances so that the Dwarf info for the concrete inlined
19815 instances can have something to refer to) but the compiler never
19816 generates any out-of-lines instances of such things (despite the fact
19817 that they *are* definitions).
19819 The important point is that the C front-end marks these "extern
19820 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
19821 them anyway. Note that the C++ front-end also plays some similar games
19822 for inline function definitions appearing within include files which
19823 also contain `#pragma interface' pragmas. */
19824 if (DECL_INITIAL (decl) == NULL_TREE)
19827 /* If we're a nested function, initially use a parent of NULL; if we're
19828 a plain function, this will be fixed up in decls_for_scope. If
19829 we're a method, it will be ignored, since we already have a DIE. */
19830 if (decl_function_context (decl)
19831 /* But if we're in terse mode, we don't care about scope. */
19832 && debug_info_level > DINFO_LEVEL_TERSE)
19833 context_die = NULL;
19837 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
19838 declaration and if the declaration was never even referenced from
19839 within this entire compilation unit. We suppress these DIEs in
19840 order to save space in the .debug section (by eliminating entries
19841 which are probably useless). Note that we must not suppress
19842 block-local extern declarations (whether used or not) because that
19843 would screw-up the debugger's name lookup mechanism and cause it to
19844 miss things which really ought to be in scope at a given point. */
19845 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
19848 /* For local statics lookup proper context die. */
19849 if (TREE_STATIC (decl) && decl_function_context (decl))
19850 context_die = lookup_decl_die (DECL_CONTEXT (decl));
19852 /* If we are in terse mode, don't generate any DIEs to represent any
19853 variable declarations or definitions. */
19854 if (debug_info_level <= DINFO_LEVEL_TERSE)
19859 if (debug_info_level <= DINFO_LEVEL_TERSE)
19861 if (!is_fortran ())
19863 if (TREE_STATIC (decl) && decl_function_context (decl))
19864 context_die = lookup_decl_die (DECL_CONTEXT (decl));
19867 case NAMESPACE_DECL:
19868 case IMPORTED_DECL:
19869 if (debug_info_level <= DINFO_LEVEL_TERSE)
19871 if (lookup_decl_die (decl) != NULL)
19876 /* Don't emit stubs for types unless they are needed by other DIEs. */
19877 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
19880 /* Don't bother trying to generate any DIEs to represent any of the
19881 normal built-in types for the language we are compiling. */
19882 if (DECL_IS_BUILTIN (decl))
19884 /* OK, we need to generate one for `bool' so GDB knows what type
19885 comparisons have. */
19887 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
19888 && ! DECL_IGNORED_P (decl))
19889 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
19894 /* If we are in terse mode, don't generate any DIEs for types. */
19895 if (debug_info_level <= DINFO_LEVEL_TERSE)
19898 /* If we're a function-scope tag, initially use a parent of NULL;
19899 this will be fixed up in decls_for_scope. */
19900 if (decl_function_context (decl))
19901 context_die = NULL;
19909 gen_decl_die (decl, NULL, context_die);
19912 /* Output a marker (i.e. a label) for the beginning of the generated code for
19913 a lexical block. */
19916 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
19917 unsigned int blocknum)
19919 switch_to_section (current_function_section ());
19920 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
19923 /* Output a marker (i.e. a label) for the end of the generated code for a
19927 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
19929 switch_to_section (current_function_section ());
19930 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
19933 /* Returns nonzero if it is appropriate not to emit any debugging
19934 information for BLOCK, because it doesn't contain any instructions.
19936 Don't allow this for blocks with nested functions or local classes
19937 as we would end up with orphans, and in the presence of scheduling
19938 we may end up calling them anyway. */
19941 dwarf2out_ignore_block (const_tree block)
19946 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
19947 if (TREE_CODE (decl) == FUNCTION_DECL
19948 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
19950 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
19952 decl = BLOCK_NONLOCALIZED_VAR (block, i);
19953 if (TREE_CODE (decl) == FUNCTION_DECL
19954 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
19961 /* Hash table routines for file_hash. */
19964 file_table_eq (const void *p1_p, const void *p2_p)
19966 const struct dwarf_file_data *const p1 =
19967 (const struct dwarf_file_data *) p1_p;
19968 const char *const p2 = (const char *) p2_p;
19969 return strcmp (p1->filename, p2) == 0;
19973 file_table_hash (const void *p_p)
19975 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
19976 return htab_hash_string (p->filename);
19979 /* Lookup FILE_NAME (in the list of filenames that we know about here in
19980 dwarf2out.c) and return its "index". The index of each (known) filename is
19981 just a unique number which is associated with only that one filename. We
19982 need such numbers for the sake of generating labels (in the .debug_sfnames
19983 section) and references to those files numbers (in the .debug_srcinfo
19984 and.debug_macinfo sections). If the filename given as an argument is not
19985 found in our current list, add it to the list and assign it the next
19986 available unique index number. In order to speed up searches, we remember
19987 the index of the filename was looked up last. This handles the majority of
19990 static struct dwarf_file_data *
19991 lookup_filename (const char *file_name)
19994 struct dwarf_file_data * created;
19996 /* Check to see if the file name that was searched on the previous
19997 call matches this file name. If so, return the index. */
19998 if (file_table_last_lookup
19999 && (file_name == file_table_last_lookup->filename
20000 || strcmp (file_table_last_lookup->filename, file_name) == 0))
20001 return file_table_last_lookup;
20003 /* Didn't match the previous lookup, search the table. */
20004 slot = htab_find_slot_with_hash (file_table, file_name,
20005 htab_hash_string (file_name), INSERT);
20007 return (struct dwarf_file_data *) *slot;
20009 created = GGC_NEW (struct dwarf_file_data);
20010 created->filename = file_name;
20011 created->emitted_number = 0;
20016 /* If the assembler will construct the file table, then translate the compiler
20017 internal file table number into the assembler file table number, and emit
20018 a .file directive if we haven't already emitted one yet. The file table
20019 numbers are different because we prune debug info for unused variables and
20020 types, which may include filenames. */
20023 maybe_emit_file (struct dwarf_file_data * fd)
20025 if (! fd->emitted_number)
20027 if (last_emitted_file)
20028 fd->emitted_number = last_emitted_file->emitted_number + 1;
20030 fd->emitted_number = 1;
20031 last_emitted_file = fd;
20033 if (DWARF2_ASM_LINE_DEBUG_INFO)
20035 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
20036 output_quoted_string (asm_out_file,
20037 remap_debug_filename (fd->filename));
20038 fputc ('\n', asm_out_file);
20042 return fd->emitted_number;
20045 /* Schedule generation of a DW_AT_const_value attribute to DIE.
20046 That generation should happen after function debug info has been
20047 generated. The value of the attribute is the constant value of ARG. */
20050 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
20052 die_arg_entry entry;
20057 if (!tmpl_value_parm_die_table)
20058 tmpl_value_parm_die_table
20059 = VEC_alloc (die_arg_entry, gc, 32);
20063 VEC_safe_push (die_arg_entry, gc,
20064 tmpl_value_parm_die_table,
20068 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
20069 by append_entry_to_tmpl_value_parm_die_table. This function must
20070 be called after function DIEs have been generated. */
20073 gen_remaining_tmpl_value_param_die_attribute (void)
20075 if (tmpl_value_parm_die_table)
20081 VEC_iterate (die_arg_entry, tmpl_value_parm_die_table, i, e);
20083 tree_add_const_value_attribute (e->die, e->arg);
20088 /* Replace DW_AT_name for the decl with name. */
20091 dwarf2out_set_name (tree decl, tree name)
20097 die = TYPE_SYMTAB_DIE (decl);
20101 dname = dwarf2_name (name, 0);
20105 attr = get_AT (die, DW_AT_name);
20108 struct indirect_string_node *node;
20110 node = find_AT_string (dname);
20111 /* replace the string. */
20112 attr->dw_attr_val.v.val_str = node;
20116 add_name_attribute (die, dname);
20119 /* Called by the final INSN scan whenever we see a direct function call.
20120 Make an entry into the direct call table, recording the point of call
20121 and a reference to the target function's debug entry. */
20124 dwarf2out_direct_call (tree targ)
20127 tree origin = decl_ultimate_origin (targ);
20129 /* If this is a clone, use the abstract origin as the target. */
20133 e.poc_label_num = poc_label_num++;
20134 e.poc_decl = current_function_decl;
20135 e.targ_die = force_decl_die (targ);
20136 VEC_safe_push (dcall_entry, gc, dcall_table, &e);
20138 /* Drop a label at the return point to mark the point of call. */
20139 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LPOC", e.poc_label_num);
20142 /* Returns a hash value for X (which really is a struct vcall_insn). */
20145 vcall_insn_table_hash (const void *x)
20147 return (hashval_t) ((const struct vcall_insn *) x)->insn_uid;
20150 /* Return nonzero if insn_uid of struct vcall_insn *X is the same as
20151 insnd_uid of *Y. */
20154 vcall_insn_table_eq (const void *x, const void *y)
20156 return (((const struct vcall_insn *) x)->insn_uid
20157 == ((const struct vcall_insn *) y)->insn_uid);
20160 /* Associate VTABLE_SLOT with INSN_UID in the VCALL_INSN_TABLE. */
20163 store_vcall_insn (unsigned int vtable_slot, int insn_uid)
20165 struct vcall_insn *item = GGC_NEW (struct vcall_insn);
20166 struct vcall_insn **slot;
20169 item->insn_uid = insn_uid;
20170 item->vtable_slot = vtable_slot;
20171 slot = (struct vcall_insn **)
20172 htab_find_slot_with_hash (vcall_insn_table, &item,
20173 (hashval_t) insn_uid, INSERT);
20177 /* Return the VTABLE_SLOT associated with INSN_UID. */
20179 static unsigned int
20180 lookup_vcall_insn (unsigned int insn_uid)
20182 struct vcall_insn item;
20183 struct vcall_insn *p;
20185 item.insn_uid = insn_uid;
20186 item.vtable_slot = 0;
20187 p = (struct vcall_insn *) htab_find_with_hash (vcall_insn_table,
20189 (hashval_t) insn_uid);
20191 return (unsigned int) -1;
20192 return p->vtable_slot;
20196 /* Called when lowering indirect calls to RTL. We make a note of INSN_UID
20197 and the OBJ_TYPE_REF_TOKEN from ADDR. For C++ virtual calls, the token
20198 is the vtable slot index that we will need to put in the virtual call
20202 dwarf2out_virtual_call_token (tree addr, int insn_uid)
20204 if (is_cxx() && TREE_CODE (addr) == OBJ_TYPE_REF)
20206 tree token = OBJ_TYPE_REF_TOKEN (addr);
20207 if (TREE_CODE (token) == INTEGER_CST)
20208 store_vcall_insn (TREE_INT_CST_LOW (token), insn_uid);
20212 /* Called when scheduling RTL, when a CALL_INSN is split. Copies the
20213 OBJ_TYPE_REF_TOKEN previously associated with OLD_INSN and associates it
20217 dwarf2out_copy_call_info (rtx old_insn, rtx new_insn)
20219 unsigned int vtable_slot = lookup_vcall_insn (INSN_UID (old_insn));
20221 if (vtable_slot != (unsigned int) -1)
20222 store_vcall_insn (vtable_slot, INSN_UID (new_insn));
20225 /* Called by the final INSN scan whenever we see a virtual function call.
20226 Make an entry into the virtual call table, recording the point of call
20227 and the slot index of the vtable entry used to call the virtual member
20228 function. The slot index was associated with the INSN_UID during the
20229 lowering to RTL. */
20232 dwarf2out_virtual_call (int insn_uid)
20234 unsigned int vtable_slot = lookup_vcall_insn (insn_uid);
20237 if (vtable_slot == (unsigned int) -1)
20240 e.poc_label_num = poc_label_num++;
20241 e.vtable_slot = vtable_slot;
20242 VEC_safe_push (vcall_entry, gc, vcall_table, &e);
20244 /* Drop a label at the return point to mark the point of call. */
20245 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LPOC", e.poc_label_num);
20248 /* Called by the final INSN scan whenever we see a var location. We
20249 use it to drop labels in the right places, and throw the location in
20250 our lookup table. */
20253 dwarf2out_var_location (rtx loc_note)
20255 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
20256 struct var_loc_node *newloc;
20258 static const char *last_label;
20259 static const char *last_postcall_label;
20260 static bool last_in_cold_section_p;
20263 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
20266 next_real = next_real_insn (loc_note);
20267 /* If there are no instructions which would be affected by this note,
20268 don't do anything. */
20269 if (next_real == NULL_RTX)
20272 decl = NOTE_VAR_LOCATION_DECL (loc_note);
20273 newloc = add_var_loc_to_decl (decl, loc_note);
20274 if (newloc == NULL)
20277 /* If there were no real insns between note we processed last time
20278 and this note, use the label we emitted last time. */
20279 if (last_var_location_insn == NULL_RTX
20280 || last_var_location_insn != next_real
20281 || last_in_cold_section_p != in_cold_section_p)
20283 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
20284 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
20286 last_label = ggc_strdup (loclabel);
20287 last_postcall_label = NULL;
20289 newloc->var_loc_note = loc_note;
20290 newloc->next = NULL;
20292 if (!NOTE_DURING_CALL_P (loc_note))
20293 newloc->label = last_label;
20296 if (!last_postcall_label)
20298 sprintf (loclabel, "%s-1", last_label);
20299 last_postcall_label = ggc_strdup (loclabel);
20301 newloc->label = last_postcall_label;
20304 if (cfun && in_cold_section_p)
20305 newloc->section_label = crtl->subsections.cold_section_label;
20307 newloc->section_label = text_section_label;
20309 last_var_location_insn = next_real;
20310 last_in_cold_section_p = in_cold_section_p;
20313 /* We need to reset the locations at the beginning of each
20314 function. We can't do this in the end_function hook, because the
20315 declarations that use the locations won't have been output when
20316 that hook is called. Also compute have_multiple_function_sections here. */
20319 dwarf2out_begin_function (tree fun)
20321 htab_empty (decl_loc_table);
20323 if (function_section (fun) != text_section)
20324 have_multiple_function_sections = true;
20326 dwarf2out_note_section_used ();
20329 /* Output a label to mark the beginning of a source code line entry
20330 and record information relating to this source line, in
20331 'line_info_table' for later output of the .debug_line section. */
20334 dwarf2out_source_line (unsigned int line, const char *filename,
20335 int discriminator, bool is_stmt)
20337 static bool last_is_stmt = true;
20339 if (debug_info_level >= DINFO_LEVEL_NORMAL
20342 int file_num = maybe_emit_file (lookup_filename (filename));
20344 switch_to_section (current_function_section ());
20346 /* If requested, emit something human-readable. */
20347 if (flag_debug_asm)
20348 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
20351 if (DWARF2_ASM_LINE_DEBUG_INFO)
20353 /* Emit the .loc directive understood by GNU as. */
20354 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
20355 if (is_stmt != last_is_stmt)
20357 fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
20358 last_is_stmt = is_stmt;
20360 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
20361 fprintf (asm_out_file, " discriminator %d", discriminator);
20362 fputc ('\n', asm_out_file);
20364 /* Indicate that line number info exists. */
20365 line_info_table_in_use++;
20367 else if (function_section (current_function_decl) != text_section)
20369 dw_separate_line_info_ref line_info;
20370 targetm.asm_out.internal_label (asm_out_file,
20371 SEPARATE_LINE_CODE_LABEL,
20372 separate_line_info_table_in_use);
20374 /* Expand the line info table if necessary. */
20375 if (separate_line_info_table_in_use
20376 == separate_line_info_table_allocated)
20378 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
20379 separate_line_info_table
20380 = GGC_RESIZEVEC (dw_separate_line_info_entry,
20381 separate_line_info_table,
20382 separate_line_info_table_allocated);
20383 memset (separate_line_info_table
20384 + separate_line_info_table_in_use,
20386 (LINE_INFO_TABLE_INCREMENT
20387 * sizeof (dw_separate_line_info_entry)));
20390 /* Add the new entry at the end of the line_info_table. */
20392 = &separate_line_info_table[separate_line_info_table_in_use++];
20393 line_info->dw_file_num = file_num;
20394 line_info->dw_line_num = line;
20395 line_info->function = current_function_funcdef_no;
20399 dw_line_info_ref line_info;
20401 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
20402 line_info_table_in_use);
20404 /* Expand the line info table if necessary. */
20405 if (line_info_table_in_use == line_info_table_allocated)
20407 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
20409 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
20410 line_info_table_allocated);
20411 memset (line_info_table + line_info_table_in_use, 0,
20412 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
20415 /* Add the new entry at the end of the line_info_table. */
20416 line_info = &line_info_table[line_info_table_in_use++];
20417 line_info->dw_file_num = file_num;
20418 line_info->dw_line_num = line;
20423 /* Record the beginning of a new source file. */
20426 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
20428 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
20430 /* Record the beginning of the file for break_out_includes. */
20431 dw_die_ref bincl_die;
20433 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
20434 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
20437 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20439 int file_num = maybe_emit_file (lookup_filename (filename));
20441 switch_to_section (debug_macinfo_section);
20442 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
20443 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
20446 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
20450 /* Record the end of a source file. */
20453 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
20455 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
20456 /* Record the end of the file for break_out_includes. */
20457 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
20459 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20461 switch_to_section (debug_macinfo_section);
20462 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
20466 /* Called from debug_define in toplev.c. The `buffer' parameter contains
20467 the tail part of the directive line, i.e. the part which is past the
20468 initial whitespace, #, whitespace, directive-name, whitespace part. */
20471 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
20472 const char *buffer ATTRIBUTE_UNUSED)
20474 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20476 switch_to_section (debug_macinfo_section);
20477 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
20478 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
20479 dw2_asm_output_nstring (buffer, -1, "The macro");
20483 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
20484 the tail part of the directive line, i.e. the part which is past the
20485 initial whitespace, #, whitespace, directive-name, whitespace part. */
20488 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
20489 const char *buffer ATTRIBUTE_UNUSED)
20491 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20493 switch_to_section (debug_macinfo_section);
20494 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
20495 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
20496 dw2_asm_output_nstring (buffer, -1, "The macro");
20500 /* Set up for Dwarf output at the start of compilation. */
20503 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
20505 /* Allocate the file_table. */
20506 file_table = htab_create_ggc (50, file_table_hash,
20507 file_table_eq, NULL);
20509 /* Allocate the decl_die_table. */
20510 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
20511 decl_die_table_eq, NULL);
20513 /* Allocate the decl_loc_table. */
20514 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
20515 decl_loc_table_eq, NULL);
20517 /* Allocate the initial hunk of the decl_scope_table. */
20518 decl_scope_table = VEC_alloc (tree, gc, 256);
20520 /* Allocate the initial hunk of the abbrev_die_table. */
20521 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
20522 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
20523 /* Zero-th entry is allocated, but unused. */
20524 abbrev_die_table_in_use = 1;
20526 /* Allocate the initial hunk of the line_info_table. */
20527 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
20528 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
20530 /* Zero-th entry is allocated, but unused. */
20531 line_info_table_in_use = 1;
20533 /* Allocate the pubtypes and pubnames vectors. */
20534 pubname_table = VEC_alloc (pubname_entry, gc, 32);
20535 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
20537 /* Allocate the table that maps insn UIDs to vtable slot indexes. */
20538 vcall_insn_table = htab_create_ggc (10, vcall_insn_table_hash,
20539 vcall_insn_table_eq, NULL);
20541 /* Generate the initial DIE for the .debug section. Note that the (string)
20542 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
20543 will (typically) be a relative pathname and that this pathname should be
20544 taken as being relative to the directory from which the compiler was
20545 invoked when the given (base) source file was compiled. We will fill
20546 in this value in dwarf2out_finish. */
20547 comp_unit_die = gen_compile_unit_die (NULL);
20549 incomplete_types = VEC_alloc (tree, gc, 64);
20551 used_rtx_array = VEC_alloc (rtx, gc, 32);
20553 debug_info_section = get_section (DEBUG_INFO_SECTION,
20554 SECTION_DEBUG, NULL);
20555 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
20556 SECTION_DEBUG, NULL);
20557 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
20558 SECTION_DEBUG, NULL);
20559 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
20560 SECTION_DEBUG, NULL);
20561 debug_line_section = get_section (DEBUG_LINE_SECTION,
20562 SECTION_DEBUG, NULL);
20563 debug_loc_section = get_section (DEBUG_LOC_SECTION,
20564 SECTION_DEBUG, NULL);
20565 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
20566 SECTION_DEBUG, NULL);
20567 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
20568 SECTION_DEBUG, NULL);
20569 debug_dcall_section = get_section (DEBUG_DCALL_SECTION,
20570 SECTION_DEBUG, NULL);
20571 debug_vcall_section = get_section (DEBUG_VCALL_SECTION,
20572 SECTION_DEBUG, NULL);
20573 debug_str_section = get_section (DEBUG_STR_SECTION,
20574 DEBUG_STR_SECTION_FLAGS, NULL);
20575 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
20576 SECTION_DEBUG, NULL);
20577 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
20578 SECTION_DEBUG, NULL);
20580 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
20581 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
20582 DEBUG_ABBREV_SECTION_LABEL, 0);
20583 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
20584 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
20585 COLD_TEXT_SECTION_LABEL, 0);
20586 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
20588 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
20589 DEBUG_INFO_SECTION_LABEL, 0);
20590 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
20591 DEBUG_LINE_SECTION_LABEL, 0);
20592 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
20593 DEBUG_RANGES_SECTION_LABEL, 0);
20594 switch_to_section (debug_abbrev_section);
20595 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
20596 switch_to_section (debug_info_section);
20597 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
20598 switch_to_section (debug_line_section);
20599 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
20601 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
20603 switch_to_section (debug_macinfo_section);
20604 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
20605 DEBUG_MACINFO_SECTION_LABEL, 0);
20606 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
20609 switch_to_section (text_section);
20610 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
20611 if (flag_reorder_blocks_and_partition)
20613 cold_text_section = unlikely_text_section ();
20614 switch_to_section (cold_text_section);
20615 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
20620 /* Called before cgraph_optimize starts outputtting functions, variables
20621 and toplevel asms into assembly. */
20624 dwarf2out_assembly_start (void)
20626 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE && dwarf2out_do_cfi_asm ())
20628 #ifndef TARGET_UNWIND_INFO
20629 if (USING_SJLJ_EXCEPTIONS || (!flag_unwind_tables && !flag_exceptions))
20631 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
20635 /* A helper function for dwarf2out_finish called through
20636 htab_traverse. Emit one queued .debug_str string. */
20639 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
20641 struct indirect_string_node *node = (struct indirect_string_node *) *h;
20643 if (node->label && node->refcount)
20645 switch_to_section (debug_str_section);
20646 ASM_OUTPUT_LABEL (asm_out_file, node->label);
20647 assemble_string (node->str, strlen (node->str) + 1);
20653 #if ENABLE_ASSERT_CHECKING
20654 /* Verify that all marks are clear. */
20657 verify_marks_clear (dw_die_ref die)
20661 gcc_assert (! die->die_mark);
20662 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
20664 #endif /* ENABLE_ASSERT_CHECKING */
20666 /* Clear the marks for a die and its children.
20667 Be cool if the mark isn't set. */
20670 prune_unmark_dies (dw_die_ref die)
20676 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
20679 /* Given DIE that we're marking as used, find any other dies
20680 it references as attributes and mark them as used. */
20683 prune_unused_types_walk_attribs (dw_die_ref die)
20688 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
20690 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
20692 /* A reference to another DIE.
20693 Make sure that it will get emitted.
20694 If it was broken out into a comdat group, don't follow it. */
20695 if (dwarf_version < 4
20696 || a->dw_attr == DW_AT_specification
20697 || a->dw_attr_val.v.val_die_ref.die->die_id.die_type_node == NULL)
20698 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
20700 /* Set the string's refcount to 0 so that prune_unused_types_mark
20701 accounts properly for it. */
20702 if (AT_class (a) == dw_val_class_str)
20703 a->dw_attr_val.v.val_str->refcount = 0;
20708 /* Mark DIE as being used. If DOKIDS is true, then walk down
20709 to DIE's children. */
20712 prune_unused_types_mark (dw_die_ref die, int dokids)
20716 if (die->die_mark == 0)
20718 /* We haven't done this node yet. Mark it as used. */
20721 /* We also have to mark its parents as used.
20722 (But we don't want to mark our parents' kids due to this.) */
20723 if (die->die_parent)
20724 prune_unused_types_mark (die->die_parent, 0);
20726 /* Mark any referenced nodes. */
20727 prune_unused_types_walk_attribs (die);
20729 /* If this node is a specification,
20730 also mark the definition, if it exists. */
20731 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
20732 prune_unused_types_mark (die->die_definition, 1);
20735 if (dokids && die->die_mark != 2)
20737 /* We need to walk the children, but haven't done so yet.
20738 Remember that we've walked the kids. */
20741 /* If this is an array type, we need to make sure our
20742 kids get marked, even if they're types. If we're
20743 breaking out types into comdat sections, do this
20744 for all type definitions. */
20745 if (die->die_tag == DW_TAG_array_type
20746 || (dwarf_version >= 4
20747 && is_type_die (die) && ! is_declaration_die (die)))
20748 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
20750 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
20754 /* For local classes, look if any static member functions were emitted
20755 and if so, mark them. */
20758 prune_unused_types_walk_local_classes (dw_die_ref die)
20762 if (die->die_mark == 2)
20765 switch (die->die_tag)
20767 case DW_TAG_structure_type:
20768 case DW_TAG_union_type:
20769 case DW_TAG_class_type:
20772 case DW_TAG_subprogram:
20773 if (!get_AT_flag (die, DW_AT_declaration)
20774 || die->die_definition != NULL)
20775 prune_unused_types_mark (die, 1);
20782 /* Mark children. */
20783 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
20786 /* Walk the tree DIE and mark types that we actually use. */
20789 prune_unused_types_walk (dw_die_ref die)
20793 /* Don't do anything if this node is already marked and
20794 children have been marked as well. */
20795 if (die->die_mark == 2)
20798 switch (die->die_tag)
20800 case DW_TAG_structure_type:
20801 case DW_TAG_union_type:
20802 case DW_TAG_class_type:
20803 if (die->die_perennial_p)
20806 for (c = die->die_parent; c; c = c->die_parent)
20807 if (c->die_tag == DW_TAG_subprogram)
20810 /* Finding used static member functions inside of classes
20811 is needed just for local classes, because for other classes
20812 static member function DIEs with DW_AT_specification
20813 are emitted outside of the DW_TAG_*_type. If we ever change
20814 it, we'd need to call this even for non-local classes. */
20816 prune_unused_types_walk_local_classes (die);
20818 /* It's a type node --- don't mark it. */
20821 case DW_TAG_const_type:
20822 case DW_TAG_packed_type:
20823 case DW_TAG_pointer_type:
20824 case DW_TAG_reference_type:
20825 case DW_TAG_volatile_type:
20826 case DW_TAG_typedef:
20827 case DW_TAG_array_type:
20828 case DW_TAG_interface_type:
20829 case DW_TAG_friend:
20830 case DW_TAG_variant_part:
20831 case DW_TAG_enumeration_type:
20832 case DW_TAG_subroutine_type:
20833 case DW_TAG_string_type:
20834 case DW_TAG_set_type:
20835 case DW_TAG_subrange_type:
20836 case DW_TAG_ptr_to_member_type:
20837 case DW_TAG_file_type:
20838 if (die->die_perennial_p)
20841 /* It's a type node --- don't mark it. */
20845 /* Mark everything else. */
20849 if (die->die_mark == 0)
20853 /* Now, mark any dies referenced from here. */
20854 prune_unused_types_walk_attribs (die);
20859 /* Mark children. */
20860 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
20863 /* Increment the string counts on strings referred to from DIE's
20867 prune_unused_types_update_strings (dw_die_ref die)
20872 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
20873 if (AT_class (a) == dw_val_class_str)
20875 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
20877 /* Avoid unnecessarily putting strings that are used less than
20878 twice in the hash table. */
20880 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
20883 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
20884 htab_hash_string (s->str),
20886 gcc_assert (*slot == NULL);
20892 /* Remove from the tree DIE any dies that aren't marked. */
20895 prune_unused_types_prune (dw_die_ref die)
20899 gcc_assert (die->die_mark);
20900 prune_unused_types_update_strings (die);
20902 if (! die->die_child)
20905 c = die->die_child;
20907 dw_die_ref prev = c;
20908 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
20909 if (c == die->die_child)
20911 /* No marked children between 'prev' and the end of the list. */
20913 /* No marked children at all. */
20914 die->die_child = NULL;
20917 prev->die_sib = c->die_sib;
20918 die->die_child = prev;
20923 if (c != prev->die_sib)
20925 prune_unused_types_prune (c);
20926 } while (c != die->die_child);
20929 /* A helper function for dwarf2out_finish called through
20930 htab_traverse. Clear .debug_str strings that we haven't already
20931 decided to emit. */
20934 prune_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
20936 struct indirect_string_node *node = (struct indirect_string_node *) *h;
20938 if (!node->label || !node->refcount)
20939 htab_clear_slot (debug_str_hash, h);
20944 /* Remove dies representing declarations that we never use. */
20947 prune_unused_types (void)
20950 limbo_die_node *node;
20951 comdat_type_node *ctnode;
20953 dcall_entry *dcall;
20955 #if ENABLE_ASSERT_CHECKING
20956 /* All the marks should already be clear. */
20957 verify_marks_clear (comp_unit_die);
20958 for (node = limbo_die_list; node; node = node->next)
20959 verify_marks_clear (node->die);
20960 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
20961 verify_marks_clear (ctnode->root_die);
20962 #endif /* ENABLE_ASSERT_CHECKING */
20964 /* Mark types that are used in global variables. */
20965 premark_types_used_by_global_vars ();
20967 /* Set the mark on nodes that are actually used. */
20968 prune_unused_types_walk (comp_unit_die);
20969 for (node = limbo_die_list; node; node = node->next)
20970 prune_unused_types_walk (node->die);
20971 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
20973 prune_unused_types_walk (ctnode->root_die);
20974 prune_unused_types_mark (ctnode->type_die, 1);
20977 /* Also set the mark on nodes referenced from the
20978 pubname_table or arange_table. */
20979 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
20980 prune_unused_types_mark (pub->die, 1);
20981 for (i = 0; i < arange_table_in_use; i++)
20982 prune_unused_types_mark (arange_table[i], 1);
20984 /* Mark nodes referenced from the direct call table. */
20985 for (i = 0; VEC_iterate (dcall_entry, dcall_table, i, dcall); i++)
20986 prune_unused_types_mark (dcall->targ_die, 1);
20988 /* Get rid of nodes that aren't marked; and update the string counts. */
20989 if (debug_str_hash && debug_str_hash_forced)
20990 htab_traverse (debug_str_hash, prune_indirect_string, NULL);
20991 else if (debug_str_hash)
20992 htab_empty (debug_str_hash);
20993 prune_unused_types_prune (comp_unit_die);
20994 for (node = limbo_die_list; node; node = node->next)
20995 prune_unused_types_prune (node->die);
20996 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
20997 prune_unused_types_prune (ctnode->root_die);
20999 /* Leave the marks clear. */
21000 prune_unmark_dies (comp_unit_die);
21001 for (node = limbo_die_list; node; node = node->next)
21002 prune_unmark_dies (node->die);
21003 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21004 prune_unmark_dies (ctnode->root_die);
21007 /* Set the parameter to true if there are any relative pathnames in
21010 file_table_relative_p (void ** slot, void *param)
21012 bool *p = (bool *) param;
21013 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
21014 if (!IS_ABSOLUTE_PATH (d->filename))
21022 /* Routines to manipulate hash table of comdat type units. */
21025 htab_ct_hash (const void *of)
21028 const comdat_type_node *const type_node = (const comdat_type_node *) of;
21030 memcpy (&h, type_node->signature, sizeof (h));
21035 htab_ct_eq (const void *of1, const void *of2)
21037 const comdat_type_node *const type_node_1 = (const comdat_type_node *) of1;
21038 const comdat_type_node *const type_node_2 = (const comdat_type_node *) of2;
21040 return (! memcmp (type_node_1->signature, type_node_2->signature,
21041 DWARF_TYPE_SIGNATURE_SIZE));
21044 /* Move a DW_AT_MIPS_linkage_name attribute just added to dw_die_ref
21045 to the location it would have been added, should we know its
21046 DECL_ASSEMBLER_NAME when we added other attributes. This will
21047 probably improve compactness of debug info, removing equivalent
21048 abbrevs, and hide any differences caused by deferring the
21049 computation of the assembler name, triggered by e.g. PCH. */
21052 move_linkage_attr (dw_die_ref die)
21054 unsigned ix = VEC_length (dw_attr_node, die->die_attr);
21055 dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1);
21057 gcc_assert (linkage.dw_attr == DW_AT_MIPS_linkage_name);
21061 dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1);
21063 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
21067 if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
21069 VEC_pop (dw_attr_node, die->die_attr);
21070 VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
21074 /* Helper function for resolve_addr, attempt to resolve
21075 one CONST_STRING, return non-zero if not successful. Similarly verify that
21076 SYMBOL_REFs refer to variables emitted in the current CU. */
21079 resolve_one_addr (rtx *addr, void *data ATTRIBUTE_UNUSED)
21083 if (GET_CODE (rtl) == CONST_STRING)
21085 size_t len = strlen (XSTR (rtl, 0)) + 1;
21086 tree t = build_string (len, XSTR (rtl, 0));
21087 tree tlen = build_int_cst (NULL_TREE, len - 1);
21089 = build_array_type (char_type_node, build_index_type (tlen));
21090 rtl = lookup_constant_def (t);
21091 if (!rtl || !MEM_P (rtl))
21093 rtl = XEXP (rtl, 0);
21094 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
21099 if (GET_CODE (rtl) == SYMBOL_REF
21100 && SYMBOL_REF_DECL (rtl)
21101 && TREE_CODE (SYMBOL_REF_DECL (rtl)) == VAR_DECL
21102 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
21105 if (GET_CODE (rtl) == CONST
21106 && for_each_rtx (&XEXP (rtl, 0), resolve_one_addr, NULL))
21112 /* Helper function for resolve_addr, handle one location
21113 expression, return false if at least one CONST_STRING or SYMBOL_REF in
21114 the location list couldn't be resolved. */
21117 resolve_addr_in_expr (dw_loc_descr_ref loc)
21119 for (; loc; loc = loc->dw_loc_next)
21120 if ((loc->dw_loc_opc == DW_OP_addr
21121 && resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr, NULL))
21122 || (loc->dw_loc_opc == DW_OP_implicit_value
21123 && loc->dw_loc_oprnd2.val_class == dw_val_class_addr
21124 && resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr, NULL)))
21129 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
21130 an address in .rodata section if the string literal is emitted there,
21131 or remove the containing location list or replace DW_AT_const_value
21132 with DW_AT_location and empty location expression, if it isn't found
21133 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
21134 to something that has been emitted in the current CU. */
21137 resolve_addr (dw_die_ref die)
21141 dw_loc_list_ref *curr;
21144 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
21145 switch (AT_class (a))
21147 case dw_val_class_loc_list:
21148 curr = AT_loc_list_ptr (a);
21151 if (!resolve_addr_in_expr ((*curr)->expr))
21153 dw_loc_list_ref next = (*curr)->dw_loc_next;
21154 if (next && (*curr)->ll_symbol)
21156 gcc_assert (!next->ll_symbol);
21157 next->ll_symbol = (*curr)->ll_symbol;
21162 curr = &(*curr)->dw_loc_next;
21164 if (!AT_loc_list (a))
21166 remove_AT (die, a->dw_attr);
21170 case dw_val_class_loc:
21171 if (!resolve_addr_in_expr (AT_loc (a)))
21173 remove_AT (die, a->dw_attr);
21177 case dw_val_class_addr:
21178 if (a->dw_attr == DW_AT_const_value
21179 && resolve_one_addr (&a->dw_attr_val.v.val_addr, NULL))
21181 remove_AT (die, a->dw_attr);
21189 FOR_EACH_CHILD (die, c, resolve_addr (c));
21192 /* Output stuff that dwarf requires at the end of every file,
21193 and generate the DWARF-2 debugging info. */
21196 dwarf2out_finish (const char *filename)
21198 limbo_die_node *node, *next_node;
21199 comdat_type_node *ctnode;
21200 htab_t comdat_type_table;
21201 dw_die_ref die = 0;
21204 gen_remaining_tmpl_value_param_die_attribute ();
21206 /* Add the name for the main input file now. We delayed this from
21207 dwarf2out_init to avoid complications with PCH. */
21208 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
21209 if (!IS_ABSOLUTE_PATH (filename))
21210 add_comp_dir_attribute (comp_unit_die);
21211 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
21214 htab_traverse (file_table, file_table_relative_p, &p);
21216 add_comp_dir_attribute (comp_unit_die);
21219 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
21221 add_location_or_const_value_attribute (
21222 VEC_index (deferred_locations, deferred_locations_list, i)->die,
21223 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
21227 /* Traverse the limbo die list, and add parent/child links. The only
21228 dies without parents that should be here are concrete instances of
21229 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
21230 For concrete instances, we can get the parent die from the abstract
21232 for (node = limbo_die_list; node; node = next_node)
21234 next_node = node->next;
21237 if (die->die_parent == NULL)
21239 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
21242 add_child_die (origin->die_parent, die);
21243 else if (die == comp_unit_die)
21245 else if (errorcount > 0 || sorrycount > 0)
21246 /* It's OK to be confused by errors in the input. */
21247 add_child_die (comp_unit_die, die);
21250 /* In certain situations, the lexical block containing a
21251 nested function can be optimized away, which results
21252 in the nested function die being orphaned. Likewise
21253 with the return type of that nested function. Force
21254 this to be a child of the containing function.
21256 It may happen that even the containing function got fully
21257 inlined and optimized out. In that case we are lost and
21258 assign the empty child. This should not be big issue as
21259 the function is likely unreachable too. */
21260 tree context = NULL_TREE;
21262 gcc_assert (node->created_for);
21264 if (DECL_P (node->created_for))
21265 context = DECL_CONTEXT (node->created_for);
21266 else if (TYPE_P (node->created_for))
21267 context = TYPE_CONTEXT (node->created_for);
21269 gcc_assert (context
21270 && (TREE_CODE (context) == FUNCTION_DECL
21271 || TREE_CODE (context) == NAMESPACE_DECL));
21273 origin = lookup_decl_die (context);
21275 add_child_die (origin, die);
21277 add_child_die (comp_unit_die, die);
21282 limbo_die_list = NULL;
21284 resolve_addr (comp_unit_die);
21286 for (node = deferred_asm_name; node; node = node->next)
21288 tree decl = node->created_for;
21289 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
21291 add_AT_string (node->die, DW_AT_MIPS_linkage_name,
21292 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
21293 move_linkage_attr (node->die);
21297 deferred_asm_name = NULL;
21299 /* Walk through the list of incomplete types again, trying once more to
21300 emit full debugging info for them. */
21301 retry_incomplete_types ();
21303 if (flag_eliminate_unused_debug_types)
21304 prune_unused_types ();
21306 /* Generate separate CUs for each of the include files we've seen.
21307 They will go into limbo_die_list. */
21308 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
21309 break_out_includes (comp_unit_die);
21311 /* Generate separate COMDAT sections for type DIEs. */
21312 if (dwarf_version >= 4)
21314 break_out_comdat_types (comp_unit_die);
21316 /* Each new type_unit DIE was added to the limbo die list when created.
21317 Since these have all been added to comdat_type_list, clear the
21319 limbo_die_list = NULL;
21321 /* For each new comdat type unit, copy declarations for incomplete
21322 types to make the new unit self-contained (i.e., no direct
21323 references to the main compile unit). */
21324 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
21325 copy_decls_for_unworthy_types (ctnode->root_die);
21326 copy_decls_for_unworthy_types (comp_unit_die);
21328 /* In the process of copying declarations from one unit to another,
21329 we may have left some declarations behind that are no longer
21330 referenced. Prune them. */
21331 prune_unused_types ();
21334 /* Traverse the DIE's and add add sibling attributes to those DIE's
21335 that have children. */
21336 add_sibling_attributes (comp_unit_die);
21337 for (node = limbo_die_list; node; node = node->next)
21338 add_sibling_attributes (node->die);
21339 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
21340 add_sibling_attributes (ctnode->root_die);
21342 /* Output a terminator label for the .text section. */
21343 switch_to_section (text_section);
21344 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
21345 if (flag_reorder_blocks_and_partition)
21347 switch_to_section (unlikely_text_section ());
21348 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
21351 /* We can only use the low/high_pc attributes if all of the code was
21353 if (!have_multiple_function_sections
21354 || !(dwarf_version >= 3 || !dwarf_strict))
21356 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
21357 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
21362 unsigned fde_idx = 0;
21363 bool range_list_added = false;
21365 /* We need to give .debug_loc and .debug_ranges an appropriate
21366 "base address". Use zero so that these addresses become
21367 absolute. Historically, we've emitted the unexpected
21368 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
21369 Emit both to give time for other tools to adapt. */
21370 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
21371 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
21373 if (text_section_used)
21374 add_ranges_by_labels (comp_unit_die, text_section_label,
21375 text_end_label, &range_list_added);
21376 if (flag_reorder_blocks_and_partition && cold_text_section_used)
21377 add_ranges_by_labels (comp_unit_die, cold_text_section_label,
21378 cold_end_label, &range_list_added);
21380 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
21382 dw_fde_ref fde = &fde_table[fde_idx];
21384 if (fde->dw_fde_switched_sections)
21386 if (!fde->in_std_section)
21387 add_ranges_by_labels (comp_unit_die,
21388 fde->dw_fde_hot_section_label,
21389 fde->dw_fde_hot_section_end_label,
21390 &range_list_added);
21391 if (!fde->cold_in_std_section)
21392 add_ranges_by_labels (comp_unit_die,
21393 fde->dw_fde_unlikely_section_label,
21394 fde->dw_fde_unlikely_section_end_label,
21395 &range_list_added);
21397 else if (!fde->in_std_section)
21398 add_ranges_by_labels (comp_unit_die, fde->dw_fde_begin,
21399 fde->dw_fde_end, &range_list_added);
21402 if (range_list_added)
21406 /* Output location list section if necessary. */
21407 if (have_location_lists)
21409 /* Output the location lists info. */
21410 switch_to_section (debug_loc_section);
21411 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
21412 DEBUG_LOC_SECTION_LABEL, 0);
21413 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
21414 output_location_lists (die);
21417 if (debug_info_level >= DINFO_LEVEL_NORMAL)
21418 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
21419 debug_line_section_label);
21421 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21422 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
21424 /* Output all of the compilation units. We put the main one last so that
21425 the offsets are available to output_pubnames. */
21426 for (node = limbo_die_list; node; node = node->next)
21427 output_comp_unit (node->die, 0);
21429 comdat_type_table = htab_create (100, htab_ct_hash, htab_ct_eq, NULL);
21430 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
21432 void **slot = htab_find_slot (comdat_type_table, ctnode, INSERT);
21434 /* Don't output duplicate types. */
21435 if (*slot != HTAB_EMPTY_ENTRY)
21438 /* Add a pointer to the line table for the main compilation unit
21439 so that the debugger can make sense of DW_AT_decl_file
21441 if (debug_info_level >= DINFO_LEVEL_NORMAL)
21442 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
21443 debug_line_section_label);
21445 output_comdat_type_unit (ctnode);
21448 htab_delete (comdat_type_table);
21450 /* Output the main compilation unit if non-empty or if .debug_macinfo
21451 has been emitted. */
21452 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
21454 /* Output the abbreviation table. */
21455 switch_to_section (debug_abbrev_section);
21456 output_abbrev_section ();
21458 /* Output public names table if necessary. */
21459 if (!VEC_empty (pubname_entry, pubname_table))
21461 switch_to_section (debug_pubnames_section);
21462 output_pubnames (pubname_table);
21465 /* Output public types table if necessary. */
21466 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
21467 It shouldn't hurt to emit it always, since pure DWARF2 consumers
21468 simply won't look for the section. */
21469 if (!VEC_empty (pubname_entry, pubtype_table))
21471 switch_to_section (debug_pubtypes_section);
21472 output_pubnames (pubtype_table);
21475 /* Output direct and virtual call tables if necessary. */
21476 if (!VEC_empty (dcall_entry, dcall_table))
21478 switch_to_section (debug_dcall_section);
21479 output_dcall_table ();
21481 if (!VEC_empty (vcall_entry, vcall_table))
21483 switch_to_section (debug_vcall_section);
21484 output_vcall_table ();
21487 /* Output the address range information. We only put functions in the arange
21488 table, so don't write it out if we don't have any. */
21489 if (fde_table_in_use)
21491 switch_to_section (debug_aranges_section);
21495 /* Output ranges section if necessary. */
21496 if (ranges_table_in_use)
21498 switch_to_section (debug_ranges_section);
21499 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
21503 /* Output the source line correspondence table. We must do this
21504 even if there is no line information. Otherwise, on an empty
21505 translation unit, we will generate a present, but empty,
21506 .debug_info section. IRIX 6.5 `nm' will then complain when
21507 examining the file. This is done late so that any filenames
21508 used by the debug_info section are marked as 'used'. */
21509 if (! DWARF2_ASM_LINE_DEBUG_INFO)
21511 switch_to_section (debug_line_section);
21512 output_line_info ();
21515 /* Have to end the macro section. */
21516 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21518 switch_to_section (debug_macinfo_section);
21519 dw2_asm_output_data (1, 0, "End compilation unit");
21522 /* If we emitted any DW_FORM_strp form attribute, output the string
21524 if (debug_str_hash)
21525 htab_traverse (debug_str_hash, output_indirect_string, NULL);
21529 /* This should never be used, but its address is needed for comparisons. */
21530 const struct gcc_debug_hooks dwarf2_debug_hooks =
21534 0, /* assembly_start */
21537 0, /* start_source_file */
21538 0, /* end_source_file */
21539 0, /* begin_block */
21541 0, /* ignore_block */
21542 0, /* source_line */
21543 0, /* begin_prologue */
21544 0, /* end_prologue */
21545 0, /* end_epilogue */
21546 0, /* begin_function */
21547 0, /* end_function */
21548 0, /* function_decl */
21549 0, /* global_decl */
21551 0, /* imported_module_or_decl */
21552 0, /* deferred_inline_function */
21553 0, /* outlining_inline_function */
21555 0, /* handle_pch */
21556 0, /* var_location */
21557 0, /* switch_text_section */
21558 0, /* direct_call */
21559 0, /* virtual_call_token */
21560 0, /* copy_call_info */
21561 0, /* virtual_call */
21563 0 /* start_end_main_source_file */
21566 #endif /* DWARF2_DEBUGGING_INFO */
21568 #include "gt-dwarf2out.h"