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 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* TODO: Emit .debug_line header even when there are no functions, since
25 the file numbers are used by .debug_info. Alternately, leave
26 out locations for types and decls.
27 Avoid talking about ctors and op= for PODs.
28 Factor out common prologue sequences into multiple CIEs. */
30 /* The first part of this file deals with the DWARF 2 frame unwind
31 information, which is also used by the GCC efficient exception handling
32 mechanism. The second part, controlled only by an #ifdef
33 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
36 /* DWARF2 Abbreviation Glossary:
38 CFA = Canonical Frame Address
39 a fixed address on the stack which identifies a call frame.
40 We define it to be the value of SP just before the call insn.
41 The CFA register and offset, which may change during the course
42 of the function, are used to calculate its value at runtime.
44 CFI = Call Frame Instruction
45 an instruction for the DWARF2 abstract machine
47 CIE = Common Information Entry
48 information describing information common to one or more FDEs
50 DIE = Debugging Information Entry
52 FDE = Frame Description Entry
53 information describing the stack call frame, in particular,
54 how to restore registers
56 DW_CFA_... = DWARF2 CFA call frame instruction
57 DW_TAG_... = DWARF2 DIE tag */
61 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
85 #include "diagnostic.h"
88 #include "langhooks.h"
93 #include "tree-pass.h"
95 #ifdef DWARF2_DEBUGGING_INFO
96 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
98 static rtx last_var_location_insn;
101 #ifdef VMS_DEBUGGING_INFO
102 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
104 /* Define this macro to be a nonzero value if the directory specifications
105 which are output in the debug info should end with a separator. */
106 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
107 /* Define this macro to evaluate to a nonzero value if GCC should refrain
108 from generating indirect strings in DWARF2 debug information, for instance
109 if your target is stuck with an old version of GDB that is unable to
110 process them properly or uses VMS Debug. */
111 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
113 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
114 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
117 #ifndef DWARF2_FRAME_INFO
118 # ifdef DWARF2_DEBUGGING_INFO
119 # define DWARF2_FRAME_INFO \
120 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
122 # define DWARF2_FRAME_INFO 0
126 /* Map register numbers held in the call frame info that gcc has
127 collected using DWARF_FRAME_REGNUM to those that should be output in
128 .debug_frame and .eh_frame. */
129 #ifndef DWARF2_FRAME_REG_OUT
130 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
133 /* Save the result of dwarf2out_do_frame across PCH. */
134 static GTY(()) bool saved_do_cfi_asm = 0;
136 /* Decide whether we want to emit frame unwind information for the current
140 dwarf2out_do_frame (void)
142 /* We want to emit correct CFA location expressions or lists, so we
143 have to return true if we're going to output debug info, even if
144 we're not going to output frame or unwind info. */
145 return (write_symbols == DWARF2_DEBUG
146 || write_symbols == VMS_AND_DWARF2_DEBUG
147 || DWARF2_FRAME_INFO || saved_do_cfi_asm
148 #ifdef DWARF2_UNWIND_INFO
149 || (DWARF2_UNWIND_INFO
150 && (flag_unwind_tables
151 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
156 /* Decide whether to emit frame unwind via assembler directives. */
159 dwarf2out_do_cfi_asm (void)
163 #ifdef MIPS_DEBUGGING_INFO
166 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
168 if (saved_do_cfi_asm)
170 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
173 /* Make sure the personality encoding is one the assembler can support.
174 In particular, aligned addresses can't be handled. */
175 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
176 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
178 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
179 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
182 saved_do_cfi_asm = true;
186 /* The size of the target's pointer type. */
188 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
191 /* Array of RTXes referenced by the debugging information, which therefore
192 must be kept around forever. */
193 static GTY(()) VEC(rtx,gc) *used_rtx_array;
195 /* A pointer to the base of a list of incomplete types which might be
196 completed at some later time. incomplete_types_list needs to be a
197 VEC(tree,gc) because we want to tell the garbage collector about
199 static GTY(()) VEC(tree,gc) *incomplete_types;
201 /* A pointer to the base of a table of references to declaration
202 scopes. This table is a display which tracks the nesting
203 of declaration scopes at the current scope and containing
204 scopes. This table is used to find the proper place to
205 define type declaration DIE's. */
206 static GTY(()) VEC(tree,gc) *decl_scope_table;
208 /* Pointers to various DWARF2 sections. */
209 static GTY(()) section *debug_info_section;
210 static GTY(()) section *debug_abbrev_section;
211 static GTY(()) section *debug_aranges_section;
212 static GTY(()) section *debug_macinfo_section;
213 static GTY(()) section *debug_line_section;
214 static GTY(()) section *debug_loc_section;
215 static GTY(()) section *debug_pubnames_section;
216 static GTY(()) section *debug_pubtypes_section;
217 static GTY(()) section *debug_str_section;
218 static GTY(()) section *debug_ranges_section;
219 static GTY(()) section *debug_frame_section;
221 /* Personality decl of current unit. Used only when assembler does not support
223 static GTY(()) rtx current_unit_personality;
225 /* How to start an assembler comment. */
226 #ifndef ASM_COMMENT_START
227 #define ASM_COMMENT_START ";#"
230 typedef struct dw_cfi_struct *dw_cfi_ref;
231 typedef struct dw_fde_struct *dw_fde_ref;
232 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
234 /* Call frames are described using a sequence of Call Frame
235 Information instructions. The register number, offset
236 and address fields are provided as possible operands;
237 their use is selected by the opcode field. */
239 enum dw_cfi_oprnd_type {
241 dw_cfi_oprnd_reg_num,
247 typedef union GTY(()) dw_cfi_oprnd_struct {
248 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
249 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
250 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
251 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
255 typedef struct GTY(()) dw_cfi_struct {
256 dw_cfi_ref dw_cfi_next;
257 enum dwarf_call_frame_info dw_cfi_opc;
258 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
260 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
265 /* This is how we define the location of the CFA. We use to handle it
266 as REG + OFFSET all the time, but now it can be more complex.
267 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
268 Instead of passing around REG and OFFSET, we pass a copy
269 of this structure. */
270 typedef struct GTY(()) cfa_loc {
271 HOST_WIDE_INT offset;
272 HOST_WIDE_INT base_offset;
274 BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
275 BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
278 /* All call frame descriptions (FDE's) in the GCC generated DWARF
279 refer to a single Common Information Entry (CIE), defined at
280 the beginning of the .debug_frame section. This use of a single
281 CIE obviates the need to keep track of multiple CIE's
282 in the DWARF generation routines below. */
284 typedef struct GTY(()) dw_fde_struct {
286 const char *dw_fde_begin;
287 const char *dw_fde_current_label;
288 const char *dw_fde_end;
289 const char *dw_fde_hot_section_label;
290 const char *dw_fde_hot_section_end_label;
291 const char *dw_fde_unlikely_section_label;
292 const char *dw_fde_unlikely_section_end_label;
293 dw_cfi_ref dw_fde_cfi;
294 dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections. */
295 unsigned funcdef_number;
296 HOST_WIDE_INT stack_realignment;
297 /* Dynamic realign argument pointer register. */
298 unsigned int drap_reg;
299 /* Virtual dynamic realign argument pointer register. */
300 unsigned int vdrap_reg;
301 unsigned all_throwers_are_sibcalls : 1;
302 unsigned nothrow : 1;
303 unsigned uses_eh_lsda : 1;
304 /* Whether we did stack realign in this call frame. */
305 unsigned stack_realign : 1;
306 /* Whether dynamic realign argument pointer register has been saved. */
307 unsigned drap_reg_saved: 1;
308 /* True iff dw_fde_begin label is in text_section or cold_text_section. */
309 unsigned in_std_section : 1;
310 /* True iff dw_fde_unlikely_section_label is in text_section or
311 cold_text_section. */
312 unsigned cold_in_std_section : 1;
313 /* True iff switched sections. */
314 unsigned dw_fde_switched_sections : 1;
315 /* True iff switching from cold to hot section. */
316 unsigned dw_fde_switched_cold_to_hot : 1;
320 /* Maximum size (in bytes) of an artificially generated label. */
321 #define MAX_ARTIFICIAL_LABEL_BYTES 30
323 /* The size of addresses as they appear in the Dwarf 2 data.
324 Some architectures use word addresses to refer to code locations,
325 but Dwarf 2 info always uses byte addresses. On such machines,
326 Dwarf 2 addresses need to be larger than the architecture's
328 #ifndef DWARF2_ADDR_SIZE
329 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
332 /* The size in bytes of a DWARF field indicating an offset or length
333 relative to a debug info section, specified to be 4 bytes in the
334 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
337 #ifndef DWARF_OFFSET_SIZE
338 #define DWARF_OFFSET_SIZE 4
341 /* According to the (draft) DWARF 3 specification, the initial length
342 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
343 bytes are 0xffffffff, followed by the length stored in the next 8
346 However, the SGI/MIPS ABI uses an initial length which is equal to
347 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
349 #ifndef DWARF_INITIAL_LENGTH_SIZE
350 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
353 /* Round SIZE up to the nearest BOUNDARY. */
354 #define DWARF_ROUND(SIZE,BOUNDARY) \
355 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
357 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
358 #ifndef DWARF_CIE_DATA_ALIGNMENT
359 #ifdef STACK_GROWS_DOWNWARD
360 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
362 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
366 /* CIE identifier. */
367 #if HOST_BITS_PER_WIDE_INT >= 64
368 #define DWARF_CIE_ID \
369 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
371 #define DWARF_CIE_ID DW_CIE_ID
374 /* A pointer to the base of a table that contains frame description
375 information for each routine. */
376 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
378 /* Number of elements currently allocated for fde_table. */
379 static GTY(()) unsigned fde_table_allocated;
381 /* Number of elements in fde_table currently in use. */
382 static GTY(()) unsigned fde_table_in_use;
384 /* Size (in elements) of increments by which we may expand the
386 #define FDE_TABLE_INCREMENT 256
388 /* Get the current fde_table entry we should use. */
390 static inline dw_fde_ref
393 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
396 /* A list of call frame insns for the CIE. */
397 static GTY(()) dw_cfi_ref cie_cfi_head;
399 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
400 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
401 attribute that accelerates the lookup of the FDE associated
402 with the subprogram. This variable holds the table index of the FDE
403 associated with the current function (body) definition. */
404 static unsigned current_funcdef_fde;
407 struct GTY(()) indirect_string_node {
409 unsigned int refcount;
410 enum dwarf_form form;
414 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
416 /* True if the compilation unit has location entries that reference
418 static GTY(()) bool debug_str_hash_forced = false;
420 static GTY(()) int dw2_string_counter;
421 static GTY(()) unsigned long dwarf2out_cfi_label_num;
423 /* True if the compilation unit places functions in more than one section. */
424 static GTY(()) bool have_multiple_function_sections = false;
426 /* Whether the default text and cold text sections have been used at all. */
428 static GTY(()) bool text_section_used = false;
429 static GTY(()) bool cold_text_section_used = false;
431 /* The default cold text section. */
432 static GTY(()) section *cold_text_section;
434 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
436 /* Forward declarations for functions defined in this file. */
438 static char *stripattributes (const char *);
439 static const char *dwarf_cfi_name (unsigned);
440 static dw_cfi_ref new_cfi (void);
441 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
442 static void add_fde_cfi (const char *, dw_cfi_ref);
443 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
444 static void lookup_cfa (dw_cfa_location *);
445 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
446 #ifdef DWARF2_UNWIND_INFO
447 static void initial_return_save (rtx);
449 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
451 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
452 static void output_cfi_directive (dw_cfi_ref);
453 static void output_call_frame_info (int);
454 static void dwarf2out_note_section_used (void);
455 static void dwarf2out_stack_adjust (rtx, bool);
456 static void dwarf2out_args_size_adjust (HOST_WIDE_INT, const char *);
457 static void flush_queued_reg_saves (void);
458 static bool clobbers_queued_reg_save (const_rtx);
459 static void dwarf2out_frame_debug_expr (rtx, const char *);
461 /* Support for complex CFA locations. */
462 static void output_cfa_loc (dw_cfi_ref);
463 static void output_cfa_loc_raw (dw_cfi_ref);
464 static void get_cfa_from_loc_descr (dw_cfa_location *,
465 struct dw_loc_descr_struct *);
466 static struct dw_loc_descr_struct *build_cfa_loc
467 (dw_cfa_location *, HOST_WIDE_INT);
468 static struct dw_loc_descr_struct *build_cfa_aligned_loc
469 (HOST_WIDE_INT, HOST_WIDE_INT);
470 static void def_cfa_1 (const char *, dw_cfa_location *);
472 /* How to start an assembler comment. */
473 #ifndef ASM_COMMENT_START
474 #define ASM_COMMENT_START ";#"
477 /* Data and reference forms for relocatable data. */
478 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
479 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
481 #ifndef DEBUG_FRAME_SECTION
482 #define DEBUG_FRAME_SECTION ".debug_frame"
485 #ifndef FUNC_BEGIN_LABEL
486 #define FUNC_BEGIN_LABEL "LFB"
489 #ifndef FUNC_END_LABEL
490 #define FUNC_END_LABEL "LFE"
493 #ifndef FRAME_BEGIN_LABEL
494 #define FRAME_BEGIN_LABEL "Lframe"
496 #define CIE_AFTER_SIZE_LABEL "LSCIE"
497 #define CIE_END_LABEL "LECIE"
498 #define FDE_LABEL "LSFDE"
499 #define FDE_AFTER_SIZE_LABEL "LASFDE"
500 #define FDE_END_LABEL "LEFDE"
501 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
502 #define LINE_NUMBER_END_LABEL "LELT"
503 #define LN_PROLOG_AS_LABEL "LASLTP"
504 #define LN_PROLOG_END_LABEL "LELTP"
505 #define DIE_LABEL_PREFIX "DW"
507 /* The DWARF 2 CFA column which tracks the return address. Normally this
508 is the column for PC, or the first column after all of the hard
510 #ifndef DWARF_FRAME_RETURN_COLUMN
512 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
514 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
518 /* The mapping from gcc register number to DWARF 2 CFA column number. By
519 default, we just provide columns for all registers. */
520 #ifndef DWARF_FRAME_REGNUM
521 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
524 /* Hook used by __throw. */
527 expand_builtin_dwarf_sp_column (void)
529 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
530 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
533 /* Return a pointer to a copy of the section string name S with all
534 attributes stripped off, and an asterisk prepended (for assemble_name). */
537 stripattributes (const char *s)
539 char *stripped = XNEWVEC (char, strlen (s) + 2);
544 while (*s && *s != ',')
551 /* MEM is a memory reference for the register size table, each element of
552 which has mode MODE. Initialize column C as a return address column. */
555 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
557 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
558 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
559 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
562 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
564 static inline HOST_WIDE_INT
565 div_data_align (HOST_WIDE_INT off)
567 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
568 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
572 /* Return true if we need a signed version of a given opcode
573 (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended). */
576 need_data_align_sf_opcode (HOST_WIDE_INT off)
578 return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
581 /* Generate code to initialize the register size table. */
584 expand_builtin_init_dwarf_reg_sizes (tree address)
587 enum machine_mode mode = TYPE_MODE (char_type_node);
588 rtx addr = expand_normal (address);
589 rtx mem = gen_rtx_MEM (BLKmode, addr);
590 bool wrote_return_column = false;
592 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
594 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
596 if (rnum < DWARF_FRAME_REGISTERS)
598 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
599 enum machine_mode save_mode = reg_raw_mode[i];
602 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
603 save_mode = choose_hard_reg_mode (i, 1, true);
604 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
606 if (save_mode == VOIDmode)
608 wrote_return_column = true;
610 size = GET_MODE_SIZE (save_mode);
614 emit_move_insn (adjust_address (mem, mode, offset),
615 gen_int_mode (size, mode));
619 if (!wrote_return_column)
620 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
622 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
623 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
626 targetm.init_dwarf_reg_sizes_extra (address);
629 /* Convert a DWARF call frame info. operation to its string name */
632 dwarf_cfi_name (unsigned int cfi_opc)
636 case DW_CFA_advance_loc:
637 return "DW_CFA_advance_loc";
639 return "DW_CFA_offset";
641 return "DW_CFA_restore";
645 return "DW_CFA_set_loc";
646 case DW_CFA_advance_loc1:
647 return "DW_CFA_advance_loc1";
648 case DW_CFA_advance_loc2:
649 return "DW_CFA_advance_loc2";
650 case DW_CFA_advance_loc4:
651 return "DW_CFA_advance_loc4";
652 case DW_CFA_offset_extended:
653 return "DW_CFA_offset_extended";
654 case DW_CFA_restore_extended:
655 return "DW_CFA_restore_extended";
656 case DW_CFA_undefined:
657 return "DW_CFA_undefined";
658 case DW_CFA_same_value:
659 return "DW_CFA_same_value";
660 case DW_CFA_register:
661 return "DW_CFA_register";
662 case DW_CFA_remember_state:
663 return "DW_CFA_remember_state";
664 case DW_CFA_restore_state:
665 return "DW_CFA_restore_state";
667 return "DW_CFA_def_cfa";
668 case DW_CFA_def_cfa_register:
669 return "DW_CFA_def_cfa_register";
670 case DW_CFA_def_cfa_offset:
671 return "DW_CFA_def_cfa_offset";
674 case DW_CFA_def_cfa_expression:
675 return "DW_CFA_def_cfa_expression";
676 case DW_CFA_expression:
677 return "DW_CFA_expression";
678 case DW_CFA_offset_extended_sf:
679 return "DW_CFA_offset_extended_sf";
680 case DW_CFA_def_cfa_sf:
681 return "DW_CFA_def_cfa_sf";
682 case DW_CFA_def_cfa_offset_sf:
683 return "DW_CFA_def_cfa_offset_sf";
685 /* SGI/MIPS specific */
686 case DW_CFA_MIPS_advance_loc8:
687 return "DW_CFA_MIPS_advance_loc8";
690 case DW_CFA_GNU_window_save:
691 return "DW_CFA_GNU_window_save";
692 case DW_CFA_GNU_args_size:
693 return "DW_CFA_GNU_args_size";
694 case DW_CFA_GNU_negative_offset_extended:
695 return "DW_CFA_GNU_negative_offset_extended";
698 return "DW_CFA_<unknown>";
702 /* Return a pointer to a newly allocated Call Frame Instruction. */
704 static inline dw_cfi_ref
707 dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
709 cfi->dw_cfi_next = NULL;
710 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
711 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
716 /* Add a Call Frame Instruction to list of instructions. */
719 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
722 dw_fde_ref fde = current_fde ();
724 /* When DRAP is used, CFA is defined with an expression. Redefine
725 CFA may lead to a different CFA value. */
726 /* ??? Of course, this heuristic fails when we're annotating epilogues,
727 because of course we'll always want to redefine the CFA back to the
728 stack pointer on the way out. Where should we move this check? */
729 if (0 && fde && fde->drap_reg != INVALID_REGNUM)
730 switch (cfi->dw_cfi_opc)
732 case DW_CFA_def_cfa_register:
733 case DW_CFA_def_cfa_offset:
734 case DW_CFA_def_cfa_offset_sf:
736 case DW_CFA_def_cfa_sf:
743 /* Find the end of the chain. */
744 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
750 /* Generate a new label for the CFI info to refer to. FORCE is true
751 if a label needs to be output even when using .cfi_* directives. */
754 dwarf2out_cfi_label (bool force)
756 static char label[20];
758 if (!force && dwarf2out_do_cfi_asm ())
760 /* In this case, we will be emitting the asm directive instead of
761 the label, so just return a placeholder to keep the rest of the
763 strcpy (label, "<do not output>");
767 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
768 ASM_OUTPUT_LABEL (asm_out_file, label);
774 /* True if remember_state should be emitted before following CFI directive. */
775 static bool emit_cfa_remember;
777 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
778 or to the CIE if LABEL is NULL. */
781 add_fde_cfi (const char *label, dw_cfi_ref cfi)
783 dw_cfi_ref *list_head;
785 if (emit_cfa_remember)
787 dw_cfi_ref cfi_remember;
789 /* Emit the state save. */
790 emit_cfa_remember = false;
791 cfi_remember = new_cfi ();
792 cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
793 add_fde_cfi (label, cfi_remember);
796 list_head = &cie_cfi_head;
798 if (dwarf2out_do_cfi_asm ())
802 dw_fde_ref fde = current_fde ();
804 gcc_assert (fde != NULL);
806 /* We still have to add the cfi to the list so that lookup_cfa
807 works later on. When -g2 and above we even need to force
808 emitting of CFI labels and add to list a DW_CFA_set_loc for
809 convert_cfa_to_fb_loc_list purposes. If we're generating
810 DWARF3 output we use DW_OP_call_frame_cfa and so don't use
811 convert_cfa_to_fb_loc_list. */
812 if (dwarf_version == 2
813 && debug_info_level > DINFO_LEVEL_TERSE
814 && (write_symbols == DWARF2_DEBUG
815 || write_symbols == VMS_AND_DWARF2_DEBUG))
817 switch (cfi->dw_cfi_opc)
819 case DW_CFA_def_cfa_offset:
820 case DW_CFA_def_cfa_offset_sf:
821 case DW_CFA_def_cfa_register:
823 case DW_CFA_def_cfa_sf:
824 case DW_CFA_def_cfa_expression:
825 case DW_CFA_restore_state:
826 if (*label == 0 || strcmp (label, "<do not output>") == 0)
827 label = dwarf2out_cfi_label (true);
829 if (fde->dw_fde_current_label == NULL
830 || strcmp (label, fde->dw_fde_current_label) != 0)
834 label = xstrdup (label);
836 /* Set the location counter to the new label. */
838 /* It doesn't metter whether DW_CFA_set_loc
839 or DW_CFA_advance_loc4 is added here, those aren't
840 emitted into assembly, only looked up by
841 convert_cfa_to_fb_loc_list. */
842 xcfi->dw_cfi_opc = DW_CFA_set_loc;
843 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
844 add_cfi (&fde->dw_fde_cfi, xcfi);
845 fde->dw_fde_current_label = label;
853 output_cfi_directive (cfi);
855 list_head = &fde->dw_fde_cfi;
857 /* ??? If this is a CFI for the CIE, we don't emit. This
858 assumes that the standard CIE contents that the assembler
859 uses matches the standard CIE contents that the compiler
860 uses. This is probably a bad assumption. I'm not quite
861 sure how to address this for now. */
865 dw_fde_ref fde = current_fde ();
867 gcc_assert (fde != NULL);
870 label = dwarf2out_cfi_label (false);
872 if (fde->dw_fde_current_label == NULL
873 || strcmp (label, fde->dw_fde_current_label) != 0)
877 label = xstrdup (label);
879 /* Set the location counter to the new label. */
881 /* If we have a current label, advance from there, otherwise
882 set the location directly using set_loc. */
883 xcfi->dw_cfi_opc = fde->dw_fde_current_label
884 ? DW_CFA_advance_loc4
886 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
887 add_cfi (&fde->dw_fde_cfi, xcfi);
889 fde->dw_fde_current_label = label;
892 list_head = &fde->dw_fde_cfi;
895 add_cfi (list_head, cfi);
898 /* Subroutine of lookup_cfa. */
901 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
903 switch (cfi->dw_cfi_opc)
905 case DW_CFA_def_cfa_offset:
906 case DW_CFA_def_cfa_offset_sf:
907 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
909 case DW_CFA_def_cfa_register:
910 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
913 case DW_CFA_def_cfa_sf:
914 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
915 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
917 case DW_CFA_def_cfa_expression:
918 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
921 case DW_CFA_remember_state:
922 gcc_assert (!remember->in_use);
924 remember->in_use = 1;
926 case DW_CFA_restore_state:
927 gcc_assert (remember->in_use);
929 remember->in_use = 0;
937 /* Find the previous value for the CFA. */
940 lookup_cfa (dw_cfa_location *loc)
944 dw_cfa_location remember;
946 memset (loc, 0, sizeof (*loc));
947 loc->reg = INVALID_REGNUM;
950 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
951 lookup_cfa_1 (cfi, loc, &remember);
953 fde = current_fde ();
955 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
956 lookup_cfa_1 (cfi, loc, &remember);
959 /* The current rule for calculating the DWARF2 canonical frame address. */
960 static dw_cfa_location cfa;
962 /* The register used for saving registers to the stack, and its offset
964 static dw_cfa_location cfa_store;
966 /* The current save location around an epilogue. */
967 static dw_cfa_location cfa_remember;
969 /* The running total of the size of arguments pushed onto the stack. */
970 static HOST_WIDE_INT args_size;
972 /* The last args_size we actually output. */
973 static HOST_WIDE_INT old_args_size;
975 /* Entry point to update the canonical frame address (CFA).
976 LABEL is passed to add_fde_cfi. The value of CFA is now to be
977 calculated from REG+OFFSET. */
980 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
987 def_cfa_1 (label, &loc);
990 /* Determine if two dw_cfa_location structures define the same data. */
993 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
995 return (loc1->reg == loc2->reg
996 && loc1->offset == loc2->offset
997 && loc1->indirect == loc2->indirect
998 && (loc1->indirect == 0
999 || loc1->base_offset == loc2->base_offset));
1002 /* This routine does the actual work. The CFA is now calculated from
1003 the dw_cfa_location structure. */
1006 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1009 dw_cfa_location old_cfa, loc;
1014 if (cfa_store.reg == loc.reg && loc.indirect == 0)
1015 cfa_store.offset = loc.offset;
1017 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1018 lookup_cfa (&old_cfa);
1020 /* If nothing changed, no need to issue any call frame instructions. */
1021 if (cfa_equal_p (&loc, &old_cfa))
1026 if (loc.reg == old_cfa.reg && !loc.indirect)
1028 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1029 the CFA register did not change but the offset did. The data
1030 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1031 in the assembler via the .cfi_def_cfa_offset directive. */
1033 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1035 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1036 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1039 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
1040 else if (loc.offset == old_cfa.offset
1041 && old_cfa.reg != INVALID_REGNUM
1044 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1045 indicating the CFA register has changed to <register> but the
1046 offset has not changed. */
1047 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1048 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1052 else if (loc.indirect == 0)
1054 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1055 indicating the CFA register has changed to <register> with
1056 the specified offset. The data factoring for DW_CFA_def_cfa_sf
1057 happens in output_cfi, or in the assembler via the .cfi_def_cfa
1060 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1062 cfi->dw_cfi_opc = DW_CFA_def_cfa;
1063 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1064 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1068 /* Construct a DW_CFA_def_cfa_expression instruction to
1069 calculate the CFA using a full location expression since no
1070 register-offset pair is available. */
1071 struct dw_loc_descr_struct *loc_list;
1073 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1074 loc_list = build_cfa_loc (&loc, 0);
1075 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1078 add_fde_cfi (label, cfi);
1081 /* Add the CFI for saving a register. REG is the CFA column number.
1082 LABEL is passed to add_fde_cfi.
1083 If SREG is -1, the register is saved at OFFSET from the CFA;
1084 otherwise it is saved in SREG. */
1087 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1089 dw_cfi_ref cfi = new_cfi ();
1090 dw_fde_ref fde = current_fde ();
1092 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1094 /* When stack is aligned, store REG using DW_CFA_expression with
1097 && fde->stack_realign
1098 && sreg == INVALID_REGNUM)
1100 cfi->dw_cfi_opc = DW_CFA_expression;
1101 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = reg;
1102 cfi->dw_cfi_oprnd1.dw_cfi_loc
1103 = build_cfa_aligned_loc (offset, fde->stack_realignment);
1105 else if (sreg == INVALID_REGNUM)
1107 if (need_data_align_sf_opcode (offset))
1108 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1109 else if (reg & ~0x3f)
1110 cfi->dw_cfi_opc = DW_CFA_offset_extended;
1112 cfi->dw_cfi_opc = DW_CFA_offset;
1113 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1115 else if (sreg == reg)
1116 cfi->dw_cfi_opc = DW_CFA_same_value;
1119 cfi->dw_cfi_opc = DW_CFA_register;
1120 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1123 add_fde_cfi (label, cfi);
1126 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1127 This CFI tells the unwinder that it needs to restore the window registers
1128 from the previous frame's window save area.
1130 ??? Perhaps we should note in the CIE where windows are saved (instead of
1131 assuming 0(cfa)) and what registers are in the window. */
1134 dwarf2out_window_save (const char *label)
1136 dw_cfi_ref cfi = new_cfi ();
1138 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1139 add_fde_cfi (label, cfi);
1142 /* Add a CFI to update the running total of the size of arguments
1143 pushed onto the stack. */
1146 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1150 if (size == old_args_size)
1153 old_args_size = size;
1156 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1157 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1158 add_fde_cfi (label, cfi);
1161 /* Entry point for saving a register to the stack. REG is the GCC register
1162 number. LABEL and OFFSET are passed to reg_save. */
1165 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1167 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1170 /* Entry point for saving the return address in the stack.
1171 LABEL and OFFSET are passed to reg_save. */
1174 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1176 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1179 /* Entry point for saving the return address in a register.
1180 LABEL and SREG are passed to reg_save. */
1183 dwarf2out_return_reg (const char *label, unsigned int sreg)
1185 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1188 #ifdef DWARF2_UNWIND_INFO
1189 /* Record the initial position of the return address. RTL is
1190 INCOMING_RETURN_ADDR_RTX. */
1193 initial_return_save (rtx rtl)
1195 unsigned int reg = INVALID_REGNUM;
1196 HOST_WIDE_INT offset = 0;
1198 switch (GET_CODE (rtl))
1201 /* RA is in a register. */
1202 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1206 /* RA is on the stack. */
1207 rtl = XEXP (rtl, 0);
1208 switch (GET_CODE (rtl))
1211 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1216 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1217 offset = INTVAL (XEXP (rtl, 1));
1221 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1222 offset = -INTVAL (XEXP (rtl, 1));
1232 /* The return address is at some offset from any value we can
1233 actually load. For instance, on the SPARC it is in %i7+8. Just
1234 ignore the offset for now; it doesn't matter for unwinding frames. */
1235 gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1236 initial_return_save (XEXP (rtl, 0));
1243 if (reg != DWARF_FRAME_RETURN_COLUMN)
1244 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1248 /* Given a SET, calculate the amount of stack adjustment it
1251 static HOST_WIDE_INT
1252 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1253 HOST_WIDE_INT cur_offset)
1255 const_rtx src = SET_SRC (pattern);
1256 const_rtx dest = SET_DEST (pattern);
1257 HOST_WIDE_INT offset = 0;
1260 if (dest == stack_pointer_rtx)
1262 code = GET_CODE (src);
1264 /* Assume (set (reg sp) (reg whatever)) sets args_size
1266 if (code == REG && src != stack_pointer_rtx)
1268 offset = -cur_args_size;
1269 #ifndef STACK_GROWS_DOWNWARD
1272 return offset - cur_offset;
1275 if (! (code == PLUS || code == MINUS)
1276 || XEXP (src, 0) != stack_pointer_rtx
1277 || !CONST_INT_P (XEXP (src, 1)))
1280 /* (set (reg sp) (plus (reg sp) (const_int))) */
1281 offset = INTVAL (XEXP (src, 1));
1287 if (MEM_P (src) && !MEM_P (dest))
1291 /* (set (mem (pre_dec (reg sp))) (foo)) */
1292 src = XEXP (dest, 0);
1293 code = GET_CODE (src);
1299 if (XEXP (src, 0) == stack_pointer_rtx)
1301 rtx val = XEXP (XEXP (src, 1), 1);
1302 /* We handle only adjustments by constant amount. */
1303 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1304 && CONST_INT_P (val));
1305 offset = -INTVAL (val);
1312 if (XEXP (src, 0) == stack_pointer_rtx)
1314 offset = GET_MODE_SIZE (GET_MODE (dest));
1321 if (XEXP (src, 0) == stack_pointer_rtx)
1323 offset = -GET_MODE_SIZE (GET_MODE (dest));
1338 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1339 indexed by INSN_UID. */
1341 static HOST_WIDE_INT *barrier_args_size;
1343 /* Helper function for compute_barrier_args_size. Handle one insn. */
1345 static HOST_WIDE_INT
1346 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1347 VEC (rtx, heap) **next)
1349 HOST_WIDE_INT offset = 0;
1352 if (! RTX_FRAME_RELATED_P (insn))
1354 if (prologue_epilogue_contains (insn))
1356 else if (GET_CODE (PATTERN (insn)) == SET)
1357 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1358 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1359 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1361 /* There may be stack adjustments inside compound insns. Search
1363 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1364 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1365 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1366 cur_args_size, offset);
1371 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1375 expr = XEXP (expr, 0);
1376 if (GET_CODE (expr) == PARALLEL
1377 || GET_CODE (expr) == SEQUENCE)
1378 for (i = 1; i < XVECLEN (expr, 0); i++)
1380 rtx elem = XVECEXP (expr, 0, i);
1382 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1383 offset += stack_adjust_offset (elem, cur_args_size, offset);
1388 #ifndef STACK_GROWS_DOWNWARD
1392 cur_args_size += offset;
1393 if (cur_args_size < 0)
1398 rtx dest = JUMP_LABEL (insn);
1402 if (barrier_args_size [INSN_UID (dest)] < 0)
1404 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1405 VEC_safe_push (rtx, heap, *next, dest);
1410 return cur_args_size;
1413 /* Walk the whole function and compute args_size on BARRIERs. */
1416 compute_barrier_args_size (void)
1418 int max_uid = get_max_uid (), i;
1420 VEC (rtx, heap) *worklist, *next, *tmp;
1422 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1423 for (i = 0; i < max_uid; i++)
1424 barrier_args_size[i] = -1;
1426 worklist = VEC_alloc (rtx, heap, 20);
1427 next = VEC_alloc (rtx, heap, 20);
1428 insn = get_insns ();
1429 barrier_args_size[INSN_UID (insn)] = 0;
1430 VEC_quick_push (rtx, worklist, insn);
1433 while (!VEC_empty (rtx, worklist))
1435 rtx prev, body, first_insn;
1436 HOST_WIDE_INT cur_args_size;
1438 first_insn = insn = VEC_pop (rtx, worklist);
1439 cur_args_size = barrier_args_size[INSN_UID (insn)];
1440 prev = prev_nonnote_insn (insn);
1441 if (prev && BARRIER_P (prev))
1442 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1444 for (; insn; insn = NEXT_INSN (insn))
1446 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1448 if (BARRIER_P (insn))
1453 if (insn == first_insn)
1455 else if (barrier_args_size[INSN_UID (insn)] < 0)
1457 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1462 /* The insns starting with this label have been
1463 already scanned or are in the worklist. */
1468 body = PATTERN (insn);
1469 if (GET_CODE (body) == SEQUENCE)
1471 HOST_WIDE_INT dest_args_size = cur_args_size;
1472 for (i = 1; i < XVECLEN (body, 0); i++)
1473 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1474 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1476 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1477 dest_args_size, &next);
1480 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1481 cur_args_size, &next);
1483 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1484 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1485 dest_args_size, &next);
1488 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1489 cur_args_size, &next);
1493 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1497 if (VEC_empty (rtx, next))
1500 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1504 VEC_truncate (rtx, next, 0);
1507 VEC_free (rtx, heap, worklist);
1508 VEC_free (rtx, heap, next);
1512 /* Check INSN to see if it looks like a push or a stack adjustment, and
1513 make a note of it if it does. EH uses this information to find out how
1514 much extra space it needs to pop off the stack. */
1517 dwarf2out_stack_adjust (rtx insn, bool after_p)
1519 HOST_WIDE_INT offset;
1523 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1524 with this function. Proper support would require all frame-related
1525 insns to be marked, and to be able to handle saving state around
1526 epilogues textually in the middle of the function. */
1527 if (prologue_epilogue_contains (insn))
1530 /* If INSN is an instruction from target of an annulled branch, the
1531 effects are for the target only and so current argument size
1532 shouldn't change at all. */
1534 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1535 && INSN_FROM_TARGET_P (insn))
1538 /* If only calls can throw, and we have a frame pointer,
1539 save up adjustments until we see the CALL_INSN. */
1540 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1542 if (CALL_P (insn) && !after_p)
1544 /* Extract the size of the args from the CALL rtx itself. */
1545 insn = PATTERN (insn);
1546 if (GET_CODE (insn) == PARALLEL)
1547 insn = XVECEXP (insn, 0, 0);
1548 if (GET_CODE (insn) == SET)
1549 insn = SET_SRC (insn);
1550 gcc_assert (GET_CODE (insn) == CALL);
1551 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1556 if (CALL_P (insn) && !after_p)
1558 if (!flag_asynchronous_unwind_tables)
1559 dwarf2out_args_size ("", args_size);
1562 else if (BARRIER_P (insn))
1564 /* Don't call compute_barrier_args_size () if the only
1565 BARRIER is at the end of function. */
1566 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1567 compute_barrier_args_size ();
1568 if (barrier_args_size == NULL)
1572 offset = barrier_args_size[INSN_UID (insn)];
1577 offset -= args_size;
1578 #ifndef STACK_GROWS_DOWNWARD
1582 else if (GET_CODE (PATTERN (insn)) == SET)
1583 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1584 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1585 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1587 /* There may be stack adjustments inside compound insns. Search
1589 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1590 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1591 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1600 label = dwarf2out_cfi_label (false);
1601 dwarf2out_args_size_adjust (offset, label);
1604 /* Adjust args_size based on stack adjustment OFFSET. */
1607 dwarf2out_args_size_adjust (HOST_WIDE_INT offset, const char *label)
1609 if (cfa.reg == STACK_POINTER_REGNUM)
1610 cfa.offset += offset;
1612 if (cfa_store.reg == STACK_POINTER_REGNUM)
1613 cfa_store.offset += offset;
1615 #ifndef STACK_GROWS_DOWNWARD
1619 args_size += offset;
1623 def_cfa_1 (label, &cfa);
1624 if (flag_asynchronous_unwind_tables)
1625 dwarf2out_args_size (label, args_size);
1630 /* We delay emitting a register save until either (a) we reach the end
1631 of the prologue or (b) the register is clobbered. This clusters
1632 register saves so that there are fewer pc advances. */
1634 struct GTY(()) queued_reg_save {
1635 struct queued_reg_save *next;
1637 HOST_WIDE_INT cfa_offset;
1641 static GTY(()) struct queued_reg_save *queued_reg_saves;
1643 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1644 struct GTY(()) reg_saved_in_data {
1649 /* A list of registers saved in other registers.
1650 The list intentionally has a small maximum capacity of 4; if your
1651 port needs more than that, you might consider implementing a
1652 more efficient data structure. */
1653 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1654 static GTY(()) size_t num_regs_saved_in_regs;
1656 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1657 static const char *last_reg_save_label;
1659 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1660 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1663 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1665 struct queued_reg_save *q;
1667 /* Duplicates waste space, but it's also necessary to remove them
1668 for correctness, since the queue gets output in reverse
1670 for (q = queued_reg_saves; q != NULL; q = q->next)
1671 if (REGNO (q->reg) == REGNO (reg))
1676 q = GGC_NEW (struct queued_reg_save);
1677 q->next = queued_reg_saves;
1678 queued_reg_saves = q;
1682 q->cfa_offset = offset;
1683 q->saved_reg = sreg;
1685 last_reg_save_label = label;
1688 /* Output all the entries in QUEUED_REG_SAVES. */
1691 flush_queued_reg_saves (void)
1693 struct queued_reg_save *q;
1695 for (q = queued_reg_saves; q; q = q->next)
1698 unsigned int reg, sreg;
1700 for (i = 0; i < num_regs_saved_in_regs; i++)
1701 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1703 if (q->saved_reg && i == num_regs_saved_in_regs)
1705 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1706 num_regs_saved_in_regs++;
1708 if (i != num_regs_saved_in_regs)
1710 regs_saved_in_regs[i].orig_reg = q->reg;
1711 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1714 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1716 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1718 sreg = INVALID_REGNUM;
1719 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1722 queued_reg_saves = NULL;
1723 last_reg_save_label = NULL;
1726 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1727 location for? Or, does it clobber a register which we've previously
1728 said that some other register is saved in, and for which we now
1729 have a new location for? */
1732 clobbers_queued_reg_save (const_rtx insn)
1734 struct queued_reg_save *q;
1736 for (q = queued_reg_saves; q; q = q->next)
1739 if (modified_in_p (q->reg, insn))
1741 for (i = 0; i < num_regs_saved_in_regs; i++)
1742 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1743 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1750 /* Entry point for saving the first register into the second. */
1753 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1756 unsigned int regno, sregno;
1758 for (i = 0; i < num_regs_saved_in_regs; i++)
1759 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1761 if (i == num_regs_saved_in_regs)
1763 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1764 num_regs_saved_in_regs++;
1766 regs_saved_in_regs[i].orig_reg = reg;
1767 regs_saved_in_regs[i].saved_in_reg = sreg;
1769 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1770 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1771 reg_save (label, regno, sregno, 0);
1774 /* What register, if any, is currently saved in REG? */
1777 reg_saved_in (rtx reg)
1779 unsigned int regn = REGNO (reg);
1781 struct queued_reg_save *q;
1783 for (q = queued_reg_saves; q; q = q->next)
1784 if (q->saved_reg && regn == REGNO (q->saved_reg))
1787 for (i = 0; i < num_regs_saved_in_regs; i++)
1788 if (regs_saved_in_regs[i].saved_in_reg
1789 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1790 return regs_saved_in_regs[i].orig_reg;
1796 /* A temporary register holding an integral value used in adjusting SP
1797 or setting up the store_reg. The "offset" field holds the integer
1798 value, not an offset. */
1799 static dw_cfa_location cfa_temp;
1801 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1804 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1806 memset (&cfa, 0, sizeof (cfa));
1808 switch (GET_CODE (pat))
1811 cfa.reg = REGNO (XEXP (pat, 0));
1812 cfa.offset = INTVAL (XEXP (pat, 1));
1816 cfa.reg = REGNO (pat);
1820 /* Recurse and define an expression. */
1824 def_cfa_1 (label, &cfa);
1827 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1830 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1834 gcc_assert (GET_CODE (pat) == SET);
1835 dest = XEXP (pat, 0);
1836 src = XEXP (pat, 1);
1838 switch (GET_CODE (src))
1841 gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1842 cfa.offset -= INTVAL (XEXP (src, 1));
1852 cfa.reg = REGNO (dest);
1853 gcc_assert (cfa.indirect == 0);
1855 def_cfa_1 (label, &cfa);
1858 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1861 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1863 HOST_WIDE_INT offset;
1864 rtx src, addr, span;
1866 src = XEXP (set, 1);
1867 addr = XEXP (set, 0);
1868 gcc_assert (MEM_P (addr));
1869 addr = XEXP (addr, 0);
1871 /* As documented, only consider extremely simple addresses. */
1872 switch (GET_CODE (addr))
1875 gcc_assert (REGNO (addr) == cfa.reg);
1876 offset = -cfa.offset;
1879 gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1880 offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1886 span = targetm.dwarf_register_span (src);
1888 /* ??? We'd like to use queue_reg_save, but we need to come up with
1889 a different flushing heuristic for epilogues. */
1891 reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1894 /* We have a PARALLEL describing where the contents of SRC live.
1895 Queue register saves for each piece of the PARALLEL. */
1898 HOST_WIDE_INT span_offset = offset;
1900 gcc_assert (GET_CODE (span) == PARALLEL);
1902 limit = XVECLEN (span, 0);
1903 for (par_index = 0; par_index < limit; par_index++)
1905 rtx elem = XVECEXP (span, 0, par_index);
1907 reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1908 INVALID_REGNUM, span_offset);
1909 span_offset += GET_MODE_SIZE (GET_MODE (elem));
1914 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
1917 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1920 unsigned sregno, dregno;
1922 src = XEXP (set, 1);
1923 dest = XEXP (set, 0);
1926 sregno = DWARF_FRAME_RETURN_COLUMN;
1928 sregno = DWARF_FRAME_REGNUM (REGNO (src));
1930 dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1932 /* ??? We'd like to use queue_reg_save, but we need to come up with
1933 a different flushing heuristic for epilogues. */
1934 reg_save (label, sregno, dregno, 0);
1937 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
1940 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
1942 dw_cfi_ref cfi = new_cfi ();
1943 unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
1945 cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
1946 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
1948 add_fde_cfi (label, cfi);
1951 /* Record call frame debugging information for an expression EXPR,
1952 which either sets SP or FP (adjusting how we calculate the frame
1953 address) or saves a register to the stack or another register.
1954 LABEL indicates the address of EXPR.
1956 This function encodes a state machine mapping rtxes to actions on
1957 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1958 users need not read the source code.
1960 The High-Level Picture
1962 Changes in the register we use to calculate the CFA: Currently we
1963 assume that if you copy the CFA register into another register, we
1964 should take the other one as the new CFA register; this seems to
1965 work pretty well. If it's wrong for some target, it's simple
1966 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1968 Changes in the register we use for saving registers to the stack:
1969 This is usually SP, but not always. Again, we deduce that if you
1970 copy SP into another register (and SP is not the CFA register),
1971 then the new register is the one we will be using for register
1972 saves. This also seems to work.
1974 Register saves: There's not much guesswork about this one; if
1975 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1976 register save, and the register used to calculate the destination
1977 had better be the one we think we're using for this purpose.
1978 It's also assumed that a copy from a call-saved register to another
1979 register is saving that register if RTX_FRAME_RELATED_P is set on
1980 that instruction. If the copy is from a call-saved register to
1981 the *same* register, that means that the register is now the same
1982 value as in the caller.
1984 Except: If the register being saved is the CFA register, and the
1985 offset is nonzero, we are saving the CFA, so we assume we have to
1986 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1987 the intent is to save the value of SP from the previous frame.
1989 In addition, if a register has previously been saved to a different
1992 Invariants / Summaries of Rules
1994 cfa current rule for calculating the CFA. It usually
1995 consists of a register and an offset.
1996 cfa_store register used by prologue code to save things to the stack
1997 cfa_store.offset is the offset from the value of
1998 cfa_store.reg to the actual CFA
1999 cfa_temp register holding an integral value. cfa_temp.offset
2000 stores the value, which will be used to adjust the
2001 stack pointer. cfa_temp is also used like cfa_store,
2002 to track stores to the stack via fp or a temp reg.
2004 Rules 1- 4: Setting a register's value to cfa.reg or an expression
2005 with cfa.reg as the first operand changes the cfa.reg and its
2006 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
2009 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
2010 expression yielding a constant. This sets cfa_temp.reg
2011 and cfa_temp.offset.
2013 Rule 5: Create a new register cfa_store used to save items to the
2016 Rules 10-14: Save a register to the stack. Define offset as the
2017 difference of the original location and cfa_store's
2018 location (or cfa_temp's location if cfa_temp is used).
2020 Rules 16-20: If AND operation happens on sp in prologue, we assume
2021 stack is realigned. We will use a group of DW_OP_XXX
2022 expressions to represent the location of the stored
2023 register instead of CFA+offset.
2027 "{a,b}" indicates a choice of a xor b.
2028 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2031 (set <reg1> <reg2>:cfa.reg)
2032 effects: cfa.reg = <reg1>
2033 cfa.offset unchanged
2034 cfa_temp.reg = <reg1>
2035 cfa_temp.offset = cfa.offset
2038 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2039 {<const_int>,<reg>:cfa_temp.reg}))
2040 effects: cfa.reg = sp if fp used
2041 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2042 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2043 if cfa_store.reg==sp
2046 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2047 effects: cfa.reg = fp
2048 cfa_offset += +/- <const_int>
2051 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2052 constraints: <reg1> != fp
2054 effects: cfa.reg = <reg1>
2055 cfa_temp.reg = <reg1>
2056 cfa_temp.offset = cfa.offset
2059 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2060 constraints: <reg1> != fp
2062 effects: cfa_store.reg = <reg1>
2063 cfa_store.offset = cfa.offset - cfa_temp.offset
2066 (set <reg> <const_int>)
2067 effects: cfa_temp.reg = <reg>
2068 cfa_temp.offset = <const_int>
2071 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2072 effects: cfa_temp.reg = <reg1>
2073 cfa_temp.offset |= <const_int>
2076 (set <reg> (high <exp>))
2080 (set <reg> (lo_sum <exp> <const_int>))
2081 effects: cfa_temp.reg = <reg>
2082 cfa_temp.offset = <const_int>
2085 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2086 effects: cfa_store.offset -= <const_int>
2087 cfa.offset = cfa_store.offset if cfa.reg == sp
2089 cfa.base_offset = -cfa_store.offset
2092 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2093 effects: cfa_store.offset += -/+ mode_size(mem)
2094 cfa.offset = cfa_store.offset if cfa.reg == sp
2096 cfa.base_offset = -cfa_store.offset
2099 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2102 effects: cfa.reg = <reg1>
2103 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2106 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2107 effects: cfa.reg = <reg1>
2108 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2111 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2112 effects: cfa.reg = <reg1>
2113 cfa.base_offset = -cfa_temp.offset
2114 cfa_temp.offset -= mode_size(mem)
2117 (set <reg> {unspec, unspec_volatile})
2118 effects: target-dependent
2121 (set sp (and: sp <const_int>))
2122 constraints: cfa_store.reg == sp
2123 effects: current_fde.stack_realign = 1
2124 cfa_store.offset = 0
2125 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2128 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2129 effects: cfa_store.offset += -/+ mode_size(mem)
2132 (set (mem ({pre_inc, pre_dec} sp)) fp)
2133 constraints: fde->stack_realign == 1
2134 effects: cfa_store.offset = 0
2135 cfa.reg != HARD_FRAME_POINTER_REGNUM
2138 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2139 constraints: fde->stack_realign == 1
2141 && cfa.indirect == 0
2142 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2143 effects: Use DW_CFA_def_cfa_expression to define cfa
2144 cfa.reg == fde->drap_reg
2147 (set reg fde->drap_reg)
2148 constraints: fde->vdrap_reg == INVALID_REGNUM
2149 effects: fde->vdrap_reg = reg.
2150 (set mem fde->drap_reg)
2151 constraints: fde->drap_reg_saved == 1
2155 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2157 rtx src, dest, span;
2158 HOST_WIDE_INT offset;
2161 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2162 the PARALLEL independently. The first element is always processed if
2163 it is a SET. This is for backward compatibility. Other elements
2164 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2165 flag is set in them. */
2166 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2169 int limit = XVECLEN (expr, 0);
2172 /* PARALLELs have strict read-modify-write semantics, so we
2173 ought to evaluate every rvalue before changing any lvalue.
2174 It's cumbersome to do that in general, but there's an
2175 easy approximation that is enough for all current users:
2176 handle register saves before register assignments. */
2177 if (GET_CODE (expr) == PARALLEL)
2178 for (par_index = 0; par_index < limit; par_index++)
2180 elem = XVECEXP (expr, 0, par_index);
2181 if (GET_CODE (elem) == SET
2182 && MEM_P (SET_DEST (elem))
2183 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2184 dwarf2out_frame_debug_expr (elem, label);
2187 for (par_index = 0; par_index < limit; par_index++)
2189 elem = XVECEXP (expr, 0, par_index);
2190 if (GET_CODE (elem) == SET
2191 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2192 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2193 dwarf2out_frame_debug_expr (elem, label);
2194 else if (GET_CODE (elem) == SET
2196 && !RTX_FRAME_RELATED_P (elem))
2198 /* Stack adjustment combining might combine some post-prologue
2199 stack adjustment into a prologue stack adjustment. */
2200 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2203 dwarf2out_args_size_adjust (offset, label);
2209 gcc_assert (GET_CODE (expr) == SET);
2211 src = SET_SRC (expr);
2212 dest = SET_DEST (expr);
2216 rtx rsi = reg_saved_in (src);
2221 fde = current_fde ();
2225 && fde->drap_reg == REGNO (src)
2226 && (fde->drap_reg_saved
2230 /* If we are saving dynamic realign argument pointer to a
2231 register, the destination is virtual dynamic realign
2232 argument pointer. It may be used to access argument. */
2235 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2236 fde->vdrap_reg = REGNO (dest);
2241 switch (GET_CODE (dest))
2244 switch (GET_CODE (src))
2246 /* Setting FP from SP. */
2248 if (cfa.reg == (unsigned) REGNO (src))
2251 /* Update the CFA rule wrt SP or FP. Make sure src is
2252 relative to the current CFA register.
2254 We used to require that dest be either SP or FP, but the
2255 ARM copies SP to a temporary register, and from there to
2256 FP. So we just rely on the backends to only set
2257 RTX_FRAME_RELATED_P on appropriate insns. */
2258 cfa.reg = REGNO (dest);
2259 cfa_temp.reg = cfa.reg;
2260 cfa_temp.offset = cfa.offset;
2264 /* Saving a register in a register. */
2265 gcc_assert (!fixed_regs [REGNO (dest)]
2266 /* For the SPARC and its register window. */
2267 || (DWARF_FRAME_REGNUM (REGNO (src))
2268 == DWARF_FRAME_RETURN_COLUMN));
2270 /* After stack is aligned, we can only save SP in FP
2271 if drap register is used. In this case, we have
2272 to restore stack pointer with the CFA value and we
2273 don't generate this DWARF information. */
2275 && fde->stack_realign
2276 && REGNO (src) == STACK_POINTER_REGNUM)
2277 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2278 && fde->drap_reg != INVALID_REGNUM
2279 && cfa.reg != REGNO (src));
2281 queue_reg_save (label, src, dest, 0);
2288 if (dest == stack_pointer_rtx)
2292 switch (GET_CODE (XEXP (src, 1)))
2295 offset = INTVAL (XEXP (src, 1));
2298 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2300 offset = cfa_temp.offset;
2306 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2308 /* Restoring SP from FP in the epilogue. */
2309 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2310 cfa.reg = STACK_POINTER_REGNUM;
2312 else if (GET_CODE (src) == LO_SUM)
2313 /* Assume we've set the source reg of the LO_SUM from sp. */
2316 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2318 if (GET_CODE (src) != MINUS)
2320 if (cfa.reg == STACK_POINTER_REGNUM)
2321 cfa.offset += offset;
2322 if (cfa_store.reg == STACK_POINTER_REGNUM)
2323 cfa_store.offset += offset;
2325 else if (dest == hard_frame_pointer_rtx)
2328 /* Either setting the FP from an offset of the SP,
2329 or adjusting the FP */
2330 gcc_assert (frame_pointer_needed);
2332 gcc_assert (REG_P (XEXP (src, 0))
2333 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2334 && CONST_INT_P (XEXP (src, 1)));
2335 offset = INTVAL (XEXP (src, 1));
2336 if (GET_CODE (src) != MINUS)
2338 cfa.offset += offset;
2339 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2343 gcc_assert (GET_CODE (src) != MINUS);
2346 if (REG_P (XEXP (src, 0))
2347 && REGNO (XEXP (src, 0)) == cfa.reg
2348 && CONST_INT_P (XEXP (src, 1)))
2350 /* Setting a temporary CFA register that will be copied
2351 into the FP later on. */
2352 offset = - INTVAL (XEXP (src, 1));
2353 cfa.offset += offset;
2354 cfa.reg = REGNO (dest);
2355 /* Or used to save regs to the stack. */
2356 cfa_temp.reg = cfa.reg;
2357 cfa_temp.offset = cfa.offset;
2361 else if (REG_P (XEXP (src, 0))
2362 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2363 && XEXP (src, 1) == stack_pointer_rtx)
2365 /* Setting a scratch register that we will use instead
2366 of SP for saving registers to the stack. */
2367 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2368 cfa_store.reg = REGNO (dest);
2369 cfa_store.offset = cfa.offset - cfa_temp.offset;
2373 else if (GET_CODE (src) == LO_SUM
2374 && CONST_INT_P (XEXP (src, 1)))
2376 cfa_temp.reg = REGNO (dest);
2377 cfa_temp.offset = INTVAL (XEXP (src, 1));
2386 cfa_temp.reg = REGNO (dest);
2387 cfa_temp.offset = INTVAL (src);
2392 gcc_assert (REG_P (XEXP (src, 0))
2393 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2394 && CONST_INT_P (XEXP (src, 1)));
2396 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2397 cfa_temp.reg = REGNO (dest);
2398 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2401 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2402 which will fill in all of the bits. */
2409 case UNSPEC_VOLATILE:
2410 gcc_assert (targetm.dwarf_handle_frame_unspec);
2411 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2416 /* If this AND operation happens on stack pointer in prologue,
2417 we assume the stack is realigned and we extract the
2419 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2421 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2422 fde->stack_realign = 1;
2423 fde->stack_realignment = INTVAL (XEXP (src, 1));
2424 cfa_store.offset = 0;
2426 if (cfa.reg != STACK_POINTER_REGNUM
2427 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2428 fde->drap_reg = cfa.reg;
2436 def_cfa_1 (label, &cfa);
2441 /* Saving a register to the stack. Make sure dest is relative to the
2443 switch (GET_CODE (XEXP (dest, 0)))
2448 /* We can't handle variable size modifications. */
2449 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2451 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2453 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2454 && cfa_store.reg == STACK_POINTER_REGNUM);
2456 cfa_store.offset += offset;
2457 if (cfa.reg == STACK_POINTER_REGNUM)
2458 cfa.offset = cfa_store.offset;
2460 offset = -cfa_store.offset;
2466 offset = GET_MODE_SIZE (GET_MODE (dest));
2467 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2470 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2471 == STACK_POINTER_REGNUM)
2472 && cfa_store.reg == STACK_POINTER_REGNUM);
2474 cfa_store.offset += offset;
2476 /* Rule 18: If stack is aligned, we will use FP as a
2477 reference to represent the address of the stored
2480 && fde->stack_realign
2481 && src == hard_frame_pointer_rtx)
2483 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2484 cfa_store.offset = 0;
2487 if (cfa.reg == STACK_POINTER_REGNUM)
2488 cfa.offset = cfa_store.offset;
2490 offset = -cfa_store.offset;
2494 /* With an offset. */
2501 gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2502 && REG_P (XEXP (XEXP (dest, 0), 0)));
2503 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2504 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2507 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2509 if (cfa_store.reg == (unsigned) regno)
2510 offset -= cfa_store.offset;
2513 gcc_assert (cfa_temp.reg == (unsigned) regno);
2514 offset -= cfa_temp.offset;
2520 /* Without an offset. */
2523 int regno = REGNO (XEXP (dest, 0));
2525 if (cfa_store.reg == (unsigned) regno)
2526 offset = -cfa_store.offset;
2529 gcc_assert (cfa_temp.reg == (unsigned) regno);
2530 offset = -cfa_temp.offset;
2537 gcc_assert (cfa_temp.reg
2538 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2539 offset = -cfa_temp.offset;
2540 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2548 /* If the source operand of this MEM operation is not a
2549 register, basically the source is return address. Here
2550 we only care how much stack grew and we don't save it. */
2554 if (REGNO (src) != STACK_POINTER_REGNUM
2555 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2556 && (unsigned) REGNO (src) == cfa.reg)
2558 /* We're storing the current CFA reg into the stack. */
2560 if (cfa.offset == 0)
2563 /* If stack is aligned, putting CFA reg into stack means
2564 we can no longer use reg + offset to represent CFA.
2565 Here we use DW_CFA_def_cfa_expression instead. The
2566 result of this expression equals to the original CFA
2569 && fde->stack_realign
2570 && cfa.indirect == 0
2571 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2573 dw_cfa_location cfa_exp;
2575 gcc_assert (fde->drap_reg == cfa.reg);
2577 cfa_exp.indirect = 1;
2578 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2579 cfa_exp.base_offset = offset;
2582 fde->drap_reg_saved = 1;
2584 def_cfa_1 (label, &cfa_exp);
2588 /* If the source register is exactly the CFA, assume
2589 we're saving SP like any other register; this happens
2591 def_cfa_1 (label, &cfa);
2592 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2597 /* Otherwise, we'll need to look in the stack to
2598 calculate the CFA. */
2599 rtx x = XEXP (dest, 0);
2603 gcc_assert (REG_P (x));
2605 cfa.reg = REGNO (x);
2606 cfa.base_offset = offset;
2608 def_cfa_1 (label, &cfa);
2613 def_cfa_1 (label, &cfa);
2615 span = targetm.dwarf_register_span (src);
2618 queue_reg_save (label, src, NULL_RTX, offset);
2621 /* We have a PARALLEL describing where the contents of SRC
2622 live. Queue register saves for each piece of the
2626 HOST_WIDE_INT span_offset = offset;
2628 gcc_assert (GET_CODE (span) == PARALLEL);
2630 limit = XVECLEN (span, 0);
2631 for (par_index = 0; par_index < limit; par_index++)
2633 rtx elem = XVECEXP (span, 0, par_index);
2635 queue_reg_save (label, elem, NULL_RTX, span_offset);
2636 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2647 /* Record call frame debugging information for INSN, which either
2648 sets SP or FP (adjusting how we calculate the frame address) or saves a
2649 register to the stack. If INSN is NULL_RTX, initialize our state.
2651 If AFTER_P is false, we're being called before the insn is emitted,
2652 otherwise after. Call instructions get invoked twice. */
2655 dwarf2out_frame_debug (rtx insn, bool after_p)
2659 bool handled_one = false;
2661 if (insn == NULL_RTX)
2665 /* Flush any queued register saves. */
2666 flush_queued_reg_saves ();
2668 /* Set up state for generating call frame debug info. */
2671 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2673 cfa.reg = STACK_POINTER_REGNUM;
2676 cfa_temp.offset = 0;
2678 for (i = 0; i < num_regs_saved_in_regs; i++)
2680 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2681 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2683 num_regs_saved_in_regs = 0;
2685 if (barrier_args_size)
2687 XDELETEVEC (barrier_args_size);
2688 barrier_args_size = NULL;
2693 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2694 flush_queued_reg_saves ();
2696 if (! RTX_FRAME_RELATED_P (insn))
2698 if (!ACCUMULATE_OUTGOING_ARGS)
2699 dwarf2out_stack_adjust (insn, after_p);
2703 label = dwarf2out_cfi_label (false);
2705 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2706 switch (REG_NOTE_KIND (note))
2708 case REG_FRAME_RELATED_EXPR:
2709 insn = XEXP (note, 0);
2712 case REG_CFA_DEF_CFA:
2713 dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2717 case REG_CFA_ADJUST_CFA:
2722 if (GET_CODE (n) == PARALLEL)
2723 n = XVECEXP (n, 0, 0);
2725 dwarf2out_frame_debug_adjust_cfa (n, label);
2729 case REG_CFA_OFFSET:
2732 n = single_set (insn);
2733 dwarf2out_frame_debug_cfa_offset (n, label);
2737 case REG_CFA_REGISTER:
2742 if (GET_CODE (n) == PARALLEL)
2743 n = XVECEXP (n, 0, 0);
2745 dwarf2out_frame_debug_cfa_register (n, label);
2749 case REG_CFA_RESTORE:
2754 if (GET_CODE (n) == PARALLEL)
2755 n = XVECEXP (n, 0, 0);
2758 dwarf2out_frame_debug_cfa_restore (n, label);
2768 insn = PATTERN (insn);
2770 dwarf2out_frame_debug_expr (insn, label);
2773 /* Determine if we need to save and restore CFI information around this
2774 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2775 we do need to save/restore, then emit the save now, and insert a
2776 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2779 dwarf2out_begin_epilogue (rtx insn)
2781 bool saw_frp = false;
2784 /* Scan forward to the return insn, noticing if there are possible
2785 frame related insns. */
2786 for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2791 /* Look for both regular and sibcalls to end the block. */
2792 if (returnjump_p (i))
2794 if (CALL_P (i) && SIBLING_CALL_P (i))
2797 if (GET_CODE (PATTERN (i)) == SEQUENCE)
2800 rtx seq = PATTERN (i);
2802 if (returnjump_p (XVECEXP (seq, 0, 0)))
2804 if (CALL_P (XVECEXP (seq, 0, 0))
2805 && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2808 for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2809 if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2813 if (RTX_FRAME_RELATED_P (i))
2817 /* If the port doesn't emit epilogue unwind info, we don't need a
2818 save/restore pair. */
2822 /* Otherwise, search forward to see if the return insn was the last
2823 basic block of the function. If so, we don't need save/restore. */
2824 gcc_assert (i != NULL);
2825 i = next_real_insn (i);
2829 /* Insert the restore before that next real insn in the stream, and before
2830 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2831 properly nested. This should be after any label or alignment. This
2832 will be pushed into the CFI stream by the function below. */
2835 rtx p = PREV_INSN (i);
2838 if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2842 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2844 emit_cfa_remember = true;
2846 /* And emulate the state save. */
2847 gcc_assert (!cfa_remember.in_use);
2849 cfa_remember.in_use = 1;
2852 /* A "subroutine" of dwarf2out_begin_epilogue. Emit the restore required. */
2855 dwarf2out_frame_debug_restore_state (void)
2857 dw_cfi_ref cfi = new_cfi ();
2858 const char *label = dwarf2out_cfi_label (false);
2860 cfi->dw_cfi_opc = DW_CFA_restore_state;
2861 add_fde_cfi (label, cfi);
2863 gcc_assert (cfa_remember.in_use);
2865 cfa_remember.in_use = 0;
2870 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2871 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2872 (enum dwarf_call_frame_info cfi);
2874 static enum dw_cfi_oprnd_type
2875 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2880 case DW_CFA_GNU_window_save:
2881 case DW_CFA_remember_state:
2882 case DW_CFA_restore_state:
2883 return dw_cfi_oprnd_unused;
2885 case DW_CFA_set_loc:
2886 case DW_CFA_advance_loc1:
2887 case DW_CFA_advance_loc2:
2888 case DW_CFA_advance_loc4:
2889 case DW_CFA_MIPS_advance_loc8:
2890 return dw_cfi_oprnd_addr;
2893 case DW_CFA_offset_extended:
2894 case DW_CFA_def_cfa:
2895 case DW_CFA_offset_extended_sf:
2896 case DW_CFA_def_cfa_sf:
2897 case DW_CFA_restore:
2898 case DW_CFA_restore_extended:
2899 case DW_CFA_undefined:
2900 case DW_CFA_same_value:
2901 case DW_CFA_def_cfa_register:
2902 case DW_CFA_register:
2903 return dw_cfi_oprnd_reg_num;
2905 case DW_CFA_def_cfa_offset:
2906 case DW_CFA_GNU_args_size:
2907 case DW_CFA_def_cfa_offset_sf:
2908 return dw_cfi_oprnd_offset;
2910 case DW_CFA_def_cfa_expression:
2911 case DW_CFA_expression:
2912 return dw_cfi_oprnd_loc;
2919 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2920 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2921 (enum dwarf_call_frame_info cfi);
2923 static enum dw_cfi_oprnd_type
2924 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2928 case DW_CFA_def_cfa:
2929 case DW_CFA_def_cfa_sf:
2931 case DW_CFA_offset_extended_sf:
2932 case DW_CFA_offset_extended:
2933 return dw_cfi_oprnd_offset;
2935 case DW_CFA_register:
2936 return dw_cfi_oprnd_reg_num;
2939 return dw_cfi_oprnd_unused;
2943 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2945 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
2946 switch to the data section instead, and write out a synthetic start label
2947 for collect2 the first time around. */
2950 switch_to_eh_frame_section (bool back)
2954 #ifdef EH_FRAME_SECTION_NAME
2955 if (eh_frame_section == 0)
2959 if (EH_TABLES_CAN_BE_READ_ONLY)
2965 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2967 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2969 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2971 flags = ((! flag_pic
2972 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2973 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2974 && (per_encoding & 0x70) != DW_EH_PE_absptr
2975 && (per_encoding & 0x70) != DW_EH_PE_aligned
2976 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2977 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2978 ? 0 : SECTION_WRITE);
2981 flags = SECTION_WRITE;
2982 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2986 if (eh_frame_section)
2987 switch_to_section (eh_frame_section);
2990 /* We have no special eh_frame section. Put the information in
2991 the data section and emit special labels to guide collect2. */
2992 switch_to_section (data_section);
2996 label = get_file_function_name ("F");
2997 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2998 targetm.asm_out.globalize_label (asm_out_file,
2999 IDENTIFIER_POINTER (label));
3000 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
3005 /* Switch [BACK] to the eh or debug frame table section, depending on
3009 switch_to_frame_table_section (int for_eh, bool back)
3012 switch_to_eh_frame_section (back);
3015 if (!debug_frame_section)
3016 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3017 SECTION_DEBUG, NULL);
3018 switch_to_section (debug_frame_section);
3022 /* Output a Call Frame Information opcode and its operand(s). */
3025 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3030 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3031 dw2_asm_output_data (1, (cfi->dw_cfi_opc
3032 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3033 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3034 ((unsigned HOST_WIDE_INT)
3035 cfi->dw_cfi_oprnd1.dw_cfi_offset));
3036 else if (cfi->dw_cfi_opc == DW_CFA_offset)
3038 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3039 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3040 "DW_CFA_offset, column 0x%lx", r);
3041 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3042 dw2_asm_output_data_uleb128 (off, NULL);
3044 else if (cfi->dw_cfi_opc == DW_CFA_restore)
3046 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3047 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3048 "DW_CFA_restore, column 0x%lx", r);
3052 dw2_asm_output_data (1, cfi->dw_cfi_opc,
3053 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3055 switch (cfi->dw_cfi_opc)
3057 case DW_CFA_set_loc:
3059 dw2_asm_output_encoded_addr_rtx (
3060 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3061 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3064 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3065 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3066 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3069 case DW_CFA_advance_loc1:
3070 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3071 fde->dw_fde_current_label, NULL);
3072 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3075 case DW_CFA_advance_loc2:
3076 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3077 fde->dw_fde_current_label, NULL);
3078 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3081 case DW_CFA_advance_loc4:
3082 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3083 fde->dw_fde_current_label, NULL);
3084 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3087 case DW_CFA_MIPS_advance_loc8:
3088 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3089 fde->dw_fde_current_label, NULL);
3090 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3093 case DW_CFA_offset_extended:
3094 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3095 dw2_asm_output_data_uleb128 (r, NULL);
3096 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3097 dw2_asm_output_data_uleb128 (off, NULL);
3100 case DW_CFA_def_cfa:
3101 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3102 dw2_asm_output_data_uleb128 (r, NULL);
3103 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3106 case DW_CFA_offset_extended_sf:
3107 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3108 dw2_asm_output_data_uleb128 (r, NULL);
3109 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3110 dw2_asm_output_data_sleb128 (off, NULL);
3113 case DW_CFA_def_cfa_sf:
3114 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3115 dw2_asm_output_data_uleb128 (r, NULL);
3116 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3117 dw2_asm_output_data_sleb128 (off, NULL);
3120 case DW_CFA_restore_extended:
3121 case DW_CFA_undefined:
3122 case DW_CFA_same_value:
3123 case DW_CFA_def_cfa_register:
3124 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3125 dw2_asm_output_data_uleb128 (r, NULL);
3128 case DW_CFA_register:
3129 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3130 dw2_asm_output_data_uleb128 (r, NULL);
3131 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3132 dw2_asm_output_data_uleb128 (r, NULL);
3135 case DW_CFA_def_cfa_offset:
3136 case DW_CFA_GNU_args_size:
3137 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3140 case DW_CFA_def_cfa_offset_sf:
3141 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3142 dw2_asm_output_data_sleb128 (off, NULL);
3145 case DW_CFA_GNU_window_save:
3148 case DW_CFA_def_cfa_expression:
3149 case DW_CFA_expression:
3150 output_cfa_loc (cfi);
3153 case DW_CFA_GNU_negative_offset_extended:
3154 /* Obsoleted by DW_CFA_offset_extended_sf. */
3163 /* Similar, but do it via assembler directives instead. */
3166 output_cfi_directive (dw_cfi_ref cfi)
3168 unsigned long r, r2;
3170 switch (cfi->dw_cfi_opc)
3172 case DW_CFA_advance_loc:
3173 case DW_CFA_advance_loc1:
3174 case DW_CFA_advance_loc2:
3175 case DW_CFA_advance_loc4:
3176 case DW_CFA_MIPS_advance_loc8:
3177 case DW_CFA_set_loc:
3178 /* Should only be created by add_fde_cfi in a code path not
3179 followed when emitting via directives. The assembler is
3180 going to take care of this for us. */
3184 case DW_CFA_offset_extended:
3185 case DW_CFA_offset_extended_sf:
3186 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3187 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3188 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3191 case DW_CFA_restore:
3192 case DW_CFA_restore_extended:
3193 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3194 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3197 case DW_CFA_undefined:
3198 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3199 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3202 case DW_CFA_same_value:
3203 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3204 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3207 case DW_CFA_def_cfa:
3208 case DW_CFA_def_cfa_sf:
3209 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3210 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3211 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3214 case DW_CFA_def_cfa_register:
3215 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3216 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3219 case DW_CFA_register:
3220 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3221 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3222 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3225 case DW_CFA_def_cfa_offset:
3226 case DW_CFA_def_cfa_offset_sf:
3227 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3228 HOST_WIDE_INT_PRINT_DEC"\n",
3229 cfi->dw_cfi_oprnd1.dw_cfi_offset);
3232 case DW_CFA_remember_state:
3233 fprintf (asm_out_file, "\t.cfi_remember_state\n");
3235 case DW_CFA_restore_state:
3236 fprintf (asm_out_file, "\t.cfi_restore_state\n");
3239 case DW_CFA_GNU_args_size:
3240 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size);
3241 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3243 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3244 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3245 fputc ('\n', asm_out_file);
3248 case DW_CFA_GNU_window_save:
3249 fprintf (asm_out_file, "\t.cfi_window_save\n");
3252 case DW_CFA_def_cfa_expression:
3253 case DW_CFA_expression:
3254 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", cfi->dw_cfi_opc);
3255 output_cfa_loc_raw (cfi);
3256 fputc ('\n', asm_out_file);
3264 DEF_VEC_P (dw_cfi_ref);
3265 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
3267 /* Output CFIs to bring current FDE to the same state as after executing
3268 CFIs in CFI chain. DO_CFI_ASM is true if .cfi_* directives shall
3269 be emitted, false otherwise. If it is false, FDE and FOR_EH are the
3270 other arguments to pass to output_cfi. */
3273 output_cfis (dw_cfi_ref cfi, bool do_cfi_asm, dw_fde_ref fde, bool for_eh)
3275 struct dw_cfi_struct cfi_buf;
3277 dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3278 VEC (dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3279 unsigned int len, idx;
3281 for (;; cfi = cfi->dw_cfi_next)
3282 switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3284 case DW_CFA_advance_loc:
3285 case DW_CFA_advance_loc1:
3286 case DW_CFA_advance_loc2:
3287 case DW_CFA_advance_loc4:
3288 case DW_CFA_MIPS_advance_loc8:
3289 case DW_CFA_set_loc:
3290 /* All advances should be ignored. */
3292 case DW_CFA_remember_state:
3294 dw_cfi_ref args_size = cfi_args_size;
3296 /* Skip everything between .cfi_remember_state and
3297 .cfi_restore_state. */
3298 for (cfi2 = cfi->dw_cfi_next; cfi2; cfi2 = cfi2->dw_cfi_next)
3299 if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3301 else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3304 gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3311 cfi_args_size = args_size;
3315 case DW_CFA_GNU_args_size:
3316 cfi_args_size = cfi;
3318 case DW_CFA_GNU_window_save:
3321 case DW_CFA_offset_extended:
3322 case DW_CFA_offset_extended_sf:
3323 case DW_CFA_restore:
3324 case DW_CFA_restore_extended:
3325 case DW_CFA_undefined:
3326 case DW_CFA_same_value:
3327 case DW_CFA_register:
3328 case DW_CFA_val_offset:
3329 case DW_CFA_val_offset_sf:
3330 case DW_CFA_expression:
3331 case DW_CFA_val_expression:
3332 case DW_CFA_GNU_negative_offset_extended:
3333 if (VEC_length (dw_cfi_ref, regs) <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3334 VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3335 cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3336 VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, cfi);
3338 case DW_CFA_def_cfa:
3339 case DW_CFA_def_cfa_sf:
3340 case DW_CFA_def_cfa_expression:
3342 cfi_cfa_offset = cfi;
3344 case DW_CFA_def_cfa_register:
3347 case DW_CFA_def_cfa_offset:
3348 case DW_CFA_def_cfa_offset_sf:
3349 cfi_cfa_offset = cfi;
3352 gcc_assert (cfi == NULL);
3354 len = VEC_length (dw_cfi_ref, regs);
3355 for (idx = 0; idx < len; idx++)
3357 cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3359 && cfi2->dw_cfi_opc != DW_CFA_restore
3360 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3363 output_cfi_directive (cfi2);
3365 output_cfi (cfi2, fde, for_eh);
3368 if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3370 gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3372 switch (cfi_cfa_offset->dw_cfi_opc)
3374 case DW_CFA_def_cfa_offset:
3375 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3376 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3378 case DW_CFA_def_cfa_offset_sf:
3379 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3380 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3382 case DW_CFA_def_cfa:
3383 case DW_CFA_def_cfa_sf:
3384 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3385 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3392 else if (cfi_cfa_offset)
3393 cfi_cfa = cfi_cfa_offset;
3397 output_cfi_directive (cfi_cfa);
3399 output_cfi (cfi_cfa, fde, for_eh);
3402 cfi_cfa_offset = NULL;
3404 && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3407 output_cfi_directive (cfi_args_size);
3409 output_cfi (cfi_args_size, fde, for_eh);
3411 cfi_args_size = NULL;
3414 VEC_free (dw_cfi_ref, heap, regs);
3417 else if (do_cfi_asm)
3418 output_cfi_directive (cfi);
3420 output_cfi (cfi, fde, for_eh);
3427 /* Output one FDE. */
3430 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3431 char *section_start_label, int fde_encoding, char *augmentation,
3432 bool any_lsda_needed, int lsda_encoding)
3434 const char *begin, *end;
3435 static unsigned int j;
3436 char l1[20], l2[20];
3439 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh,
3441 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3443 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3444 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3445 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3446 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3447 " indicating 64-bit DWARF extension");
3448 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3450 ASM_OUTPUT_LABEL (asm_out_file, l1);
3453 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3455 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3456 debug_frame_section, "FDE CIE offset");
3458 if (!fde->dw_fde_switched_sections)
3460 begin = fde->dw_fde_begin;
3461 end = fde->dw_fde_end;
3465 /* For the first section, prefer dw_fde_begin over
3466 dw_fde_{hot,cold}_section_label, as the latter
3467 might be separated from the real start of the
3468 function by alignment padding. */
3470 begin = fde->dw_fde_begin;
3471 else if (fde->dw_fde_switched_cold_to_hot)
3472 begin = fde->dw_fde_hot_section_label;
3474 begin = fde->dw_fde_unlikely_section_label;
3475 if (second ^ fde->dw_fde_switched_cold_to_hot)
3476 end = fde->dw_fde_unlikely_section_end_label;
3478 end = fde->dw_fde_hot_section_end_label;
3483 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
3484 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3485 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
3486 "FDE initial location");
3487 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3488 end, begin, "FDE address range");
3492 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
3493 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
3496 if (augmentation[0])
3498 if (any_lsda_needed)
3500 int size = size_of_encoded_value (lsda_encoding);
3502 if (lsda_encoding == DW_EH_PE_aligned)
3504 int offset = ( 4 /* Length */
3505 + 4 /* CIE offset */
3506 + 2 * size_of_encoded_value (fde_encoding)
3507 + 1 /* Augmentation size */ );
3508 int pad = -offset & (PTR_SIZE - 1);
3511 gcc_assert (size_of_uleb128 (size) == 1);
3514 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3516 if (fde->uses_eh_lsda)
3518 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
3519 fde->funcdef_number);
3520 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
3521 gen_rtx_SYMBOL_REF (Pmode, l1),
3523 "Language Specific Data Area");
3527 if (lsda_encoding == DW_EH_PE_aligned)
3528 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3529 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
3530 "Language Specific Data Area (none)");
3534 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3537 /* Loop through the Call Frame Instructions associated with
3539 fde->dw_fde_current_label = begin;
3540 if (!fde->dw_fde_switched_sections)
3541 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3542 output_cfi (cfi, fde, for_eh);
3545 if (fde->dw_fde_switch_cfi)
3546 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3548 output_cfi (cfi, fde, for_eh);
3549 if (cfi == fde->dw_fde_switch_cfi)
3555 dw_cfi_ref cfi_next = fde->dw_fde_cfi;
3557 if (fde->dw_fde_switch_cfi)
3559 cfi_next = fde->dw_fde_switch_cfi->dw_cfi_next;
3560 fde->dw_fde_switch_cfi->dw_cfi_next = NULL;
3561 output_cfis (fde->dw_fde_cfi, false, fde, for_eh);
3562 fde->dw_fde_switch_cfi->dw_cfi_next = cfi_next;
3564 for (cfi = cfi_next; cfi != NULL; cfi = cfi->dw_cfi_next)
3565 output_cfi (cfi, fde, for_eh);
3568 /* If we are to emit a ref/link from function bodies to their frame tables,
3569 do it now. This is typically performed to make sure that tables
3570 associated with functions are dragged with them and not discarded in
3571 garbage collecting links. We need to do this on a per function basis to
3572 cope with -ffunction-sections. */
3574 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3575 /* Switch to the function section, emit the ref to the tables, and
3576 switch *back* into the table section. */
3577 switch_to_section (function_section (fde->decl));
3578 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
3579 switch_to_frame_table_section (for_eh, true);
3582 /* Pad the FDE out to an address sized boundary. */
3583 ASM_OUTPUT_ALIGN (asm_out_file,
3584 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3585 ASM_OUTPUT_LABEL (asm_out_file, l2);
3590 /* Output the call frame information used to record information
3591 that relates to calculating the frame pointer, and records the
3592 location of saved registers. */
3595 output_call_frame_info (int for_eh)
3600 char l1[20], l2[20], section_start_label[20];
3601 bool any_lsda_needed = false;
3602 char augmentation[6];
3603 int augmentation_size;
3604 int fde_encoding = DW_EH_PE_absptr;
3605 int per_encoding = DW_EH_PE_absptr;
3606 int lsda_encoding = DW_EH_PE_absptr;
3608 rtx personality = NULL;
3611 /* Don't emit a CIE if there won't be any FDEs. */
3612 if (fde_table_in_use == 0)
3615 /* Nothing to do if the assembler's doing it all. */
3616 if (dwarf2out_do_cfi_asm ())
3619 /* If we make FDEs linkonce, we may have to emit an empty label for
3620 an FDE that wouldn't otherwise be emitted. We want to avoid
3621 having an FDE kept around when the function it refers to is
3622 discarded. Example where this matters: a primary function
3623 template in C++ requires EH information, but an explicit
3624 specialization doesn't. */
3625 if (TARGET_USES_WEAK_UNWIND_INFO
3626 && ! flag_asynchronous_unwind_tables
3629 for (i = 0; i < fde_table_in_use; i++)
3630 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
3631 && !fde_table[i].uses_eh_lsda
3632 && ! DECL_WEAK (fde_table[i].decl))
3633 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
3634 for_eh, /* empty */ 1);
3636 /* If we don't have any functions we'll want to unwind out of, don't
3637 emit any EH unwind information. Note that if exceptions aren't
3638 enabled, we won't have collected nothrow information, and if we
3639 asked for asynchronous tables, we always want this info. */
3642 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
3644 for (i = 0; i < fde_table_in_use; i++)
3645 if (fde_table[i].uses_eh_lsda)
3646 any_eh_needed = any_lsda_needed = true;
3647 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3648 any_eh_needed = true;
3649 else if (! fde_table[i].nothrow
3650 && ! fde_table[i].all_throwers_are_sibcalls)
3651 any_eh_needed = true;
3653 if (! any_eh_needed)
3657 /* We're going to be generating comments, so turn on app. */
3661 /* Switch to the proper frame section, first time. */
3662 switch_to_frame_table_section (for_eh, false);
3664 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3665 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3667 /* Output the CIE. */
3668 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3669 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3670 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3671 dw2_asm_output_data (4, 0xffffffff,
3672 "Initial length escape value indicating 64-bit DWARF extension");
3673 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3674 "Length of Common Information Entry");
3675 ASM_OUTPUT_LABEL (asm_out_file, l1);
3677 /* Now that the CIE pointer is PC-relative for EH,
3678 use 0 to identify the CIE. */
3679 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3680 (for_eh ? 0 : DWARF_CIE_ID),
3681 "CIE Identifier Tag");
3683 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3684 use CIE version 1, unless that would produce incorrect results
3685 due to overflowing the return register column. */
3686 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3688 if (return_reg >= 256 || dwarf_version > 2)
3690 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
3692 augmentation[0] = 0;
3693 augmentation_size = 0;
3695 personality = current_unit_personality;
3701 z Indicates that a uleb128 is present to size the
3702 augmentation section.
3703 L Indicates the encoding (and thus presence) of
3704 an LSDA pointer in the FDE augmentation.
3705 R Indicates a non-default pointer encoding for
3707 P Indicates the presence of an encoding + language
3708 personality routine in the CIE augmentation. */
3710 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3711 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3712 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3714 p = augmentation + 1;
3718 augmentation_size += 1 + size_of_encoded_value (per_encoding);
3719 assemble_external_libcall (personality);
3721 if (any_lsda_needed)
3724 augmentation_size += 1;
3726 if (fde_encoding != DW_EH_PE_absptr)
3729 augmentation_size += 1;
3731 if (p > augmentation + 1)
3733 augmentation[0] = 'z';
3737 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3738 if (personality && per_encoding == DW_EH_PE_aligned)
3740 int offset = ( 4 /* Length */
3742 + 1 /* CIE version */
3743 + strlen (augmentation) + 1 /* Augmentation */
3744 + size_of_uleb128 (1) /* Code alignment */
3745 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3747 + 1 /* Augmentation size */
3748 + 1 /* Personality encoding */ );
3749 int pad = -offset & (PTR_SIZE - 1);
3751 augmentation_size += pad;
3753 /* Augmentations should be small, so there's scarce need to
3754 iterate for a solution. Die if we exceed one uleb128 byte. */
3755 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3759 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3760 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3761 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3762 "CIE Data Alignment Factor");
3764 if (dw_cie_version == 1)
3765 dw2_asm_output_data (1, return_reg, "CIE RA Column");
3767 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3769 if (augmentation[0])
3771 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3774 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3775 eh_data_format_name (per_encoding));
3776 dw2_asm_output_encoded_addr_rtx (per_encoding,
3781 if (any_lsda_needed)
3782 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3783 eh_data_format_name (lsda_encoding));
3785 if (fde_encoding != DW_EH_PE_absptr)
3786 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3787 eh_data_format_name (fde_encoding));
3790 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3791 output_cfi (cfi, NULL, for_eh);
3793 /* Pad the CIE out to an address sized boundary. */
3794 ASM_OUTPUT_ALIGN (asm_out_file,
3795 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3796 ASM_OUTPUT_LABEL (asm_out_file, l2);
3798 /* Loop through all of the FDE's. */
3799 for (i = 0; i < fde_table_in_use; i++)
3802 fde = &fde_table[i];
3804 /* Don't emit EH unwind info for leaf functions that don't need it. */
3805 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3806 && (fde->nothrow || fde->all_throwers_are_sibcalls)
3807 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3808 && !fde->uses_eh_lsda)
3811 for (k = 0; k < (fde->dw_fde_switched_sections ? 2 : 1); k++)
3812 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
3813 augmentation, any_lsda_needed, lsda_encoding);
3816 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3817 dw2_asm_output_data (4, 0, "End of Table");
3818 #ifdef MIPS_DEBUGGING_INFO
3819 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3820 get a value of 0. Putting .align 0 after the label fixes it. */
3821 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3824 /* Turn off app to make assembly quicker. */
3829 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
3832 dwarf2out_do_cfi_startproc (bool second)
3836 rtx personality = get_personality_function (current_function_decl);
3838 fprintf (asm_out_file, "\t.cfi_startproc\n");
3842 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3845 /* ??? The GAS support isn't entirely consistent. We have to
3846 handle indirect support ourselves, but PC-relative is done
3847 in the assembler. Further, the assembler can't handle any
3848 of the weirder relocation types. */
3849 if (enc & DW_EH_PE_indirect)
3850 ref = dw2_force_const_mem (ref, true);
3852 fprintf (asm_out_file, "\t.cfi_personality 0x%x,", enc);
3853 output_addr_const (asm_out_file, ref);
3854 fputc ('\n', asm_out_file);
3857 if (crtl->uses_eh_lsda)
3861 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3862 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
3863 current_function_funcdef_no);
3864 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3865 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3867 if (enc & DW_EH_PE_indirect)
3868 ref = dw2_force_const_mem (ref, true);
3870 fprintf (asm_out_file, "\t.cfi_lsda 0x%x,", enc);
3871 output_addr_const (asm_out_file, ref);
3872 fputc ('\n', asm_out_file);
3876 /* Output a marker (i.e. a label) for the beginning of a function, before
3880 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3881 const char *file ATTRIBUTE_UNUSED)
3883 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3888 current_function_func_begin_label = NULL;
3890 #ifdef TARGET_UNWIND_INFO
3891 /* ??? current_function_func_begin_label is also used by except.c
3892 for call-site information. We must emit this label if it might
3894 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3895 && ! dwarf2out_do_frame ())
3898 if (! dwarf2out_do_frame ())
3902 fnsec = function_section (current_function_decl);
3903 switch_to_section (fnsec);
3904 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3905 current_function_funcdef_no);
3906 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3907 current_function_funcdef_no);
3908 dup_label = xstrdup (label);
3909 current_function_func_begin_label = dup_label;
3911 #ifdef TARGET_UNWIND_INFO
3912 /* We can elide the fde allocation if we're not emitting debug info. */
3913 if (! dwarf2out_do_frame ())
3917 /* Expand the fde table if necessary. */
3918 if (fde_table_in_use == fde_table_allocated)
3920 fde_table_allocated += FDE_TABLE_INCREMENT;
3921 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3922 memset (fde_table + fde_table_in_use, 0,
3923 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3926 /* Record the FDE associated with this function. */
3927 current_funcdef_fde = fde_table_in_use;
3929 /* Add the new FDE at the end of the fde_table. */
3930 fde = &fde_table[fde_table_in_use++];
3931 fde->decl = current_function_decl;
3932 fde->dw_fde_begin = dup_label;
3933 fde->dw_fde_current_label = dup_label;
3934 fde->dw_fde_hot_section_label = NULL;
3935 fde->dw_fde_hot_section_end_label = NULL;
3936 fde->dw_fde_unlikely_section_label = NULL;
3937 fde->dw_fde_unlikely_section_end_label = NULL;
3938 fde->dw_fde_switched_sections = 0;
3939 fde->dw_fde_switched_cold_to_hot = 0;
3940 fde->dw_fde_end = NULL;
3941 fde->dw_fde_cfi = NULL;
3942 fde->dw_fde_switch_cfi = NULL;
3943 fde->funcdef_number = current_function_funcdef_no;
3944 fde->nothrow = crtl->nothrow;
3945 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3946 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3947 fde->drap_reg = INVALID_REGNUM;
3948 fde->vdrap_reg = INVALID_REGNUM;
3949 if (flag_reorder_blocks_and_partition)
3951 section *unlikelysec;
3952 if (first_function_block_is_cold)
3953 fde->in_std_section = 1;
3956 = (fnsec == text_section
3957 || (cold_text_section && fnsec == cold_text_section));
3958 unlikelysec = unlikely_text_section ();
3959 fde->cold_in_std_section
3960 = (unlikelysec == text_section
3961 || (cold_text_section && unlikelysec == cold_text_section));
3966 = (fnsec == text_section
3967 || (cold_text_section && fnsec == cold_text_section));
3968 fde->cold_in_std_section = 0;
3971 args_size = old_args_size = 0;
3973 /* We only want to output line number information for the genuine dwarf2
3974 prologue case, not the eh frame case. */
3975 #ifdef DWARF2_DEBUGGING_INFO
3977 dwarf2out_source_line (line, file, 0, true);
3980 if (dwarf2out_do_cfi_asm ())
3981 dwarf2out_do_cfi_startproc (false);
3984 rtx personality = get_personality_function (current_function_decl);
3985 if (!current_unit_personality)
3986 current_unit_personality = personality;
3988 /* We cannot keep a current personality per function as without CFI
3989 asm at the point where we emit the CFI data there is no current
3990 function anymore. */
3992 && current_unit_personality != personality)
3993 sorry ("Multiple EH personalities are supported only with assemblers "
3994 "supporting .cfi.personality directive.");
3998 /* Output a marker (i.e. a label) for the absolute end of the generated code
3999 for a function definition. This gets called *after* the epilogue code has
4003 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4004 const char *file ATTRIBUTE_UNUSED)
4007 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4009 #ifdef DWARF2_DEBUGGING_INFO
4010 last_var_location_insn = NULL_RTX;
4013 if (dwarf2out_do_cfi_asm ())
4014 fprintf (asm_out_file, "\t.cfi_endproc\n");
4016 /* Output a label to mark the endpoint of the code generated for this
4018 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
4019 current_function_funcdef_no);
4020 ASM_OUTPUT_LABEL (asm_out_file, label);
4021 fde = current_fde ();
4022 gcc_assert (fde != NULL);
4023 fde->dw_fde_end = xstrdup (label);
4027 dwarf2out_frame_init (void)
4029 /* Allocate the initial hunk of the fde_table. */
4030 fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
4031 fde_table_allocated = FDE_TABLE_INCREMENT;
4032 fde_table_in_use = 0;
4034 /* Generate the CFA instructions common to all FDE's. Do it now for the
4035 sake of lookup_cfa. */
4037 /* On entry, the Canonical Frame Address is at SP. */
4038 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
4040 #ifdef DWARF2_UNWIND_INFO
4041 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
4042 initial_return_save (INCOMING_RETURN_ADDR_RTX);
4047 dwarf2out_frame_finish (void)
4049 /* Output call frame information. */
4050 if (DWARF2_FRAME_INFO)
4051 output_call_frame_info (0);
4053 #ifndef TARGET_UNWIND_INFO
4054 /* Output another copy for the unwinder. */
4055 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
4056 output_call_frame_info (1);
4060 /* Note that the current function section is being used for code. */
4063 dwarf2out_note_section_used (void)
4065 section *sec = current_function_section ();
4066 if (sec == text_section)
4067 text_section_used = true;
4068 else if (sec == cold_text_section)
4069 cold_text_section_used = true;
4073 dwarf2out_switch_text_section (void)
4075 dw_fde_ref fde = current_fde ();
4077 gcc_assert (cfun && fde && !fde->dw_fde_switched_sections);
4079 fde->dw_fde_switched_sections = 1;
4080 fde->dw_fde_switched_cold_to_hot = !in_cold_section_p;
4082 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
4083 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
4084 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
4085 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
4086 have_multiple_function_sections = true;
4088 /* Reset the current label on switching text sections, so that we
4089 don't attempt to advance_loc4 between labels in different sections. */
4090 fde->dw_fde_current_label = NULL;
4092 /* There is no need to mark used sections when not debugging. */
4093 if (cold_text_section != NULL)
4094 dwarf2out_note_section_used ();
4096 if (dwarf2out_do_cfi_asm ())
4097 fprintf (asm_out_file, "\t.cfi_endproc\n");
4099 /* Now do the real section switch. */
4100 switch_to_section (current_function_section ());
4102 if (dwarf2out_do_cfi_asm ())
4104 dwarf2out_do_cfi_startproc (true);
4105 /* As this is a different FDE, insert all current CFI instructions
4107 output_cfis (fde->dw_fde_cfi, true, fde, true);
4111 dw_cfi_ref cfi = fde->dw_fde_cfi;
4113 cfi = fde->dw_fde_cfi;
4115 while (cfi->dw_cfi_next != NULL)
4116 cfi = cfi->dw_cfi_next;
4117 fde->dw_fde_switch_cfi = cfi;
4122 /* And now, the subset of the debugging information support code necessary
4123 for emitting location expressions. */
4125 /* Data about a single source file. */
4126 struct GTY(()) dwarf_file_data {
4127 const char * filename;
4131 typedef struct dw_val_struct *dw_val_ref;
4132 typedef struct die_struct *dw_die_ref;
4133 typedef const struct die_struct *const_dw_die_ref;
4134 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
4135 typedef struct dw_loc_list_struct *dw_loc_list_ref;
4137 typedef struct GTY(()) deferred_locations_struct
4141 } deferred_locations;
4143 DEF_VEC_O(deferred_locations);
4144 DEF_VEC_ALLOC_O(deferred_locations,gc);
4146 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
4148 /* Each DIE may have a series of attribute/value pairs. Values
4149 can take on several forms. The forms that are used in this
4150 implementation are listed below. */
4155 dw_val_class_offset,
4157 dw_val_class_loc_list,
4158 dw_val_class_range_list,
4160 dw_val_class_unsigned_const,
4161 dw_val_class_long_long,
4164 dw_val_class_die_ref,
4165 dw_val_class_fde_ref,
4166 dw_val_class_lbl_id,
4167 dw_val_class_lineptr,
4169 dw_val_class_macptr,
4173 /* Describe a floating point constant value, or a vector constant value. */
4175 typedef struct GTY(()) dw_vec_struct {
4176 unsigned char * GTY((length ("%h.length"))) array;
4182 /* The dw_val_node describes an attribute's value, as it is
4183 represented internally. */
4185 typedef struct GTY(()) dw_val_struct {
4186 enum dw_val_class val_class;
4187 union dw_val_struct_union
4189 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
4190 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
4191 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
4192 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
4193 HOST_WIDE_INT GTY ((default)) val_int;
4194 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
4195 rtx GTY ((tag ("dw_val_class_long_long"))) val_long_long;
4196 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
4197 struct dw_val_die_union
4201 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
4202 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
4203 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
4204 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
4205 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
4206 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
4208 GTY ((desc ("%1.val_class"))) v;
4212 /* Locations in memory are described using a sequence of stack machine
4215 typedef struct GTY(()) dw_loc_descr_struct {
4216 dw_loc_descr_ref dw_loc_next;
4217 ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
4218 /* Used to distinguish DW_OP_addr with a direct symbol relocation
4219 from DW_OP_addr with a dtp-relative symbol relocation. */
4220 unsigned int dtprel : 1;
4222 dw_val_node dw_loc_oprnd1;
4223 dw_val_node dw_loc_oprnd2;
4227 /* Location lists are ranges + location descriptions for that range,
4228 so you can track variables that are in different places over
4229 their entire life. */
4230 typedef struct GTY(()) dw_loc_list_struct {
4231 dw_loc_list_ref dw_loc_next;
4232 const char *begin; /* Label for begin address of range */
4233 const char *end; /* Label for end address of range */
4234 char *ll_symbol; /* Label for beginning of location list.
4235 Only on head of list */
4236 const char *section; /* Section this loclist is relative to */
4237 dw_loc_descr_ref expr;
4240 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
4242 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4244 /* Convert a DWARF stack opcode into its string name. */
4247 dwarf_stack_op_name (unsigned int op)
4252 return "DW_OP_addr";
4254 return "DW_OP_deref";
4256 return "DW_OP_const1u";
4258 return "DW_OP_const1s";
4260 return "DW_OP_const2u";
4262 return "DW_OP_const2s";
4264 return "DW_OP_const4u";
4266 return "DW_OP_const4s";
4268 return "DW_OP_const8u";
4270 return "DW_OP_const8s";
4272 return "DW_OP_constu";
4274 return "DW_OP_consts";
4278 return "DW_OP_drop";
4280 return "DW_OP_over";
4282 return "DW_OP_pick";
4284 return "DW_OP_swap";
4288 return "DW_OP_xderef";
4296 return "DW_OP_minus";
4308 return "DW_OP_plus";
4309 case DW_OP_plus_uconst:
4310 return "DW_OP_plus_uconst";
4316 return "DW_OP_shra";
4334 return "DW_OP_skip";
4336 return "DW_OP_lit0";
4338 return "DW_OP_lit1";
4340 return "DW_OP_lit2";
4342 return "DW_OP_lit3";
4344 return "DW_OP_lit4";
4346 return "DW_OP_lit5";
4348 return "DW_OP_lit6";
4350 return "DW_OP_lit7";
4352 return "DW_OP_lit8";
4354 return "DW_OP_lit9";
4356 return "DW_OP_lit10";
4358 return "DW_OP_lit11";
4360 return "DW_OP_lit12";
4362 return "DW_OP_lit13";
4364 return "DW_OP_lit14";
4366 return "DW_OP_lit15";
4368 return "DW_OP_lit16";
4370 return "DW_OP_lit17";
4372 return "DW_OP_lit18";
4374 return "DW_OP_lit19";
4376 return "DW_OP_lit20";
4378 return "DW_OP_lit21";
4380 return "DW_OP_lit22";
4382 return "DW_OP_lit23";
4384 return "DW_OP_lit24";
4386 return "DW_OP_lit25";
4388 return "DW_OP_lit26";
4390 return "DW_OP_lit27";
4392 return "DW_OP_lit28";
4394 return "DW_OP_lit29";
4396 return "DW_OP_lit30";
4398 return "DW_OP_lit31";
4400 return "DW_OP_reg0";
4402 return "DW_OP_reg1";
4404 return "DW_OP_reg2";
4406 return "DW_OP_reg3";
4408 return "DW_OP_reg4";
4410 return "DW_OP_reg5";
4412 return "DW_OP_reg6";
4414 return "DW_OP_reg7";
4416 return "DW_OP_reg8";
4418 return "DW_OP_reg9";
4420 return "DW_OP_reg10";
4422 return "DW_OP_reg11";
4424 return "DW_OP_reg12";
4426 return "DW_OP_reg13";
4428 return "DW_OP_reg14";
4430 return "DW_OP_reg15";
4432 return "DW_OP_reg16";
4434 return "DW_OP_reg17";
4436 return "DW_OP_reg18";
4438 return "DW_OP_reg19";
4440 return "DW_OP_reg20";
4442 return "DW_OP_reg21";
4444 return "DW_OP_reg22";
4446 return "DW_OP_reg23";
4448 return "DW_OP_reg24";
4450 return "DW_OP_reg25";
4452 return "DW_OP_reg26";
4454 return "DW_OP_reg27";
4456 return "DW_OP_reg28";
4458 return "DW_OP_reg29";
4460 return "DW_OP_reg30";
4462 return "DW_OP_reg31";
4464 return "DW_OP_breg0";
4466 return "DW_OP_breg1";
4468 return "DW_OP_breg2";
4470 return "DW_OP_breg3";
4472 return "DW_OP_breg4";
4474 return "DW_OP_breg5";
4476 return "DW_OP_breg6";
4478 return "DW_OP_breg7";
4480 return "DW_OP_breg8";
4482 return "DW_OP_breg9";
4484 return "DW_OP_breg10";
4486 return "DW_OP_breg11";
4488 return "DW_OP_breg12";
4490 return "DW_OP_breg13";
4492 return "DW_OP_breg14";
4494 return "DW_OP_breg15";
4496 return "DW_OP_breg16";
4498 return "DW_OP_breg17";
4500 return "DW_OP_breg18";
4502 return "DW_OP_breg19";
4504 return "DW_OP_breg20";
4506 return "DW_OP_breg21";
4508 return "DW_OP_breg22";
4510 return "DW_OP_breg23";
4512 return "DW_OP_breg24";
4514 return "DW_OP_breg25";
4516 return "DW_OP_breg26";
4518 return "DW_OP_breg27";
4520 return "DW_OP_breg28";
4522 return "DW_OP_breg29";
4524 return "DW_OP_breg30";
4526 return "DW_OP_breg31";
4528 return "DW_OP_regx";
4530 return "DW_OP_fbreg";
4532 return "DW_OP_bregx";
4534 return "DW_OP_piece";
4535 case DW_OP_deref_size:
4536 return "DW_OP_deref_size";
4537 case DW_OP_xderef_size:
4538 return "DW_OP_xderef_size";
4542 case DW_OP_push_object_address:
4543 return "DW_OP_push_object_address";
4545 return "DW_OP_call2";
4547 return "DW_OP_call4";
4548 case DW_OP_call_ref:
4549 return "DW_OP_call_ref";
4550 case DW_OP_implicit_value:
4551 return "DW_OP_implicit_value";
4552 case DW_OP_stack_value:
4553 return "DW_OP_stack_value";
4554 case DW_OP_form_tls_address:
4555 return "DW_OP_form_tls_address";
4556 case DW_OP_call_frame_cfa:
4557 return "DW_OP_call_frame_cfa";
4558 case DW_OP_bit_piece:
4559 return "DW_OP_bit_piece";
4561 case DW_OP_GNU_push_tls_address:
4562 return "DW_OP_GNU_push_tls_address";
4563 case DW_OP_GNU_uninit:
4564 return "DW_OP_GNU_uninit";
4565 case DW_OP_GNU_encoded_addr:
4566 return "DW_OP_GNU_encoded_addr";
4569 return "OP_<unknown>";
4573 /* Return a pointer to a newly allocated location description. Location
4574 descriptions are simple expression terms that can be strung
4575 together to form more complicated location (address) descriptions. */
4577 static inline dw_loc_descr_ref
4578 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
4579 unsigned HOST_WIDE_INT oprnd2)
4581 dw_loc_descr_ref descr = GGC_CNEW (dw_loc_descr_node);
4583 descr->dw_loc_opc = op;
4584 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4585 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4586 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4587 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4592 /* Return a pointer to a newly allocated location description for
4595 static inline dw_loc_descr_ref
4596 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
4599 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
4602 return new_loc_descr (DW_OP_bregx, reg, offset);
4605 /* Add a location description term to a location description expression. */
4608 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
4610 dw_loc_descr_ref *d;
4612 /* Find the end of the chain. */
4613 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4619 /* Add a constant OFFSET to a location expression. */
4622 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
4624 dw_loc_descr_ref loc;
4627 gcc_assert (*list_head != NULL);
4632 /* Find the end of the chain. */
4633 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
4637 if (loc->dw_loc_opc == DW_OP_fbreg
4638 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
4639 p = &loc->dw_loc_oprnd1.v.val_int;
4640 else if (loc->dw_loc_opc == DW_OP_bregx)
4641 p = &loc->dw_loc_oprnd2.v.val_int;
4643 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4644 offset. Don't optimize if an signed integer overflow would happen. */
4646 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
4647 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
4650 else if (offset > 0)
4651 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4655 loc->dw_loc_next = int_loc_descriptor (offset);
4656 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_plus, 0, 0));
4660 /* Add a constant OFFSET to a location list. */
4663 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
4666 for (d = list_head; d != NULL; d = d->dw_loc_next)
4667 loc_descr_plus_const (&d->expr, offset);
4670 /* Return the size of a location descriptor. */
4672 static unsigned long
4673 size_of_loc_descr (dw_loc_descr_ref loc)
4675 unsigned long size = 1;
4677 switch (loc->dw_loc_opc)
4680 size += DWARF2_ADDR_SIZE;
4699 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4702 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4707 case DW_OP_plus_uconst:
4708 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4746 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4749 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4752 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4755 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4756 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4759 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4761 case DW_OP_deref_size:
4762 case DW_OP_xderef_size:
4771 case DW_OP_call_ref:
4772 size += DWARF2_ADDR_SIZE;
4774 case DW_OP_implicit_value:
4775 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
4776 + loc->dw_loc_oprnd1.v.val_unsigned;
4785 /* Return the size of a series of location descriptors. */
4787 static unsigned long
4788 size_of_locs (dw_loc_descr_ref loc)
4793 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4794 field, to avoid writing to a PCH file. */
4795 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4797 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4799 size += size_of_loc_descr (l);
4804 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4806 l->dw_loc_addr = size;
4807 size += size_of_loc_descr (l);
4813 #ifdef DWARF2_DEBUGGING_INFO
4814 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4817 /* Output location description stack opcode's operands (if any). */
4820 output_loc_operands (dw_loc_descr_ref loc)
4822 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4823 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4825 switch (loc->dw_loc_opc)
4827 #ifdef DWARF2_DEBUGGING_INFO
4830 dw2_asm_output_data (2, val1->v.val_int, NULL);
4834 dw2_asm_output_data (4, val1->v.val_int, NULL);
4838 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
4839 dw2_asm_output_data (8, val1->v.val_int, NULL);
4846 gcc_assert (val1->val_class == dw_val_class_loc);
4847 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4849 dw2_asm_output_data (2, offset, NULL);
4852 case DW_OP_implicit_value:
4853 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4854 switch (val2->val_class)
4856 case dw_val_class_const:
4857 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
4859 case dw_val_class_vec:
4861 unsigned int elt_size = val2->v.val_vec.elt_size;
4862 unsigned int len = val2->v.val_vec.length;
4866 if (elt_size > sizeof (HOST_WIDE_INT))
4871 for (i = 0, p = val2->v.val_vec.array;
4874 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
4875 "fp or vector constant word %u", i);
4878 case dw_val_class_long_long:
4880 unsigned HOST_WIDE_INT first, second;
4882 if (WORDS_BIG_ENDIAN)
4884 first = CONST_DOUBLE_HIGH (val2->v.val_long_long);
4885 second = CONST_DOUBLE_LOW (val2->v.val_long_long);
4889 first = CONST_DOUBLE_LOW (val2->v.val_long_long);
4890 second = CONST_DOUBLE_HIGH (val2->v.val_long_long);
4892 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
4893 first, "long long constant");
4894 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
4898 case dw_val_class_addr:
4899 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
4900 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
4915 case DW_OP_implicit_value:
4916 /* We currently don't make any attempt to make sure these are
4917 aligned properly like we do for the main unwind info, so
4918 don't support emitting things larger than a byte if we're
4919 only doing unwinding. */
4924 dw2_asm_output_data (1, val1->v.val_int, NULL);
4927 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4930 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4933 dw2_asm_output_data (1, val1->v.val_int, NULL);
4935 case DW_OP_plus_uconst:
4936 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4970 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4973 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4976 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4979 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4980 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
4983 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4985 case DW_OP_deref_size:
4986 case DW_OP_xderef_size:
4987 dw2_asm_output_data (1, val1->v.val_int, NULL);
4993 if (targetm.asm_out.output_dwarf_dtprel)
4995 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
4998 fputc ('\n', asm_out_file);
5005 #ifdef DWARF2_DEBUGGING_INFO
5006 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
5014 /* Other codes have no operands. */
5019 /* Output a sequence of location operations. */
5022 output_loc_sequence (dw_loc_descr_ref loc)
5024 for (; loc != NULL; loc = loc->dw_loc_next)
5026 /* Output the opcode. */
5027 dw2_asm_output_data (1, loc->dw_loc_opc,
5028 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
5030 /* Output the operand(s) (if any). */
5031 output_loc_operands (loc);
5035 /* Output location description stack opcode's operands (if any).
5036 The output is single bytes on a line, suitable for .cfi_escape. */
5039 output_loc_operands_raw (dw_loc_descr_ref loc)
5041 dw_val_ref val1 = &loc->dw_loc_oprnd1;
5042 dw_val_ref val2 = &loc->dw_loc_oprnd2;
5044 switch (loc->dw_loc_opc)
5047 case DW_OP_implicit_value:
5048 /* We cannot output addresses in .cfi_escape, only bytes. */
5054 case DW_OP_deref_size:
5055 case DW_OP_xderef_size:
5056 fputc (',', asm_out_file);
5057 dw2_asm_output_data_raw (1, val1->v.val_int);
5062 fputc (',', asm_out_file);
5063 dw2_asm_output_data_raw (2, val1->v.val_int);
5068 fputc (',', asm_out_file);
5069 dw2_asm_output_data_raw (4, val1->v.val_int);
5074 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5075 fputc (',', asm_out_file);
5076 dw2_asm_output_data_raw (8, val1->v.val_int);
5084 gcc_assert (val1->val_class == dw_val_class_loc);
5085 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5087 fputc (',', asm_out_file);
5088 dw2_asm_output_data_raw (2, offset);
5093 case DW_OP_plus_uconst:
5096 fputc (',', asm_out_file);
5097 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5134 fputc (',', asm_out_file);
5135 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
5139 fputc (',', asm_out_file);
5140 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5141 fputc (',', asm_out_file);
5142 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
5146 /* Other codes have no operands. */
5152 output_loc_sequence_raw (dw_loc_descr_ref loc)
5156 /* Output the opcode. */
5157 fprintf (asm_out_file, "0x%x", loc->dw_loc_opc);
5158 output_loc_operands_raw (loc);
5160 if (!loc->dw_loc_next)
5162 loc = loc->dw_loc_next;
5164 fputc (',', asm_out_file);
5168 /* This routine will generate the correct assembly data for a location
5169 description based on a cfi entry with a complex address. */
5172 output_cfa_loc (dw_cfi_ref cfi)
5174 dw_loc_descr_ref loc;
5177 if (cfi->dw_cfi_opc == DW_CFA_expression)
5178 dw2_asm_output_data (1, cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL);
5180 /* Output the size of the block. */
5181 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5182 size = size_of_locs (loc);
5183 dw2_asm_output_data_uleb128 (size, NULL);
5185 /* Now output the operations themselves. */
5186 output_loc_sequence (loc);
5189 /* Similar, but used for .cfi_escape. */
5192 output_cfa_loc_raw (dw_cfi_ref cfi)
5194 dw_loc_descr_ref loc;
5197 if (cfi->dw_cfi_opc == DW_CFA_expression)
5198 fprintf (asm_out_file, "0x%x,", cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
5200 /* Output the size of the block. */
5201 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5202 size = size_of_locs (loc);
5203 dw2_asm_output_data_uleb128_raw (size);
5204 fputc (',', asm_out_file);
5206 /* Now output the operations themselves. */
5207 output_loc_sequence_raw (loc);
5210 /* This function builds a dwarf location descriptor sequence from a
5211 dw_cfa_location, adding the given OFFSET to the result of the
5214 static struct dw_loc_descr_struct *
5215 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
5217 struct dw_loc_descr_struct *head, *tmp;
5219 offset += cfa->offset;
5223 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
5224 head->dw_loc_oprnd1.val_class = dw_val_class_const;
5225 tmp = new_loc_descr (DW_OP_deref, 0, 0);
5226 add_loc_descr (&head, tmp);
5229 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
5230 add_loc_descr (&head, tmp);
5234 head = new_reg_loc_descr (cfa->reg, offset);
5239 /* This function builds a dwarf location descriptor sequence for
5240 the address at OFFSET from the CFA when stack is aligned to
5243 static struct dw_loc_descr_struct *
5244 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
5246 struct dw_loc_descr_struct *head;
5247 unsigned int dwarf_fp
5248 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
5250 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
5251 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
5253 head = new_reg_loc_descr (dwarf_fp, 0);
5254 add_loc_descr (&head, int_loc_descriptor (alignment));
5255 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
5256 loc_descr_plus_const (&head, offset);
5259 head = new_reg_loc_descr (dwarf_fp, offset);
5263 /* This function fills in aa dw_cfa_location structure from a dwarf location
5264 descriptor sequence. */
5267 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
5269 struct dw_loc_descr_struct *ptr;
5271 cfa->base_offset = 0;
5275 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
5277 enum dwarf_location_atom op = ptr->dw_loc_opc;
5313 cfa->reg = op - DW_OP_reg0;
5316 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5350 cfa->reg = op - DW_OP_breg0;
5351 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
5354 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5355 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
5360 case DW_OP_plus_uconst:
5361 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
5364 internal_error ("DW_LOC_OP %s not implemented",
5365 dwarf_stack_op_name (ptr->dw_loc_opc));
5369 #endif /* .debug_frame support */
5371 /* And now, the support for symbolic debugging information. */
5372 #ifdef DWARF2_DEBUGGING_INFO
5374 /* .debug_str support. */
5375 static int output_indirect_string (void **, void *);
5377 static void dwarf2out_init (const char *);
5378 static void dwarf2out_finish (const char *);
5379 static void dwarf2out_define (unsigned int, const char *);
5380 static void dwarf2out_undef (unsigned int, const char *);
5381 static void dwarf2out_start_source_file (unsigned, const char *);
5382 static void dwarf2out_end_source_file (unsigned);
5383 static void dwarf2out_begin_block (unsigned, unsigned);
5384 static void dwarf2out_end_block (unsigned, unsigned);
5385 static bool dwarf2out_ignore_block (const_tree);
5386 static void dwarf2out_global_decl (tree);
5387 static void dwarf2out_type_decl (tree, int);
5388 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
5389 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
5391 static void dwarf2out_abstract_function (tree);
5392 static void dwarf2out_var_location (rtx);
5393 static void dwarf2out_begin_function (tree);
5394 static void dwarf2out_set_name (tree, tree);
5396 /* The debug hooks structure. */
5398 const struct gcc_debug_hooks dwarf2_debug_hooks =
5404 dwarf2out_start_source_file,
5405 dwarf2out_end_source_file,
5406 dwarf2out_begin_block,
5407 dwarf2out_end_block,
5408 dwarf2out_ignore_block,
5409 dwarf2out_source_line,
5410 dwarf2out_begin_prologue,
5411 debug_nothing_int_charstar, /* end_prologue */
5412 dwarf2out_end_epilogue,
5413 dwarf2out_begin_function,
5414 debug_nothing_int, /* end_function */
5415 dwarf2out_decl, /* function_decl */
5416 dwarf2out_global_decl,
5417 dwarf2out_type_decl, /* type_decl */
5418 dwarf2out_imported_module_or_decl,
5419 debug_nothing_tree, /* deferred_inline_function */
5420 /* The DWARF 2 backend tries to reduce debugging bloat by not
5421 emitting the abstract description of inline functions until
5422 something tries to reference them. */
5423 dwarf2out_abstract_function, /* outlining_inline_function */
5424 debug_nothing_rtx, /* label */
5425 debug_nothing_int, /* handle_pch */
5426 dwarf2out_var_location,
5427 dwarf2out_switch_text_section,
5429 1 /* start_end_main_source_file */
5433 /* NOTE: In the comments in this file, many references are made to
5434 "Debugging Information Entries". This term is abbreviated as `DIE'
5435 throughout the remainder of this file. */
5437 /* An internal representation of the DWARF output is built, and then
5438 walked to generate the DWARF debugging info. The walk of the internal
5439 representation is done after the entire program has been compiled.
5440 The types below are used to describe the internal representation. */
5442 /* Various DIE's use offsets relative to the beginning of the
5443 .debug_info section to refer to each other. */
5445 typedef long int dw_offset;
5447 /* Define typedefs here to avoid circular dependencies. */
5449 typedef struct dw_attr_struct *dw_attr_ref;
5450 typedef struct dw_line_info_struct *dw_line_info_ref;
5451 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
5452 typedef struct pubname_struct *pubname_ref;
5453 typedef struct dw_ranges_struct *dw_ranges_ref;
5454 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
5456 /* Each entry in the line_info_table maintains the file and
5457 line number associated with the label generated for that
5458 entry. The label gives the PC value associated with
5459 the line number entry. */
5461 typedef struct GTY(()) dw_line_info_struct {
5462 unsigned long dw_file_num;
5463 unsigned long dw_line_num;
5467 /* Line information for functions in separate sections; each one gets its
5469 typedef struct GTY(()) dw_separate_line_info_struct {
5470 unsigned long dw_file_num;
5471 unsigned long dw_line_num;
5472 unsigned long function;
5474 dw_separate_line_info_entry;
5476 /* Each DIE attribute has a field specifying the attribute kind,
5477 a link to the next attribute in the chain, and an attribute value.
5478 Attributes are typically linked below the DIE they modify. */
5480 typedef struct GTY(()) dw_attr_struct {
5481 enum dwarf_attribute dw_attr;
5482 dw_val_node dw_attr_val;
5486 DEF_VEC_O(dw_attr_node);
5487 DEF_VEC_ALLOC_O(dw_attr_node,gc);
5489 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
5490 The children of each node form a circular list linked by
5491 die_sib. die_child points to the node *before* the "first" child node. */
5493 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
5494 enum dwarf_tag die_tag;
5496 VEC(dw_attr_node,gc) * die_attr;
5497 dw_die_ref die_parent;
5498 dw_die_ref die_child;
5500 dw_die_ref die_definition; /* ref from a specification to its definition */
5501 dw_offset die_offset;
5502 unsigned long die_abbrev;
5504 /* Die is used and must not be pruned as unused. */
5505 int die_perennial_p;
5506 unsigned int decl_id;
5510 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
5511 #define FOR_EACH_CHILD(die, c, expr) do { \
5512 c = die->die_child; \
5516 } while (c != die->die_child); \
5519 /* The pubname structure */
5521 typedef struct GTY(()) pubname_struct {
5527 DEF_VEC_O(pubname_entry);
5528 DEF_VEC_ALLOC_O(pubname_entry, gc);
5530 struct GTY(()) dw_ranges_struct {
5531 /* If this is positive, it's a block number, otherwise it's a
5532 bitwise-negated index into dw_ranges_by_label. */
5536 struct GTY(()) dw_ranges_by_label_struct {
5541 /* The limbo die list structure. */
5542 typedef struct GTY(()) limbo_die_struct {
5545 struct limbo_die_struct *next;
5549 /* How to start an assembler comment. */
5550 #ifndef ASM_COMMENT_START
5551 #define ASM_COMMENT_START ";#"
5554 /* Define a macro which returns nonzero for a TYPE_DECL which was
5555 implicitly generated for a tagged type.
5557 Note that unlike the gcc front end (which generates a NULL named
5558 TYPE_DECL node for each complete tagged type, each array type, and
5559 each function type node created) the g++ front end generates a
5560 _named_ TYPE_DECL node for each tagged type node created.
5561 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
5562 generate a DW_TAG_typedef DIE for them. */
5564 #define TYPE_DECL_IS_STUB(decl) \
5565 (DECL_NAME (decl) == NULL_TREE \
5566 || (DECL_ARTIFICIAL (decl) \
5567 && is_tagged_type (TREE_TYPE (decl)) \
5568 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
5569 /* This is necessary for stub decls that \
5570 appear in nested inline functions. */ \
5571 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
5572 && (decl_ultimate_origin (decl) \
5573 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
5575 /* Information concerning the compilation unit's programming
5576 language, and compiler version. */
5578 /* Fixed size portion of the DWARF compilation unit header. */
5579 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
5580 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
5582 /* Fixed size portion of public names info. */
5583 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
5585 /* Fixed size portion of the address range info. */
5586 #define DWARF_ARANGES_HEADER_SIZE \
5587 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5588 DWARF2_ADDR_SIZE * 2) \
5589 - DWARF_INITIAL_LENGTH_SIZE)
5591 /* Size of padding portion in the address range info. It must be
5592 aligned to twice the pointer size. */
5593 #define DWARF_ARANGES_PAD_SIZE \
5594 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5595 DWARF2_ADDR_SIZE * 2) \
5596 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
5598 /* Use assembler line directives if available. */
5599 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
5600 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
5601 #define DWARF2_ASM_LINE_DEBUG_INFO 1
5603 #define DWARF2_ASM_LINE_DEBUG_INFO 0
5607 /* Minimum line offset in a special line info. opcode.
5608 This value was chosen to give a reasonable range of values. */
5609 #define DWARF_LINE_BASE -10
5611 /* First special line opcode - leave room for the standard opcodes. */
5612 #define DWARF_LINE_OPCODE_BASE 10
5614 /* Range of line offsets in a special line info. opcode. */
5615 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
5617 /* Flag that indicates the initial value of the is_stmt_start flag.
5618 In the present implementation, we do not mark any lines as
5619 the beginning of a source statement, because that information
5620 is not made available by the GCC front-end. */
5621 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
5623 #ifdef DWARF2_DEBUGGING_INFO
5624 /* This location is used by calc_die_sizes() to keep track
5625 the offset of each DIE within the .debug_info section. */
5626 static unsigned long next_die_offset;
5629 /* Record the root of the DIE's built for the current compilation unit. */
5630 static GTY(()) dw_die_ref comp_unit_die;
5632 /* A list of DIEs with a NULL parent waiting to be relocated. */
5633 static GTY(()) limbo_die_node *limbo_die_list;
5635 /* A list of DIEs for which we may have to generate
5636 DW_AT_MIPS_linkage_name once their DECL_ASSEMBLER_NAMEs are
5638 static GTY(()) limbo_die_node *deferred_asm_name;
5640 /* Filenames referenced by this compilation unit. */
5641 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
5643 /* A hash table of references to DIE's that describe declarations.
5644 The key is a DECL_UID() which is a unique number identifying each decl. */
5645 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
5647 /* A hash table of references to DIE's that describe COMMON blocks.
5648 The key is DECL_UID() ^ die_parent. */
5649 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
5651 typedef struct GTY(()) die_arg_entry_struct {
5656 DEF_VEC_O(die_arg_entry);
5657 DEF_VEC_ALLOC_O(die_arg_entry,gc);
5659 /* Node of the variable location list. */
5660 struct GTY ((chain_next ("%h.next"))) var_loc_node {
5661 rtx GTY (()) var_loc_note;
5662 const char * GTY (()) label;
5663 const char * GTY (()) section_label;
5664 struct var_loc_node * GTY (()) next;
5667 /* Variable location list. */
5668 struct GTY (()) var_loc_list_def {
5669 struct var_loc_node * GTY (()) first;
5671 /* Do not mark the last element of the chained list because
5672 it is marked through the chain. */
5673 struct var_loc_node * GTY ((skip ("%h"))) last;
5675 /* DECL_UID of the variable decl. */
5676 unsigned int decl_id;
5678 typedef struct var_loc_list_def var_loc_list;
5681 /* Table of decl location linked lists. */
5682 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
5684 /* A pointer to the base of a list of references to DIE's that
5685 are uniquely identified by their tag, presence/absence of
5686 children DIE's, and list of attribute/value pairs. */
5687 static GTY((length ("abbrev_die_table_allocated")))
5688 dw_die_ref *abbrev_die_table;
5690 /* Number of elements currently allocated for abbrev_die_table. */
5691 static GTY(()) unsigned abbrev_die_table_allocated;
5693 /* Number of elements in type_die_table currently in use. */
5694 static GTY(()) unsigned abbrev_die_table_in_use;
5696 /* Size (in elements) of increments by which we may expand the
5697 abbrev_die_table. */
5698 #define ABBREV_DIE_TABLE_INCREMENT 256
5700 /* A pointer to the base of a table that contains line information
5701 for each source code line in .text in the compilation unit. */
5702 static GTY((length ("line_info_table_allocated")))
5703 dw_line_info_ref line_info_table;
5705 /* Number of elements currently allocated for line_info_table. */
5706 static GTY(()) unsigned line_info_table_allocated;
5708 /* Number of elements in line_info_table currently in use. */
5709 static GTY(()) unsigned line_info_table_in_use;
5711 /* A pointer to the base of a table that contains line information
5712 for each source code line outside of .text in the compilation unit. */
5713 static GTY ((length ("separate_line_info_table_allocated")))
5714 dw_separate_line_info_ref separate_line_info_table;
5716 /* Number of elements currently allocated for separate_line_info_table. */
5717 static GTY(()) unsigned separate_line_info_table_allocated;
5719 /* Number of elements in separate_line_info_table currently in use. */
5720 static GTY(()) unsigned separate_line_info_table_in_use;
5722 /* Size (in elements) of increments by which we may expand the
5724 #define LINE_INFO_TABLE_INCREMENT 1024
5726 /* A pointer to the base of a table that contains a list of publicly
5727 accessible names. */
5728 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
5730 /* A pointer to the base of a table that contains a list of publicly
5731 accessible types. */
5732 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
5734 /* Array of dies for which we should generate .debug_arange info. */
5735 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
5737 /* Number of elements currently allocated for arange_table. */
5738 static GTY(()) unsigned arange_table_allocated;
5740 /* Number of elements in arange_table currently in use. */
5741 static GTY(()) unsigned arange_table_in_use;
5743 /* Size (in elements) of increments by which we may expand the
5745 #define ARANGE_TABLE_INCREMENT 64
5747 /* Array of dies for which we should generate .debug_ranges info. */
5748 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
5750 /* Number of elements currently allocated for ranges_table. */
5751 static GTY(()) unsigned ranges_table_allocated;
5753 /* Number of elements in ranges_table currently in use. */
5754 static GTY(()) unsigned ranges_table_in_use;
5756 /* Array of pairs of labels referenced in ranges_table. */
5757 static GTY ((length ("ranges_by_label_allocated")))
5758 dw_ranges_by_label_ref ranges_by_label;
5760 /* Number of elements currently allocated for ranges_by_label. */
5761 static GTY(()) unsigned ranges_by_label_allocated;
5763 /* Number of elements in ranges_by_label currently in use. */
5764 static GTY(()) unsigned ranges_by_label_in_use;
5766 /* Size (in elements) of increments by which we may expand the
5768 #define RANGES_TABLE_INCREMENT 64
5770 /* Whether we have location lists that need outputting */
5771 static GTY(()) bool have_location_lists;
5773 /* Unique label counter. */
5774 static GTY(()) unsigned int loclabel_num;
5776 #ifdef DWARF2_DEBUGGING_INFO
5777 /* Record whether the function being analyzed contains inlined functions. */
5778 static int current_function_has_inlines;
5780 #if 0 && defined (MIPS_DEBUGGING_INFO)
5781 static int comp_unit_has_inlines;
5784 /* The last file entry emitted by maybe_emit_file(). */
5785 static GTY(()) struct dwarf_file_data * last_emitted_file;
5787 /* Number of internal labels generated by gen_internal_sym(). */
5788 static GTY(()) int label_num;
5790 /* Cached result of previous call to lookup_filename. */
5791 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
5793 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
5795 #ifdef DWARF2_DEBUGGING_INFO
5797 /* Offset from the "steady-state frame pointer" to the frame base,
5798 within the current function. */
5799 static HOST_WIDE_INT frame_pointer_fb_offset;
5801 /* Forward declarations for functions defined in this file. */
5803 static int is_pseudo_reg (const_rtx);
5804 static tree type_main_variant (tree);
5805 static int is_tagged_type (const_tree);
5806 static const char *dwarf_tag_name (unsigned);
5807 static const char *dwarf_attr_name (unsigned);
5808 static const char *dwarf_form_name (unsigned);
5809 static tree decl_ultimate_origin (const_tree);
5810 static tree decl_class_context (tree);
5811 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
5812 static inline enum dw_val_class AT_class (dw_attr_ref);
5813 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
5814 static inline unsigned AT_flag (dw_attr_ref);
5815 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
5816 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
5817 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
5818 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
5819 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, rtx);
5820 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
5821 unsigned int, unsigned char *);
5822 static hashval_t debug_str_do_hash (const void *);
5823 static int debug_str_eq (const void *, const void *);
5824 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
5825 static inline const char *AT_string (dw_attr_ref);
5826 static enum dwarf_form AT_string_form (dw_attr_ref);
5827 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
5828 static void add_AT_specification (dw_die_ref, dw_die_ref);
5829 static inline dw_die_ref AT_ref (dw_attr_ref);
5830 static inline int AT_ref_external (dw_attr_ref);
5831 static inline void set_AT_ref_external (dw_attr_ref, int);
5832 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
5833 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
5834 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
5835 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
5837 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
5838 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
5839 static inline rtx AT_addr (dw_attr_ref);
5840 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
5841 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
5842 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
5843 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
5844 unsigned HOST_WIDE_INT);
5845 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
5847 static inline const char *AT_lbl (dw_attr_ref);
5848 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
5849 static const char *get_AT_low_pc (dw_die_ref);
5850 static const char *get_AT_hi_pc (dw_die_ref);
5851 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
5852 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
5853 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
5854 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
5855 static bool is_c_family (void);
5856 static bool is_cxx (void);
5857 static bool is_java (void);
5858 static bool is_fortran (void);
5859 static bool is_ada (void);
5860 static void remove_AT (dw_die_ref, enum dwarf_attribute);
5861 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
5862 static void add_child_die (dw_die_ref, dw_die_ref);
5863 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
5864 static dw_die_ref lookup_type_die (tree);
5865 static void equate_type_number_to_die (tree, dw_die_ref);
5866 static hashval_t decl_die_table_hash (const void *);
5867 static int decl_die_table_eq (const void *, const void *);
5868 static dw_die_ref lookup_decl_die (tree);
5869 static hashval_t common_block_die_table_hash (const void *);
5870 static int common_block_die_table_eq (const void *, const void *);
5871 static hashval_t decl_loc_table_hash (const void *);
5872 static int decl_loc_table_eq (const void *, const void *);
5873 static var_loc_list *lookup_decl_loc (const_tree);
5874 static void equate_decl_number_to_die (tree, dw_die_ref);
5875 static void add_var_loc_to_decl (tree, struct var_loc_node *);
5876 static void print_spaces (FILE *);
5877 static void print_die (dw_die_ref, FILE *);
5878 static void print_dwarf_line_table (FILE *);
5879 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
5880 static dw_die_ref pop_compile_unit (dw_die_ref);
5881 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
5882 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
5883 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
5884 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
5885 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
5886 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
5887 static int same_die_p (dw_die_ref, dw_die_ref, int *);
5888 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
5889 static void compute_section_prefix (dw_die_ref);
5890 static int is_type_die (dw_die_ref);
5891 static int is_comdat_die (dw_die_ref);
5892 static int is_symbol_die (dw_die_ref);
5893 static void assign_symbol_names (dw_die_ref);
5894 static void break_out_includes (dw_die_ref);
5895 static hashval_t htab_cu_hash (const void *);
5896 static int htab_cu_eq (const void *, const void *);
5897 static void htab_cu_del (void *);
5898 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
5899 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
5900 static void add_sibling_attributes (dw_die_ref);
5901 static void build_abbrev_table (dw_die_ref);
5902 static void output_location_lists (dw_die_ref);
5903 static int constant_size (unsigned HOST_WIDE_INT);
5904 static unsigned long size_of_die (dw_die_ref);
5905 static void calc_die_sizes (dw_die_ref);
5906 static void mark_dies (dw_die_ref);
5907 static void unmark_dies (dw_die_ref);
5908 static void unmark_all_dies (dw_die_ref);
5909 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
5910 static unsigned long size_of_aranges (void);
5911 static enum dwarf_form value_format (dw_attr_ref);
5912 static void output_value_format (dw_attr_ref);
5913 static void output_abbrev_section (void);
5914 static void output_die_symbol (dw_die_ref);
5915 static void output_die (dw_die_ref);
5916 static void output_compilation_unit_header (void);
5917 static void output_comp_unit (dw_die_ref, int);
5918 static const char *dwarf2_name (tree, int);
5919 static void add_pubname (tree, dw_die_ref);
5920 static void add_pubname_string (const char *, dw_die_ref);
5921 static void add_pubtype (tree, dw_die_ref);
5922 static void output_pubnames (VEC (pubname_entry,gc) *);
5923 static void add_arange (tree, dw_die_ref);
5924 static void output_aranges (void);
5925 static unsigned int add_ranges_num (int);
5926 static unsigned int add_ranges (const_tree);
5927 static unsigned int add_ranges_by_labels (const char *, const char *);
5928 static void output_ranges (void);
5929 static void output_line_info (void);
5930 static void output_file_names (void);
5931 static dw_die_ref base_type_die (tree);
5932 static int is_base_type (tree);
5933 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
5934 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
5935 static dw_die_ref generic_parameter_die (tree, tree, dw_die_ref, int);
5936 static int type_is_enum (const_tree);
5937 static unsigned int dbx_reg_number (const_rtx);
5938 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
5939 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
5940 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
5941 enum var_init_status);
5942 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
5943 enum var_init_status);
5944 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
5945 enum var_init_status);
5946 static int is_based_loc (const_rtx);
5947 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
5948 enum var_init_status);
5949 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
5950 enum var_init_status);
5951 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
5952 enum var_init_status);
5953 static dw_loc_list_ref loc_list_from_tree (tree, int);
5954 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
5955 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
5956 static tree field_type (const_tree);
5957 static unsigned int simple_type_align_in_bits (const_tree);
5958 static unsigned int simple_decl_align_in_bits (const_tree);
5959 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
5960 static HOST_WIDE_INT field_byte_offset (const_tree);
5961 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
5963 static void add_data_member_location_attribute (dw_die_ref, tree);
5964 static bool add_const_value_attribute (dw_die_ref, rtx);
5965 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
5966 static void insert_float (const_rtx, unsigned char *);
5967 static rtx rtl_for_decl_location (tree);
5968 static bool add_location_or_const_value_attribute (dw_die_ref, tree,
5969 enum dwarf_attribute);
5970 static bool tree_add_const_value_attribute (dw_die_ref, tree);
5971 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
5972 static void add_name_attribute (dw_die_ref, const char *);
5973 static void add_comp_dir_attribute (dw_die_ref);
5974 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
5975 static void add_subscript_info (dw_die_ref, tree, bool);
5976 static void add_byte_size_attribute (dw_die_ref, tree);
5977 static void add_bit_offset_attribute (dw_die_ref, tree);
5978 static void add_bit_size_attribute (dw_die_ref, tree);
5979 static void add_prototyped_attribute (dw_die_ref, tree);
5980 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
5981 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
5982 static void add_src_coords_attributes (dw_die_ref, tree);
5983 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
5984 static void push_decl_scope (tree);
5985 static void pop_decl_scope (void);
5986 static dw_die_ref scope_die_for (tree, dw_die_ref);
5987 static inline int local_scope_p (dw_die_ref);
5988 static inline int class_scope_p (dw_die_ref);
5989 static inline int class_or_namespace_scope_p (dw_die_ref);
5990 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
5991 static void add_calling_convention_attribute (dw_die_ref, tree);
5992 static const char *type_tag (const_tree);
5993 static tree member_declared_type (const_tree);
5995 static const char *decl_start_label (tree);
5997 static void gen_array_type_die (tree, dw_die_ref);
5998 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
6000 static void gen_entry_point_die (tree, dw_die_ref);
6002 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
6003 static dw_die_ref gen_formal_parameter_die (tree, tree, dw_die_ref);
6004 static void gen_unspecified_parameters_die (tree, dw_die_ref);
6005 static void gen_formal_types_die (tree, dw_die_ref);
6006 static void gen_subprogram_die (tree, dw_die_ref);
6007 static void gen_variable_die (tree, tree, dw_die_ref);
6008 static void gen_const_die (tree, dw_die_ref);
6009 static void gen_label_die (tree, dw_die_ref);
6010 static void gen_lexical_block_die (tree, dw_die_ref, int);
6011 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
6012 static void gen_field_die (tree, dw_die_ref);
6013 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
6014 static dw_die_ref gen_compile_unit_die (const char *);
6015 static void gen_inheritance_die (tree, tree, dw_die_ref);
6016 static void gen_member_die (tree, dw_die_ref);
6017 static void gen_struct_or_union_type_die (tree, dw_die_ref,
6018 enum debug_info_usage);
6019 static void gen_subroutine_type_die (tree, dw_die_ref);
6020 static void gen_typedef_die (tree, dw_die_ref);
6021 static void gen_type_die (tree, dw_die_ref);
6022 static void gen_block_die (tree, dw_die_ref, int);
6023 static void decls_for_scope (tree, dw_die_ref, int);
6024 static int is_redundant_typedef (const_tree);
6025 static inline dw_die_ref get_context_die (tree);
6026 static void gen_namespace_die (tree, dw_die_ref);
6027 static void gen_decl_die (tree, tree, dw_die_ref);
6028 static dw_die_ref force_decl_die (tree);
6029 static dw_die_ref force_type_die (tree);
6030 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
6031 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
6032 static struct dwarf_file_data * lookup_filename (const char *);
6033 static void retry_incomplete_types (void);
6034 static void gen_type_die_for_member (tree, tree, dw_die_ref);
6035 static tree make_ith_pack_parameter_name (tree, int);
6036 static void gen_generic_params_dies (tree);
6037 static void splice_child_die (dw_die_ref, dw_die_ref);
6038 static int file_info_cmp (const void *, const void *);
6039 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
6040 const char *, const char *, unsigned);
6041 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
6042 const char *, const char *,
6044 static void output_loc_list (dw_loc_list_ref);
6045 static char *gen_internal_sym (const char *);
6047 static void prune_unmark_dies (dw_die_ref);
6048 static void prune_unused_types_mark (dw_die_ref, int);
6049 static void prune_unused_types_walk (dw_die_ref);
6050 static void prune_unused_types_walk_attribs (dw_die_ref);
6051 static void prune_unused_types_prune (dw_die_ref);
6052 static void prune_unused_types (void);
6053 static int maybe_emit_file (struct dwarf_file_data *fd);
6054 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
6055 static void gen_remaining_tmpl_value_param_die_attribute (void);
6057 /* Section names used to hold DWARF debugging information. */
6058 #ifndef DEBUG_INFO_SECTION
6059 #define DEBUG_INFO_SECTION ".debug_info"
6061 #ifndef DEBUG_ABBREV_SECTION
6062 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
6064 #ifndef DEBUG_ARANGES_SECTION
6065 #define DEBUG_ARANGES_SECTION ".debug_aranges"
6067 #ifndef DEBUG_MACINFO_SECTION
6068 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
6070 #ifndef DEBUG_LINE_SECTION
6071 #define DEBUG_LINE_SECTION ".debug_line"
6073 #ifndef DEBUG_LOC_SECTION
6074 #define DEBUG_LOC_SECTION ".debug_loc"
6076 #ifndef DEBUG_PUBNAMES_SECTION
6077 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
6079 #ifndef DEBUG_PUBTYPES_SECTION
6080 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
6082 #ifndef DEBUG_STR_SECTION
6083 #define DEBUG_STR_SECTION ".debug_str"
6085 #ifndef DEBUG_RANGES_SECTION
6086 #define DEBUG_RANGES_SECTION ".debug_ranges"
6089 /* Standard ELF section names for compiled code and data. */
6090 #ifndef TEXT_SECTION_NAME
6091 #define TEXT_SECTION_NAME ".text"
6094 /* Section flags for .debug_str section. */
6095 #define DEBUG_STR_SECTION_FLAGS \
6096 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
6097 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
6100 /* Labels we insert at beginning sections we can reference instead of
6101 the section names themselves. */
6103 #ifndef TEXT_SECTION_LABEL
6104 #define TEXT_SECTION_LABEL "Ltext"
6106 #ifndef COLD_TEXT_SECTION_LABEL
6107 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
6109 #ifndef DEBUG_LINE_SECTION_LABEL
6110 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
6112 #ifndef DEBUG_INFO_SECTION_LABEL
6113 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
6115 #ifndef DEBUG_ABBREV_SECTION_LABEL
6116 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
6118 #ifndef DEBUG_LOC_SECTION_LABEL
6119 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
6121 #ifndef DEBUG_RANGES_SECTION_LABEL
6122 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
6124 #ifndef DEBUG_MACINFO_SECTION_LABEL
6125 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
6128 /* Definitions of defaults for formats and names of various special
6129 (artificial) labels which may be generated within this file (when the -g
6130 options is used and DWARF2_DEBUGGING_INFO is in effect.
6131 If necessary, these may be overridden from within the tm.h file, but
6132 typically, overriding these defaults is unnecessary. */
6134 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6135 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6136 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6137 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6138 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6139 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6140 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6141 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6142 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6143 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
6145 #ifndef TEXT_END_LABEL
6146 #define TEXT_END_LABEL "Letext"
6148 #ifndef COLD_END_LABEL
6149 #define COLD_END_LABEL "Letext_cold"
6151 #ifndef BLOCK_BEGIN_LABEL
6152 #define BLOCK_BEGIN_LABEL "LBB"
6154 #ifndef BLOCK_END_LABEL
6155 #define BLOCK_END_LABEL "LBE"
6157 #ifndef LINE_CODE_LABEL
6158 #define LINE_CODE_LABEL "LM"
6160 #ifndef SEPARATE_LINE_CODE_LABEL
6161 #define SEPARATE_LINE_CODE_LABEL "LSM"
6165 /* We allow a language front-end to designate a function that is to be
6166 called to "demangle" any name before it is put into a DIE. */
6168 static const char *(*demangle_name_func) (const char *);
6171 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
6173 demangle_name_func = func;
6176 /* Test if rtl node points to a pseudo register. */
6179 is_pseudo_reg (const_rtx rtl)
6181 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
6182 || (GET_CODE (rtl) == SUBREG
6183 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
6186 /* Return a reference to a type, with its const and volatile qualifiers
6190 type_main_variant (tree type)
6192 type = TYPE_MAIN_VARIANT (type);
6194 /* ??? There really should be only one main variant among any group of
6195 variants of a given type (and all of the MAIN_VARIANT values for all
6196 members of the group should point to that one type) but sometimes the C
6197 front-end messes this up for array types, so we work around that bug
6199 if (TREE_CODE (type) == ARRAY_TYPE)
6200 while (type != TYPE_MAIN_VARIANT (type))
6201 type = TYPE_MAIN_VARIANT (type);
6206 /* Return nonzero if the given type node represents a tagged type. */
6209 is_tagged_type (const_tree type)
6211 enum tree_code code = TREE_CODE (type);
6213 return (code == RECORD_TYPE || code == UNION_TYPE
6214 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
6217 /* Convert a DIE tag into its string name. */
6220 dwarf_tag_name (unsigned int tag)
6224 case DW_TAG_padding:
6225 return "DW_TAG_padding";
6226 case DW_TAG_array_type:
6227 return "DW_TAG_array_type";
6228 case DW_TAG_class_type:
6229 return "DW_TAG_class_type";
6230 case DW_TAG_entry_point:
6231 return "DW_TAG_entry_point";
6232 case DW_TAG_enumeration_type:
6233 return "DW_TAG_enumeration_type";
6234 case DW_TAG_formal_parameter:
6235 return "DW_TAG_formal_parameter";
6236 case DW_TAG_imported_declaration:
6237 return "DW_TAG_imported_declaration";
6239 return "DW_TAG_label";
6240 case DW_TAG_lexical_block:
6241 return "DW_TAG_lexical_block";
6243 return "DW_TAG_member";
6244 case DW_TAG_pointer_type:
6245 return "DW_TAG_pointer_type";
6246 case DW_TAG_reference_type:
6247 return "DW_TAG_reference_type";
6248 case DW_TAG_compile_unit:
6249 return "DW_TAG_compile_unit";
6250 case DW_TAG_string_type:
6251 return "DW_TAG_string_type";
6252 case DW_TAG_structure_type:
6253 return "DW_TAG_structure_type";
6254 case DW_TAG_subroutine_type:
6255 return "DW_TAG_subroutine_type";
6256 case DW_TAG_typedef:
6257 return "DW_TAG_typedef";
6258 case DW_TAG_union_type:
6259 return "DW_TAG_union_type";
6260 case DW_TAG_unspecified_parameters:
6261 return "DW_TAG_unspecified_parameters";
6262 case DW_TAG_variant:
6263 return "DW_TAG_variant";
6264 case DW_TAG_common_block:
6265 return "DW_TAG_common_block";
6266 case DW_TAG_common_inclusion:
6267 return "DW_TAG_common_inclusion";
6268 case DW_TAG_inheritance:
6269 return "DW_TAG_inheritance";
6270 case DW_TAG_inlined_subroutine:
6271 return "DW_TAG_inlined_subroutine";
6273 return "DW_TAG_module";
6274 case DW_TAG_ptr_to_member_type:
6275 return "DW_TAG_ptr_to_member_type";
6276 case DW_TAG_set_type:
6277 return "DW_TAG_set_type";
6278 case DW_TAG_subrange_type:
6279 return "DW_TAG_subrange_type";
6280 case DW_TAG_with_stmt:
6281 return "DW_TAG_with_stmt";
6282 case DW_TAG_access_declaration:
6283 return "DW_TAG_access_declaration";
6284 case DW_TAG_base_type:
6285 return "DW_TAG_base_type";
6286 case DW_TAG_catch_block:
6287 return "DW_TAG_catch_block";
6288 case DW_TAG_const_type:
6289 return "DW_TAG_const_type";
6290 case DW_TAG_constant:
6291 return "DW_TAG_constant";
6292 case DW_TAG_enumerator:
6293 return "DW_TAG_enumerator";
6294 case DW_TAG_file_type:
6295 return "DW_TAG_file_type";
6297 return "DW_TAG_friend";
6298 case DW_TAG_namelist:
6299 return "DW_TAG_namelist";
6300 case DW_TAG_namelist_item:
6301 return "DW_TAG_namelist_item";
6302 case DW_TAG_packed_type:
6303 return "DW_TAG_packed_type";
6304 case DW_TAG_subprogram:
6305 return "DW_TAG_subprogram";
6306 case DW_TAG_template_type_param:
6307 return "DW_TAG_template_type_param";
6308 case DW_TAG_template_value_param:
6309 return "DW_TAG_template_value_param";
6310 case DW_TAG_thrown_type:
6311 return "DW_TAG_thrown_type";
6312 case DW_TAG_try_block:
6313 return "DW_TAG_try_block";
6314 case DW_TAG_variant_part:
6315 return "DW_TAG_variant_part";
6316 case DW_TAG_variable:
6317 return "DW_TAG_variable";
6318 case DW_TAG_volatile_type:
6319 return "DW_TAG_volatile_type";
6320 case DW_TAG_dwarf_procedure:
6321 return "DW_TAG_dwarf_procedure";
6322 case DW_TAG_restrict_type:
6323 return "DW_TAG_restrict_type";
6324 case DW_TAG_interface_type:
6325 return "DW_TAG_interface_type";
6326 case DW_TAG_namespace:
6327 return "DW_TAG_namespace";
6328 case DW_TAG_imported_module:
6329 return "DW_TAG_imported_module";
6330 case DW_TAG_unspecified_type:
6331 return "DW_TAG_unspecified_type";
6332 case DW_TAG_partial_unit:
6333 return "DW_TAG_partial_unit";
6334 case DW_TAG_imported_unit:
6335 return "DW_TAG_imported_unit";
6336 case DW_TAG_condition:
6337 return "DW_TAG_condition";
6338 case DW_TAG_shared_type:
6339 return "DW_TAG_shared_type";
6340 case DW_TAG_MIPS_loop:
6341 return "DW_TAG_MIPS_loop";
6342 case DW_TAG_format_label:
6343 return "DW_TAG_format_label";
6344 case DW_TAG_function_template:
6345 return "DW_TAG_function_template";
6346 case DW_TAG_class_template:
6347 return "DW_TAG_class_template";
6348 case DW_TAG_GNU_BINCL:
6349 return "DW_TAG_GNU_BINCL";
6350 case DW_TAG_GNU_EINCL:
6351 return "DW_TAG_GNU_EINCL";
6352 case DW_TAG_GNU_template_template_param:
6353 return "DW_TAG_GNU_template_template_param";
6355 return "DW_TAG_<unknown>";
6359 /* Convert a DWARF attribute code into its string name. */
6362 dwarf_attr_name (unsigned int attr)
6367 return "DW_AT_sibling";
6368 case DW_AT_location:
6369 return "DW_AT_location";
6371 return "DW_AT_name";
6372 case DW_AT_ordering:
6373 return "DW_AT_ordering";
6374 case DW_AT_subscr_data:
6375 return "DW_AT_subscr_data";
6376 case DW_AT_byte_size:
6377 return "DW_AT_byte_size";
6378 case DW_AT_bit_offset:
6379 return "DW_AT_bit_offset";
6380 case DW_AT_bit_size:
6381 return "DW_AT_bit_size";
6382 case DW_AT_element_list:
6383 return "DW_AT_element_list";
6384 case DW_AT_stmt_list:
6385 return "DW_AT_stmt_list";
6387 return "DW_AT_low_pc";
6389 return "DW_AT_high_pc";
6390 case DW_AT_language:
6391 return "DW_AT_language";
6393 return "DW_AT_member";
6395 return "DW_AT_discr";
6396 case DW_AT_discr_value:
6397 return "DW_AT_discr_value";
6398 case DW_AT_visibility:
6399 return "DW_AT_visibility";
6401 return "DW_AT_import";
6402 case DW_AT_string_length:
6403 return "DW_AT_string_length";
6404 case DW_AT_common_reference:
6405 return "DW_AT_common_reference";
6406 case DW_AT_comp_dir:
6407 return "DW_AT_comp_dir";
6408 case DW_AT_const_value:
6409 return "DW_AT_const_value";
6410 case DW_AT_containing_type:
6411 return "DW_AT_containing_type";
6412 case DW_AT_default_value:
6413 return "DW_AT_default_value";
6415 return "DW_AT_inline";
6416 case DW_AT_is_optional:
6417 return "DW_AT_is_optional";
6418 case DW_AT_lower_bound:
6419 return "DW_AT_lower_bound";
6420 case DW_AT_producer:
6421 return "DW_AT_producer";
6422 case DW_AT_prototyped:
6423 return "DW_AT_prototyped";
6424 case DW_AT_return_addr:
6425 return "DW_AT_return_addr";
6426 case DW_AT_start_scope:
6427 return "DW_AT_start_scope";
6428 case DW_AT_bit_stride:
6429 return "DW_AT_bit_stride";
6430 case DW_AT_upper_bound:
6431 return "DW_AT_upper_bound";
6432 case DW_AT_abstract_origin:
6433 return "DW_AT_abstract_origin";
6434 case DW_AT_accessibility:
6435 return "DW_AT_accessibility";
6436 case DW_AT_address_class:
6437 return "DW_AT_address_class";
6438 case DW_AT_artificial:
6439 return "DW_AT_artificial";
6440 case DW_AT_base_types:
6441 return "DW_AT_base_types";
6442 case DW_AT_calling_convention:
6443 return "DW_AT_calling_convention";
6445 return "DW_AT_count";
6446 case DW_AT_data_member_location:
6447 return "DW_AT_data_member_location";
6448 case DW_AT_decl_column:
6449 return "DW_AT_decl_column";
6450 case DW_AT_decl_file:
6451 return "DW_AT_decl_file";
6452 case DW_AT_decl_line:
6453 return "DW_AT_decl_line";
6454 case DW_AT_declaration:
6455 return "DW_AT_declaration";
6456 case DW_AT_discr_list:
6457 return "DW_AT_discr_list";
6458 case DW_AT_encoding:
6459 return "DW_AT_encoding";
6460 case DW_AT_external:
6461 return "DW_AT_external";
6462 case DW_AT_explicit:
6463 return "DW_AT_explicit";
6464 case DW_AT_frame_base:
6465 return "DW_AT_frame_base";
6467 return "DW_AT_friend";
6468 case DW_AT_identifier_case:
6469 return "DW_AT_identifier_case";
6470 case DW_AT_macro_info:
6471 return "DW_AT_macro_info";
6472 case DW_AT_namelist_items:
6473 return "DW_AT_namelist_items";
6474 case DW_AT_priority:
6475 return "DW_AT_priority";
6477 return "DW_AT_segment";
6478 case DW_AT_specification:
6479 return "DW_AT_specification";
6480 case DW_AT_static_link:
6481 return "DW_AT_static_link";
6483 return "DW_AT_type";
6484 case DW_AT_use_location:
6485 return "DW_AT_use_location";
6486 case DW_AT_variable_parameter:
6487 return "DW_AT_variable_parameter";
6488 case DW_AT_virtuality:
6489 return "DW_AT_virtuality";
6490 case DW_AT_vtable_elem_location:
6491 return "DW_AT_vtable_elem_location";
6493 case DW_AT_allocated:
6494 return "DW_AT_allocated";
6495 case DW_AT_associated:
6496 return "DW_AT_associated";
6497 case DW_AT_data_location:
6498 return "DW_AT_data_location";
6499 case DW_AT_byte_stride:
6500 return "DW_AT_byte_stride";
6501 case DW_AT_entry_pc:
6502 return "DW_AT_entry_pc";
6503 case DW_AT_use_UTF8:
6504 return "DW_AT_use_UTF8";
6505 case DW_AT_extension:
6506 return "DW_AT_extension";
6508 return "DW_AT_ranges";
6509 case DW_AT_trampoline:
6510 return "DW_AT_trampoline";
6511 case DW_AT_call_column:
6512 return "DW_AT_call_column";
6513 case DW_AT_call_file:
6514 return "DW_AT_call_file";
6515 case DW_AT_call_line:
6516 return "DW_AT_call_line";
6518 case DW_AT_MIPS_fde:
6519 return "DW_AT_MIPS_fde";
6520 case DW_AT_MIPS_loop_begin:
6521 return "DW_AT_MIPS_loop_begin";
6522 case DW_AT_MIPS_tail_loop_begin:
6523 return "DW_AT_MIPS_tail_loop_begin";
6524 case DW_AT_MIPS_epilog_begin:
6525 return "DW_AT_MIPS_epilog_begin";
6526 case DW_AT_MIPS_loop_unroll_factor:
6527 return "DW_AT_MIPS_loop_unroll_factor";
6528 case DW_AT_MIPS_software_pipeline_depth:
6529 return "DW_AT_MIPS_software_pipeline_depth";
6530 case DW_AT_MIPS_linkage_name:
6531 return "DW_AT_MIPS_linkage_name";
6532 case DW_AT_MIPS_stride:
6533 return "DW_AT_MIPS_stride";
6534 case DW_AT_MIPS_abstract_name:
6535 return "DW_AT_MIPS_abstract_name";
6536 case DW_AT_MIPS_clone_origin:
6537 return "DW_AT_MIPS_clone_origin";
6538 case DW_AT_MIPS_has_inlines:
6539 return "DW_AT_MIPS_has_inlines";
6541 case DW_AT_sf_names:
6542 return "DW_AT_sf_names";
6543 case DW_AT_src_info:
6544 return "DW_AT_src_info";
6545 case DW_AT_mac_info:
6546 return "DW_AT_mac_info";
6547 case DW_AT_src_coords:
6548 return "DW_AT_src_coords";
6549 case DW_AT_body_begin:
6550 return "DW_AT_body_begin";
6551 case DW_AT_body_end:
6552 return "DW_AT_body_end";
6553 case DW_AT_GNU_vector:
6554 return "DW_AT_GNU_vector";
6555 case DW_AT_GNU_template_name:
6556 return "DW_AT_GNU_template_name";
6558 case DW_AT_VMS_rtnbeg_pd_address:
6559 return "DW_AT_VMS_rtnbeg_pd_address";
6562 return "DW_AT_<unknown>";
6566 /* Convert a DWARF value form code into its string name. */
6569 dwarf_form_name (unsigned int form)
6574 return "DW_FORM_addr";
6575 case DW_FORM_block2:
6576 return "DW_FORM_block2";
6577 case DW_FORM_block4:
6578 return "DW_FORM_block4";
6580 return "DW_FORM_data2";
6582 return "DW_FORM_data4";
6584 return "DW_FORM_data8";
6585 case DW_FORM_string:
6586 return "DW_FORM_string";
6588 return "DW_FORM_block";
6589 case DW_FORM_block1:
6590 return "DW_FORM_block1";
6592 return "DW_FORM_data1";
6594 return "DW_FORM_flag";
6596 return "DW_FORM_sdata";
6598 return "DW_FORM_strp";
6600 return "DW_FORM_udata";
6601 case DW_FORM_ref_addr:
6602 return "DW_FORM_ref_addr";
6604 return "DW_FORM_ref1";
6606 return "DW_FORM_ref2";
6608 return "DW_FORM_ref4";
6610 return "DW_FORM_ref8";
6611 case DW_FORM_ref_udata:
6612 return "DW_FORM_ref_udata";
6613 case DW_FORM_indirect:
6614 return "DW_FORM_indirect";
6616 return "DW_FORM_<unknown>";
6620 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
6621 instance of an inlined instance of a decl which is local to an inline
6622 function, so we have to trace all of the way back through the origin chain
6623 to find out what sort of node actually served as the original seed for the
6627 decl_ultimate_origin (const_tree decl)
6629 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
6632 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
6633 nodes in the function to point to themselves; ignore that if
6634 we're trying to output the abstract instance of this function. */
6635 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
6638 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
6639 most distant ancestor, this should never happen. */
6640 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
6642 return DECL_ABSTRACT_ORIGIN (decl);
6645 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
6646 of a virtual function may refer to a base class, so we check the 'this'
6650 decl_class_context (tree decl)
6652 tree context = NULL_TREE;
6654 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
6655 context = DECL_CONTEXT (decl);
6657 context = TYPE_MAIN_VARIANT
6658 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
6660 if (context && !TYPE_P (context))
6661 context = NULL_TREE;
6666 /* Add an attribute/value pair to a DIE. */
6669 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
6671 /* Maybe this should be an assert? */
6675 if (die->die_attr == NULL)
6676 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
6677 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
6680 static inline enum dw_val_class
6681 AT_class (dw_attr_ref a)
6683 return a->dw_attr_val.val_class;
6686 /* Add a flag value attribute to a DIE. */
6689 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
6693 attr.dw_attr = attr_kind;
6694 attr.dw_attr_val.val_class = dw_val_class_flag;
6695 attr.dw_attr_val.v.val_flag = flag;
6696 add_dwarf_attr (die, &attr);
6699 static inline unsigned
6700 AT_flag (dw_attr_ref a)
6702 gcc_assert (a && AT_class (a) == dw_val_class_flag);
6703 return a->dw_attr_val.v.val_flag;
6706 /* Add a signed integer attribute value to a DIE. */
6709 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
6713 attr.dw_attr = attr_kind;
6714 attr.dw_attr_val.val_class = dw_val_class_const;
6715 attr.dw_attr_val.v.val_int = int_val;
6716 add_dwarf_attr (die, &attr);
6719 static inline HOST_WIDE_INT
6720 AT_int (dw_attr_ref a)
6722 gcc_assert (a && AT_class (a) == dw_val_class_const);
6723 return a->dw_attr_val.v.val_int;
6726 /* Add an unsigned integer attribute value to a DIE. */
6729 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
6730 unsigned HOST_WIDE_INT unsigned_val)
6734 attr.dw_attr = attr_kind;
6735 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
6736 attr.dw_attr_val.v.val_unsigned = unsigned_val;
6737 add_dwarf_attr (die, &attr);
6740 static inline unsigned HOST_WIDE_INT
6741 AT_unsigned (dw_attr_ref a)
6743 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
6744 return a->dw_attr_val.v.val_unsigned;
6747 /* Add an unsigned double integer attribute value to a DIE. */
6750 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
6751 rtx val_const_double)
6755 attr.dw_attr = attr_kind;
6756 attr.dw_attr_val.val_class = dw_val_class_long_long;
6757 attr.dw_attr_val.v.val_long_long = val_const_double;
6758 add_dwarf_attr (die, &attr);
6761 /* Add a floating point attribute value to a DIE and return it. */
6764 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
6765 unsigned int length, unsigned int elt_size, unsigned char *array)
6769 attr.dw_attr = attr_kind;
6770 attr.dw_attr_val.val_class = dw_val_class_vec;
6771 attr.dw_attr_val.v.val_vec.length = length;
6772 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
6773 attr.dw_attr_val.v.val_vec.array = array;
6774 add_dwarf_attr (die, &attr);
6777 /* Hash and equality functions for debug_str_hash. */
6780 debug_str_do_hash (const void *x)
6782 return htab_hash_string (((const struct indirect_string_node *)x)->str);
6786 debug_str_eq (const void *x1, const void *x2)
6788 return strcmp ((((const struct indirect_string_node *)x1)->str),
6789 (const char *)x2) == 0;
6792 /* Add STR to the indirect string hash table. */
6794 static struct indirect_string_node *
6795 find_AT_string (const char *str)
6797 struct indirect_string_node *node;
6800 if (! debug_str_hash)
6801 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
6802 debug_str_eq, NULL);
6804 slot = htab_find_slot_with_hash (debug_str_hash, str,
6805 htab_hash_string (str), INSERT);
6808 node = (struct indirect_string_node *)
6809 ggc_alloc_cleared (sizeof (struct indirect_string_node));
6810 node->str = ggc_strdup (str);
6814 node = (struct indirect_string_node *) *slot;
6820 /* Add a string attribute value to a DIE. */
6823 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
6826 struct indirect_string_node *node;
6828 node = find_AT_string (str);
6830 attr.dw_attr = attr_kind;
6831 attr.dw_attr_val.val_class = dw_val_class_str;
6832 attr.dw_attr_val.v.val_str = node;
6833 add_dwarf_attr (die, &attr);
6836 /* Create a label for an indirect string node, ensuring it is going to
6837 be output, unless its reference count goes down to zero. */
6840 gen_label_for_indirect_string (struct indirect_string_node *node)
6847 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
6848 ++dw2_string_counter;
6849 node->label = xstrdup (label);
6852 /* Create a SYMBOL_REF rtx whose value is the initial address of a
6853 debug string STR. */
6856 get_debug_string_label (const char *str)
6858 struct indirect_string_node *node = find_AT_string (str);
6860 debug_str_hash_forced = true;
6862 gen_label_for_indirect_string (node);
6864 return gen_rtx_SYMBOL_REF (Pmode, node->label);
6867 static inline const char *
6868 AT_string (dw_attr_ref a)
6870 gcc_assert (a && AT_class (a) == dw_val_class_str);
6871 return a->dw_attr_val.v.val_str->str;
6874 /* Find out whether a string should be output inline in DIE
6875 or out-of-line in .debug_str section. */
6877 static enum dwarf_form
6878 AT_string_form (dw_attr_ref a)
6880 struct indirect_string_node *node;
6883 gcc_assert (a && AT_class (a) == dw_val_class_str);
6885 node = a->dw_attr_val.v.val_str;
6889 len = strlen (node->str) + 1;
6891 /* If the string is shorter or equal to the size of the reference, it is
6892 always better to put it inline. */
6893 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
6894 return node->form = DW_FORM_string;
6896 /* If we cannot expect the linker to merge strings in .debug_str
6897 section, only put it into .debug_str if it is worth even in this
6899 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
6900 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
6901 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
6902 return node->form = DW_FORM_string;
6904 gen_label_for_indirect_string (node);
6906 return node->form = DW_FORM_strp;
6909 /* Add a DIE reference attribute value to a DIE. */
6912 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
6916 attr.dw_attr = attr_kind;
6917 attr.dw_attr_val.val_class = dw_val_class_die_ref;
6918 attr.dw_attr_val.v.val_die_ref.die = targ_die;
6919 attr.dw_attr_val.v.val_die_ref.external = 0;
6920 add_dwarf_attr (die, &attr);
6923 /* Add an AT_specification attribute to a DIE, and also make the back
6924 pointer from the specification to the definition. */
6927 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
6929 add_AT_die_ref (die, DW_AT_specification, targ_die);
6930 gcc_assert (!targ_die->die_definition);
6931 targ_die->die_definition = die;
6934 static inline dw_die_ref
6935 AT_ref (dw_attr_ref a)
6937 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6938 return a->dw_attr_val.v.val_die_ref.die;
6942 AT_ref_external (dw_attr_ref a)
6944 if (a && AT_class (a) == dw_val_class_die_ref)
6945 return a->dw_attr_val.v.val_die_ref.external;
6951 set_AT_ref_external (dw_attr_ref a, int i)
6953 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6954 a->dw_attr_val.v.val_die_ref.external = i;
6957 /* Add an FDE reference attribute value to a DIE. */
6960 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
6964 attr.dw_attr = attr_kind;
6965 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
6966 attr.dw_attr_val.v.val_fde_index = targ_fde;
6967 add_dwarf_attr (die, &attr);
6970 /* Add a location description attribute value to a DIE. */
6973 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
6977 attr.dw_attr = attr_kind;
6978 attr.dw_attr_val.val_class = dw_val_class_loc;
6979 attr.dw_attr_val.v.val_loc = loc;
6980 add_dwarf_attr (die, &attr);
6983 static inline dw_loc_descr_ref
6984 AT_loc (dw_attr_ref a)
6986 gcc_assert (a && AT_class (a) == dw_val_class_loc);
6987 return a->dw_attr_val.v.val_loc;
6991 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
6995 attr.dw_attr = attr_kind;
6996 attr.dw_attr_val.val_class = dw_val_class_loc_list;
6997 attr.dw_attr_val.v.val_loc_list = loc_list;
6998 add_dwarf_attr (die, &attr);
6999 have_location_lists = true;
7002 static inline dw_loc_list_ref
7003 AT_loc_list (dw_attr_ref a)
7005 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7006 return a->dw_attr_val.v.val_loc_list;
7009 /* Add an address constant attribute value to a DIE. */
7012 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
7016 attr.dw_attr = attr_kind;
7017 attr.dw_attr_val.val_class = dw_val_class_addr;
7018 attr.dw_attr_val.v.val_addr = addr;
7019 add_dwarf_attr (die, &attr);
7022 /* Get the RTX from to an address DIE attribute. */
7025 AT_addr (dw_attr_ref a)
7027 gcc_assert (a && AT_class (a) == dw_val_class_addr);
7028 return a->dw_attr_val.v.val_addr;
7031 /* Add a file attribute value to a DIE. */
7034 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
7035 struct dwarf_file_data *fd)
7039 attr.dw_attr = attr_kind;
7040 attr.dw_attr_val.val_class = dw_val_class_file;
7041 attr.dw_attr_val.v.val_file = fd;
7042 add_dwarf_attr (die, &attr);
7045 /* Get the dwarf_file_data from a file DIE attribute. */
7047 static inline struct dwarf_file_data *
7048 AT_file (dw_attr_ref a)
7050 gcc_assert (a && AT_class (a) == dw_val_class_file);
7051 return a->dw_attr_val.v.val_file;
7054 /* Add a label identifier attribute value to a DIE. */
7057 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
7061 attr.dw_attr = attr_kind;
7062 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
7063 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
7064 add_dwarf_attr (die, &attr);
7067 /* Add a section offset attribute value to a DIE, an offset into the
7068 debug_line section. */
7071 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7076 attr.dw_attr = attr_kind;
7077 attr.dw_attr_val.val_class = dw_val_class_lineptr;
7078 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7079 add_dwarf_attr (die, &attr);
7082 /* Add a section offset attribute value to a DIE, an offset into the
7083 debug_macinfo section. */
7086 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7091 attr.dw_attr = attr_kind;
7092 attr.dw_attr_val.val_class = dw_val_class_macptr;
7093 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7094 add_dwarf_attr (die, &attr);
7097 /* Add an offset attribute value to a DIE. */
7100 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
7101 unsigned HOST_WIDE_INT offset)
7105 attr.dw_attr = attr_kind;
7106 attr.dw_attr_val.val_class = dw_val_class_offset;
7107 attr.dw_attr_val.v.val_offset = offset;
7108 add_dwarf_attr (die, &attr);
7111 /* Add an range_list attribute value to a DIE. */
7114 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
7115 long unsigned int offset)
7119 attr.dw_attr = attr_kind;
7120 attr.dw_attr_val.val_class = dw_val_class_range_list;
7121 attr.dw_attr_val.v.val_offset = offset;
7122 add_dwarf_attr (die, &attr);
7125 static inline const char *
7126 AT_lbl (dw_attr_ref a)
7128 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
7129 || AT_class (a) == dw_val_class_lineptr
7130 || AT_class (a) == dw_val_class_macptr));
7131 return a->dw_attr_val.v.val_lbl_id;
7134 /* Get the attribute of type attr_kind. */
7137 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7141 dw_die_ref spec = NULL;
7146 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7147 if (a->dw_attr == attr_kind)
7149 else if (a->dw_attr == DW_AT_specification
7150 || a->dw_attr == DW_AT_abstract_origin)
7154 return get_AT (spec, attr_kind);
7159 /* Return the "low pc" attribute value, typically associated with a subprogram
7160 DIE. Return null if the "low pc" attribute is either not present, or if it
7161 cannot be represented as an assembler label identifier. */
7163 static inline const char *
7164 get_AT_low_pc (dw_die_ref die)
7166 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
7168 return a ? AT_lbl (a) : NULL;
7171 /* Return the "high pc" attribute value, typically associated with a subprogram
7172 DIE. Return null if the "high pc" attribute is either not present, or if it
7173 cannot be represented as an assembler label identifier. */
7175 static inline const char *
7176 get_AT_hi_pc (dw_die_ref die)
7178 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
7180 return a ? AT_lbl (a) : NULL;
7183 /* Return the value of the string attribute designated by ATTR_KIND, or
7184 NULL if it is not present. */
7186 static inline const char *
7187 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
7189 dw_attr_ref a = get_AT (die, attr_kind);
7191 return a ? AT_string (a) : NULL;
7194 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
7195 if it is not present. */
7198 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
7200 dw_attr_ref a = get_AT (die, attr_kind);
7202 return a ? AT_flag (a) : 0;
7205 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
7206 if it is not present. */
7208 static inline unsigned
7209 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
7211 dw_attr_ref a = get_AT (die, attr_kind);
7213 return a ? AT_unsigned (a) : 0;
7216 static inline dw_die_ref
7217 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
7219 dw_attr_ref a = get_AT (die, attr_kind);
7221 return a ? AT_ref (a) : NULL;
7224 static inline struct dwarf_file_data *
7225 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
7227 dw_attr_ref a = get_AT (die, attr_kind);
7229 return a ? AT_file (a) : NULL;
7232 /* Return TRUE if the language is C or C++. */
7237 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7239 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
7240 || lang == DW_LANG_C99
7241 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
7244 /* Return TRUE if the language is C++. */
7249 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7251 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
7254 /* Return TRUE if the language is Fortran. */
7259 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7261 return (lang == DW_LANG_Fortran77
7262 || lang == DW_LANG_Fortran90
7263 || lang == DW_LANG_Fortran95);
7266 /* Return TRUE if the language is Java. */
7271 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7273 return lang == DW_LANG_Java;
7276 /* Return TRUE if the language is Ada. */
7281 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7283 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
7286 /* Remove the specified attribute if present. */
7289 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7297 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7298 if (a->dw_attr == attr_kind)
7300 if (AT_class (a) == dw_val_class_str)
7301 if (a->dw_attr_val.v.val_str->refcount)
7302 a->dw_attr_val.v.val_str->refcount--;
7304 /* VEC_ordered_remove should help reduce the number of abbrevs
7306 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
7311 /* Remove CHILD from its parent. PREV must have the property that
7312 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
7315 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
7317 gcc_assert (child->die_parent == prev->die_parent);
7318 gcc_assert (prev->die_sib == child);
7321 gcc_assert (child->die_parent->die_child == child);
7325 prev->die_sib = child->die_sib;
7326 if (child->die_parent->die_child == child)
7327 child->die_parent->die_child = prev;
7330 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
7334 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
7340 dw_die_ref prev = c;
7342 while (c->die_tag == tag)
7344 remove_child_with_prev (c, prev);
7345 /* Might have removed every child. */
7346 if (c == c->die_sib)
7350 } while (c != die->die_child);
7353 /* Add a CHILD_DIE as the last child of DIE. */
7356 add_child_die (dw_die_ref die, dw_die_ref child_die)
7358 /* FIXME this should probably be an assert. */
7359 if (! die || ! child_die)
7361 gcc_assert (die != child_die);
7363 child_die->die_parent = die;
7366 child_die->die_sib = die->die_child->die_sib;
7367 die->die_child->die_sib = child_die;
7370 child_die->die_sib = child_die;
7371 die->die_child = child_die;
7374 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
7375 is the specification, to the end of PARENT's list of children.
7376 This is done by removing and re-adding it. */
7379 splice_child_die (dw_die_ref parent, dw_die_ref child)
7383 /* We want the declaration DIE from inside the class, not the
7384 specification DIE at toplevel. */
7385 if (child->die_parent != parent)
7387 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
7393 gcc_assert (child->die_parent == parent
7394 || (child->die_parent
7395 == get_AT_ref (parent, DW_AT_specification)));
7397 for (p = child->die_parent->die_child; ; p = p->die_sib)
7398 if (p->die_sib == child)
7400 remove_child_with_prev (child, p);
7404 add_child_die (parent, child);
7407 /* Return a pointer to a newly created DIE node. */
7409 static inline dw_die_ref
7410 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
7412 dw_die_ref die = GGC_CNEW (die_node);
7414 die->die_tag = tag_value;
7416 if (parent_die != NULL)
7417 add_child_die (parent_die, die);
7420 limbo_die_node *limbo_node;
7422 limbo_node = GGC_CNEW (limbo_die_node);
7423 limbo_node->die = die;
7424 limbo_node->created_for = t;
7425 limbo_node->next = limbo_die_list;
7426 limbo_die_list = limbo_node;
7432 /* Return the DIE associated with the given type specifier. */
7434 static inline dw_die_ref
7435 lookup_type_die (tree type)
7437 return TYPE_SYMTAB_DIE (type);
7440 /* Equate a DIE to a given type specifier. */
7443 equate_type_number_to_die (tree type, dw_die_ref type_die)
7445 TYPE_SYMTAB_DIE (type) = type_die;
7448 /* Returns a hash value for X (which really is a die_struct). */
7451 decl_die_table_hash (const void *x)
7453 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
7456 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
7459 decl_die_table_eq (const void *x, const void *y)
7461 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
7464 /* Return the DIE associated with a given declaration. */
7466 static inline dw_die_ref
7467 lookup_decl_die (tree decl)
7469 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
7472 /* Returns a hash value for X (which really is a var_loc_list). */
7475 decl_loc_table_hash (const void *x)
7477 return (hashval_t) ((const var_loc_list *) x)->decl_id;
7480 /* Return nonzero if decl_id of var_loc_list X is the same as
7484 decl_loc_table_eq (const void *x, const void *y)
7486 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
7489 /* Return the var_loc list associated with a given declaration. */
7491 static inline var_loc_list *
7492 lookup_decl_loc (const_tree decl)
7494 return (var_loc_list *)
7495 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
7498 /* Equate a DIE to a particular declaration. */
7501 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
7503 unsigned int decl_id = DECL_UID (decl);
7506 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
7508 decl_die->decl_id = decl_id;
7511 /* Add a variable location node to the linked list for DECL. */
7514 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
7516 unsigned int decl_id = DECL_UID (decl);
7520 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
7523 temp = GGC_CNEW (var_loc_list);
7524 temp->decl_id = decl_id;
7528 temp = (var_loc_list *) *slot;
7532 /* If the current location is the same as the end of the list,
7533 and either both or neither of the locations is uninitialized,
7534 we have nothing to do. */
7535 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
7536 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
7537 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7538 != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
7539 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7540 == VAR_INIT_STATUS_UNINITIALIZED)
7541 || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
7542 == VAR_INIT_STATUS_UNINITIALIZED))))
7544 /* Add LOC to the end of list and update LAST. */
7545 temp->last->next = loc;
7549 /* Do not add empty location to the beginning of the list. */
7550 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
7557 /* Keep track of the number of spaces used to indent the
7558 output of the debugging routines that print the structure of
7559 the DIE internal representation. */
7560 static int print_indent;
7562 /* Indent the line the number of spaces given by print_indent. */
7565 print_spaces (FILE *outfile)
7567 fprintf (outfile, "%*s", print_indent, "");
7570 /* Print the information associated with a given DIE, and its children.
7571 This routine is a debugging aid only. */
7574 print_die (dw_die_ref die, FILE *outfile)
7580 print_spaces (outfile);
7581 fprintf (outfile, "DIE %4ld: %s\n",
7582 die->die_offset, dwarf_tag_name (die->die_tag));
7583 print_spaces (outfile);
7584 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
7585 fprintf (outfile, " offset: %ld\n", die->die_offset);
7587 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7589 print_spaces (outfile);
7590 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
7592 switch (AT_class (a))
7594 case dw_val_class_addr:
7595 fprintf (outfile, "address");
7597 case dw_val_class_offset:
7598 fprintf (outfile, "offset");
7600 case dw_val_class_loc:
7601 fprintf (outfile, "location descriptor");
7603 case dw_val_class_loc_list:
7604 fprintf (outfile, "location list -> label:%s",
7605 AT_loc_list (a)->ll_symbol);
7607 case dw_val_class_range_list:
7608 fprintf (outfile, "range list");
7610 case dw_val_class_const:
7611 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
7613 case dw_val_class_unsigned_const:
7614 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
7616 case dw_val_class_long_long:
7617 fprintf (outfile, "constant (" HOST_WIDE_INT_PRINT_UNSIGNED
7618 "," HOST_WIDE_INT_PRINT_UNSIGNED ")",
7619 CONST_DOUBLE_HIGH (a->dw_attr_val.v.val_long_long),
7620 CONST_DOUBLE_LOW (a->dw_attr_val.v.val_long_long));
7622 case dw_val_class_vec:
7623 fprintf (outfile, "floating-point or vector constant");
7625 case dw_val_class_flag:
7626 fprintf (outfile, "%u", AT_flag (a));
7628 case dw_val_class_die_ref:
7629 if (AT_ref (a) != NULL)
7631 if (AT_ref (a)->die_symbol)
7632 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
7634 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
7637 fprintf (outfile, "die -> <null>");
7639 case dw_val_class_lbl_id:
7640 case dw_val_class_lineptr:
7641 case dw_val_class_macptr:
7642 fprintf (outfile, "label: %s", AT_lbl (a));
7644 case dw_val_class_str:
7645 if (AT_string (a) != NULL)
7646 fprintf (outfile, "\"%s\"", AT_string (a));
7648 fprintf (outfile, "<null>");
7650 case dw_val_class_file:
7651 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
7652 AT_file (a)->emitted_number);
7658 fprintf (outfile, "\n");
7661 if (die->die_child != NULL)
7664 FOR_EACH_CHILD (die, c, print_die (c, outfile));
7667 if (print_indent == 0)
7668 fprintf (outfile, "\n");
7671 /* Print the contents of the source code line number correspondence table.
7672 This routine is a debugging aid only. */
7675 print_dwarf_line_table (FILE *outfile)
7678 dw_line_info_ref line_info;
7680 fprintf (outfile, "\n\nDWARF source line information\n");
7681 for (i = 1; i < line_info_table_in_use; i++)
7683 line_info = &line_info_table[i];
7684 fprintf (outfile, "%5d: %4ld %6ld\n", i,
7685 line_info->dw_file_num,
7686 line_info->dw_line_num);
7689 fprintf (outfile, "\n\n");
7692 /* Print the information collected for a given DIE. */
7695 debug_dwarf_die (dw_die_ref die)
7697 print_die (die, stderr);
7700 /* Print all DWARF information collected for the compilation unit.
7701 This routine is a debugging aid only. */
7707 print_die (comp_unit_die, stderr);
7708 if (! DWARF2_ASM_LINE_DEBUG_INFO)
7709 print_dwarf_line_table (stderr);
7712 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
7713 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
7714 DIE that marks the start of the DIEs for this include file. */
7717 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
7719 const char *filename = get_AT_string (bincl_die, DW_AT_name);
7720 dw_die_ref new_unit = gen_compile_unit_die (filename);
7722 new_unit->die_sib = old_unit;
7726 /* Close an include-file CU and reopen the enclosing one. */
7729 pop_compile_unit (dw_die_ref old_unit)
7731 dw_die_ref new_unit = old_unit->die_sib;
7733 old_unit->die_sib = NULL;
7737 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7738 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
7740 /* Calculate the checksum of a location expression. */
7743 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
7747 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
7749 CHECKSUM (loc->dw_loc_oprnd1);
7750 CHECKSUM (loc->dw_loc_oprnd2);
7753 /* Calculate the checksum of an attribute. */
7756 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
7758 dw_loc_descr_ref loc;
7761 CHECKSUM (at->dw_attr);
7763 /* We don't care that this was compiled with a different compiler
7764 snapshot; if the output is the same, that's what matters. */
7765 if (at->dw_attr == DW_AT_producer)
7768 switch (AT_class (at))
7770 case dw_val_class_const:
7771 CHECKSUM (at->dw_attr_val.v.val_int);
7773 case dw_val_class_unsigned_const:
7774 CHECKSUM (at->dw_attr_val.v.val_unsigned);
7776 case dw_val_class_long_long:
7777 CHECKSUM (CONST_DOUBLE_HIGH (at->dw_attr_val.v.val_long_long));
7778 CHECKSUM (CONST_DOUBLE_LOW (at->dw_attr_val.v.val_long_long));
7780 case dw_val_class_vec:
7781 CHECKSUM (at->dw_attr_val.v.val_vec);
7783 case dw_val_class_flag:
7784 CHECKSUM (at->dw_attr_val.v.val_flag);
7786 case dw_val_class_str:
7787 CHECKSUM_STRING (AT_string (at));
7790 case dw_val_class_addr:
7792 gcc_assert (GET_CODE (r) == SYMBOL_REF);
7793 CHECKSUM_STRING (XSTR (r, 0));
7796 case dw_val_class_offset:
7797 CHECKSUM (at->dw_attr_val.v.val_offset);
7800 case dw_val_class_loc:
7801 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
7802 loc_checksum (loc, ctx);
7805 case dw_val_class_die_ref:
7806 die_checksum (AT_ref (at), ctx, mark);
7809 case dw_val_class_fde_ref:
7810 case dw_val_class_lbl_id:
7811 case dw_val_class_lineptr:
7812 case dw_val_class_macptr:
7815 case dw_val_class_file:
7816 CHECKSUM_STRING (AT_file (at)->filename);
7824 /* Calculate the checksum of a DIE. */
7827 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
7833 /* To avoid infinite recursion. */
7836 CHECKSUM (die->die_mark);
7839 die->die_mark = ++(*mark);
7841 CHECKSUM (die->die_tag);
7843 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7844 attr_checksum (a, ctx, mark);
7846 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
7850 #undef CHECKSUM_STRING
7852 /* Do the location expressions look same? */
7854 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
7856 return loc1->dw_loc_opc == loc2->dw_loc_opc
7857 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
7858 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
7861 /* Do the values look the same? */
7863 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
7865 dw_loc_descr_ref loc1, loc2;
7868 if (v1->val_class != v2->val_class)
7871 switch (v1->val_class)
7873 case dw_val_class_const:
7874 return v1->v.val_int == v2->v.val_int;
7875 case dw_val_class_unsigned_const:
7876 return v1->v.val_unsigned == v2->v.val_unsigned;
7877 case dw_val_class_long_long:
7878 return CONST_DOUBLE_HIGH (v1->v.val_long_long)
7879 == CONST_DOUBLE_HIGH (v2->v.val_long_long)
7880 && CONST_DOUBLE_LOW (v1->v.val_long_long)
7881 == CONST_DOUBLE_LOW (v2->v.val_long_long);
7882 case dw_val_class_vec:
7883 if (v1->v.val_vec.length != v2->v.val_vec.length
7884 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
7886 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
7887 v1->v.val_vec.length * v1->v.val_vec.elt_size))
7890 case dw_val_class_flag:
7891 return v1->v.val_flag == v2->v.val_flag;
7892 case dw_val_class_str:
7893 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
7895 case dw_val_class_addr:
7896 r1 = v1->v.val_addr;
7897 r2 = v2->v.val_addr;
7898 if (GET_CODE (r1) != GET_CODE (r2))
7900 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
7901 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
7903 case dw_val_class_offset:
7904 return v1->v.val_offset == v2->v.val_offset;
7906 case dw_val_class_loc:
7907 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
7909 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7910 if (!same_loc_p (loc1, loc2, mark))
7912 return !loc1 && !loc2;
7914 case dw_val_class_die_ref:
7915 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7917 case dw_val_class_fde_ref:
7918 case dw_val_class_lbl_id:
7919 case dw_val_class_lineptr:
7920 case dw_val_class_macptr:
7923 case dw_val_class_file:
7924 return v1->v.val_file == v2->v.val_file;
7931 /* Do the attributes look the same? */
7934 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
7936 if (at1->dw_attr != at2->dw_attr)
7939 /* We don't care that this was compiled with a different compiler
7940 snapshot; if the output is the same, that's what matters. */
7941 if (at1->dw_attr == DW_AT_producer)
7944 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7947 /* Do the dies look the same? */
7950 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7956 /* To avoid infinite recursion. */
7958 return die1->die_mark == die2->die_mark;
7959 die1->die_mark = die2->die_mark = ++(*mark);
7961 if (die1->die_tag != die2->die_tag)
7964 if (VEC_length (dw_attr_node, die1->die_attr)
7965 != VEC_length (dw_attr_node, die2->die_attr))
7968 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
7969 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
7972 c1 = die1->die_child;
7973 c2 = die2->die_child;
7982 if (!same_die_p (c1, c2, mark))
7986 if (c1 == die1->die_child)
7988 if (c2 == die2->die_child)
7998 /* Do the dies look the same? Wrapper around same_die_p. */
8001 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
8004 int ret = same_die_p (die1, die2, &mark);
8006 unmark_all_dies (die1);
8007 unmark_all_dies (die2);
8012 /* The prefix to attach to symbols on DIEs in the current comdat debug
8014 static char *comdat_symbol_id;
8016 /* The index of the current symbol within the current comdat CU. */
8017 static unsigned int comdat_symbol_number;
8019 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
8020 children, and set comdat_symbol_id accordingly. */
8023 compute_section_prefix (dw_die_ref unit_die)
8025 const char *die_name = get_AT_string (unit_die, DW_AT_name);
8026 const char *base = die_name ? lbasename (die_name) : "anonymous";
8027 char *name = XALLOCAVEC (char, strlen (base) + 64);
8030 unsigned char checksum[16];
8033 /* Compute the checksum of the DIE, then append part of it as hex digits to
8034 the name filename of the unit. */
8036 md5_init_ctx (&ctx);
8038 die_checksum (unit_die, &ctx, &mark);
8039 unmark_all_dies (unit_die);
8040 md5_finish_ctx (&ctx, checksum);
8042 sprintf (name, "%s.", base);
8043 clean_symbol_name (name);
8045 p = name + strlen (name);
8046 for (i = 0; i < 4; i++)
8048 sprintf (p, "%.2x", checksum[i]);
8052 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
8053 comdat_symbol_number = 0;
8056 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
8059 is_type_die (dw_die_ref die)
8061 switch (die->die_tag)
8063 case DW_TAG_array_type:
8064 case DW_TAG_class_type:
8065 case DW_TAG_interface_type:
8066 case DW_TAG_enumeration_type:
8067 case DW_TAG_pointer_type:
8068 case DW_TAG_reference_type:
8069 case DW_TAG_string_type:
8070 case DW_TAG_structure_type:
8071 case DW_TAG_subroutine_type:
8072 case DW_TAG_union_type:
8073 case DW_TAG_ptr_to_member_type:
8074 case DW_TAG_set_type:
8075 case DW_TAG_subrange_type:
8076 case DW_TAG_base_type:
8077 case DW_TAG_const_type:
8078 case DW_TAG_file_type:
8079 case DW_TAG_packed_type:
8080 case DW_TAG_volatile_type:
8081 case DW_TAG_typedef:
8088 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
8089 Basically, we want to choose the bits that are likely to be shared between
8090 compilations (types) and leave out the bits that are specific to individual
8091 compilations (functions). */
8094 is_comdat_die (dw_die_ref c)
8096 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
8097 we do for stabs. The advantage is a greater likelihood of sharing between
8098 objects that don't include headers in the same order (and therefore would
8099 put the base types in a different comdat). jason 8/28/00 */
8101 if (c->die_tag == DW_TAG_base_type)
8104 if (c->die_tag == DW_TAG_pointer_type
8105 || c->die_tag == DW_TAG_reference_type
8106 || c->die_tag == DW_TAG_const_type
8107 || c->die_tag == DW_TAG_volatile_type)
8109 dw_die_ref t = get_AT_ref (c, DW_AT_type);
8111 return t ? is_comdat_die (t) : 0;
8114 return is_type_die (c);
8117 /* Returns 1 iff C is the sort of DIE that might be referred to from another
8118 compilation unit. */
8121 is_symbol_die (dw_die_ref c)
8123 return (is_type_die (c)
8124 || (get_AT (c, DW_AT_declaration)
8125 && !get_AT (c, DW_AT_specification))
8126 || c->die_tag == DW_TAG_namespace
8127 || c->die_tag == DW_TAG_module);
8131 gen_internal_sym (const char *prefix)
8135 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
8136 return xstrdup (buf);
8139 /* Assign symbols to all worthy DIEs under DIE. */
8142 assign_symbol_names (dw_die_ref die)
8146 if (is_symbol_die (die))
8148 if (comdat_symbol_id)
8150 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
8152 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
8153 comdat_symbol_id, comdat_symbol_number++);
8154 die->die_symbol = xstrdup (p);
8157 die->die_symbol = gen_internal_sym ("LDIE");
8160 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
8163 struct cu_hash_table_entry
8166 unsigned min_comdat_num, max_comdat_num;
8167 struct cu_hash_table_entry *next;
8170 /* Routines to manipulate hash table of CUs. */
8172 htab_cu_hash (const void *of)
8174 const struct cu_hash_table_entry *const entry =
8175 (const struct cu_hash_table_entry *) of;
8177 return htab_hash_string (entry->cu->die_symbol);
8181 htab_cu_eq (const void *of1, const void *of2)
8183 const struct cu_hash_table_entry *const entry1 =
8184 (const struct cu_hash_table_entry *) of1;
8185 const struct die_struct *const entry2 = (const struct die_struct *) of2;
8187 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
8191 htab_cu_del (void *what)
8193 struct cu_hash_table_entry *next,
8194 *entry = (struct cu_hash_table_entry *) what;
8204 /* Check whether we have already seen this CU and set up SYM_NUM
8207 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
8209 struct cu_hash_table_entry dummy;
8210 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
8212 dummy.max_comdat_num = 0;
8214 slot = (struct cu_hash_table_entry **)
8215 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
8219 for (; entry; last = entry, entry = entry->next)
8221 if (same_die_p_wrap (cu, entry->cu))
8227 *sym_num = entry->min_comdat_num;
8231 entry = XCNEW (struct cu_hash_table_entry);
8233 entry->min_comdat_num = *sym_num = last->max_comdat_num;
8234 entry->next = *slot;
8240 /* Record SYM_NUM to record of CU in HTABLE. */
8242 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
8244 struct cu_hash_table_entry **slot, *entry;
8246 slot = (struct cu_hash_table_entry **)
8247 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
8251 entry->max_comdat_num = sym_num;
8254 /* Traverse the DIE (which is always comp_unit_die), and set up
8255 additional compilation units for each of the include files we see
8256 bracketed by BINCL/EINCL. */
8259 break_out_includes (dw_die_ref die)
8262 dw_die_ref unit = NULL;
8263 limbo_die_node *node, **pnode;
8264 htab_t cu_hash_table;
8268 dw_die_ref prev = c;
8270 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
8271 || (unit && is_comdat_die (c)))
8273 dw_die_ref next = c->die_sib;
8275 /* This DIE is for a secondary CU; remove it from the main one. */
8276 remove_child_with_prev (c, prev);
8278 if (c->die_tag == DW_TAG_GNU_BINCL)
8279 unit = push_new_compile_unit (unit, c);
8280 else if (c->die_tag == DW_TAG_GNU_EINCL)
8281 unit = pop_compile_unit (unit);
8283 add_child_die (unit, c);
8285 if (c == die->die_child)
8288 } while (c != die->die_child);
8291 /* We can only use this in debugging, since the frontend doesn't check
8292 to make sure that we leave every include file we enter. */
8296 assign_symbol_names (die);
8297 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
8298 for (node = limbo_die_list, pnode = &limbo_die_list;
8304 compute_section_prefix (node->die);
8305 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
8306 &comdat_symbol_number);
8307 assign_symbol_names (node->die);
8309 *pnode = node->next;
8312 pnode = &node->next;
8313 record_comdat_symbol_number (node->die, cu_hash_table,
8314 comdat_symbol_number);
8317 htab_delete (cu_hash_table);
8320 /* Traverse the DIE and add a sibling attribute if it may have the
8321 effect of speeding up access to siblings. To save some space,
8322 avoid generating sibling attributes for DIE's without children. */
8325 add_sibling_attributes (dw_die_ref die)
8329 if (! die->die_child)
8332 if (die->die_parent && die != die->die_parent->die_child)
8333 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
8335 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
8338 /* Output all location lists for the DIE and its children. */
8341 output_location_lists (dw_die_ref die)
8347 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8348 if (AT_class (a) == dw_val_class_loc_list)
8349 output_loc_list (AT_loc_list (a));
8351 FOR_EACH_CHILD (die, c, output_location_lists (c));
8354 /* The format of each DIE (and its attribute value pairs) is encoded in an
8355 abbreviation table. This routine builds the abbreviation table and assigns
8356 a unique abbreviation id for each abbreviation entry. The children of each
8357 die are visited recursively. */
8360 build_abbrev_table (dw_die_ref die)
8362 unsigned long abbrev_id;
8363 unsigned int n_alloc;
8368 /* Scan the DIE references, and mark as external any that refer to
8369 DIEs from other CUs (i.e. those which are not marked). */
8370 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8371 if (AT_class (a) == dw_val_class_die_ref
8372 && AT_ref (a)->die_mark == 0)
8374 gcc_assert (AT_ref (a)->die_symbol);
8375 set_AT_ref_external (a, 1);
8378 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8380 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
8381 dw_attr_ref die_a, abbrev_a;
8385 if (abbrev->die_tag != die->die_tag)
8387 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
8390 if (VEC_length (dw_attr_node, abbrev->die_attr)
8391 != VEC_length (dw_attr_node, die->die_attr))
8394 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
8396 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
8397 if ((abbrev_a->dw_attr != die_a->dw_attr)
8398 || (value_format (abbrev_a) != value_format (die_a)))
8408 if (abbrev_id >= abbrev_die_table_in_use)
8410 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
8412 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
8413 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
8416 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
8417 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
8418 abbrev_die_table_allocated = n_alloc;
8421 ++abbrev_die_table_in_use;
8422 abbrev_die_table[abbrev_id] = die;
8425 die->die_abbrev = abbrev_id;
8426 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
8429 /* Return the power-of-two number of bytes necessary to represent VALUE. */
8432 constant_size (unsigned HOST_WIDE_INT value)
8439 log = floor_log2 (value);
8442 log = 1 << (floor_log2 (log) + 1);
8447 /* Return the size of a DIE as it is represented in the
8448 .debug_info section. */
8450 static unsigned long
8451 size_of_die (dw_die_ref die)
8453 unsigned long size = 0;
8457 size += size_of_uleb128 (die->die_abbrev);
8458 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8460 switch (AT_class (a))
8462 case dw_val_class_addr:
8463 size += DWARF2_ADDR_SIZE;
8465 case dw_val_class_offset:
8466 size += DWARF_OFFSET_SIZE;
8468 case dw_val_class_loc:
8470 unsigned long lsize = size_of_locs (AT_loc (a));
8473 size += constant_size (lsize);
8477 case dw_val_class_loc_list:
8478 size += DWARF_OFFSET_SIZE;
8480 case dw_val_class_range_list:
8481 size += DWARF_OFFSET_SIZE;
8483 case dw_val_class_const:
8484 size += size_of_sleb128 (AT_int (a));
8486 case dw_val_class_unsigned_const:
8487 size += constant_size (AT_unsigned (a));
8489 case dw_val_class_long_long:
8490 size += 1 + 2*HOST_BITS_PER_WIDE_INT/HOST_BITS_PER_CHAR; /* block */
8492 case dw_val_class_vec:
8493 size += constant_size (a->dw_attr_val.v.val_vec.length
8494 * a->dw_attr_val.v.val_vec.elt_size)
8495 + a->dw_attr_val.v.val_vec.length
8496 * a->dw_attr_val.v.val_vec.elt_size; /* block */
8498 case dw_val_class_flag:
8501 case dw_val_class_die_ref:
8502 /* In DWARF2, DW_FORM_ref_addr is sized by target address length,
8503 whereas in DWARF3 it's always sized as an offset. */
8504 if (AT_ref_external (a) && dwarf_version == 2)
8505 size += DWARF2_ADDR_SIZE;
8507 size += DWARF_OFFSET_SIZE;
8509 case dw_val_class_fde_ref:
8510 size += DWARF_OFFSET_SIZE;
8512 case dw_val_class_lbl_id:
8513 size += DWARF2_ADDR_SIZE;
8515 case dw_val_class_lineptr:
8516 case dw_val_class_macptr:
8517 size += DWARF_OFFSET_SIZE;
8519 case dw_val_class_str:
8520 if (AT_string_form (a) == DW_FORM_strp)
8521 size += DWARF_OFFSET_SIZE;
8523 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
8525 case dw_val_class_file:
8526 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
8536 /* Size the debugging information associated with a given DIE. Visits the
8537 DIE's children recursively. Updates the global variable next_die_offset, on
8538 each time through. Uses the current value of next_die_offset to update the
8539 die_offset field in each DIE. */
8542 calc_die_sizes (dw_die_ref die)
8546 die->die_offset = next_die_offset;
8547 next_die_offset += size_of_die (die);
8549 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
8551 if (die->die_child != NULL)
8552 /* Count the null byte used to terminate sibling lists. */
8553 next_die_offset += 1;
8556 /* Set the marks for a die and its children. We do this so
8557 that we know whether or not a reference needs to use FORM_ref_addr; only
8558 DIEs in the same CU will be marked. We used to clear out the offset
8559 and use that as the flag, but ran into ordering problems. */
8562 mark_dies (dw_die_ref die)
8566 gcc_assert (!die->die_mark);
8569 FOR_EACH_CHILD (die, c, mark_dies (c));
8572 /* Clear the marks for a die and its children. */
8575 unmark_dies (dw_die_ref die)
8579 gcc_assert (die->die_mark);
8582 FOR_EACH_CHILD (die, c, unmark_dies (c));
8585 /* Clear the marks for a die, its children and referred dies. */
8588 unmark_all_dies (dw_die_ref die)
8598 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
8600 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8601 if (AT_class (a) == dw_val_class_die_ref)
8602 unmark_all_dies (AT_ref (a));
8605 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8606 generated for the compilation unit. */
8608 static unsigned long
8609 size_of_pubnames (VEC (pubname_entry, gc) * names)
8615 size = DWARF_PUBNAMES_HEADER_SIZE;
8616 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
8617 if (names != pubtype_table
8618 || p->die->die_offset != 0
8619 || !flag_eliminate_unused_debug_types)
8620 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
8622 size += DWARF_OFFSET_SIZE;
8626 /* Return the size of the information in the .debug_aranges section. */
8628 static unsigned long
8629 size_of_aranges (void)
8633 size = DWARF_ARANGES_HEADER_SIZE;
8635 /* Count the address/length pair for this compilation unit. */
8636 if (text_section_used)
8637 size += 2 * DWARF2_ADDR_SIZE;
8638 if (cold_text_section_used)
8639 size += 2 * DWARF2_ADDR_SIZE;
8640 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
8642 /* Count the two zero words used to terminated the address range table. */
8643 size += 2 * DWARF2_ADDR_SIZE;
8647 /* Select the encoding of an attribute value. */
8649 static enum dwarf_form
8650 value_format (dw_attr_ref a)
8652 switch (a->dw_attr_val.val_class)
8654 case dw_val_class_addr:
8655 return DW_FORM_addr;
8656 case dw_val_class_range_list:
8657 case dw_val_class_offset:
8658 case dw_val_class_loc_list:
8659 switch (DWARF_OFFSET_SIZE)
8662 return DW_FORM_data4;
8664 return DW_FORM_data8;
8668 case dw_val_class_loc:
8669 switch (constant_size (size_of_locs (AT_loc (a))))
8672 return DW_FORM_block1;
8674 return DW_FORM_block2;
8678 case dw_val_class_const:
8679 return DW_FORM_sdata;
8680 case dw_val_class_unsigned_const:
8681 switch (constant_size (AT_unsigned (a)))
8684 return DW_FORM_data1;
8686 return DW_FORM_data2;
8688 return DW_FORM_data4;
8690 return DW_FORM_data8;
8694 case dw_val_class_long_long:
8695 return DW_FORM_block1;
8696 case dw_val_class_vec:
8697 switch (constant_size (a->dw_attr_val.v.val_vec.length
8698 * a->dw_attr_val.v.val_vec.elt_size))
8701 return DW_FORM_block1;
8703 return DW_FORM_block2;
8705 return DW_FORM_block4;
8709 case dw_val_class_flag:
8710 return DW_FORM_flag;
8711 case dw_val_class_die_ref:
8712 if (AT_ref_external (a))
8713 return DW_FORM_ref_addr;
8716 case dw_val_class_fde_ref:
8717 return DW_FORM_data;
8718 case dw_val_class_lbl_id:
8719 return DW_FORM_addr;
8720 case dw_val_class_lineptr:
8721 case dw_val_class_macptr:
8722 return DW_FORM_data;
8723 case dw_val_class_str:
8724 return AT_string_form (a);
8725 case dw_val_class_file:
8726 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
8729 return DW_FORM_data1;
8731 return DW_FORM_data2;
8733 return DW_FORM_data4;
8743 /* Output the encoding of an attribute value. */
8746 output_value_format (dw_attr_ref a)
8748 enum dwarf_form form = value_format (a);
8750 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
8753 /* Output the .debug_abbrev section which defines the DIE abbreviation
8757 output_abbrev_section (void)
8759 unsigned long abbrev_id;
8761 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8763 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
8767 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
8768 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
8769 dwarf_tag_name (abbrev->die_tag));
8771 if (abbrev->die_child != NULL)
8772 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
8774 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
8776 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
8779 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
8780 dwarf_attr_name (a_attr->dw_attr));
8781 output_value_format (a_attr);
8784 dw2_asm_output_data (1, 0, NULL);
8785 dw2_asm_output_data (1, 0, NULL);
8788 /* Terminate the table. */
8789 dw2_asm_output_data (1, 0, NULL);
8792 /* Output a symbol we can use to refer to this DIE from another CU. */
8795 output_die_symbol (dw_die_ref die)
8797 char *sym = die->die_symbol;
8802 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
8803 /* We make these global, not weak; if the target doesn't support
8804 .linkonce, it doesn't support combining the sections, so debugging
8806 targetm.asm_out.globalize_label (asm_out_file, sym);
8808 ASM_OUTPUT_LABEL (asm_out_file, sym);
8811 /* Return a new location list, given the begin and end range, and the
8812 expression. gensym tells us whether to generate a new internal symbol for
8813 this location list node, which is done for the head of the list only. */
8815 static inline dw_loc_list_ref
8816 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
8817 const char *section, unsigned int gensym)
8819 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
8821 retlist->begin = begin;
8823 retlist->expr = expr;
8824 retlist->section = section;
8826 retlist->ll_symbol = gen_internal_sym ("LLST");
8831 /* Add a location description expression to a location list. */
8834 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
8835 const char *begin, const char *end,
8836 const char *section)
8840 /* Find the end of the chain. */
8841 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
8844 /* Add a new location list node to the list. */
8845 *d = new_loc_list (descr, begin, end, section, 0);
8848 /* Output the location list given to us. */
8851 output_loc_list (dw_loc_list_ref list_head)
8853 dw_loc_list_ref curr = list_head;
8855 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
8857 /* Walk the location list, and output each range + expression. */
8858 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
8861 /* Don't output an entry that starts and ends at the same address. */
8862 if (strcmp (curr->begin, curr->end) == 0)
8864 if (!have_multiple_function_sections)
8866 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
8867 "Location list begin address (%s)",
8868 list_head->ll_symbol);
8869 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
8870 "Location list end address (%s)",
8871 list_head->ll_symbol);
8875 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
8876 "Location list begin address (%s)",
8877 list_head->ll_symbol);
8878 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
8879 "Location list end address (%s)",
8880 list_head->ll_symbol);
8882 size = size_of_locs (curr->expr);
8884 /* Output the block length for this list of location operations. */
8885 gcc_assert (size <= 0xffff);
8886 dw2_asm_output_data (2, size, "%s", "Location expression size");
8888 output_loc_sequence (curr->expr);
8891 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8892 "Location list terminator begin (%s)",
8893 list_head->ll_symbol);
8894 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8895 "Location list terminator end (%s)",
8896 list_head->ll_symbol);
8899 /* Output the DIE and its attributes. Called recursively to generate
8900 the definitions of each child DIE. */
8903 output_die (dw_die_ref die)
8910 /* If someone in another CU might refer to us, set up a symbol for
8911 them to point to. */
8912 if (die->die_symbol)
8913 output_die_symbol (die);
8915 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
8916 (unsigned long)die->die_offset,
8917 dwarf_tag_name (die->die_tag));
8919 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8921 const char *name = dwarf_attr_name (a->dw_attr);
8923 switch (AT_class (a))
8925 case dw_val_class_addr:
8926 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8929 case dw_val_class_offset:
8930 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8934 case dw_val_class_range_list:
8936 char *p = strchr (ranges_section_label, '\0');
8938 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8939 a->dw_attr_val.v.val_offset);
8940 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8941 debug_ranges_section, "%s", name);
8946 case dw_val_class_loc:
8947 size = size_of_locs (AT_loc (a));
8949 /* Output the block length for this list of location operations. */
8950 dw2_asm_output_data (constant_size (size), size, "%s", name);
8952 output_loc_sequence (AT_loc (a));
8955 case dw_val_class_const:
8956 /* ??? It would be slightly more efficient to use a scheme like is
8957 used for unsigned constants below, but gdb 4.x does not sign
8958 extend. Gdb 5.x does sign extend. */
8959 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8962 case dw_val_class_unsigned_const:
8963 dw2_asm_output_data (constant_size (AT_unsigned (a)),
8964 AT_unsigned (a), "%s", name);
8967 case dw_val_class_long_long:
8969 unsigned HOST_WIDE_INT first, second;
8971 dw2_asm_output_data (1,
8972 2 * HOST_BITS_PER_WIDE_INT
8973 / HOST_BITS_PER_CHAR,
8976 if (WORDS_BIG_ENDIAN)
8978 first = CONST_DOUBLE_HIGH (a->dw_attr_val.v.val_long_long);
8979 second = CONST_DOUBLE_LOW (a->dw_attr_val.v.val_long_long);
8983 first = CONST_DOUBLE_LOW (a->dw_attr_val.v.val_long_long);
8984 second = CONST_DOUBLE_HIGH (a->dw_attr_val.v.val_long_long);
8987 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8988 first, "long long constant");
8989 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8994 case dw_val_class_vec:
8996 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8997 unsigned int len = a->dw_attr_val.v.val_vec.length;
9001 dw2_asm_output_data (constant_size (len * elt_size),
9002 len * elt_size, "%s", name);
9003 if (elt_size > sizeof (HOST_WIDE_INT))
9008 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
9011 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
9012 "fp or vector constant word %u", i);
9016 case dw_val_class_flag:
9017 dw2_asm_output_data (1, AT_flag (a), "%s", name);
9020 case dw_val_class_loc_list:
9022 char *sym = AT_loc_list (a)->ll_symbol;
9025 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
9030 case dw_val_class_die_ref:
9031 if (AT_ref_external (a))
9033 char *sym = AT_ref (a)->die_symbol;
9038 /* In DWARF2, DW_FORM_ref_addr is sized by target address
9039 length, whereas in DWARF3 it's always sized as an offset. */
9040 if (dwarf_version == 2)
9041 size = DWARF2_ADDR_SIZE;
9043 size = DWARF_OFFSET_SIZE;
9044 dw2_asm_output_offset (size, sym, debug_info_section, "%s", name);
9048 gcc_assert (AT_ref (a)->die_offset);
9049 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
9054 case dw_val_class_fde_ref:
9058 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
9059 a->dw_attr_val.v.val_fde_index * 2);
9060 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
9065 case dw_val_class_lbl_id:
9066 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
9069 case dw_val_class_lineptr:
9070 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9071 debug_line_section, "%s", name);
9074 case dw_val_class_macptr:
9075 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9076 debug_macinfo_section, "%s", name);
9079 case dw_val_class_str:
9080 if (AT_string_form (a) == DW_FORM_strp)
9081 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
9082 a->dw_attr_val.v.val_str->label,
9084 "%s: \"%s\"", name, AT_string (a));
9086 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
9089 case dw_val_class_file:
9091 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
9093 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
9094 a->dw_attr_val.v.val_file->filename);
9103 FOR_EACH_CHILD (die, c, output_die (c));
9105 /* Add null byte to terminate sibling list. */
9106 if (die->die_child != NULL)
9107 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
9108 (unsigned long) die->die_offset);
9111 /* Output the compilation unit that appears at the beginning of the
9112 .debug_info section, and precedes the DIE descriptions. */
9115 output_compilation_unit_header (void)
9117 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9118 dw2_asm_output_data (4, 0xffffffff,
9119 "Initial length escape value indicating 64-bit DWARF extension");
9120 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9121 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
9122 "Length of Compilation Unit Info");
9123 dw2_asm_output_data (2, dwarf_version, "DWARF version number");
9124 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
9125 debug_abbrev_section,
9126 "Offset Into Abbrev. Section");
9127 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9130 /* Output the compilation unit DIE and its children. */
9133 output_comp_unit (dw_die_ref die, int output_if_empty)
9135 const char *secname;
9138 /* Unless we are outputting main CU, we may throw away empty ones. */
9139 if (!output_if_empty && die->die_child == NULL)
9142 /* Even if there are no children of this DIE, we must output the information
9143 about the compilation unit. Otherwise, on an empty translation unit, we
9144 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
9145 will then complain when examining the file. First mark all the DIEs in
9146 this CU so we know which get local refs. */
9149 build_abbrev_table (die);
9151 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9152 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
9153 calc_die_sizes (die);
9155 oldsym = die->die_symbol;
9158 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
9160 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
9162 die->die_symbol = NULL;
9163 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9166 switch_to_section (debug_info_section);
9168 /* Output debugging information. */
9169 output_compilation_unit_header ();
9172 /* Leave the marks on the main CU, so we can check them in
9177 die->die_symbol = oldsym;
9181 /* Return the DWARF2/3 pubname associated with a decl. */
9184 dwarf2_name (tree decl, int scope)
9186 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
9189 /* Add a new entry to .debug_pubnames if appropriate. */
9192 add_pubname_string (const char *str, dw_die_ref die)
9197 e.name = xstrdup (str);
9198 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
9202 add_pubname (tree decl, dw_die_ref die)
9204 if (TREE_PUBLIC (decl))
9205 add_pubname_string (dwarf2_name (decl, 1), die);
9208 /* Add a new entry to .debug_pubtypes if appropriate. */
9211 add_pubtype (tree decl, dw_die_ref die)
9216 if ((TREE_PUBLIC (decl)
9217 || die->die_parent == comp_unit_die)
9218 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
9223 if (TYPE_NAME (decl))
9225 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
9226 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
9227 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
9228 && DECL_NAME (TYPE_NAME (decl)))
9229 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
9231 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
9235 e.name = xstrdup (dwarf2_name (decl, 1));
9237 /* If we don't have a name for the type, there's no point in adding
9239 if (e.name && e.name[0] != '\0')
9240 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
9244 /* Output the public names table used to speed up access to externally
9245 visible names; or the public types table used to find type definitions. */
9248 output_pubnames (VEC (pubname_entry, gc) * names)
9251 unsigned long pubnames_length = size_of_pubnames (names);
9254 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9255 dw2_asm_output_data (4, 0xffffffff,
9256 "Initial length escape value indicating 64-bit DWARF extension");
9257 if (names == pubname_table)
9258 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
9259 "Length of Public Names Info");
9261 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
9262 "Length of Public Type Names Info");
9263 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
9264 dw2_asm_output_data (2, 2, "DWARF Version");
9265 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9267 "Offset of Compilation Unit Info");
9268 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
9269 "Compilation Unit Length");
9271 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
9273 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9274 if (names == pubname_table)
9275 gcc_assert (pub->die->die_mark);
9277 if (names != pubtype_table
9278 || pub->die->die_offset != 0
9279 || !flag_eliminate_unused_debug_types)
9281 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
9284 dw2_asm_output_nstring (pub->name, -1, "external name");
9288 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
9291 /* Add a new entry to .debug_aranges if appropriate. */
9294 add_arange (tree decl, dw_die_ref die)
9296 if (! DECL_SECTION_NAME (decl))
9299 if (arange_table_in_use == arange_table_allocated)
9301 arange_table_allocated += ARANGE_TABLE_INCREMENT;
9302 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
9303 arange_table_allocated);
9304 memset (arange_table + arange_table_in_use, 0,
9305 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
9308 arange_table[arange_table_in_use++] = die;
9311 /* Output the information that goes into the .debug_aranges table.
9312 Namely, define the beginning and ending address range of the
9313 text section generated for this compilation unit. */
9316 output_aranges (void)
9319 unsigned long aranges_length = size_of_aranges ();
9321 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9322 dw2_asm_output_data (4, 0xffffffff,
9323 "Initial length escape value indicating 64-bit DWARF extension");
9324 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
9325 "Length of Address Ranges Info");
9326 /* Version number for aranges is still 2, even in DWARF3. */
9327 dw2_asm_output_data (2, 2, "DWARF Version");
9328 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9330 "Offset of Compilation Unit Info");
9331 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
9332 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9334 /* We need to align to twice the pointer size here. */
9335 if (DWARF_ARANGES_PAD_SIZE)
9337 /* Pad using a 2 byte words so that padding is correct for any
9339 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9340 2 * DWARF2_ADDR_SIZE);
9341 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
9342 dw2_asm_output_data (2, 0, NULL);
9345 /* It is necessary not to output these entries if the sections were
9346 not used; if the sections were not used, the length will be 0 and
9347 the address may end up as 0 if the section is discarded by ld
9348 --gc-sections, leaving an invalid (0, 0) entry that can be
9349 confused with the terminator. */
9350 if (text_section_used)
9352 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
9353 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
9354 text_section_label, "Length");
9356 if (cold_text_section_used)
9358 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
9360 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
9361 cold_text_section_label, "Length");
9364 for (i = 0; i < arange_table_in_use; i++)
9366 dw_die_ref die = arange_table[i];
9368 /* We shouldn't see aranges for DIEs outside of the main CU. */
9369 gcc_assert (die->die_mark);
9371 if (die->die_tag == DW_TAG_subprogram)
9373 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
9375 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
9376 get_AT_low_pc (die), "Length");
9380 /* A static variable; extract the symbol from DW_AT_location.
9381 Note that this code isn't currently hit, as we only emit
9382 aranges for functions (jason 9/23/99). */
9383 dw_attr_ref a = get_AT (die, DW_AT_location);
9384 dw_loc_descr_ref loc;
9386 gcc_assert (a && AT_class (a) == dw_val_class_loc);
9389 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
9391 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
9392 loc->dw_loc_oprnd1.v.val_addr, "Address");
9393 dw2_asm_output_data (DWARF2_ADDR_SIZE,
9394 get_AT_unsigned (die, DW_AT_byte_size),
9399 /* Output the terminator words. */
9400 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9401 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9404 /* Add a new entry to .debug_ranges. Return the offset at which it
9408 add_ranges_num (int num)
9410 unsigned int in_use = ranges_table_in_use;
9412 if (in_use == ranges_table_allocated)
9414 ranges_table_allocated += RANGES_TABLE_INCREMENT;
9415 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
9416 ranges_table_allocated);
9417 memset (ranges_table + ranges_table_in_use, 0,
9418 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
9421 ranges_table[in_use].num = num;
9422 ranges_table_in_use = in_use + 1;
9424 return in_use * 2 * DWARF2_ADDR_SIZE;
9427 /* Add a new entry to .debug_ranges corresponding to a block, or a
9428 range terminator if BLOCK is NULL. */
9431 add_ranges (const_tree block)
9433 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
9436 /* Add a new entry to .debug_ranges corresponding to a pair of
9440 add_ranges_by_labels (const char *begin, const char *end)
9442 unsigned int in_use = ranges_by_label_in_use;
9444 if (in_use == ranges_by_label_allocated)
9446 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
9447 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
9449 ranges_by_label_allocated);
9450 memset (ranges_by_label + ranges_by_label_in_use, 0,
9451 RANGES_TABLE_INCREMENT
9452 * sizeof (struct dw_ranges_by_label_struct));
9455 ranges_by_label[in_use].begin = begin;
9456 ranges_by_label[in_use].end = end;
9457 ranges_by_label_in_use = in_use + 1;
9459 return add_ranges_num (-(int)in_use - 1);
9463 output_ranges (void)
9466 static const char *const start_fmt = "Offset 0x%x";
9467 const char *fmt = start_fmt;
9469 for (i = 0; i < ranges_table_in_use; i++)
9471 int block_num = ranges_table[i].num;
9475 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
9476 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
9478 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
9479 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
9481 /* If all code is in the text section, then the compilation
9482 unit base address defaults to DW_AT_low_pc, which is the
9483 base of the text section. */
9484 if (!have_multiple_function_sections)
9486 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
9488 fmt, i * 2 * DWARF2_ADDR_SIZE);
9489 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
9490 text_section_label, NULL);
9493 /* Otherwise, the compilation unit base address is zero,
9494 which allows us to use absolute addresses, and not worry
9495 about whether the target supports cross-section
9499 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
9500 fmt, i * 2 * DWARF2_ADDR_SIZE);
9501 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
9507 /* Negative block_num stands for an index into ranges_by_label. */
9508 else if (block_num < 0)
9510 int lab_idx = - block_num - 1;
9512 if (!have_multiple_function_sections)
9516 /* If we ever use add_ranges_by_labels () for a single
9517 function section, all we have to do is to take out
9519 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9520 ranges_by_label[lab_idx].begin,
9522 fmt, i * 2 * DWARF2_ADDR_SIZE);
9523 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9524 ranges_by_label[lab_idx].end,
9525 text_section_label, NULL);
9530 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9531 ranges_by_label[lab_idx].begin,
9532 fmt, i * 2 * DWARF2_ADDR_SIZE);
9533 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9534 ranges_by_label[lab_idx].end,
9540 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9541 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9547 /* Data structure containing information about input files. */
9550 const char *path; /* Complete file name. */
9551 const char *fname; /* File name part. */
9552 int length; /* Length of entire string. */
9553 struct dwarf_file_data * file_idx; /* Index in input file table. */
9554 int dir_idx; /* Index in directory table. */
9557 /* Data structure containing information about directories with source
9561 const char *path; /* Path including directory name. */
9562 int length; /* Path length. */
9563 int prefix; /* Index of directory entry which is a prefix. */
9564 int count; /* Number of files in this directory. */
9565 int dir_idx; /* Index of directory used as base. */
9568 /* Callback function for file_info comparison. We sort by looking at
9569 the directories in the path. */
9572 file_info_cmp (const void *p1, const void *p2)
9574 const struct file_info *const s1 = (const struct file_info *) p1;
9575 const struct file_info *const s2 = (const struct file_info *) p2;
9576 const unsigned char *cp1;
9577 const unsigned char *cp2;
9579 /* Take care of file names without directories. We need to make sure that
9580 we return consistent values to qsort since some will get confused if
9581 we return the same value when identical operands are passed in opposite
9582 orders. So if neither has a directory, return 0 and otherwise return
9583 1 or -1 depending on which one has the directory. */
9584 if ((s1->path == s1->fname || s2->path == s2->fname))
9585 return (s2->path == s2->fname) - (s1->path == s1->fname);
9587 cp1 = (const unsigned char *) s1->path;
9588 cp2 = (const unsigned char *) s2->path;
9594 /* Reached the end of the first path? If so, handle like above. */
9595 if ((cp1 == (const unsigned char *) s1->fname)
9596 || (cp2 == (const unsigned char *) s2->fname))
9597 return ((cp2 == (const unsigned char *) s2->fname)
9598 - (cp1 == (const unsigned char *) s1->fname));
9600 /* Character of current path component the same? */
9601 else if (*cp1 != *cp2)
9606 struct file_name_acquire_data
9608 struct file_info *files;
9613 /* Traversal function for the hash table. */
9616 file_name_acquire (void ** slot, void *data)
9618 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
9619 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
9620 struct file_info *fi;
9623 gcc_assert (fnad->max_files >= d->emitted_number);
9625 if (! d->emitted_number)
9628 gcc_assert (fnad->max_files != fnad->used_files);
9630 fi = fnad->files + fnad->used_files++;
9632 /* Skip all leading "./". */
9634 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
9637 /* Create a new array entry. */
9639 fi->length = strlen (f);
9642 /* Search for the file name part. */
9643 f = strrchr (f, DIR_SEPARATOR);
9644 #if defined (DIR_SEPARATOR_2)
9646 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
9650 if (f == NULL || f < g)
9656 fi->fname = f == NULL ? fi->path : f + 1;
9660 /* Output the directory table and the file name table. We try to minimize
9661 the total amount of memory needed. A heuristic is used to avoid large
9662 slowdowns with many input files. */
9665 output_file_names (void)
9667 struct file_name_acquire_data fnad;
9669 struct file_info *files;
9670 struct dir_info *dirs;
9679 if (!last_emitted_file)
9681 dw2_asm_output_data (1, 0, "End directory table");
9682 dw2_asm_output_data (1, 0, "End file name table");
9686 numfiles = last_emitted_file->emitted_number;
9688 /* Allocate the various arrays we need. */
9689 files = XALLOCAVEC (struct file_info, numfiles);
9690 dirs = XALLOCAVEC (struct dir_info, numfiles);
9693 fnad.used_files = 0;
9694 fnad.max_files = numfiles;
9695 htab_traverse (file_table, file_name_acquire, &fnad);
9696 gcc_assert (fnad.used_files == fnad.max_files);
9698 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
9700 /* Find all the different directories used. */
9701 dirs[0].path = files[0].path;
9702 dirs[0].length = files[0].fname - files[0].path;
9703 dirs[0].prefix = -1;
9705 dirs[0].dir_idx = 0;
9706 files[0].dir_idx = 0;
9709 for (i = 1; i < numfiles; i++)
9710 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
9711 && memcmp (dirs[ndirs - 1].path, files[i].path,
9712 dirs[ndirs - 1].length) == 0)
9714 /* Same directory as last entry. */
9715 files[i].dir_idx = ndirs - 1;
9716 ++dirs[ndirs - 1].count;
9722 /* This is a new directory. */
9723 dirs[ndirs].path = files[i].path;
9724 dirs[ndirs].length = files[i].fname - files[i].path;
9725 dirs[ndirs].count = 1;
9726 dirs[ndirs].dir_idx = ndirs;
9727 files[i].dir_idx = ndirs;
9729 /* Search for a prefix. */
9730 dirs[ndirs].prefix = -1;
9731 for (j = 0; j < ndirs; j++)
9732 if (dirs[j].length < dirs[ndirs].length
9733 && dirs[j].length > 1
9734 && (dirs[ndirs].prefix == -1
9735 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
9736 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
9737 dirs[ndirs].prefix = j;
9742 /* Now to the actual work. We have to find a subset of the directories which
9743 allow expressing the file name using references to the directory table
9744 with the least amount of characters. We do not do an exhaustive search
9745 where we would have to check out every combination of every single
9746 possible prefix. Instead we use a heuristic which provides nearly optimal
9747 results in most cases and never is much off. */
9748 saved = XALLOCAVEC (int, ndirs);
9749 savehere = XALLOCAVEC (int, ndirs);
9751 memset (saved, '\0', ndirs * sizeof (saved[0]));
9752 for (i = 0; i < ndirs; i++)
9757 /* We can always save some space for the current directory. But this
9758 does not mean it will be enough to justify adding the directory. */
9759 savehere[i] = dirs[i].length;
9760 total = (savehere[i] - saved[i]) * dirs[i].count;
9762 for (j = i + 1; j < ndirs; j++)
9765 if (saved[j] < dirs[i].length)
9767 /* Determine whether the dirs[i] path is a prefix of the
9772 while (k != -1 && k != (int) i)
9777 /* Yes it is. We can possibly save some memory by
9778 writing the filenames in dirs[j] relative to
9780 savehere[j] = dirs[i].length;
9781 total += (savehere[j] - saved[j]) * dirs[j].count;
9786 /* Check whether we can save enough to justify adding the dirs[i]
9788 if (total > dirs[i].length + 1)
9790 /* It's worthwhile adding. */
9791 for (j = i; j < ndirs; j++)
9792 if (savehere[j] > 0)
9794 /* Remember how much we saved for this directory so far. */
9795 saved[j] = savehere[j];
9797 /* Remember the prefix directory. */
9798 dirs[j].dir_idx = i;
9803 /* Emit the directory name table. */
9805 idx_offset = dirs[0].length > 0 ? 1 : 0;
9806 for (i = 1 - idx_offset; i < ndirs; i++)
9807 dw2_asm_output_nstring (dirs[i].path,
9809 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
9810 "Directory Entry: 0x%x", i + idx_offset);
9812 dw2_asm_output_data (1, 0, "End directory table");
9814 /* We have to emit them in the order of emitted_number since that's
9815 used in the debug info generation. To do this efficiently we
9816 generate a back-mapping of the indices first. */
9817 backmap = XALLOCAVEC (int, numfiles);
9818 for (i = 0; i < numfiles; i++)
9819 backmap[files[i].file_idx->emitted_number - 1] = i;
9821 /* Now write all the file names. */
9822 for (i = 0; i < numfiles; i++)
9824 int file_idx = backmap[i];
9825 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
9827 #ifdef VMS_DEBUGGING_INFO
9828 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
9830 /* Setting these fields can lead to debugger miscomparisons,
9831 but VMS Debug requires them to be set correctly. */
9836 int maxfilelen = strlen (files[file_idx].path)
9837 + dirs[dir_idx].length
9838 + MAX_VMS_VERSION_LEN + 1;
9839 char *filebuf = XALLOCAVEC (char, maxfilelen);
9841 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
9842 snprintf (filebuf, maxfilelen, "%s;%d",
9843 files[file_idx].path + dirs[dir_idx].length, ver);
9845 dw2_asm_output_nstring
9846 (filebuf, -1, "File Entry: 0x%x", (unsigned) i + 1);
9848 /* Include directory index. */
9849 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
9851 /* Modification time. */
9852 dw2_asm_output_data_uleb128
9853 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
9857 /* File length in bytes. */
9858 dw2_asm_output_data_uleb128
9859 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
9863 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
9864 "File Entry: 0x%x", (unsigned) i + 1);
9866 /* Include directory index. */
9867 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
9869 /* Modification time. */
9870 dw2_asm_output_data_uleb128 (0, NULL);
9872 /* File length in bytes. */
9873 dw2_asm_output_data_uleb128 (0, NULL);
9877 dw2_asm_output_data (1, 0, "End file name table");
9881 /* Output the source line number correspondence information. This
9882 information goes into the .debug_line section. */
9885 output_line_info (void)
9887 char l1[20], l2[20], p1[20], p2[20];
9888 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
9889 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
9892 unsigned long lt_index;
9893 unsigned long current_line;
9896 unsigned long current_file;
9897 unsigned long function;
9899 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
9900 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
9901 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
9902 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
9904 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9905 dw2_asm_output_data (4, 0xffffffff,
9906 "Initial length escape value indicating 64-bit DWARF extension");
9907 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
9908 "Length of Source Line Info");
9909 ASM_OUTPUT_LABEL (asm_out_file, l1);
9911 dw2_asm_output_data (2, dwarf_version, "DWARF Version");
9912 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
9913 ASM_OUTPUT_LABEL (asm_out_file, p1);
9915 /* Define the architecture-dependent minimum instruction length (in
9916 bytes). In this implementation of DWARF, this field is used for
9917 information purposes only. Since GCC generates assembly language,
9918 we have no a priori knowledge of how many instruction bytes are
9919 generated for each source line, and therefore can use only the
9920 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
9921 commands. Accordingly, we fix this as `1', which is "correct
9922 enough" for all architectures, and don't let the target override. */
9923 dw2_asm_output_data (1, 1,
9924 "Minimum Instruction Length");
9926 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
9927 "Default is_stmt_start flag");
9928 dw2_asm_output_data (1, DWARF_LINE_BASE,
9929 "Line Base Value (Special Opcodes)");
9930 dw2_asm_output_data (1, DWARF_LINE_RANGE,
9931 "Line Range Value (Special Opcodes)");
9932 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
9933 "Special Opcode Base");
9935 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
9939 case DW_LNS_advance_pc:
9940 case DW_LNS_advance_line:
9941 case DW_LNS_set_file:
9942 case DW_LNS_set_column:
9943 case DW_LNS_fixed_advance_pc:
9951 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
9955 /* Write out the information about the files we use. */
9956 output_file_names ();
9957 ASM_OUTPUT_LABEL (asm_out_file, p2);
9959 /* We used to set the address register to the first location in the text
9960 section here, but that didn't accomplish anything since we already
9961 have a line note for the opening brace of the first function. */
9963 /* Generate the line number to PC correspondence table, encoded as
9964 a series of state machine operations. */
9968 if (cfun && in_cold_section_p)
9969 strcpy (prev_line_label, crtl->subsections.cold_section_label);
9971 strcpy (prev_line_label, text_section_label);
9972 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
9974 dw_line_info_ref line_info = &line_info_table[lt_index];
9977 /* Disable this optimization for now; GDB wants to see two line notes
9978 at the beginning of a function so it can find the end of the
9981 /* Don't emit anything for redundant notes. Just updating the
9982 address doesn't accomplish anything, because we already assume
9983 that anything after the last address is this line. */
9984 if (line_info->dw_line_num == current_line
9985 && line_info->dw_file_num == current_file)
9989 /* Emit debug info for the address of the current line.
9991 Unfortunately, we have little choice here currently, and must always
9992 use the most general form. GCC does not know the address delta
9993 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9994 attributes which will give an upper bound on the address range. We
9995 could perhaps use length attributes to determine when it is safe to
9996 use DW_LNS_fixed_advance_pc. */
9998 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
10001 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
10002 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
10003 "DW_LNS_fixed_advance_pc");
10004 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
10008 /* This can handle any delta. This takes
10009 4+DWARF2_ADDR_SIZE bytes. */
10010 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10011 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10012 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10013 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10016 strcpy (prev_line_label, line_label);
10018 /* Emit debug info for the source file of the current line, if
10019 different from the previous line. */
10020 if (line_info->dw_file_num != current_file)
10022 current_file = line_info->dw_file_num;
10023 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
10024 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
10027 /* Emit debug info for the current line number, choosing the encoding
10028 that uses the least amount of space. */
10029 if (line_info->dw_line_num != current_line)
10031 line_offset = line_info->dw_line_num - current_line;
10032 line_delta = line_offset - DWARF_LINE_BASE;
10033 current_line = line_info->dw_line_num;
10034 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
10035 /* This can handle deltas from -10 to 234, using the current
10036 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
10038 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
10039 "line %lu", current_line);
10042 /* This can handle any delta. This takes at least 4 bytes,
10043 depending on the value being encoded. */
10044 dw2_asm_output_data (1, DW_LNS_advance_line,
10045 "advance to line %lu", current_line);
10046 dw2_asm_output_data_sleb128 (line_offset, NULL);
10047 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10051 /* We still need to start a new row, so output a copy insn. */
10052 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10055 /* Emit debug info for the address of the end of the function. */
10058 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
10059 "DW_LNS_fixed_advance_pc");
10060 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
10064 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10065 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10066 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10067 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
10070 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
10071 dw2_asm_output_data_uleb128 (1, NULL);
10072 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
10077 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
10079 dw_separate_line_info_ref line_info
10080 = &separate_line_info_table[lt_index];
10083 /* Don't emit anything for redundant notes. */
10084 if (line_info->dw_line_num == current_line
10085 && line_info->dw_file_num == current_file
10086 && line_info->function == function)
10090 /* Emit debug info for the address of the current line. If this is
10091 a new function, or the first line of a function, then we need
10092 to handle it differently. */
10093 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
10095 if (function != line_info->function)
10097 function = line_info->function;
10099 /* Set the address register to the first line in the function. */
10100 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10101 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10102 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10103 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10107 /* ??? See the DW_LNS_advance_pc comment above. */
10110 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
10111 "DW_LNS_fixed_advance_pc");
10112 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
10116 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10117 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10118 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10119 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10123 strcpy (prev_line_label, line_label);
10125 /* Emit debug info for the source file of the current line, if
10126 different from the previous line. */
10127 if (line_info->dw_file_num != current_file)
10129 current_file = line_info->dw_file_num;
10130 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
10131 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
10134 /* Emit debug info for the current line number, choosing the encoding
10135 that uses the least amount of space. */
10136 if (line_info->dw_line_num != current_line)
10138 line_offset = line_info->dw_line_num - current_line;
10139 line_delta = line_offset - DWARF_LINE_BASE;
10140 current_line = line_info->dw_line_num;
10141 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
10142 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
10143 "line %lu", current_line);
10146 dw2_asm_output_data (1, DW_LNS_advance_line,
10147 "advance to line %lu", current_line);
10148 dw2_asm_output_data_sleb128 (line_offset, NULL);
10149 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10153 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10161 /* If we're done with a function, end its sequence. */
10162 if (lt_index == separate_line_info_table_in_use
10163 || separate_line_info_table[lt_index].function != function)
10168 /* Emit debug info for the address of the end of the function. */
10169 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
10172 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
10173 "DW_LNS_fixed_advance_pc");
10174 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
10178 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10179 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10180 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10181 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10184 /* Output the marker for the end of this sequence. */
10185 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
10186 dw2_asm_output_data_uleb128 (1, NULL);
10187 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
10191 /* Output the marker for the end of the line number info. */
10192 ASM_OUTPUT_LABEL (asm_out_file, l2);
10195 /* Given a pointer to a tree node for some base type, return a pointer to
10196 a DIE that describes the given type.
10198 This routine must only be called for GCC type nodes that correspond to
10199 Dwarf base (fundamental) types. */
10202 base_type_die (tree type)
10204 dw_die_ref base_type_result;
10205 enum dwarf_type encoding;
10207 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
10210 /* If this is a subtype that should not be emitted as a subrange type,
10211 use the base type. See subrange_type_for_debug_p. */
10212 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
10213 type = TREE_TYPE (type);
10215 switch (TREE_CODE (type))
10218 if (TYPE_STRING_FLAG (type))
10220 if (TYPE_UNSIGNED (type))
10221 encoding = DW_ATE_unsigned_char;
10223 encoding = DW_ATE_signed_char;
10225 else if (TYPE_UNSIGNED (type))
10226 encoding = DW_ATE_unsigned;
10228 encoding = DW_ATE_signed;
10232 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
10233 encoding = DW_ATE_decimal_float;
10235 encoding = DW_ATE_float;
10238 case FIXED_POINT_TYPE:
10239 if (TYPE_UNSIGNED (type))
10240 encoding = DW_ATE_unsigned_fixed;
10242 encoding = DW_ATE_signed_fixed;
10245 /* Dwarf2 doesn't know anything about complex ints, so use
10246 a user defined type for it. */
10248 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
10249 encoding = DW_ATE_complex_float;
10251 encoding = DW_ATE_lo_user;
10255 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10256 encoding = DW_ATE_boolean;
10260 /* No other TREE_CODEs are Dwarf fundamental types. */
10261 gcc_unreachable ();
10264 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
10266 /* This probably indicates a bug. */
10267 if (! TYPE_NAME (type))
10268 add_name_attribute (base_type_result, "__unknown__");
10270 add_AT_unsigned (base_type_result, DW_AT_byte_size,
10271 int_size_in_bytes (type));
10272 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
10274 return base_type_result;
10277 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10278 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10281 is_base_type (tree type)
10283 switch (TREE_CODE (type))
10289 case FIXED_POINT_TYPE:
10297 case QUAL_UNION_TYPE:
10298 case ENUMERAL_TYPE:
10299 case FUNCTION_TYPE:
10302 case REFERENCE_TYPE:
10309 gcc_unreachable ();
10315 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10316 node, return the size in bits for the type if it is a constant, or else
10317 return the alignment for the type if the type's size is not constant, or
10318 else return BITS_PER_WORD if the type actually turns out to be an
10319 ERROR_MARK node. */
10321 static inline unsigned HOST_WIDE_INT
10322 simple_type_size_in_bits (const_tree type)
10324 if (TREE_CODE (type) == ERROR_MARK)
10325 return BITS_PER_WORD;
10326 else if (TYPE_SIZE (type) == NULL_TREE)
10328 else if (host_integerp (TYPE_SIZE (type), 1))
10329 return tree_low_cst (TYPE_SIZE (type), 1);
10331 return TYPE_ALIGN (type);
10334 /* Given a pointer to a tree node for a subrange type, return a pointer
10335 to a DIE that describes the given type. */
10338 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
10340 dw_die_ref subrange_die;
10341 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
10343 if (context_die == NULL)
10344 context_die = comp_unit_die;
10346 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
10348 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
10350 /* The size of the subrange type and its base type do not match,
10351 so we need to generate a size attribute for the subrange type. */
10352 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
10356 add_bound_info (subrange_die, DW_AT_lower_bound, low);
10358 add_bound_info (subrange_die, DW_AT_upper_bound, high);
10360 return subrange_die;
10363 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10364 entry that chains various modifiers in front of the given type. */
10367 modified_type_die (tree type, int is_const_type, int is_volatile_type,
10368 dw_die_ref context_die)
10370 enum tree_code code = TREE_CODE (type);
10371 dw_die_ref mod_type_die;
10372 dw_die_ref sub_die = NULL;
10373 tree item_type = NULL;
10374 tree qualified_type;
10375 tree name, low, high;
10377 if (code == ERROR_MARK)
10380 /* See if we already have the appropriately qualified variant of
10383 = get_qualified_type (type,
10384 ((is_const_type ? TYPE_QUAL_CONST : 0)
10385 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
10387 /* If we do, then we can just use its DIE, if it exists. */
10388 if (qualified_type)
10390 mod_type_die = lookup_type_die (qualified_type);
10392 return mod_type_die;
10395 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
10397 /* Handle C typedef types. */
10398 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
10400 tree dtype = TREE_TYPE (name);
10402 if (qualified_type == dtype)
10404 /* For a named type, use the typedef. */
10405 gen_type_die (qualified_type, context_die);
10406 return lookup_type_die (qualified_type);
10408 else if (is_const_type < TYPE_READONLY (dtype)
10409 || is_volatile_type < TYPE_VOLATILE (dtype)
10410 || (is_const_type <= TYPE_READONLY (dtype)
10411 && is_volatile_type <= TYPE_VOLATILE (dtype)
10412 && DECL_ORIGINAL_TYPE (name) != type))
10413 /* cv-unqualified version of named type. Just use the unnamed
10414 type to which it refers. */
10415 return modified_type_die (DECL_ORIGINAL_TYPE (name),
10416 is_const_type, is_volatile_type,
10418 /* Else cv-qualified version of named type; fall through. */
10423 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
10424 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
10426 else if (is_volatile_type)
10428 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
10429 sub_die = modified_type_die (type, 0, 0, context_die);
10431 else if (code == POINTER_TYPE)
10433 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
10434 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10435 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10436 item_type = TREE_TYPE (type);
10438 else if (code == REFERENCE_TYPE)
10440 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
10441 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10442 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10443 item_type = TREE_TYPE (type);
10445 else if (code == INTEGER_TYPE
10446 && TREE_TYPE (type) != NULL_TREE
10447 && subrange_type_for_debug_p (type, &low, &high))
10449 mod_type_die = subrange_type_die (type, low, high, context_die);
10450 item_type = TREE_TYPE (type);
10452 else if (is_base_type (type))
10453 mod_type_die = base_type_die (type);
10456 gen_type_die (type, context_die);
10458 /* We have to get the type_main_variant here (and pass that to the
10459 `lookup_type_die' routine) because the ..._TYPE node we have
10460 might simply be a *copy* of some original type node (where the
10461 copy was created to help us keep track of typedef names) and
10462 that copy might have a different TYPE_UID from the original
10464 if (TREE_CODE (type) != VECTOR_TYPE)
10465 return lookup_type_die (type_main_variant (type));
10467 /* Vectors have the debugging information in the type,
10468 not the main variant. */
10469 return lookup_type_die (type);
10472 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10473 don't output a DW_TAG_typedef, since there isn't one in the
10474 user's program; just attach a DW_AT_name to the type. */
10476 && (TREE_CODE (name) != TYPE_DECL
10477 || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
10479 if (TREE_CODE (name) == TYPE_DECL)
10480 /* Could just call add_name_and_src_coords_attributes here,
10481 but since this is a builtin type it doesn't have any
10482 useful source coordinates anyway. */
10483 name = DECL_NAME (name);
10484 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
10487 if (qualified_type)
10488 equate_type_number_to_die (qualified_type, mod_type_die);
10491 /* We must do this after the equate_type_number_to_die call, in case
10492 this is a recursive type. This ensures that the modified_type_die
10493 recursion will terminate even if the type is recursive. Recursive
10494 types are possible in Ada. */
10495 sub_die = modified_type_die (item_type,
10496 TYPE_READONLY (item_type),
10497 TYPE_VOLATILE (item_type),
10500 if (sub_die != NULL)
10501 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
10503 return mod_type_die;
10506 /* Generate a new name for the parameter pack name NAME (an
10507 IDENTIFIER_NODE) that incorporates its */
10510 make_ith_pack_parameter_name (tree name, int i)
10512 /* Munge the name to include the parameter index. */
10513 #define NUMBUF_LEN 128
10514 char numbuf[NUMBUF_LEN];
10518 snprintf (numbuf, NUMBUF_LEN, "%i", i);
10519 newname_len = IDENTIFIER_LENGTH (name)
10520 + strlen (numbuf) + 2;
10521 newname = (char*) alloca (newname_len);
10522 snprintf (newname, newname_len,
10523 "%s#%i", IDENTIFIER_POINTER (name), i);
10524 return get_identifier (newname);
10527 /* Generate DIEs for the generic parameters of T.
10528 T must be either a generic type or a generic function.
10529 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10532 gen_generic_params_dies (tree t)
10536 dw_die_ref die = NULL;
10538 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
10542 die = lookup_type_die (t);
10543 else if (DECL_P (t))
10544 die = lookup_decl_die (t);
10548 parms = lang_hooks.get_innermost_generic_parms (t);
10550 /* T has no generic parameter. It means T is neither a generic type
10551 or function. End of story. */
10554 parms_num = TREE_VEC_LENGTH (parms);
10555 args = lang_hooks.get_innermost_generic_args (t);
10556 for (i = 0; i < parms_num; i++)
10560 parm = TREE_VEC_ELT (parms, i);
10561 arg = TREE_VEC_ELT (args, i);
10562 if (parm && TREE_VALUE (parm) && arg)
10565 lang_hooks.types.get_argument_pack_elems (arg);
10568 /* So ARG is an argument pack and the elements of that pack
10569 are stored in PACK_ELEMS. */
10572 len = TREE_VEC_LENGTH (pack_elems);
10573 for (i = 0; i < len; i++)
10574 generic_parameter_die (TREE_VALUE (parm),
10575 TREE_VEC_ELT (pack_elems, i),
10578 else /* Arg is not an argument pack. */
10579 generic_parameter_die (TREE_VALUE (parm),
10581 -1/* Not a param pack. */);
10586 /* Create and return a DIE for PARM which should be
10587 the representation of a generic type parameter.
10588 For instance, in the C++ front end, PARM would be a template parameter.
10589 ARG is the argument to PARM.
10590 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10592 PACK_ELEM_INDEX is >= 0 if PARM is a generic parameter pack, and if ARG
10593 is one of the unpacked elements of the parameter PACK. In that case,
10594 PACK_ELEM_INDEX is the index of ARG in the parameter pack. */
10597 generic_parameter_die (tree parm, tree arg, dw_die_ref parent_die,
10598 int pack_elem_index)
10600 dw_die_ref tmpl_die = NULL;
10601 const char *name = NULL;
10603 if (!parm || !DECL_NAME (parm) || !arg)
10606 /* We support non-type generic parameters and arguments,
10607 type generic parameters and arguments, as well as
10608 generic generic parameters (a.k.a. template template parameters in C++)
10610 if (TREE_CODE (parm) == PARM_DECL)
10611 /* PARM is a nontype generic parameter */
10612 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
10613 else if (TREE_CODE (parm) == TYPE_DECL)
10614 /* PARM is a type generic parameter. */
10615 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
10616 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10617 /* PARM is a generic generic parameter.
10618 Its DIE is a GNU extension. It shall have a
10619 DW_AT_name attribute to represent the name of the template template
10620 parameter, and a DW_AT_GNU_template_name attribute to represent the
10621 name of the template template argument. */
10622 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
10625 gcc_unreachable ();
10631 if (pack_elem_index >= 0)
10633 /* PARM is an element of a parameter pack.
10634 Generate a name for it. */
10635 tree identifier = make_ith_pack_parameter_name (DECL_NAME (parm),
10638 name = IDENTIFIER_POINTER (identifier);
10641 name = IDENTIFIER_POINTER (DECL_NAME (parm));
10644 add_AT_string (tmpl_die, DW_AT_name, name);
10646 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10648 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10649 TMPL_DIE should have a child DW_AT_type attribute that is set
10650 to the type of the argument to PARM, which is ARG.
10651 If PARM is a type generic parameter, TMPL_DIE should have a
10652 child DW_AT_type that is set to ARG. */
10653 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
10654 add_type_attribute (tmpl_die, tmpl_type, 0,
10655 TREE_THIS_VOLATILE (tmpl_type),
10660 /* So TMPL_DIE is a DIE representing a
10661 a generic generic template parameter, a.k.a template template
10662 parameter in C++ and arg is a template. */
10664 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10665 to the name of the argument. */
10666 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
10667 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
10670 if (TREE_CODE (parm) == PARM_DECL)
10671 /* So PARM is a non-type generic parameter.
10672 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10673 attribute of TMPL_DIE which value represents the value
10675 We must be careful here:
10676 The value of ARG might reference some function decls.
10677 We might currently be emitting debug info for a generic
10678 type and types are emitted before function decls, we don't
10679 know if the function decls referenced by ARG will actually be
10680 emitted after cgraph computations.
10681 So must defer the generation of the DW_AT_const_value to
10682 after cgraph is ready. */
10683 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
10689 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10690 an enumerated type. */
10693 type_is_enum (const_tree type)
10695 return TREE_CODE (type) == ENUMERAL_TYPE;
10698 /* Return the DBX register number described by a given RTL node. */
10700 static unsigned int
10701 dbx_reg_number (const_rtx rtl)
10703 unsigned regno = REGNO (rtl);
10705 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
10707 #ifdef LEAF_REG_REMAP
10708 if (current_function_uses_only_leaf_regs)
10710 int leaf_reg = LEAF_REG_REMAP (regno);
10711 if (leaf_reg != -1)
10712 regno = (unsigned) leaf_reg;
10716 return DBX_REGISTER_NUMBER (regno);
10719 /* Optionally add a DW_OP_piece term to a location description expression.
10720 DW_OP_piece is only added if the location description expression already
10721 doesn't end with DW_OP_piece. */
10724 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
10726 dw_loc_descr_ref loc;
10728 if (*list_head != NULL)
10730 /* Find the end of the chain. */
10731 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
10734 if (loc->dw_loc_opc != DW_OP_piece)
10735 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
10739 /* Return a location descriptor that designates a machine register or
10740 zero if there is none. */
10742 static dw_loc_descr_ref
10743 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
10747 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
10750 regs = targetm.dwarf_register_span (rtl);
10752 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
10753 return multiple_reg_loc_descriptor (rtl, regs, initialized);
10755 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
10758 /* Return a location descriptor that designates a machine register for
10759 a given hard register number. */
10761 static dw_loc_descr_ref
10762 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
10764 dw_loc_descr_ref reg_loc_descr;
10768 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
10770 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
10772 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10773 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10775 return reg_loc_descr;
10778 /* Given an RTL of a register, return a location descriptor that
10779 designates a value that spans more than one register. */
10781 static dw_loc_descr_ref
10782 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
10783 enum var_init_status initialized)
10785 int nregs, size, i;
10787 dw_loc_descr_ref loc_result = NULL;
10790 #ifdef LEAF_REG_REMAP
10791 if (current_function_uses_only_leaf_regs)
10793 int leaf_reg = LEAF_REG_REMAP (reg);
10794 if (leaf_reg != -1)
10795 reg = (unsigned) leaf_reg;
10798 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
10799 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
10801 /* Simple, contiguous registers. */
10802 if (regs == NULL_RTX)
10804 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
10809 dw_loc_descr_ref t;
10811 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
10812 VAR_INIT_STATUS_INITIALIZED);
10813 add_loc_descr (&loc_result, t);
10814 add_loc_descr_op_piece (&loc_result, size);
10820 /* Now onto stupid register sets in non contiguous locations. */
10822 gcc_assert (GET_CODE (regs) == PARALLEL);
10824 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10827 for (i = 0; i < XVECLEN (regs, 0); ++i)
10829 dw_loc_descr_ref t;
10831 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
10832 VAR_INIT_STATUS_INITIALIZED);
10833 add_loc_descr (&loc_result, t);
10834 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10835 add_loc_descr_op_piece (&loc_result, size);
10838 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10839 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10843 #endif /* DWARF2_DEBUGGING_INFO */
10845 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
10847 /* Return a location descriptor that designates a constant. */
10849 static dw_loc_descr_ref
10850 int_loc_descriptor (HOST_WIDE_INT i)
10852 enum dwarf_location_atom op;
10854 /* Pick the smallest representation of a constant, rather than just
10855 defaulting to the LEB encoding. */
10859 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
10860 else if (i <= 0xff)
10861 op = DW_OP_const1u;
10862 else if (i <= 0xffff)
10863 op = DW_OP_const2u;
10864 else if (HOST_BITS_PER_WIDE_INT == 32
10865 || i <= 0xffffffff)
10866 op = DW_OP_const4u;
10873 op = DW_OP_const1s;
10874 else if (i >= -0x8000)
10875 op = DW_OP_const2s;
10876 else if (HOST_BITS_PER_WIDE_INT == 32
10877 || i >= -0x80000000)
10878 op = DW_OP_const4s;
10883 return new_loc_descr (op, i, 0);
10886 /* Return loc description representing "address" of integer value.
10887 This can appear only as toplevel expression. */
10889 static dw_loc_descr_ref
10890 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
10893 dw_loc_descr_ref loc_result = NULL;
10899 else if (i <= 0xff)
10901 else if (i <= 0xffff)
10903 else if (HOST_BITS_PER_WIDE_INT == 32
10904 || i <= 0xffffffff)
10907 litsize = 1 + size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
10913 else if (i >= -0x8000)
10915 else if (HOST_BITS_PER_WIDE_INT == 32
10916 || i >= -0x80000000)
10919 litsize = 1 + size_of_sleb128 (i);
10921 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
10922 is more compact. For DW_OP_stack_value we need:
10923 litsize + 1 (DW_OP_stack_value) + 1 (DW_OP_bit_size)
10925 and for DW_OP_implicit_value:
10926 1 (DW_OP_implicit_value) + 1 (length) + mode_size. */
10927 if (DWARF2_ADDR_SIZE >= size
10928 && litsize + 1 + 1 + 1 < 1 + 1 + size)
10930 loc_result = int_loc_descriptor (i);
10931 add_loc_descr (&loc_result,
10932 new_loc_descr (DW_OP_stack_value, 0, 0));
10933 add_loc_descr_op_piece (&loc_result, size);
10937 loc_result = new_loc_descr (DW_OP_implicit_value,
10939 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
10940 loc_result->dw_loc_oprnd2.v.val_int = i;
10945 #ifdef DWARF2_DEBUGGING_INFO
10947 /* Return a location descriptor that designates a base+offset location. */
10949 static dw_loc_descr_ref
10950 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
10951 enum var_init_status initialized)
10953 unsigned int regno;
10954 dw_loc_descr_ref result;
10955 dw_fde_ref fde = current_fde ();
10957 /* We only use "frame base" when we're sure we're talking about the
10958 post-prologue local stack frame. We do this by *not* running
10959 register elimination until this point, and recognizing the special
10960 argument pointer and soft frame pointer rtx's. */
10961 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
10963 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10967 if (GET_CODE (elim) == PLUS)
10969 offset += INTVAL (XEXP (elim, 1));
10970 elim = XEXP (elim, 0);
10972 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
10973 && (elim == hard_frame_pointer_rtx
10974 || elim == stack_pointer_rtx))
10975 || elim == (frame_pointer_needed
10976 ? hard_frame_pointer_rtx
10977 : stack_pointer_rtx));
10979 /* If drap register is used to align stack, use frame
10980 pointer + offset to access stack variables. If stack
10981 is aligned without drap, use stack pointer + offset to
10982 access stack variables. */
10983 if (crtl->stack_realign_tried
10984 && reg == frame_pointer_rtx)
10987 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
10988 ? HARD_FRAME_POINTER_REGNUM
10989 : STACK_POINTER_REGNUM);
10990 return new_reg_loc_descr (base_reg, offset);
10993 offset += frame_pointer_fb_offset;
10994 return new_loc_descr (DW_OP_fbreg, offset, 0);
10998 && fde->drap_reg != INVALID_REGNUM
10999 && (fde->drap_reg == REGNO (reg)
11000 || fde->vdrap_reg == REGNO (reg)))
11002 /* Use cfa+offset to represent the location of arguments passed
11003 on stack when drap is used to align stack. */
11004 return new_loc_descr (DW_OP_fbreg, offset, 0);
11007 regno = dbx_reg_number (reg);
11009 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
11012 result = new_loc_descr (DW_OP_bregx, regno, offset);
11014 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11015 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11020 /* Return true if this RTL expression describes a base+offset calculation. */
11023 is_based_loc (const_rtx rtl)
11025 return (GET_CODE (rtl) == PLUS
11026 && ((REG_P (XEXP (rtl, 0))
11027 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
11028 && CONST_INT_P (XEXP (rtl, 1)))));
11031 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
11034 static dw_loc_descr_ref
11035 tls_mem_loc_descriptor (rtx mem)
11038 dw_loc_descr_ref loc_result;
11040 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
11043 base = get_base_address (MEM_EXPR (mem));
11045 || TREE_CODE (base) != VAR_DECL
11046 || !DECL_THREAD_LOCAL_P (base))
11049 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 2);
11050 if (loc_result == NULL)
11053 if (INTVAL (MEM_OFFSET (mem)))
11054 loc_descr_plus_const (&loc_result, INTVAL (MEM_OFFSET (mem)));
11059 /* Output debug info about reason why we failed to expand expression as dwarf
11063 expansion_failed (tree expr, rtx rtl, char const *reason)
11065 if (dump_file && (dump_flags & TDF_DETAILS))
11067 fprintf (dump_file, "Failed to expand as dwarf: ");
11069 print_generic_expr (dump_file, expr, dump_flags);
11072 fprintf (dump_file, "\n");
11073 print_rtl (dump_file, rtl);
11075 fprintf (dump_file, "\nReason: %s\n", reason);
11079 /* The following routine converts the RTL for a variable or parameter
11080 (resident in memory) into an equivalent Dwarf representation of a
11081 mechanism for getting the address of that same variable onto the top of a
11082 hypothetical "address evaluation" stack.
11084 When creating memory location descriptors, we are effectively transforming
11085 the RTL for a memory-resident object into its Dwarf postfix expression
11086 equivalent. This routine recursively descends an RTL tree, turning
11087 it into Dwarf postfix code as it goes.
11089 MODE is the mode of the memory reference, needed to handle some
11090 autoincrement addressing modes.
11092 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
11093 location list for RTL.
11095 Return 0 if we can't represent the location. */
11097 static dw_loc_descr_ref
11098 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
11099 enum var_init_status initialized)
11101 dw_loc_descr_ref mem_loc_result = NULL;
11102 enum dwarf_location_atom op;
11103 dw_loc_descr_ref op0, op1;
11105 /* Note that for a dynamically sized array, the location we will generate a
11106 description of here will be the lowest numbered location which is
11107 actually within the array. That's *not* necessarily the same as the
11108 zeroth element of the array. */
11110 rtl = targetm.delegitimize_address (rtl);
11112 switch (GET_CODE (rtl))
11117 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
11118 just fall into the SUBREG code. */
11120 /* ... fall through ... */
11123 /* The case of a subreg may arise when we have a local (register)
11124 variable or a formal (register) parameter which doesn't quite fill
11125 up an entire register. For now, just assume that it is
11126 legitimate to make the Dwarf info refer to the whole register which
11127 contains the given subreg. */
11128 rtl = XEXP (rtl, 0);
11129 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
11131 mem_loc_result = mem_loc_descriptor (rtl, mode, initialized);
11135 /* Whenever a register number forms a part of the description of the
11136 method for calculating the (dynamic) address of a memory resident
11137 object, DWARF rules require the register number be referred to as
11138 a "base register". This distinction is not based in any way upon
11139 what category of register the hardware believes the given register
11140 belongs to. This is strictly DWARF terminology we're dealing with
11141 here. Note that in cases where the location of a memory-resident
11142 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
11143 OP_CONST (0)) the actual DWARF location descriptor that we generate
11144 may just be OP_BASEREG (basereg). This may look deceptively like
11145 the object in question was allocated to a register (rather than in
11146 memory) so DWARF consumers need to be aware of the subtle
11147 distinction between OP_REG and OP_BASEREG. */
11148 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
11149 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
11150 else if (stack_realign_drap
11152 && crtl->args.internal_arg_pointer == rtl
11153 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
11155 /* If RTL is internal_arg_pointer, which has been optimized
11156 out, use DRAP instead. */
11157 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
11158 VAR_INIT_STATUS_INITIALIZED);
11164 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11165 VAR_INIT_STATUS_INITIALIZED);
11170 int shift = DWARF2_ADDR_SIZE
11171 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
11172 shift *= BITS_PER_UNIT;
11173 if (GET_CODE (rtl) == SIGN_EXTEND)
11177 mem_loc_result = op0;
11178 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
11179 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
11180 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
11181 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11186 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
11187 VAR_INIT_STATUS_INITIALIZED);
11188 if (mem_loc_result == NULL)
11189 mem_loc_result = tls_mem_loc_descriptor (rtl);
11190 if (mem_loc_result != 0)
11191 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
11195 rtl = XEXP (rtl, 1);
11197 /* ... fall through ... */
11200 /* Some ports can transform a symbol ref into a label ref, because
11201 the symbol ref is too far away and has to be dumped into a constant
11205 /* Alternatively, the symbol in the constant pool might be referenced
11206 by a different symbol. */
11207 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
11210 rtx tmp = get_pool_constant_mark (rtl, &marked);
11212 if (GET_CODE (tmp) == SYMBOL_REF)
11215 if (CONSTANT_POOL_ADDRESS_P (tmp))
11216 get_pool_constant_mark (tmp, &marked);
11221 /* If all references to this pool constant were optimized away,
11222 it was not output and thus we can't represent it.
11223 FIXME: might try to use DW_OP_const_value here, though
11224 DW_OP_piece complicates it. */
11227 expansion_failed (NULL_TREE, rtl,
11228 "Constant was removed from constant pool.\n");
11233 if (GET_CODE (rtl) == SYMBOL_REF
11234 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11236 dw_loc_descr_ref temp;
11238 /* If this is not defined, we have no way to emit the data. */
11239 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
11242 temp = new_loc_descr (DW_OP_addr, 0, 0);
11243 temp->dw_loc_oprnd1.val_class = dw_val_class_addr;
11244 temp->dw_loc_oprnd1.v.val_addr = rtl;
11245 temp->dtprel = true;
11247 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
11248 add_loc_descr (&mem_loc_result, temp);
11254 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
11255 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
11256 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
11257 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11263 expansion_failed (NULL_TREE, rtl,
11264 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
11265 gcc_unreachable ();
11269 /* Extract the PLUS expression nested inside and fall into
11270 PLUS code below. */
11271 rtl = XEXP (rtl, 1);
11276 /* Turn these into a PLUS expression and fall into the PLUS code
11278 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
11279 GEN_INT (GET_CODE (rtl) == PRE_INC
11280 ? GET_MODE_UNIT_SIZE (mode)
11281 : -GET_MODE_UNIT_SIZE (mode)));
11283 /* ... fall through ... */
11287 if (is_based_loc (rtl))
11288 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
11289 INTVAL (XEXP (rtl, 1)),
11290 VAR_INIT_STATUS_INITIALIZED);
11293 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
11294 VAR_INIT_STATUS_INITIALIZED);
11295 if (mem_loc_result == 0)
11298 if (CONST_INT_P (XEXP (rtl, 1)))
11299 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
11302 dw_loc_descr_ref mem_loc_result2
11303 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11304 VAR_INIT_STATUS_INITIALIZED);
11305 if (mem_loc_result2 == 0)
11307 add_loc_descr (&mem_loc_result, mem_loc_result2);
11308 add_loc_descr (&mem_loc_result,
11309 new_loc_descr (DW_OP_plus, 0, 0));
11314 /* If a pseudo-reg is optimized away, it is possible for it to
11315 be replaced with a MEM containing a multiply or shift. */
11357 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11358 VAR_INIT_STATUS_INITIALIZED);
11359 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11360 VAR_INIT_STATUS_INITIALIZED);
11362 if (op0 == 0 || op1 == 0)
11365 mem_loc_result = op0;
11366 add_loc_descr (&mem_loc_result, op1);
11367 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11383 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11384 VAR_INIT_STATUS_INITIALIZED);
11389 mem_loc_result = op0;
11390 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11394 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
11422 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
11423 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
11424 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
11427 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11428 VAR_INIT_STATUS_INITIALIZED);
11429 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11430 VAR_INIT_STATUS_INITIALIZED);
11432 if (op0 == 0 || op1 == 0)
11435 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11437 int shift = DWARF2_ADDR_SIZE
11438 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
11439 shift *= BITS_PER_UNIT;
11440 add_loc_descr (&op0, int_loc_descriptor (shift));
11441 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11442 if (CONST_INT_P (XEXP (rtl, 1)))
11443 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
11446 add_loc_descr (&op1, int_loc_descriptor (shift));
11447 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11452 mem_loc_result = op0;
11453 add_loc_descr (&mem_loc_result, op1);
11454 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11455 if (STORE_FLAG_VALUE != 1)
11457 add_loc_descr (&mem_loc_result,
11458 int_loc_descriptor (STORE_FLAG_VALUE));
11459 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
11480 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
11481 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
11482 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
11485 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11486 VAR_INIT_STATUS_INITIALIZED);
11487 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11488 VAR_INIT_STATUS_INITIALIZED);
11490 if (op0 == 0 || op1 == 0)
11493 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11495 HOST_WIDE_INT mask = GET_MODE_MASK (GET_MODE (XEXP (rtl, 0)));
11496 add_loc_descr (&op0, int_loc_descriptor (mask));
11497 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11498 if (CONST_INT_P (XEXP (rtl, 1)))
11499 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
11502 add_loc_descr (&op1, int_loc_descriptor (mask));
11503 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
11508 HOST_WIDE_INT bias = 1;
11509 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
11510 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11511 if (CONST_INT_P (XEXP (rtl, 1)))
11512 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
11513 + INTVAL (XEXP (rtl, 1)));
11515 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11523 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
11524 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
11525 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
11528 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11529 VAR_INIT_STATUS_INITIALIZED);
11530 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11531 VAR_INIT_STATUS_INITIALIZED);
11533 if (op0 == 0 || op1 == 0)
11536 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
11537 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
11538 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
11539 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
11541 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11543 HOST_WIDE_INT mask = GET_MODE_MASK (GET_MODE (XEXP (rtl, 0)));
11544 add_loc_descr (&op0, int_loc_descriptor (mask));
11545 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11546 add_loc_descr (&op1, int_loc_descriptor (mask));
11547 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
11551 HOST_WIDE_INT bias = 1;
11552 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
11553 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11554 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11557 else if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11559 int shift = DWARF2_ADDR_SIZE
11560 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
11561 shift *= BITS_PER_UNIT;
11562 add_loc_descr (&op0, int_loc_descriptor (shift));
11563 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11564 add_loc_descr (&op1, int_loc_descriptor (shift));
11565 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11568 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
11572 mem_loc_result = op0;
11573 add_loc_descr (&mem_loc_result, op1);
11574 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11576 dw_loc_descr_ref bra_node, drop_node;
11578 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
11579 add_loc_descr (&mem_loc_result, bra_node);
11580 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
11581 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
11582 add_loc_descr (&mem_loc_result, drop_node);
11583 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
11584 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
11590 if (CONST_INT_P (XEXP (rtl, 1))
11591 && CONST_INT_P (XEXP (rtl, 2))
11592 && ((unsigned) INTVAL (XEXP (rtl, 1))
11593 + (unsigned) INTVAL (XEXP (rtl, 2))
11594 <= GET_MODE_BITSIZE (GET_MODE (rtl)))
11595 && GET_MODE_BITSIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
11596 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
11599 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11600 VAR_INIT_STATUS_INITIALIZED);
11603 if (GET_CODE (rtl) == SIGN_EXTRACT)
11607 mem_loc_result = op0;
11608 size = INTVAL (XEXP (rtl, 1));
11609 shift = INTVAL (XEXP (rtl, 2));
11610 if (BITS_BIG_ENDIAN)
11611 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
11613 add_loc_descr (&mem_loc_result,
11614 int_loc_descriptor (DWARF2_ADDR_SIZE - shift - size));
11615 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
11616 add_loc_descr (&mem_loc_result,
11617 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
11618 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11627 /* In theory, we could implement the above. */
11628 /* DWARF cannot represent the unsigned compare operations
11644 case FLOAT_TRUNCATE:
11646 case UNSIGNED_FLOAT:
11649 case FRACT_CONVERT:
11650 case UNSIGNED_FRACT_CONVERT:
11652 case UNSIGNED_SAT_FRACT:
11662 /* If delegitimize_address couldn't do anything with the UNSPEC, we
11663 can't express it in the debug info. This can happen e.g. with some
11668 rtl = get_debug_string_label (XSTR (rtl, 0));
11672 #ifdef ENABLE_CHECKING
11673 print_rtl (stderr, rtl);
11674 gcc_unreachable ();
11680 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
11681 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11683 return mem_loc_result;
11686 /* Return a descriptor that describes the concatenation of two locations.
11687 This is typically a complex variable. */
11689 static dw_loc_descr_ref
11690 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
11692 dw_loc_descr_ref cc_loc_result = NULL;
11693 dw_loc_descr_ref x0_ref
11694 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11695 dw_loc_descr_ref x1_ref
11696 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11698 if (x0_ref == 0 || x1_ref == 0)
11701 cc_loc_result = x0_ref;
11702 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
11704 add_loc_descr (&cc_loc_result, x1_ref);
11705 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
11707 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11708 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11710 return cc_loc_result;
11713 /* Return a descriptor that describes the concatenation of N
11716 static dw_loc_descr_ref
11717 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
11720 dw_loc_descr_ref cc_loc_result = NULL;
11721 unsigned int n = XVECLEN (concatn, 0);
11723 for (i = 0; i < n; ++i)
11725 dw_loc_descr_ref ref;
11726 rtx x = XVECEXP (concatn, 0, i);
11728 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11732 add_loc_descr (&cc_loc_result, ref);
11733 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
11736 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
11737 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11739 return cc_loc_result;
11742 /* Output a proper Dwarf location descriptor for a variable or parameter
11743 which is either allocated in a register or in a memory location. For a
11744 register, we just generate an OP_REG and the register number. For a
11745 memory location we provide a Dwarf postfix expression describing how to
11746 generate the (dynamic) address of the object onto the address stack.
11748 MODE is mode of the decl if this loc_descriptor is going to be used in
11749 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
11750 allowed, VOIDmode otherwise.
11752 If we don't know how to describe it, return 0. */
11754 static dw_loc_descr_ref
11755 loc_descriptor (rtx rtl, enum machine_mode mode,
11756 enum var_init_status initialized)
11758 dw_loc_descr_ref loc_result = NULL;
11760 switch (GET_CODE (rtl))
11763 /* The case of a subreg may arise when we have a local (register)
11764 variable or a formal (register) parameter which doesn't quite fill
11765 up an entire register. For now, just assume that it is
11766 legitimate to make the Dwarf info refer to the whole register which
11767 contains the given subreg. */
11768 loc_result = loc_descriptor (SUBREG_REG (rtl), mode, initialized);
11772 loc_result = reg_loc_descriptor (rtl, initialized);
11777 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
11781 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
11783 if (loc_result == NULL)
11784 loc_result = tls_mem_loc_descriptor (rtl);
11788 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
11793 loc_result = concatn_loc_descriptor (rtl, initialized);
11798 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
11800 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), mode,
11805 rtl = XEXP (rtl, 1);
11810 rtvec par_elems = XVEC (rtl, 0);
11811 int num_elem = GET_NUM_ELEM (par_elems);
11812 enum machine_mode mode;
11815 /* Create the first one, so we have something to add to. */
11816 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
11817 VOIDmode, initialized);
11818 if (loc_result == NULL)
11820 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
11821 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
11822 for (i = 1; i < num_elem; i++)
11824 dw_loc_descr_ref temp;
11826 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
11827 VOIDmode, initialized);
11830 add_loc_descr (&loc_result, temp);
11831 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
11832 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
11838 if (mode != VOIDmode && mode != BLKmode)
11839 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
11844 if (mode != VOIDmode)
11846 /* Note that a CONST_DOUBLE rtx could represent either an integer
11847 or a floating-point constant. A CONST_DOUBLE is used whenever
11848 the constant requires more than one word in order to be
11849 adequately represented. We output CONST_DOUBLEs as blocks. */
11850 if (GET_MODE (rtl) != VOIDmode)
11851 mode = GET_MODE (rtl);
11853 loc_result = new_loc_descr (DW_OP_implicit_value,
11854 GET_MODE_SIZE (mode), 0);
11855 if (SCALAR_FLOAT_MODE_P (mode))
11857 unsigned int length = GET_MODE_SIZE (mode);
11858 unsigned char *array = GGC_NEWVEC (unsigned char, length);
11860 insert_float (rtl, array);
11861 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
11862 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
11863 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
11864 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
11868 loc_result->dw_loc_oprnd2.val_class = dw_val_class_long_long;
11869 loc_result->dw_loc_oprnd2.v.val_long_long = rtl;
11875 if (mode != VOIDmode)
11877 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
11878 unsigned int length = CONST_VECTOR_NUNITS (rtl);
11879 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
11883 mode = GET_MODE (rtl);
11884 switch (GET_MODE_CLASS (mode))
11886 case MODE_VECTOR_INT:
11887 for (i = 0, p = array; i < length; i++, p += elt_size)
11889 rtx elt = CONST_VECTOR_ELT (rtl, i);
11890 HOST_WIDE_INT lo, hi;
11892 switch (GET_CODE (elt))
11900 lo = CONST_DOUBLE_LOW (elt);
11901 hi = CONST_DOUBLE_HIGH (elt);
11905 gcc_unreachable ();
11908 if (elt_size <= sizeof (HOST_WIDE_INT))
11909 insert_int (lo, elt_size, p);
11912 unsigned char *p0 = p;
11913 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
11915 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
11916 if (WORDS_BIG_ENDIAN)
11921 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
11922 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
11927 case MODE_VECTOR_FLOAT:
11928 for (i = 0, p = array; i < length; i++, p += elt_size)
11930 rtx elt = CONST_VECTOR_ELT (rtl, i);
11931 insert_float (elt, p);
11936 gcc_unreachable ();
11939 loc_result = new_loc_descr (DW_OP_implicit_value,
11940 length * elt_size, 0);
11941 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
11942 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
11943 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
11944 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
11949 if (mode == VOIDmode
11950 || GET_CODE (XEXP (rtl, 0)) == CONST_INT
11951 || GET_CODE (XEXP (rtl, 0)) == CONST_DOUBLE
11952 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
11954 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
11959 if (GET_CODE (rtl) == SYMBOL_REF
11960 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11963 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE)
11965 loc_result = new_loc_descr (DW_OP_implicit_value,
11966 DWARF2_ADDR_SIZE, 0);
11967 loc_result->dw_loc_oprnd2.val_class = dw_val_class_addr;
11968 loc_result->dw_loc_oprnd2.v.val_addr = rtl;
11969 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11974 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
11975 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE)
11977 /* Value expression. */
11978 loc_result = mem_loc_descriptor (rtl, VOIDmode, initialized);
11981 add_loc_descr (&loc_result,
11982 new_loc_descr (DW_OP_stack_value, 0, 0));
11983 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
11992 /* We need to figure out what section we should use as the base for the
11993 address ranges where a given location is valid.
11994 1. If this particular DECL has a section associated with it, use that.
11995 2. If this function has a section associated with it, use that.
11996 3. Otherwise, use the text section.
11997 XXX: If you split a variable across multiple sections, we won't notice. */
11999 static const char *
12000 secname_for_decl (const_tree decl)
12002 const char *secname;
12004 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
12006 tree sectree = DECL_SECTION_NAME (decl);
12007 secname = TREE_STRING_POINTER (sectree);
12009 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
12011 tree sectree = DECL_SECTION_NAME (current_function_decl);
12012 secname = TREE_STRING_POINTER (sectree);
12014 else if (cfun && in_cold_section_p)
12015 secname = crtl->subsections.cold_section_label;
12017 secname = text_section_label;
12022 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
12025 decl_by_reference_p (tree decl)
12027 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
12028 || TREE_CODE (decl) == VAR_DECL)
12029 && DECL_BY_REFERENCE (decl));
12033 /* Dereference a location expression LOC if DECL is passed by invisible
12036 static dw_loc_descr_ref
12037 loc_by_reference (dw_loc_descr_ref loc, tree decl)
12039 HOST_WIDE_INT size;
12040 enum dwarf_location_atom op;
12045 if (!decl_by_reference_p (decl))
12048 /* If loc is DW_OP_reg{0...31,x}, don't add DW_OP_deref, instead
12049 change it into corresponding DW_OP_breg{0...31,x} 0. Then the
12050 location expression is considered to be address of a memory location,
12051 rather than the register itself. */
12052 if (((loc->dw_loc_opc >= DW_OP_reg0 && loc->dw_loc_opc <= DW_OP_reg31)
12053 || loc->dw_loc_opc == DW_OP_regx)
12054 && (loc->dw_loc_next == NULL
12055 || (loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_uninit
12056 && loc->dw_loc_next->dw_loc_next == NULL)))
12058 if (loc->dw_loc_opc == DW_OP_regx)
12060 loc->dw_loc_opc = DW_OP_bregx;
12061 loc->dw_loc_oprnd2.v.val_int = 0;
12066 = (enum dwarf_location_atom)
12067 (loc->dw_loc_opc + (DW_OP_breg0 - DW_OP_reg0));
12068 loc->dw_loc_oprnd1.v.val_int = 0;
12073 size = int_size_in_bytes (TREE_TYPE (decl));
12074 if (size > DWARF2_ADDR_SIZE || size == -1)
12076 else if (size == DWARF2_ADDR_SIZE)
12079 op = DW_OP_deref_size;
12080 add_loc_descr (&loc, new_loc_descr (op, size, 0));
12084 /* Return single element location list containing loc descr REF. */
12086 static dw_loc_list_ref
12087 single_element_loc_list (dw_loc_descr_ref ref)
12089 return new_loc_list (ref, NULL, NULL, NULL, 0);
12092 /* Return dwarf representation of location list representing for
12093 LOC_LIST of DECL. */
12095 static dw_loc_list_ref
12096 dw_loc_list (var_loc_list * loc_list, tree decl, bool toplevel)
12098 const char *endname, *secname;
12099 dw_loc_list_ref list;
12101 enum var_init_status initialized;
12102 struct var_loc_node *node;
12103 dw_loc_descr_ref descr;
12104 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
12106 bool by_reference = decl_by_reference_p (decl);
12108 /* Now that we know what section we are using for a base,
12109 actually construct the list of locations.
12110 The first location information is what is passed to the
12111 function that creates the location list, and the remaining
12112 locations just get added on to that list.
12113 Note that we only know the start address for a location
12114 (IE location changes), so to build the range, we use
12115 the range [current location start, next location start].
12116 This means we have to special case the last node, and generate
12117 a range of [last location start, end of function label]. */
12119 node = loc_list->first;
12120 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
12121 secname = secname_for_decl (decl);
12123 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
12124 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
12126 initialized = VAR_INIT_STATUS_INITIALIZED;
12128 if (!toplevel || by_reference)
12130 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
12132 if (GET_CODE (XEXP (varloc, 1)) != PARALLEL)
12133 descr = loc_by_reference (mem_loc_descriptor (XEXP (XEXP (varloc, 1), 0),
12134 TYPE_MODE (TREE_TYPE (decl)),
12141 descr = loc_descriptor (varloc, DECL_MODE (decl), initialized);
12143 if (loc_list && loc_list->first != loc_list->last)
12144 list = new_loc_list (descr, node->label, node->next->label, secname, 1);
12146 return single_element_loc_list (descr);
12152 for (; node->next; node = node->next)
12153 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
12155 /* The variable has a location between NODE->LABEL and
12156 NODE->NEXT->LABEL. */
12157 enum var_init_status initialized =
12158 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
12159 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
12160 if (!toplevel || by_reference)
12162 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
12164 if (GET_CODE (XEXP (varloc, 1)) != PARALLEL)
12165 descr = mem_loc_descriptor (XEXP (XEXP (varloc, 1), 0),
12166 TYPE_MODE (TREE_TYPE (decl)), initialized);
12169 descr = loc_by_reference (descr, decl);
12172 descr = loc_descriptor (varloc, DECL_MODE (decl), initialized);
12173 add_loc_descr_to_loc_list (&list, descr,
12174 node->label, node->next->label, secname);
12177 /* If the variable has a location at the last label
12178 it keeps its location until the end of function. */
12179 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
12181 enum var_init_status initialized =
12182 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
12184 if (!current_function_decl)
12185 endname = text_end_label;
12188 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
12189 current_function_funcdef_no);
12190 endname = ggc_strdup (label_id);
12193 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
12194 if (!toplevel || by_reference)
12196 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
12198 if (GET_CODE (XEXP (varloc, 1)) != PARALLEL)
12199 descr = mem_loc_descriptor (XEXP (XEXP (varloc, 1), 0),
12200 TYPE_MODE (TREE_TYPE (decl)), initialized);
12203 descr = loc_by_reference (descr, decl);
12206 descr = loc_descriptor (varloc, DECL_MODE (decl), initialized);
12207 add_loc_descr_to_loc_list (&list, descr, node->label, endname, secname);
12212 /* Return if the loc_list has only single element and thus can be represented
12213 as location description. */
12216 single_element_loc_list_p (dw_loc_list_ref list)
12218 return (!list->dw_loc_next && !list->begin && !list->end);
12221 /* To each location in list LIST add loc descr REF. */
12224 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
12226 dw_loc_descr_ref copy;
12227 add_loc_descr (&list->expr, ref);
12228 list = list->dw_loc_next;
12231 copy = GGC_CNEW (dw_loc_descr_node);
12232 memcpy (copy, ref, sizeof (dw_loc_descr_node));
12233 add_loc_descr (&list->expr, copy);
12234 while (copy->dw_loc_next)
12236 dw_loc_descr_ref new_copy = GGC_CNEW (dw_loc_descr_node);
12237 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
12238 copy->dw_loc_next = new_copy;
12241 list = list->dw_loc_next;
12245 /* Given two lists RET and LIST
12246 produce location list that is result of adding expression in LIST
12247 to expression in RET on each possition in program.
12248 Might be destructive on both RET and LIST.
12250 TODO: We handle only simple cases of RET or LIST having at most one
12251 element. General case would inolve sorting the lists in program order
12252 and merging them that will need some additional work.
12253 Adding that will improve quality of debug info especially for SRA-ed
12257 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
12266 if (!list->dw_loc_next)
12268 add_loc_descr_to_each (*ret, list->expr);
12271 if (!(*ret)->dw_loc_next)
12273 add_loc_descr_to_each (list, (*ret)->expr);
12277 expansion_failed (NULL_TREE, NULL_RTX,
12278 "Don't know how to merge two non-trivial"
12279 " location lists.\n");
12284 /* LOC is constant expression. Try a luck, look it up in constant
12285 pool and return its loc_descr of its address. */
12287 static dw_loc_descr_ref
12288 cst_pool_loc_descr (tree loc)
12290 /* Get an RTL for this, if something has been emitted. */
12291 rtx rtl = lookup_constant_def (loc);
12292 enum machine_mode mode;
12294 if (!rtl || !MEM_P (rtl))
12299 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
12301 /* TODO: We might get more coverage if we was actually delaying expansion
12302 of all expressions till end of compilation when constant pools are fully
12304 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
12306 expansion_failed (loc, NULL_RTX,
12307 "CST value in contant pool but not marked.");
12310 mode = GET_MODE (rtl);
12311 rtl = XEXP (rtl, 0);
12312 return mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
12315 /* Return dw_loc_list representing address of addr_expr LOC
12316 by looking for innder INDIRECT_REF expression and turing it
12317 into simple arithmetics. */
12319 static dw_loc_list_ref
12320 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev)
12323 HOST_WIDE_INT bitsize, bitpos, bytepos;
12324 enum machine_mode mode;
12326 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
12327 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
12329 obj = get_inner_reference (TREE_OPERAND (loc, 0),
12330 &bitsize, &bitpos, &offset, &mode,
12331 &unsignedp, &volatilep, false);
12333 if (bitpos % BITS_PER_UNIT)
12335 expansion_failed (loc, NULL_RTX, "bitfield access");
12338 if (!INDIRECT_REF_P (obj))
12340 expansion_failed (obj,
12341 NULL_RTX, "no indirect ref in inner refrence");
12344 if (!offset && !bitpos)
12345 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1);
12347 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE)
12349 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0);
12354 /* Variable offset. */
12355 list_ret1 = loc_list_from_tree (offset, 0);
12356 if (list_ret1 == 0)
12358 add_loc_list (&list_ret, list_ret1);
12361 add_loc_descr_to_each (list_ret,
12362 new_loc_descr (DW_OP_plus, 0, 0));
12364 bytepos = bitpos / BITS_PER_UNIT;
12366 add_loc_descr_to_each (list_ret,
12367 new_loc_descr (DW_OP_plus_uconst,
12369 else if (bytepos < 0)
12370 loc_list_plus_const (list_ret, bytepos);
12371 add_loc_descr_to_each (list_ret,
12372 new_loc_descr (DW_OP_stack_value, 0, 0));
12373 add_loc_descr_to_each (list_ret,
12374 new_loc_descr (DW_OP_piece,
12375 int_size_in_bytes (TREE_TYPE
12383 /* Generate Dwarf location list representing LOC.
12384 If WANT_ADDRESS is false, expression computing LOC will be computed
12385 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
12386 if WANT_ADDRESS is 2, expression computing address useable in location
12387 will be returned (i.e. DW_OP_reg can be used
12388 to refer to register values)
12389 TODO: Dwarf4 adds types to the stack machine that ought to be used here
12390 DW_OP_stack_value will help in cases where we fail to find address of the
12394 static dw_loc_list_ref
12395 loc_list_from_tree (tree loc, int want_address)
12397 dw_loc_descr_ref ret = NULL, ret1 = NULL;
12398 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
12399 int have_address = 0;
12400 enum dwarf_location_atom op;
12402 /* ??? Most of the time we do not take proper care for sign/zero
12403 extending the values properly. Hopefully this won't be a real
12406 switch (TREE_CODE (loc))
12409 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
12412 case PLACEHOLDER_EXPR:
12413 /* This case involves extracting fields from an object to determine the
12414 position of other fields. We don't try to encode this here. The
12415 only user of this is Ada, which encodes the needed information using
12416 the names of types. */
12417 expansion_failed (loc, NULL_RTX, "PLACEHOLDER_EXPR");
12421 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
12422 /* There are no opcodes for these operations. */
12425 case PREINCREMENT_EXPR:
12426 case PREDECREMENT_EXPR:
12427 case POSTINCREMENT_EXPR:
12428 case POSTDECREMENT_EXPR:
12429 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
12430 /* There are no opcodes for these operations. */
12434 /* If we already want an address, see if there is INDIRECT_REF inside
12435 e.g. for &this->field. */
12438 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
12439 (loc, want_address == 2);
12442 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
12443 && (ret = cst_pool_loc_descr (loc)))
12446 /* Otherwise, process the argument and look for the address. */
12447 if (!list_ret && !ret)
12448 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1);
12452 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
12458 if (DECL_THREAD_LOCAL_P (loc))
12461 enum dwarf_location_atom first_op;
12462 enum dwarf_location_atom second_op;
12463 bool dtprel = false;
12465 if (targetm.have_tls)
12467 /* If this is not defined, we have no way to emit the
12469 if (!targetm.asm_out.output_dwarf_dtprel)
12472 /* The way DW_OP_GNU_push_tls_address is specified, we
12473 can only look up addresses of objects in the current
12475 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
12477 first_op = DW_OP_addr;
12479 second_op = DW_OP_GNU_push_tls_address;
12483 if (!targetm.emutls.debug_form_tls_address)
12485 loc = emutls_decl (loc);
12486 first_op = DW_OP_addr;
12487 second_op = DW_OP_form_tls_address;
12490 rtl = rtl_for_decl_location (loc);
12491 if (rtl == NULL_RTX)
12496 rtl = XEXP (rtl, 0);
12497 if (! CONSTANT_P (rtl))
12500 ret = new_loc_descr (first_op, 0, 0);
12501 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
12502 ret->dw_loc_oprnd1.v.val_addr = rtl;
12503 ret->dtprel = dtprel;
12505 ret1 = new_loc_descr (second_op, 0, 0);
12506 add_loc_descr (&ret, ret1);
12514 if (DECL_HAS_VALUE_EXPR_P (loc))
12515 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
12520 case FUNCTION_DECL:
12522 rtx rtl = rtl_for_decl_location (loc);
12523 var_loc_list *loc_list = lookup_decl_loc (loc);
12525 if (loc_list && loc_list->first
12526 && (list_ret = dw_loc_list (loc_list, loc, want_address == 2)))
12528 else if (rtl == NULL_RTX)
12530 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
12533 else if (CONST_INT_P (rtl))
12535 HOST_WIDE_INT val = INTVAL (rtl);
12536 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
12537 val &= GET_MODE_MASK (DECL_MODE (loc));
12538 ret = int_loc_descriptor (val);
12540 else if (GET_CODE (rtl) == CONST_STRING)
12542 expansion_failed (loc, NULL_RTX, "CONST_STRING");
12545 else if (CONSTANT_P (rtl))
12547 ret = new_loc_descr (DW_OP_addr, 0, 0);
12548 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
12549 ret->dw_loc_oprnd1.v.val_addr = rtl;
12553 enum machine_mode mode;
12555 /* Certain constructs can only be represented at top-level. */
12556 if (want_address == 2)
12558 ret = loc_descriptor (rtl, VOIDmode,
12559 VAR_INIT_STATUS_INITIALIZED);
12564 mode = GET_MODE (rtl);
12567 rtl = XEXP (rtl, 0);
12570 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
12573 expansion_failed (loc, rtl,
12574 "failed to produce loc descriptor for rtl");
12580 case ALIGN_INDIRECT_REF:
12581 case MISALIGNED_INDIRECT_REF:
12582 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
12586 case COMPOUND_EXPR:
12587 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address);
12590 case VIEW_CONVERT_EXPR:
12593 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address);
12595 case COMPONENT_REF:
12596 case BIT_FIELD_REF:
12598 case ARRAY_RANGE_REF:
12599 case REALPART_EXPR:
12600 case IMAGPART_EXPR:
12603 HOST_WIDE_INT bitsize, bitpos, bytepos;
12604 enum machine_mode mode;
12606 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
12608 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
12609 &unsignedp, &volatilep, false);
12611 gcc_assert (obj != loc);
12613 list_ret = loc_list_from_tree (obj,
12615 && !bitpos && !offset ? 2 : 1);
12616 /* TODO: We can extract value of the small expression via shifting even
12617 for nonzero bitpos. */
12620 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
12622 expansion_failed (loc, NULL_RTX,
12623 "bitfield access");
12627 if (offset != NULL_TREE)
12629 /* Variable offset. */
12630 list_ret1 = loc_list_from_tree (offset, 0);
12631 if (list_ret1 == 0)
12633 add_loc_list (&list_ret, list_ret1);
12636 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
12639 bytepos = bitpos / BITS_PER_UNIT;
12641 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
12642 else if (bytepos < 0)
12643 loc_list_plus_const (list_ret, bytepos);
12650 if ((want_address || !host_integerp (loc, 0))
12651 && (ret = cst_pool_loc_descr (loc)))
12653 else if (want_address == 2
12654 && host_integerp (loc, 0)
12655 && (ret = address_of_int_loc_descriptor
12656 (int_size_in_bytes (TREE_TYPE (loc)),
12657 tree_low_cst (loc, 0))))
12659 else if (host_integerp (loc, 0))
12660 ret = int_loc_descriptor (tree_low_cst (loc, 0));
12663 expansion_failed (loc, NULL_RTX,
12664 "Integer operand is not host integer");
12673 if ((ret = cst_pool_loc_descr (loc)))
12676 /* We can construct small constants here using int_loc_descriptor. */
12677 expansion_failed (loc, NULL_RTX,
12678 "constructor or constant not in constant pool");
12681 case TRUTH_AND_EXPR:
12682 case TRUTH_ANDIF_EXPR:
12687 case TRUTH_XOR_EXPR:
12692 case TRUTH_OR_EXPR:
12693 case TRUTH_ORIF_EXPR:
12698 case FLOOR_DIV_EXPR:
12699 case CEIL_DIV_EXPR:
12700 case ROUND_DIV_EXPR:
12701 case TRUNC_DIV_EXPR:
12709 case FLOOR_MOD_EXPR:
12710 case CEIL_MOD_EXPR:
12711 case ROUND_MOD_EXPR:
12712 case TRUNC_MOD_EXPR:
12725 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
12728 case POINTER_PLUS_EXPR:
12730 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
12731 && host_integerp (TREE_OPERAND (loc, 1), 0))
12733 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
12737 loc_list_plus_const (list_ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
12745 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12752 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12759 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12766 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12781 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
12782 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
12783 if (list_ret == 0 || list_ret1 == 0)
12786 add_loc_list (&list_ret, list_ret1);
12789 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
12792 case TRUTH_NOT_EXPR:
12806 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
12810 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
12816 const enum tree_code code =
12817 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
12819 loc = build3 (COND_EXPR, TREE_TYPE (loc),
12820 build2 (code, integer_type_node,
12821 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
12822 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
12825 /* ... fall through ... */
12829 dw_loc_descr_ref lhs
12830 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
12831 dw_loc_list_ref rhs
12832 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0);
12833 dw_loc_descr_ref bra_node, jump_node, tmp;
12835 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
12836 if (list_ret == 0 || lhs == 0 || rhs == 0)
12839 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
12840 add_loc_descr_to_each (list_ret, bra_node);
12842 add_loc_list (&list_ret, rhs);
12843 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
12844 add_loc_descr_to_each (list_ret, jump_node);
12846 add_loc_descr_to_each (list_ret, lhs);
12847 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12848 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
12850 /* ??? Need a node to point the skip at. Use a nop. */
12851 tmp = new_loc_descr (DW_OP_nop, 0, 0);
12852 add_loc_descr_to_each (list_ret, tmp);
12853 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12854 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
12858 case FIX_TRUNC_EXPR:
12862 /* Leave front-end specific codes as simply unknown. This comes
12863 up, for instance, with the C STMT_EXPR. */
12864 if ((unsigned int) TREE_CODE (loc)
12865 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
12867 expansion_failed (loc, NULL_RTX,
12868 "language specific tree node");
12872 #ifdef ENABLE_CHECKING
12873 /* Otherwise this is a generic code; we should just lists all of
12874 these explicitly. We forgot one. */
12875 gcc_unreachable ();
12877 /* In a release build, we want to degrade gracefully: better to
12878 generate incomplete debugging information than to crash. */
12883 if (!ret && !list_ret)
12886 if (want_address == 2 && !have_address)
12888 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
12890 expansion_failed (loc, NULL_RTX,
12891 "DWARF address size mismatch");
12894 add_loc_descr_to_each (list_ret,
12895 new_loc_descr (DW_OP_stack_value, 0, 0));
12896 add_loc_descr_to_each (list_ret,
12897 new_loc_descr (DW_OP_piece,
12898 int_size_in_bytes (TREE_TYPE
12903 /* Show if we can't fill the request for an address. */
12904 if (want_address && !have_address)
12906 expansion_failed (loc, NULL_RTX,
12907 "Want address and only have value");
12911 gcc_assert (!ret || !list_ret);
12913 /* If we've got an address and don't want one, dereference. */
12914 if (!want_address && have_address)
12916 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
12918 if (size > DWARF2_ADDR_SIZE || size == -1)
12920 expansion_failed (loc, NULL_RTX,
12921 "DWARF address size mismatch");
12924 else if (size == DWARF2_ADDR_SIZE)
12927 op = DW_OP_deref_size;
12930 add_loc_descr (&ret, new_loc_descr (op, size, 0));
12932 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
12935 list_ret = single_element_loc_list (ret);
12940 /* Same as above but return only single location expression. */
12941 static dw_loc_descr_ref
12942 loc_descriptor_from_tree (tree loc, int want_address)
12944 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address);
12947 if (ret->dw_loc_next)
12949 expansion_failed (loc, NULL_RTX,
12950 "Location list where only loc descriptor needed");
12956 /* Given a value, round it up to the lowest multiple of `boundary'
12957 which is not less than the value itself. */
12959 static inline HOST_WIDE_INT
12960 ceiling (HOST_WIDE_INT value, unsigned int boundary)
12962 return (((value + boundary - 1) / boundary) * boundary);
12965 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
12966 pointer to the declared type for the relevant field variable, or return
12967 `integer_type_node' if the given node turns out to be an
12968 ERROR_MARK node. */
12971 field_type (const_tree decl)
12975 if (TREE_CODE (decl) == ERROR_MARK)
12976 return integer_type_node;
12978 type = DECL_BIT_FIELD_TYPE (decl);
12979 if (type == NULL_TREE)
12980 type = TREE_TYPE (decl);
12985 /* Given a pointer to a tree node, return the alignment in bits for
12986 it, or else return BITS_PER_WORD if the node actually turns out to
12987 be an ERROR_MARK node. */
12989 static inline unsigned
12990 simple_type_align_in_bits (const_tree type)
12992 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
12995 static inline unsigned
12996 simple_decl_align_in_bits (const_tree decl)
12998 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
13001 /* Return the result of rounding T up to ALIGN. */
13003 static inline HOST_WIDE_INT
13004 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
13006 /* We must be careful if T is negative because HOST_WIDE_INT can be
13007 either "above" or "below" unsigned int as per the C promotion
13008 rules, depending on the host, thus making the signedness of the
13009 direct multiplication and division unpredictable. */
13010 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
13016 return (HOST_WIDE_INT) u;
13019 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
13020 lowest addressed byte of the "containing object" for the given FIELD_DECL,
13021 or return 0 if we are unable to determine what that offset is, either
13022 because the argument turns out to be a pointer to an ERROR_MARK node, or
13023 because the offset is actually variable. (We can't handle the latter case
13026 static HOST_WIDE_INT
13027 field_byte_offset (const_tree decl)
13029 HOST_WIDE_INT object_offset_in_bits;
13030 HOST_WIDE_INT bitpos_int;
13032 if (TREE_CODE (decl) == ERROR_MARK)
13035 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
13037 /* We cannot yet cope with fields whose positions are variable, so
13038 for now, when we see such things, we simply return 0. Someday, we may
13039 be able to handle such cases, but it will be damn difficult. */
13040 if (! host_integerp (bit_position (decl), 0))
13043 bitpos_int = int_bit_position (decl);
13045 #ifdef PCC_BITFIELD_TYPE_MATTERS
13046 if (PCC_BITFIELD_TYPE_MATTERS)
13049 tree field_size_tree;
13050 HOST_WIDE_INT deepest_bitpos;
13051 unsigned HOST_WIDE_INT field_size_in_bits;
13052 unsigned int type_align_in_bits;
13053 unsigned int decl_align_in_bits;
13054 unsigned HOST_WIDE_INT type_size_in_bits;
13056 type = field_type (decl);
13057 type_size_in_bits = simple_type_size_in_bits (type);
13058 type_align_in_bits = simple_type_align_in_bits (type);
13060 field_size_tree = DECL_SIZE (decl);
13062 /* The size could be unspecified if there was an error, or for
13063 a flexible array member. */
13064 if (!field_size_tree)
13065 field_size_tree = bitsize_zero_node;
13067 /* If the size of the field is not constant, use the type size. */
13068 if (host_integerp (field_size_tree, 1))
13069 field_size_in_bits = tree_low_cst (field_size_tree, 1);
13071 field_size_in_bits = type_size_in_bits;
13073 decl_align_in_bits = simple_decl_align_in_bits (decl);
13075 /* The GCC front-end doesn't make any attempt to keep track of the
13076 starting bit offset (relative to the start of the containing
13077 structure type) of the hypothetical "containing object" for a
13078 bit-field. Thus, when computing the byte offset value for the
13079 start of the "containing object" of a bit-field, we must deduce
13080 this information on our own. This can be rather tricky to do in
13081 some cases. For example, handling the following structure type
13082 definition when compiling for an i386/i486 target (which only
13083 aligns long long's to 32-bit boundaries) can be very tricky:
13085 struct S { int field1; long long field2:31; };
13087 Fortunately, there is a simple rule-of-thumb which can be used
13088 in such cases. When compiling for an i386/i486, GCC will
13089 allocate 8 bytes for the structure shown above. It decides to
13090 do this based upon one simple rule for bit-field allocation.
13091 GCC allocates each "containing object" for each bit-field at
13092 the first (i.e. lowest addressed) legitimate alignment boundary
13093 (based upon the required minimum alignment for the declared
13094 type of the field) which it can possibly use, subject to the
13095 condition that there is still enough available space remaining
13096 in the containing object (when allocated at the selected point)
13097 to fully accommodate all of the bits of the bit-field itself.
13099 This simple rule makes it obvious why GCC allocates 8 bytes for
13100 each object of the structure type shown above. When looking
13101 for a place to allocate the "containing object" for `field2',
13102 the compiler simply tries to allocate a 64-bit "containing
13103 object" at each successive 32-bit boundary (starting at zero)
13104 until it finds a place to allocate that 64- bit field such that
13105 at least 31 contiguous (and previously unallocated) bits remain
13106 within that selected 64 bit field. (As it turns out, for the
13107 example above, the compiler finds it is OK to allocate the
13108 "containing object" 64-bit field at bit-offset zero within the
13111 Here we attempt to work backwards from the limited set of facts
13112 we're given, and we try to deduce from those facts, where GCC
13113 must have believed that the containing object started (within
13114 the structure type). The value we deduce is then used (by the
13115 callers of this routine) to generate DW_AT_location and
13116 DW_AT_bit_offset attributes for fields (both bit-fields and, in
13117 the case of DW_AT_location, regular fields as well). */
13119 /* Figure out the bit-distance from the start of the structure to
13120 the "deepest" bit of the bit-field. */
13121 deepest_bitpos = bitpos_int + field_size_in_bits;
13123 /* This is the tricky part. Use some fancy footwork to deduce
13124 where the lowest addressed bit of the containing object must
13126 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
13128 /* Round up to type_align by default. This works best for
13130 object_offset_in_bits
13131 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
13133 if (object_offset_in_bits > bitpos_int)
13135 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
13137 /* Round up to decl_align instead. */
13138 object_offset_in_bits
13139 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
13144 object_offset_in_bits = bitpos_int;
13146 return object_offset_in_bits / BITS_PER_UNIT;
13149 /* The following routines define various Dwarf attributes and any data
13150 associated with them. */
13152 /* Add a location description attribute value to a DIE.
13154 This emits location attributes suitable for whole variables and
13155 whole parameters. Note that the location attributes for struct fields are
13156 generated by the routine `data_member_location_attribute' below. */
13159 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
13160 dw_loc_list_ref descr)
13164 if (single_element_loc_list_p (descr))
13165 add_AT_loc (die, attr_kind, descr->expr);
13167 add_AT_loc_list (die, attr_kind, descr);
13170 /* Attach the specialized form of location attribute used for data members of
13171 struct and union types. In the special case of a FIELD_DECL node which
13172 represents a bit-field, the "offset" part of this special location
13173 descriptor must indicate the distance in bytes from the lowest-addressed
13174 byte of the containing struct or union type to the lowest-addressed byte of
13175 the "containing object" for the bit-field. (See the `field_byte_offset'
13178 For any given bit-field, the "containing object" is a hypothetical object
13179 (of some integral or enum type) within which the given bit-field lives. The
13180 type of this hypothetical "containing object" is always the same as the
13181 declared type of the individual bit-field itself (for GCC anyway... the
13182 DWARF spec doesn't actually mandate this). Note that it is the size (in
13183 bytes) of the hypothetical "containing object" which will be given in the
13184 DW_AT_byte_size attribute for this bit-field. (See the
13185 `byte_size_attribute' function below.) It is also used when calculating the
13186 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
13187 function below.) */
13190 add_data_member_location_attribute (dw_die_ref die, tree decl)
13192 HOST_WIDE_INT offset;
13193 dw_loc_descr_ref loc_descr = 0;
13195 if (TREE_CODE (decl) == TREE_BINFO)
13197 /* We're working on the TAG_inheritance for a base class. */
13198 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
13200 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
13201 aren't at a fixed offset from all (sub)objects of the same
13202 type. We need to extract the appropriate offset from our
13203 vtable. The following dwarf expression means
13205 BaseAddr = ObAddr + *((*ObAddr) - Offset)
13207 This is specific to the V3 ABI, of course. */
13209 dw_loc_descr_ref tmp;
13211 /* Make a copy of the object address. */
13212 tmp = new_loc_descr (DW_OP_dup, 0, 0);
13213 add_loc_descr (&loc_descr, tmp);
13215 /* Extract the vtable address. */
13216 tmp = new_loc_descr (DW_OP_deref, 0, 0);
13217 add_loc_descr (&loc_descr, tmp);
13219 /* Calculate the address of the offset. */
13220 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
13221 gcc_assert (offset < 0);
13223 tmp = int_loc_descriptor (-offset);
13224 add_loc_descr (&loc_descr, tmp);
13225 tmp = new_loc_descr (DW_OP_minus, 0, 0);
13226 add_loc_descr (&loc_descr, tmp);
13228 /* Extract the offset. */
13229 tmp = new_loc_descr (DW_OP_deref, 0, 0);
13230 add_loc_descr (&loc_descr, tmp);
13232 /* Add it to the object address. */
13233 tmp = new_loc_descr (DW_OP_plus, 0, 0);
13234 add_loc_descr (&loc_descr, tmp);
13237 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
13240 offset = field_byte_offset (decl);
13244 if (dwarf_version > 2)
13246 /* Don't need to output a location expression, just the constant. */
13247 add_AT_int (die, DW_AT_data_member_location, offset);
13252 enum dwarf_location_atom op;
13254 /* The DWARF2 standard says that we should assume that the structure
13255 address is already on the stack, so we can specify a structure
13256 field address by using DW_OP_plus_uconst. */
13258 #ifdef MIPS_DEBUGGING_INFO
13259 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
13260 operator correctly. It works only if we leave the offset on the
13264 op = DW_OP_plus_uconst;
13267 loc_descr = new_loc_descr (op, offset, 0);
13271 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
13274 /* Writes integer values to dw_vec_const array. */
13277 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
13281 *dest++ = val & 0xff;
13287 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
13289 static HOST_WIDE_INT
13290 extract_int (const unsigned char *src, unsigned int size)
13292 HOST_WIDE_INT val = 0;
13298 val |= *--src & 0xff;
13304 /* Writes floating point values to dw_vec_const array. */
13307 insert_float (const_rtx rtl, unsigned char *array)
13309 REAL_VALUE_TYPE rv;
13313 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
13314 real_to_target (val, &rv, GET_MODE (rtl));
13316 /* real_to_target puts 32-bit pieces in each long. Pack them. */
13317 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
13319 insert_int (val[i], 4, array);
13324 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
13325 does not have a "location" either in memory or in a register. These
13326 things can arise in GNU C when a constant is passed as an actual parameter
13327 to an inlined function. They can also arise in C++ where declared
13328 constants do not necessarily get memory "homes". */
13331 add_const_value_attribute (dw_die_ref die, rtx rtl)
13333 switch (GET_CODE (rtl))
13337 HOST_WIDE_INT val = INTVAL (rtl);
13340 add_AT_int (die, DW_AT_const_value, val);
13342 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
13347 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
13348 floating-point constant. A CONST_DOUBLE is used whenever the
13349 constant requires more than one word in order to be adequately
13350 represented. We output CONST_DOUBLEs as blocks. */
13352 enum machine_mode mode = GET_MODE (rtl);
13354 if (SCALAR_FLOAT_MODE_P (mode))
13356 unsigned int length = GET_MODE_SIZE (mode);
13357 unsigned char *array = GGC_NEWVEC (unsigned char, length);
13359 insert_float (rtl, array);
13360 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
13363 add_AT_long_long (die, DW_AT_const_value, rtl);
13369 enum machine_mode mode = GET_MODE (rtl);
13370 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
13371 unsigned int length = CONST_VECTOR_NUNITS (rtl);
13372 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
13376 switch (GET_MODE_CLASS (mode))
13378 case MODE_VECTOR_INT:
13379 for (i = 0, p = array; i < length; i++, p += elt_size)
13381 rtx elt = CONST_VECTOR_ELT (rtl, i);
13382 HOST_WIDE_INT lo, hi;
13384 switch (GET_CODE (elt))
13392 lo = CONST_DOUBLE_LOW (elt);
13393 hi = CONST_DOUBLE_HIGH (elt);
13397 gcc_unreachable ();
13400 if (elt_size <= sizeof (HOST_WIDE_INT))
13401 insert_int (lo, elt_size, p);
13404 unsigned char *p0 = p;
13405 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
13407 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
13408 if (WORDS_BIG_ENDIAN)
13413 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
13414 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
13419 case MODE_VECTOR_FLOAT:
13420 for (i = 0, p = array; i < length; i++, p += elt_size)
13422 rtx elt = CONST_VECTOR_ELT (rtl, i);
13423 insert_float (elt, p);
13428 gcc_unreachable ();
13431 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
13436 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
13440 if (CONSTANT_P (XEXP (rtl, 0)))
13442 add_const_value_attribute (die, XEXP (rtl, 0));
13447 if (GET_CODE (rtl) == SYMBOL_REF
13448 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
13451 add_AT_addr (die, DW_AT_const_value, rtl);
13452 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
13456 /* In cases where an inlined instance of an inline function is passed
13457 the address of an `auto' variable (which is local to the caller) we
13458 can get a situation where the DECL_RTL of the artificial local
13459 variable (for the inlining) which acts as a stand-in for the
13460 corresponding formal parameter (of the inline function) will look
13461 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
13462 exactly a compile-time constant expression, but it isn't the address
13463 of the (artificial) local variable either. Rather, it represents the
13464 *value* which the artificial local variable always has during its
13465 lifetime. We currently have no way to represent such quasi-constant
13466 values in Dwarf, so for now we just punt and generate nothing. */
13470 /* No other kinds of rtx should be possible here. */
13471 gcc_unreachable ();
13476 /* Determine whether the evaluation of EXPR references any variables
13477 or functions which aren't otherwise used (and therefore may not be
13480 reference_to_unused (tree * tp, int * walk_subtrees,
13481 void * data ATTRIBUTE_UNUSED)
13483 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
13484 *walk_subtrees = 0;
13486 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
13487 && ! TREE_ASM_WRITTEN (*tp))
13489 /* ??? The C++ FE emits debug information for using decls, so
13490 putting gcc_unreachable here falls over. See PR31899. For now
13491 be conservative. */
13492 else if (!cgraph_global_info_ready
13493 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
13495 else if (TREE_CODE (*tp) == VAR_DECL)
13497 struct varpool_node *node = varpool_node (*tp);
13501 else if (TREE_CODE (*tp) == FUNCTION_DECL
13502 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
13504 /* The call graph machinery must have finished analyzing,
13505 optimizing and gimplifying the CU by now.
13506 So if *TP has no call graph node associated
13507 to it, it means *TP will not be emitted. */
13508 if (!cgraph_get_node (*tp))
13511 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
13517 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
13518 for use in a later add_const_value_attribute call. */
13521 rtl_for_decl_init (tree init, tree type)
13523 rtx rtl = NULL_RTX;
13525 /* If a variable is initialized with a string constant without embedded
13526 zeros, build CONST_STRING. */
13527 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
13529 tree enttype = TREE_TYPE (type);
13530 tree domain = TYPE_DOMAIN (type);
13531 enum machine_mode mode = TYPE_MODE (enttype);
13533 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
13535 && integer_zerop (TYPE_MIN_VALUE (domain))
13536 && compare_tree_int (TYPE_MAX_VALUE (domain),
13537 TREE_STRING_LENGTH (init) - 1) == 0
13538 && ((size_t) TREE_STRING_LENGTH (init)
13539 == strlen (TREE_STRING_POINTER (init)) + 1))
13540 rtl = gen_rtx_CONST_STRING (VOIDmode,
13541 ggc_strdup (TREE_STRING_POINTER (init)));
13543 /* Other aggregates, and complex values, could be represented using
13545 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
13547 /* Vectors only work if their mode is supported by the target.
13548 FIXME: generic vectors ought to work too. */
13549 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
13551 /* If the initializer is something that we know will expand into an
13552 immediate RTL constant, expand it now. We must be careful not to
13553 reference variables which won't be output. */
13554 else if (initializer_constant_valid_p (init, type)
13555 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
13557 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
13559 if (TREE_CODE (type) == VECTOR_TYPE)
13560 switch (TREE_CODE (init))
13565 if (TREE_CONSTANT (init))
13567 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
13568 bool constant_p = true;
13570 unsigned HOST_WIDE_INT ix;
13572 /* Even when ctor is constant, it might contain non-*_CST
13573 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
13574 belong into VECTOR_CST nodes. */
13575 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
13576 if (!CONSTANT_CLASS_P (value))
13578 constant_p = false;
13584 init = build_vector_from_ctor (type, elts);
13594 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
13596 /* If expand_expr returns a MEM, it wasn't immediate. */
13597 gcc_assert (!rtl || !MEM_P (rtl));
13603 /* Generate RTL for the variable DECL to represent its location. */
13606 rtl_for_decl_location (tree decl)
13610 /* Here we have to decide where we are going to say the parameter "lives"
13611 (as far as the debugger is concerned). We only have a couple of
13612 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
13614 DECL_RTL normally indicates where the parameter lives during most of the
13615 activation of the function. If optimization is enabled however, this
13616 could be either NULL or else a pseudo-reg. Both of those cases indicate
13617 that the parameter doesn't really live anywhere (as far as the code
13618 generation parts of GCC are concerned) during most of the function's
13619 activation. That will happen (for example) if the parameter is never
13620 referenced within the function.
13622 We could just generate a location descriptor here for all non-NULL
13623 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
13624 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
13625 where DECL_RTL is NULL or is a pseudo-reg.
13627 Note however that we can only get away with using DECL_INCOMING_RTL as
13628 a backup substitute for DECL_RTL in certain limited cases. In cases
13629 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
13630 we can be sure that the parameter was passed using the same type as it is
13631 declared to have within the function, and that its DECL_INCOMING_RTL
13632 points us to a place where a value of that type is passed.
13634 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
13635 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
13636 because in these cases DECL_INCOMING_RTL points us to a value of some
13637 type which is *different* from the type of the parameter itself. Thus,
13638 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
13639 such cases, the debugger would end up (for example) trying to fetch a
13640 `float' from a place which actually contains the first part of a
13641 `double'. That would lead to really incorrect and confusing
13642 output at debug-time.
13644 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
13645 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
13646 are a couple of exceptions however. On little-endian machines we can
13647 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
13648 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
13649 an integral type that is smaller than TREE_TYPE (decl). These cases arise
13650 when (on a little-endian machine) a non-prototyped function has a
13651 parameter declared to be of type `short' or `char'. In such cases,
13652 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
13653 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
13654 passed `int' value. If the debugger then uses that address to fetch
13655 a `short' or a `char' (on a little-endian machine) the result will be
13656 the correct data, so we allow for such exceptional cases below.
13658 Note that our goal here is to describe the place where the given formal
13659 parameter lives during most of the function's activation (i.e. between the
13660 end of the prologue and the start of the epilogue). We'll do that as best
13661 as we can. Note however that if the given formal parameter is modified
13662 sometime during the execution of the function, then a stack backtrace (at
13663 debug-time) will show the function as having been called with the *new*
13664 value rather than the value which was originally passed in. This happens
13665 rarely enough that it is not a major problem, but it *is* a problem, and
13666 I'd like to fix it.
13668 A future version of dwarf2out.c may generate two additional attributes for
13669 any given DW_TAG_formal_parameter DIE which will describe the "passed
13670 type" and the "passed location" for the given formal parameter in addition
13671 to the attributes we now generate to indicate the "declared type" and the
13672 "active location" for each parameter. This additional set of attributes
13673 could be used by debuggers for stack backtraces. Separately, note that
13674 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
13675 This happens (for example) for inlined-instances of inline function formal
13676 parameters which are never referenced. This really shouldn't be
13677 happening. All PARM_DECL nodes should get valid non-NULL
13678 DECL_INCOMING_RTL values. FIXME. */
13680 /* Use DECL_RTL as the "location" unless we find something better. */
13681 rtl = DECL_RTL_IF_SET (decl);
13683 /* When generating abstract instances, ignore everything except
13684 constants, symbols living in memory, and symbols living in
13685 fixed registers. */
13686 if (! reload_completed)
13689 && (CONSTANT_P (rtl)
13691 && CONSTANT_P (XEXP (rtl, 0)))
13693 && TREE_CODE (decl) == VAR_DECL
13694 && TREE_STATIC (decl))))
13696 rtl = targetm.delegitimize_address (rtl);
13701 else if (TREE_CODE (decl) == PARM_DECL)
13703 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
13705 tree declared_type = TREE_TYPE (decl);
13706 tree passed_type = DECL_ARG_TYPE (decl);
13707 enum machine_mode dmode = TYPE_MODE (declared_type);
13708 enum machine_mode pmode = TYPE_MODE (passed_type);
13710 /* This decl represents a formal parameter which was optimized out.
13711 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
13712 all cases where (rtl == NULL_RTX) just below. */
13713 if (dmode == pmode)
13714 rtl = DECL_INCOMING_RTL (decl);
13715 else if (SCALAR_INT_MODE_P (dmode)
13716 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
13717 && DECL_INCOMING_RTL (decl))
13719 rtx inc = DECL_INCOMING_RTL (decl);
13722 else if (MEM_P (inc))
13724 if (BYTES_BIG_ENDIAN)
13725 rtl = adjust_address_nv (inc, dmode,
13726 GET_MODE_SIZE (pmode)
13727 - GET_MODE_SIZE (dmode));
13734 /* If the parm was passed in registers, but lives on the stack, then
13735 make a big endian correction if the mode of the type of the
13736 parameter is not the same as the mode of the rtl. */
13737 /* ??? This is the same series of checks that are made in dbxout.c before
13738 we reach the big endian correction code there. It isn't clear if all
13739 of these checks are necessary here, but keeping them all is the safe
13741 else if (MEM_P (rtl)
13742 && XEXP (rtl, 0) != const0_rtx
13743 && ! CONSTANT_P (XEXP (rtl, 0))
13744 /* Not passed in memory. */
13745 && !MEM_P (DECL_INCOMING_RTL (decl))
13746 /* Not passed by invisible reference. */
13747 && (!REG_P (XEXP (rtl, 0))
13748 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
13749 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
13750 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
13751 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
13754 /* Big endian correction check. */
13755 && BYTES_BIG_ENDIAN
13756 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
13757 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
13760 int offset = (UNITS_PER_WORD
13761 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
13763 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
13764 plus_constant (XEXP (rtl, 0), offset));
13767 else if (TREE_CODE (decl) == VAR_DECL
13770 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
13771 && BYTES_BIG_ENDIAN)
13773 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
13774 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
13776 /* If a variable is declared "register" yet is smaller than
13777 a register, then if we store the variable to memory, it
13778 looks like we're storing a register-sized value, when in
13779 fact we are not. We need to adjust the offset of the
13780 storage location to reflect the actual value's bytes,
13781 else gdb will not be able to display it. */
13783 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
13784 plus_constant (XEXP (rtl, 0), rsize-dsize));
13787 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
13788 and will have been substituted directly into all expressions that use it.
13789 C does not have such a concept, but C++ and other languages do. */
13790 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
13791 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
13794 rtl = targetm.delegitimize_address (rtl);
13796 /* If we don't look past the constant pool, we risk emitting a
13797 reference to a constant pool entry that isn't referenced from
13798 code, and thus is not emitted. */
13800 rtl = avoid_constant_pool_reference (rtl);
13805 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
13806 returned. If so, the decl for the COMMON block is returned, and the
13807 value is the offset into the common block for the symbol. */
13810 fortran_common (tree decl, HOST_WIDE_INT *value)
13812 tree val_expr, cvar;
13813 enum machine_mode mode;
13814 HOST_WIDE_INT bitsize, bitpos;
13816 int volatilep = 0, unsignedp = 0;
13818 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
13819 it does not have a value (the offset into the common area), or if it
13820 is thread local (as opposed to global) then it isn't common, and shouldn't
13821 be handled as such. */
13822 if (TREE_CODE (decl) != VAR_DECL
13823 || !TREE_PUBLIC (decl)
13824 || !TREE_STATIC (decl)
13825 || !DECL_HAS_VALUE_EXPR_P (decl)
13829 val_expr = DECL_VALUE_EXPR (decl);
13830 if (TREE_CODE (val_expr) != COMPONENT_REF)
13833 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
13834 &mode, &unsignedp, &volatilep, true);
13836 if (cvar == NULL_TREE
13837 || TREE_CODE (cvar) != VAR_DECL
13838 || DECL_ARTIFICIAL (cvar)
13839 || !TREE_PUBLIC (cvar))
13843 if (offset != NULL)
13845 if (!host_integerp (offset, 0))
13847 *value = tree_low_cst (offset, 0);
13850 *value += bitpos / BITS_PER_UNIT;
13855 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
13856 data attribute for a variable or a parameter. We generate the
13857 DW_AT_const_value attribute only in those cases where the given variable
13858 or parameter does not have a true "location" either in memory or in a
13859 register. This can happen (for example) when a constant is passed as an
13860 actual argument in a call to an inline function. (It's possible that
13861 these things can crop up in other ways also.) Note that one type of
13862 constant value which can be passed into an inlined function is a constant
13863 pointer. This can happen for example if an actual argument in an inlined
13864 function call evaluates to a compile-time constant address. */
13867 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
13868 enum dwarf_attribute attr)
13871 dw_loc_list_ref list;
13872 var_loc_list *loc_list;
13874 if (TREE_CODE (decl) == ERROR_MARK)
13877 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
13878 || TREE_CODE (decl) == RESULT_DECL);
13880 /* Try to get some constant RTL for this decl, and use that as the value of
13883 rtl = rtl_for_decl_location (decl);
13884 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
13885 && add_const_value_attribute (die, rtl))
13888 /* See if we have single element location list that is equivalent to
13889 a constant value. That way we are better to use add_const_value_attribute
13890 rather than expanding constant value equivalent. */
13891 loc_list = lookup_decl_loc (decl);
13892 if (loc_list && loc_list->first && loc_list->first == loc_list->last)
13894 enum var_init_status status;
13895 struct var_loc_node *node;
13897 node = loc_list->first;
13898 status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
13899 rtl = NOTE_VAR_LOCATION (node->var_loc_note);
13900 if (GET_CODE (rtl) == VAR_LOCATION
13901 && GET_CODE (XEXP (rtl, 1)) != PARALLEL)
13902 rtl = XEXP (XEXP (rtl, 1), 0);
13903 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
13904 && add_const_value_attribute (die, rtl))
13907 list = loc_list_from_tree (decl, 2);
13910 add_AT_location_description (die, attr, list);
13913 /* None of that worked, so it must not really have a location;
13914 try adding a constant value attribute from the DECL_INITIAL. */
13915 return tree_add_const_value_attribute_for_decl (die, decl);
13918 /* Add VARIABLE and DIE into deferred locations list. */
13921 defer_location (tree variable, dw_die_ref die)
13923 deferred_locations entry;
13924 entry.variable = variable;
13926 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
13929 /* Helper function for tree_add_const_value_attribute. Natively encode
13930 initializer INIT into an array. Return true if successful. */
13933 native_encode_initializer (tree init, unsigned char *array, int size)
13937 if (init == NULL_TREE)
13941 switch (TREE_CODE (init))
13944 type = TREE_TYPE (init);
13945 if (TREE_CODE (type) == ARRAY_TYPE)
13947 tree enttype = TREE_TYPE (type);
13948 enum machine_mode mode = TYPE_MODE (enttype);
13950 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
13952 if (int_size_in_bytes (type) != size)
13954 if (size > TREE_STRING_LENGTH (init))
13956 memcpy (array, TREE_STRING_POINTER (init),
13957 TREE_STRING_LENGTH (init));
13958 memset (array + TREE_STRING_LENGTH (init),
13959 '\0', size - TREE_STRING_LENGTH (init));
13962 memcpy (array, TREE_STRING_POINTER (init), size);
13967 type = TREE_TYPE (init);
13968 if (int_size_in_bytes (type) != size)
13970 if (TREE_CODE (type) == ARRAY_TYPE)
13972 HOST_WIDE_INT min_index;
13973 unsigned HOST_WIDE_INT cnt;
13974 int curpos = 0, fieldsize;
13975 constructor_elt *ce;
13977 if (TYPE_DOMAIN (type) == NULL_TREE
13978 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
13981 fieldsize = int_size_in_bytes (TREE_TYPE (type));
13982 if (fieldsize <= 0)
13985 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
13986 memset (array, '\0', size);
13988 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
13991 tree val = ce->value;
13992 tree index = ce->index;
13994 if (index && TREE_CODE (index) == RANGE_EXPR)
13995 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
13998 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
14003 if (!native_encode_initializer (val, array + pos, fieldsize))
14006 curpos = pos + fieldsize;
14007 if (index && TREE_CODE (index) == RANGE_EXPR)
14009 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
14010 - tree_low_cst (TREE_OPERAND (index, 0), 0);
14014 memcpy (array + curpos, array + pos, fieldsize);
14015 curpos += fieldsize;
14018 gcc_assert (curpos <= size);
14022 else if (TREE_CODE (type) == RECORD_TYPE
14023 || TREE_CODE (type) == UNION_TYPE)
14025 tree field = NULL_TREE;
14026 unsigned HOST_WIDE_INT cnt;
14027 constructor_elt *ce;
14029 if (int_size_in_bytes (type) != size)
14032 if (TREE_CODE (type) == RECORD_TYPE)
14033 field = TYPE_FIELDS (type);
14036 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
14037 cnt++, field = field ? TREE_CHAIN (field) : 0)
14039 tree val = ce->value;
14040 int pos, fieldsize;
14042 if (ce->index != 0)
14048 if (field == NULL_TREE || DECL_BIT_FIELD (field))
14051 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
14052 && TYPE_DOMAIN (TREE_TYPE (field))
14053 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
14055 else if (DECL_SIZE_UNIT (field) == NULL_TREE
14056 || !host_integerp (DECL_SIZE_UNIT (field), 0))
14058 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
14059 pos = int_byte_position (field);
14060 gcc_assert (pos + fieldsize <= size);
14062 && !native_encode_initializer (val, array + pos, fieldsize))
14068 case VIEW_CONVERT_EXPR:
14069 case NON_LVALUE_EXPR:
14070 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
14072 return native_encode_expr (init, array, size) == size;
14076 /* Attach a DW_AT_const_value attribute to DIE. The value of the
14077 attribute is the const value T. */
14080 tree_add_const_value_attribute (dw_die_ref die, tree t)
14083 tree type = TREE_TYPE (t);
14086 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
14090 gcc_assert (!DECL_P (init));
14092 rtl = rtl_for_decl_init (init, type);
14095 add_const_value_attribute (die, rtl);
14098 /* If the host and target are sane, try harder. */
14099 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
14100 && initializer_constant_valid_p (init, type))
14102 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
14103 if (size > 0 && (int) size == size)
14105 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
14107 if (native_encode_initializer (init, array, size))
14109 add_AT_vec (die, DW_AT_const_value, size, 1, array);
14117 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
14118 attribute is the const value of T, where T is an integral constant
14119 variable with static storage duration
14120 (so it can't be a PARM_DECL or a RESULT_DECL). */
14123 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
14127 || (TREE_CODE (decl) != VAR_DECL
14128 && TREE_CODE (decl) != CONST_DECL))
14131 if (TREE_READONLY (decl)
14132 && ! TREE_THIS_VOLATILE (decl)
14133 && DECL_INITIAL (decl))
14138 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
14141 /* Convert the CFI instructions for the current function into a
14142 location list. This is used for DW_AT_frame_base when we targeting
14143 a dwarf2 consumer that does not support the dwarf3
14144 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
14147 static dw_loc_list_ref
14148 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
14151 dw_loc_list_ref list, *list_tail;
14153 dw_cfa_location last_cfa, next_cfa;
14154 const char *start_label, *last_label, *section;
14155 dw_cfa_location remember;
14157 fde = current_fde ();
14158 gcc_assert (fde != NULL);
14160 section = secname_for_decl (current_function_decl);
14164 memset (&next_cfa, 0, sizeof (next_cfa));
14165 next_cfa.reg = INVALID_REGNUM;
14166 remember = next_cfa;
14168 start_label = fde->dw_fde_begin;
14170 /* ??? Bald assumption that the CIE opcode list does not contain
14171 advance opcodes. */
14172 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
14173 lookup_cfa_1 (cfi, &next_cfa, &remember);
14175 last_cfa = next_cfa;
14176 last_label = start_label;
14178 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
14179 switch (cfi->dw_cfi_opc)
14181 case DW_CFA_set_loc:
14182 case DW_CFA_advance_loc1:
14183 case DW_CFA_advance_loc2:
14184 case DW_CFA_advance_loc4:
14185 if (!cfa_equal_p (&last_cfa, &next_cfa))
14187 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
14188 start_label, last_label, section,
14191 list_tail = &(*list_tail)->dw_loc_next;
14192 last_cfa = next_cfa;
14193 start_label = last_label;
14195 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
14198 case DW_CFA_advance_loc:
14199 /* The encoding is complex enough that we should never emit this. */
14200 gcc_unreachable ();
14203 lookup_cfa_1 (cfi, &next_cfa, &remember);
14207 if (!cfa_equal_p (&last_cfa, &next_cfa))
14209 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
14210 start_label, last_label, section,
14212 list_tail = &(*list_tail)->dw_loc_next;
14213 start_label = last_label;
14215 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
14216 start_label, fde->dw_fde_end, section,
14222 /* Compute a displacement from the "steady-state frame pointer" to the
14223 frame base (often the same as the CFA), and store it in
14224 frame_pointer_fb_offset. OFFSET is added to the displacement
14225 before the latter is negated. */
14228 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
14232 #ifdef FRAME_POINTER_CFA_OFFSET
14233 reg = frame_pointer_rtx;
14234 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
14236 reg = arg_pointer_rtx;
14237 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
14240 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
14241 if (GET_CODE (elim) == PLUS)
14243 offset += INTVAL (XEXP (elim, 1));
14244 elim = XEXP (elim, 0);
14247 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
14248 && (elim == hard_frame_pointer_rtx
14249 || elim == stack_pointer_rtx))
14250 || elim == (frame_pointer_needed
14251 ? hard_frame_pointer_rtx
14252 : stack_pointer_rtx));
14254 frame_pointer_fb_offset = -offset;
14257 /* Generate a DW_AT_name attribute given some string value to be included as
14258 the value of the attribute. */
14261 add_name_attribute (dw_die_ref die, const char *name_string)
14263 if (name_string != NULL && *name_string != 0)
14265 if (demangle_name_func)
14266 name_string = (*demangle_name_func) (name_string);
14268 add_AT_string (die, DW_AT_name, name_string);
14272 /* Generate a DW_AT_comp_dir attribute for DIE. */
14275 add_comp_dir_attribute (dw_die_ref die)
14277 const char *wd = get_src_pwd ();
14283 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
14287 wdlen = strlen (wd);
14288 wd1 = GGC_NEWVEC (char, wdlen + 2);
14290 wd1 [wdlen] = DIR_SEPARATOR;
14291 wd1 [wdlen + 1] = 0;
14295 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
14298 /* Given a tree node describing an array bound (either lower or upper) output
14299 a representation for that bound. */
14302 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
14304 switch (TREE_CODE (bound))
14309 /* All fixed-bounds are represented by INTEGER_CST nodes. */
14311 if (! host_integerp (bound, 0)
14312 || (bound_attr == DW_AT_lower_bound
14313 && (((is_c_family () || is_java ()) && integer_zerop (bound))
14314 || (is_fortran () && integer_onep (bound)))))
14315 /* Use the default. */
14318 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
14322 case VIEW_CONVERT_EXPR:
14323 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
14333 dw_die_ref decl_die = lookup_decl_die (bound);
14334 dw_loc_list_ref loc;
14336 /* ??? Can this happen, or should the variable have been bound
14337 first? Probably it can, since I imagine that we try to create
14338 the types of parameters in the order in which they exist in
14339 the list, and won't have created a forward reference to a
14340 later parameter. */
14341 if (decl_die != NULL)
14342 add_AT_die_ref (subrange_die, bound_attr, decl_die);
14345 loc = loc_list_from_tree (bound, 0);
14346 add_AT_location_description (subrange_die, bound_attr, loc);
14353 /* Otherwise try to create a stack operation procedure to
14354 evaluate the value of the array bound. */
14356 dw_die_ref ctx, decl_die;
14357 dw_loc_list_ref list;
14359 list = loc_list_from_tree (bound, 2);
14363 if (current_function_decl == 0)
14364 ctx = comp_unit_die;
14366 ctx = lookup_decl_die (current_function_decl);
14368 decl_die = new_die (DW_TAG_variable, ctx, bound);
14369 add_AT_flag (decl_die, DW_AT_artificial, 1);
14370 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
14371 if (list->dw_loc_next)
14372 add_AT_loc_list (decl_die, DW_AT_location, list);
14374 add_AT_loc (decl_die, DW_AT_location, list->expr);
14376 add_AT_die_ref (subrange_die, bound_attr, decl_die);
14382 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
14383 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
14384 Note that the block of subscript information for an array type also
14385 includes information about the element type of the given array type. */
14388 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
14390 unsigned dimension_number;
14392 dw_die_ref subrange_die;
14394 for (dimension_number = 0;
14395 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
14396 type = TREE_TYPE (type), dimension_number++)
14398 tree domain = TYPE_DOMAIN (type);
14400 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
14403 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
14404 and (in GNU C only) variable bounds. Handle all three forms
14406 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
14409 /* We have an array type with specified bounds. */
14410 lower = TYPE_MIN_VALUE (domain);
14411 upper = TYPE_MAX_VALUE (domain);
14413 /* Define the index type. */
14414 if (TREE_TYPE (domain))
14416 /* ??? This is probably an Ada unnamed subrange type. Ignore the
14417 TREE_TYPE field. We can't emit debug info for this
14418 because it is an unnamed integral type. */
14419 if (TREE_CODE (domain) == INTEGER_TYPE
14420 && TYPE_NAME (domain) == NULL_TREE
14421 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
14422 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
14425 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
14429 /* ??? If upper is NULL, the array has unspecified length,
14430 but it does have a lower bound. This happens with Fortran
14432 Since the debugger is definitely going to need to know N
14433 to produce useful results, go ahead and output the lower
14434 bound solo, and hope the debugger can cope. */
14436 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
14438 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
14441 /* Otherwise we have an array type with an unspecified length. The
14442 DWARF-2 spec does not say how to handle this; let's just leave out the
14448 add_byte_size_attribute (dw_die_ref die, tree tree_node)
14452 switch (TREE_CODE (tree_node))
14457 case ENUMERAL_TYPE:
14460 case QUAL_UNION_TYPE:
14461 size = int_size_in_bytes (tree_node);
14464 /* For a data member of a struct or union, the DW_AT_byte_size is
14465 generally given as the number of bytes normally allocated for an
14466 object of the *declared* type of the member itself. This is true
14467 even for bit-fields. */
14468 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
14471 gcc_unreachable ();
14474 /* Note that `size' might be -1 when we get to this point. If it is, that
14475 indicates that the byte size of the entity in question is variable. We
14476 have no good way of expressing this fact in Dwarf at the present time,
14477 so just let the -1 pass on through. */
14478 add_AT_unsigned (die, DW_AT_byte_size, size);
14481 /* For a FIELD_DECL node which represents a bit-field, output an attribute
14482 which specifies the distance in bits from the highest order bit of the
14483 "containing object" for the bit-field to the highest order bit of the
14486 For any given bit-field, the "containing object" is a hypothetical object
14487 (of some integral or enum type) within which the given bit-field lives. The
14488 type of this hypothetical "containing object" is always the same as the
14489 declared type of the individual bit-field itself. The determination of the
14490 exact location of the "containing object" for a bit-field is rather
14491 complicated. It's handled by the `field_byte_offset' function (above).
14493 Note that it is the size (in bytes) of the hypothetical "containing object"
14494 which will be given in the DW_AT_byte_size attribute for this bit-field.
14495 (See `byte_size_attribute' above). */
14498 add_bit_offset_attribute (dw_die_ref die, tree decl)
14500 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
14501 tree type = DECL_BIT_FIELD_TYPE (decl);
14502 HOST_WIDE_INT bitpos_int;
14503 HOST_WIDE_INT highest_order_object_bit_offset;
14504 HOST_WIDE_INT highest_order_field_bit_offset;
14505 HOST_WIDE_INT unsigned bit_offset;
14507 /* Must be a field and a bit field. */
14508 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
14510 /* We can't yet handle bit-fields whose offsets are variable, so if we
14511 encounter such things, just return without generating any attribute
14512 whatsoever. Likewise for variable or too large size. */
14513 if (! host_integerp (bit_position (decl), 0)
14514 || ! host_integerp (DECL_SIZE (decl), 1))
14517 bitpos_int = int_bit_position (decl);
14519 /* Note that the bit offset is always the distance (in bits) from the
14520 highest-order bit of the "containing object" to the highest-order bit of
14521 the bit-field itself. Since the "high-order end" of any object or field
14522 is different on big-endian and little-endian machines, the computation
14523 below must take account of these differences. */
14524 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
14525 highest_order_field_bit_offset = bitpos_int;
14527 if (! BYTES_BIG_ENDIAN)
14529 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
14530 highest_order_object_bit_offset += simple_type_size_in_bits (type);
14534 = (! BYTES_BIG_ENDIAN
14535 ? highest_order_object_bit_offset - highest_order_field_bit_offset
14536 : highest_order_field_bit_offset - highest_order_object_bit_offset);
14538 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
14541 /* For a FIELD_DECL node which represents a bit field, output an attribute
14542 which specifies the length in bits of the given field. */
14545 add_bit_size_attribute (dw_die_ref die, tree decl)
14547 /* Must be a field and a bit field. */
14548 gcc_assert (TREE_CODE (decl) == FIELD_DECL
14549 && DECL_BIT_FIELD_TYPE (decl));
14551 if (host_integerp (DECL_SIZE (decl), 1))
14552 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
14555 /* If the compiled language is ANSI C, then add a 'prototyped'
14556 attribute, if arg types are given for the parameters of a function. */
14559 add_prototyped_attribute (dw_die_ref die, tree func_type)
14561 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
14562 && TYPE_ARG_TYPES (func_type) != NULL)
14563 add_AT_flag (die, DW_AT_prototyped, 1);
14566 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
14567 by looking in either the type declaration or object declaration
14570 static inline dw_die_ref
14571 add_abstract_origin_attribute (dw_die_ref die, tree origin)
14573 dw_die_ref origin_die = NULL;
14575 if (TREE_CODE (origin) != FUNCTION_DECL)
14577 /* We may have gotten separated from the block for the inlined
14578 function, if we're in an exception handler or some such; make
14579 sure that the abstract function has been written out.
14581 Doing this for nested functions is wrong, however; functions are
14582 distinct units, and our context might not even be inline. */
14586 fn = TYPE_STUB_DECL (fn);
14588 fn = decl_function_context (fn);
14590 dwarf2out_abstract_function (fn);
14593 if (DECL_P (origin))
14594 origin_die = lookup_decl_die (origin);
14595 else if (TYPE_P (origin))
14596 origin_die = lookup_type_die (origin);
14598 /* XXX: Functions that are never lowered don't always have correct block
14599 trees (in the case of java, they simply have no block tree, in some other
14600 languages). For these functions, there is nothing we can really do to
14601 output correct debug info for inlined functions in all cases. Rather
14602 than die, we'll just produce deficient debug info now, in that we will
14603 have variables without a proper abstract origin. In the future, when all
14604 functions are lowered, we should re-add a gcc_assert (origin_die)
14608 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
14612 /* We do not currently support the pure_virtual attribute. */
14615 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
14617 if (DECL_VINDEX (func_decl))
14619 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
14621 if (host_integerp (DECL_VINDEX (func_decl), 0))
14622 add_AT_loc (die, DW_AT_vtable_elem_location,
14623 new_loc_descr (DW_OP_constu,
14624 tree_low_cst (DECL_VINDEX (func_decl), 0),
14627 /* GNU extension: Record what type this method came from originally. */
14628 if (debug_info_level > DINFO_LEVEL_TERSE)
14629 add_AT_die_ref (die, DW_AT_containing_type,
14630 lookup_type_die (DECL_CONTEXT (func_decl)));
14634 /* Add source coordinate attributes for the given decl. */
14637 add_src_coords_attributes (dw_die_ref die, tree decl)
14639 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
14641 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
14642 add_AT_unsigned (die, DW_AT_decl_line, s.line);
14645 /* Add a DW_AT_name attribute and source coordinate attribute for the
14646 given decl, but only if it actually has a name. */
14649 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
14653 decl_name = DECL_NAME (decl);
14654 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
14656 add_name_attribute (die, dwarf2_name (decl, 0));
14657 if (! DECL_ARTIFICIAL (decl))
14658 add_src_coords_attributes (die, decl);
14660 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
14661 && TREE_PUBLIC (decl)
14662 && !DECL_ABSTRACT (decl)
14663 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
14666 /* Defer until we have an assembler name set. */
14667 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
14669 limbo_die_node *asm_name;
14671 asm_name = GGC_CNEW (limbo_die_node);
14672 asm_name->die = die;
14673 asm_name->created_for = decl;
14674 asm_name->next = deferred_asm_name;
14675 deferred_asm_name = asm_name;
14677 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
14678 add_AT_string (die, DW_AT_MIPS_linkage_name,
14679 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
14683 #ifdef VMS_DEBUGGING_INFO
14684 /* Get the function's name, as described by its RTL. This may be different
14685 from the DECL_NAME name used in the source file. */
14686 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
14688 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
14689 XEXP (DECL_RTL (decl), 0));
14690 VEC_safe_push (rtx, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
14695 /* Push a new declaration scope. */
14698 push_decl_scope (tree scope)
14700 VEC_safe_push (tree, gc, decl_scope_table, scope);
14703 /* Pop a declaration scope. */
14706 pop_decl_scope (void)
14708 VEC_pop (tree, decl_scope_table);
14711 /* Return the DIE for the scope that immediately contains this type.
14712 Non-named types get global scope. Named types nested in other
14713 types get their containing scope if it's open, or global scope
14714 otherwise. All other types (i.e. function-local named types) get
14715 the current active scope. */
14718 scope_die_for (tree t, dw_die_ref context_die)
14720 dw_die_ref scope_die = NULL;
14721 tree containing_scope;
14724 /* Non-types always go in the current scope. */
14725 gcc_assert (TYPE_P (t));
14727 containing_scope = TYPE_CONTEXT (t);
14729 /* Use the containing namespace if it was passed in (for a declaration). */
14730 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
14732 if (context_die == lookup_decl_die (containing_scope))
14735 containing_scope = NULL_TREE;
14738 /* Ignore function type "scopes" from the C frontend. They mean that
14739 a tagged type is local to a parmlist of a function declarator, but
14740 that isn't useful to DWARF. */
14741 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
14742 containing_scope = NULL_TREE;
14744 if (containing_scope == NULL_TREE)
14745 scope_die = comp_unit_die;
14746 else if (TYPE_P (containing_scope))
14748 /* For types, we can just look up the appropriate DIE. But
14749 first we check to see if we're in the middle of emitting it
14750 so we know where the new DIE should go. */
14751 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
14752 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
14757 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
14758 || TREE_ASM_WRITTEN (containing_scope));
14760 /* If none of the current dies are suitable, we get file scope. */
14761 scope_die = comp_unit_die;
14764 scope_die = lookup_type_die (containing_scope);
14767 scope_die = context_die;
14772 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
14775 local_scope_p (dw_die_ref context_die)
14777 for (; context_die; context_die = context_die->die_parent)
14778 if (context_die->die_tag == DW_TAG_inlined_subroutine
14779 || context_die->die_tag == DW_TAG_subprogram)
14785 /* Returns nonzero if CONTEXT_DIE is a class. */
14788 class_scope_p (dw_die_ref context_die)
14790 return (context_die
14791 && (context_die->die_tag == DW_TAG_structure_type
14792 || context_die->die_tag == DW_TAG_class_type
14793 || context_die->die_tag == DW_TAG_interface_type
14794 || context_die->die_tag == DW_TAG_union_type));
14797 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
14798 whether or not to treat a DIE in this context as a declaration. */
14801 class_or_namespace_scope_p (dw_die_ref context_die)
14803 return (class_scope_p (context_die)
14804 || (context_die && context_die->die_tag == DW_TAG_namespace));
14807 /* Many forms of DIEs require a "type description" attribute. This
14808 routine locates the proper "type descriptor" die for the type given
14809 by 'type', and adds a DW_AT_type attribute below the given die. */
14812 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
14813 int decl_volatile, dw_die_ref context_die)
14815 enum tree_code code = TREE_CODE (type);
14816 dw_die_ref type_die = NULL;
14818 /* ??? If this type is an unnamed subrange type of an integral, floating-point
14819 or fixed-point type, use the inner type. This is because we have no
14820 support for unnamed types in base_type_die. This can happen if this is
14821 an Ada subrange type. Correct solution is emit a subrange type die. */
14822 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
14823 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
14824 type = TREE_TYPE (type), code = TREE_CODE (type);
14826 if (code == ERROR_MARK
14827 /* Handle a special case. For functions whose return type is void, we
14828 generate *no* type attribute. (Note that no object may have type
14829 `void', so this only applies to function return types). */
14830 || code == VOID_TYPE)
14833 type_die = modified_type_die (type,
14834 decl_const || TYPE_READONLY (type),
14835 decl_volatile || TYPE_VOLATILE (type),
14838 if (type_die != NULL)
14839 add_AT_die_ref (object_die, DW_AT_type, type_die);
14842 /* Given an object die, add the calling convention attribute for the
14843 function call type. */
14845 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
14847 enum dwarf_calling_convention value = DW_CC_normal;
14849 value = ((enum dwarf_calling_convention)
14850 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
14852 /* DWARF doesn't provide a way to identify a program's source-level
14853 entry point. DW_AT_calling_convention attributes are only meant
14854 to describe functions' calling conventions. However, lacking a
14855 better way to signal the Fortran main program, we use this for the
14856 time being, following existing custom. */
14858 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
14859 value = DW_CC_program;
14861 /* Only add the attribute if the backend requests it, and
14862 is not DW_CC_normal. */
14863 if (value && (value != DW_CC_normal))
14864 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
14867 /* Given a tree pointer to a struct, class, union, or enum type node, return
14868 a pointer to the (string) tag name for the given type, or zero if the type
14869 was declared without a tag. */
14871 static const char *
14872 type_tag (const_tree type)
14874 const char *name = 0;
14876 if (TYPE_NAME (type) != 0)
14880 /* Find the IDENTIFIER_NODE for the type name. */
14881 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
14882 t = TYPE_NAME (type);
14884 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
14885 a TYPE_DECL node, regardless of whether or not a `typedef' was
14887 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
14888 && ! DECL_IGNORED_P (TYPE_NAME (type)))
14890 /* We want to be extra verbose. Don't call dwarf_name if
14891 DECL_NAME isn't set. The default hook for decl_printable_name
14892 doesn't like that, and in this context it's correct to return
14893 0, instead of "<anonymous>" or the like. */
14894 if (DECL_NAME (TYPE_NAME (type)))
14895 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
14898 /* Now get the name as a string, or invent one. */
14899 if (!name && t != 0)
14900 name = IDENTIFIER_POINTER (t);
14903 return (name == 0 || *name == '\0') ? 0 : name;
14906 /* Return the type associated with a data member, make a special check
14907 for bit field types. */
14910 member_declared_type (const_tree member)
14912 return (DECL_BIT_FIELD_TYPE (member)
14913 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
14916 /* Get the decl's label, as described by its RTL. This may be different
14917 from the DECL_NAME name used in the source file. */
14920 static const char *
14921 decl_start_label (tree decl)
14924 const char *fnname;
14926 x = DECL_RTL (decl);
14927 gcc_assert (MEM_P (x));
14930 gcc_assert (GET_CODE (x) == SYMBOL_REF);
14932 fnname = XSTR (x, 0);
14937 /* These routines generate the internal representation of the DIE's for
14938 the compilation unit. Debugging information is collected by walking
14939 the declaration trees passed in from dwarf2out_decl(). */
14942 gen_array_type_die (tree type, dw_die_ref context_die)
14944 dw_die_ref scope_die = scope_die_for (type, context_die);
14945 dw_die_ref array_die;
14947 /* GNU compilers represent multidimensional array types as sequences of one
14948 dimensional array types whose element types are themselves array types.
14949 We sometimes squish that down to a single array_type DIE with multiple
14950 subscripts in the Dwarf debugging info. The draft Dwarf specification
14951 say that we are allowed to do this kind of compression in C, because
14952 there is no difference between an array of arrays and a multidimensional
14953 array. We don't do this for Ada to remain as close as possible to the
14954 actual representation, which is especially important against the language
14955 flexibilty wrt arrays of variable size. */
14957 bool collapse_nested_arrays = !is_ada ();
14960 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
14961 DW_TAG_string_type doesn't have DW_AT_type attribute). */
14962 if (TYPE_STRING_FLAG (type)
14963 && TREE_CODE (type) == ARRAY_TYPE
14965 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
14967 HOST_WIDE_INT size;
14969 array_die = new_die (DW_TAG_string_type, scope_die, type);
14970 add_name_attribute (array_die, type_tag (type));
14971 equate_type_number_to_die (type, array_die);
14972 size = int_size_in_bytes (type);
14974 add_AT_unsigned (array_die, DW_AT_byte_size, size);
14975 else if (TYPE_DOMAIN (type) != NULL_TREE
14976 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
14977 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
14979 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
14980 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2);
14982 size = int_size_in_bytes (TREE_TYPE (szdecl));
14983 if (loc && size > 0)
14985 add_AT_location_description (array_die, DW_AT_string_length, loc);
14986 if (size != DWARF2_ADDR_SIZE)
14987 add_AT_unsigned (array_die, DW_AT_byte_size, size);
14993 /* ??? The SGI dwarf reader fails for array of array of enum types
14994 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
14995 array type comes before the outer array type. We thus call gen_type_die
14996 before we new_die and must prevent nested array types collapsing for this
14999 #ifdef MIPS_DEBUGGING_INFO
15000 gen_type_die (TREE_TYPE (type), context_die);
15001 collapse_nested_arrays = false;
15004 array_die = new_die (DW_TAG_array_type, scope_die, type);
15005 add_name_attribute (array_die, type_tag (type));
15006 equate_type_number_to_die (type, array_die);
15008 if (TREE_CODE (type) == VECTOR_TYPE)
15010 /* The frontend feeds us a representation for the vector as a struct
15011 containing an array. Pull out the array type. */
15012 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
15013 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
15016 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
15018 && TREE_CODE (type) == ARRAY_TYPE
15019 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
15020 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
15021 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
15024 /* We default the array ordering. SDB will probably do
15025 the right things even if DW_AT_ordering is not present. It's not even
15026 an issue until we start to get into multidimensional arrays anyway. If
15027 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
15028 then we'll have to put the DW_AT_ordering attribute back in. (But if
15029 and when we find out that we need to put these in, we will only do so
15030 for multidimensional arrays. */
15031 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
15034 #ifdef MIPS_DEBUGGING_INFO
15035 /* The SGI compilers handle arrays of unknown bound by setting
15036 AT_declaration and not emitting any subrange DIEs. */
15037 if (! TYPE_DOMAIN (type))
15038 add_AT_flag (array_die, DW_AT_declaration, 1);
15041 add_subscript_info (array_die, type, collapse_nested_arrays);
15043 /* Add representation of the type of the elements of this array type and
15044 emit the corresponding DIE if we haven't done it already. */
15045 element_type = TREE_TYPE (type);
15046 if (collapse_nested_arrays)
15047 while (TREE_CODE (element_type) == ARRAY_TYPE)
15049 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
15051 element_type = TREE_TYPE (element_type);
15054 #ifndef MIPS_DEBUGGING_INFO
15055 gen_type_die (element_type, context_die);
15058 add_type_attribute (array_die, element_type, 0, 0, context_die);
15060 if (get_AT (array_die, DW_AT_name))
15061 add_pubtype (type, array_die);
15064 static dw_loc_descr_ref
15065 descr_info_loc (tree val, tree base_decl)
15067 HOST_WIDE_INT size;
15068 dw_loc_descr_ref loc, loc2;
15069 enum dwarf_location_atom op;
15071 if (val == base_decl)
15072 return new_loc_descr (DW_OP_push_object_address, 0, 0);
15074 switch (TREE_CODE (val))
15077 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
15079 return loc_descriptor_from_tree (val, 0);
15081 if (host_integerp (val, 0))
15082 return int_loc_descriptor (tree_low_cst (val, 0));
15085 size = int_size_in_bytes (TREE_TYPE (val));
15088 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
15091 if (size == DWARF2_ADDR_SIZE)
15092 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
15094 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
15096 case POINTER_PLUS_EXPR:
15098 if (host_integerp (TREE_OPERAND (val, 1), 1)
15099 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
15102 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
15105 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
15111 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
15114 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
15117 add_loc_descr (&loc, loc2);
15118 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
15140 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
15141 tree val, tree base_decl)
15143 dw_loc_descr_ref loc;
15145 if (host_integerp (val, 0))
15147 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
15151 loc = descr_info_loc (val, base_decl);
15155 add_AT_loc (die, attr, loc);
15158 /* This routine generates DIE for array with hidden descriptor, details
15159 are filled into *info by a langhook. */
15162 gen_descr_array_type_die (tree type, struct array_descr_info *info,
15163 dw_die_ref context_die)
15165 dw_die_ref scope_die = scope_die_for (type, context_die);
15166 dw_die_ref array_die;
15169 array_die = new_die (DW_TAG_array_type, scope_die, type);
15170 add_name_attribute (array_die, type_tag (type));
15171 equate_type_number_to_die (type, array_die);
15173 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
15175 && info->ndimensions >= 2)
15176 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
15178 if (info->data_location)
15179 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
15181 if (info->associated)
15182 add_descr_info_field (array_die, DW_AT_associated, info->associated,
15184 if (info->allocated)
15185 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
15188 for (dim = 0; dim < info->ndimensions; dim++)
15190 dw_die_ref subrange_die
15191 = new_die (DW_TAG_subrange_type, array_die, NULL);
15193 if (info->dimen[dim].lower_bound)
15195 /* If it is the default value, omit it. */
15196 if ((is_c_family () || is_java ())
15197 && integer_zerop (info->dimen[dim].lower_bound))
15199 else if (is_fortran ()
15200 && integer_onep (info->dimen[dim].lower_bound))
15203 add_descr_info_field (subrange_die, DW_AT_lower_bound,
15204 info->dimen[dim].lower_bound,
15207 if (info->dimen[dim].upper_bound)
15208 add_descr_info_field (subrange_die, DW_AT_upper_bound,
15209 info->dimen[dim].upper_bound,
15211 if (info->dimen[dim].stride)
15212 add_descr_info_field (subrange_die, DW_AT_byte_stride,
15213 info->dimen[dim].stride,
15217 gen_type_die (info->element_type, context_die);
15218 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
15220 if (get_AT (array_die, DW_AT_name))
15221 add_pubtype (type, array_die);
15226 gen_entry_point_die (tree decl, dw_die_ref context_die)
15228 tree origin = decl_ultimate_origin (decl);
15229 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
15231 if (origin != NULL)
15232 add_abstract_origin_attribute (decl_die, origin);
15235 add_name_and_src_coords_attributes (decl_die, decl);
15236 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
15237 0, 0, context_die);
15240 if (DECL_ABSTRACT (decl))
15241 equate_decl_number_to_die (decl, decl_die);
15243 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
15247 /* Walk through the list of incomplete types again, trying once more to
15248 emit full debugging info for them. */
15251 retry_incomplete_types (void)
15255 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
15256 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
15259 /* Determine what tag to use for a record type. */
15261 static enum dwarf_tag
15262 record_type_tag (tree type)
15264 if (! lang_hooks.types.classify_record)
15265 return DW_TAG_structure_type;
15267 switch (lang_hooks.types.classify_record (type))
15269 case RECORD_IS_STRUCT:
15270 return DW_TAG_structure_type;
15272 case RECORD_IS_CLASS:
15273 return DW_TAG_class_type;
15275 case RECORD_IS_INTERFACE:
15276 return DW_TAG_interface_type;
15279 gcc_unreachable ();
15283 /* Generate a DIE to represent an enumeration type. Note that these DIEs
15284 include all of the information about the enumeration values also. Each
15285 enumerated type name/value is listed as a child of the enumerated type
15289 gen_enumeration_type_die (tree type, dw_die_ref context_die)
15291 dw_die_ref type_die = lookup_type_die (type);
15293 if (type_die == NULL)
15295 type_die = new_die (DW_TAG_enumeration_type,
15296 scope_die_for (type, context_die), type);
15297 equate_type_number_to_die (type, type_die);
15298 add_name_attribute (type_die, type_tag (type));
15300 else if (! TYPE_SIZE (type))
15303 remove_AT (type_die, DW_AT_declaration);
15305 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
15306 given enum type is incomplete, do not generate the DW_AT_byte_size
15307 attribute or the DW_AT_element_list attribute. */
15308 if (TYPE_SIZE (type))
15312 TREE_ASM_WRITTEN (type) = 1;
15313 add_byte_size_attribute (type_die, type);
15314 if (TYPE_STUB_DECL (type) != NULL_TREE)
15315 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
15317 /* If the first reference to this type was as the return type of an
15318 inline function, then it may not have a parent. Fix this now. */
15319 if (type_die->die_parent == NULL)
15320 add_child_die (scope_die_for (type, context_die), type_die);
15322 for (link = TYPE_VALUES (type);
15323 link != NULL; link = TREE_CHAIN (link))
15325 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
15326 tree value = TREE_VALUE (link);
15328 add_name_attribute (enum_die,
15329 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
15331 if (TREE_CODE (value) == CONST_DECL)
15332 value = DECL_INITIAL (value);
15334 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
15335 /* DWARF2 does not provide a way of indicating whether or
15336 not enumeration constants are signed or unsigned. GDB
15337 always assumes the values are signed, so we output all
15338 values as if they were signed. That means that
15339 enumeration constants with very large unsigned values
15340 will appear to have negative values in the debugger. */
15341 add_AT_int (enum_die, DW_AT_const_value,
15342 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
15346 add_AT_flag (type_die, DW_AT_declaration, 1);
15348 if (get_AT (type_die, DW_AT_name))
15349 add_pubtype (type, type_die);
15354 /* Generate a DIE to represent either a real live formal parameter decl or to
15355 represent just the type of some formal parameter position in some function
15358 Note that this routine is a bit unusual because its argument may be a
15359 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
15360 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
15361 node. If it's the former then this function is being called to output a
15362 DIE to represent a formal parameter object (or some inlining thereof). If
15363 it's the latter, then this function is only being called to output a
15364 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
15365 argument type of some subprogram type. */
15368 gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
15370 tree node_or_origin = node ? node : origin;
15371 dw_die_ref parm_die
15372 = new_die (DW_TAG_formal_parameter, context_die, node);
15374 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
15376 case tcc_declaration:
15378 origin = decl_ultimate_origin (node);
15379 if (origin != NULL)
15380 add_abstract_origin_attribute (parm_die, origin);
15383 tree type = TREE_TYPE (node);
15384 add_name_and_src_coords_attributes (parm_die, node);
15385 if (decl_by_reference_p (node))
15386 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
15389 add_type_attribute (parm_die, type,
15390 TREE_READONLY (node),
15391 TREE_THIS_VOLATILE (node),
15393 if (DECL_ARTIFICIAL (node))
15394 add_AT_flag (parm_die, DW_AT_artificial, 1);
15397 if (node && node != origin)
15398 equate_decl_number_to_die (node, parm_die);
15399 if (! DECL_ABSTRACT (node_or_origin))
15400 add_location_or_const_value_attribute (parm_die, node_or_origin,
15406 /* We were called with some kind of a ..._TYPE node. */
15407 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
15411 gcc_unreachable ();
15417 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
15418 at the end of an (ANSI prototyped) formal parameters list. */
15421 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
15423 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
15426 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
15427 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
15428 parameters as specified in some function type specification (except for
15429 those which appear as part of a function *definition*). */
15432 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
15435 tree formal_type = NULL;
15436 tree first_parm_type;
15439 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
15441 arg = DECL_ARGUMENTS (function_or_method_type);
15442 function_or_method_type = TREE_TYPE (function_or_method_type);
15447 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
15449 /* Make our first pass over the list of formal parameter types and output a
15450 DW_TAG_formal_parameter DIE for each one. */
15451 for (link = first_parm_type; link; )
15453 dw_die_ref parm_die;
15455 formal_type = TREE_VALUE (link);
15456 if (formal_type == void_type_node)
15459 /* Output a (nameless) DIE to represent the formal parameter itself. */
15460 parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
15461 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
15462 && link == first_parm_type)
15463 || (arg && DECL_ARTIFICIAL (arg)))
15464 add_AT_flag (parm_die, DW_AT_artificial, 1);
15466 link = TREE_CHAIN (link);
15468 arg = TREE_CHAIN (arg);
15471 /* If this function type has an ellipsis, add a
15472 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
15473 if (formal_type != void_type_node)
15474 gen_unspecified_parameters_die (function_or_method_type, context_die);
15476 /* Make our second (and final) pass over the list of formal parameter types
15477 and output DIEs to represent those types (as necessary). */
15478 for (link = TYPE_ARG_TYPES (function_or_method_type);
15479 link && TREE_VALUE (link);
15480 link = TREE_CHAIN (link))
15481 gen_type_die (TREE_VALUE (link), context_die);
15484 /* We want to generate the DIE for TYPE so that we can generate the
15485 die for MEMBER, which has been defined; we will need to refer back
15486 to the member declaration nested within TYPE. If we're trying to
15487 generate minimal debug info for TYPE, processing TYPE won't do the
15488 trick; we need to attach the member declaration by hand. */
15491 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
15493 gen_type_die (type, context_die);
15495 /* If we're trying to avoid duplicate debug info, we may not have
15496 emitted the member decl for this function. Emit it now. */
15497 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
15498 && ! lookup_decl_die (member))
15500 dw_die_ref type_die;
15501 gcc_assert (!decl_ultimate_origin (member));
15503 push_decl_scope (type);
15504 type_die = lookup_type_die (type);
15505 if (TREE_CODE (member) == FUNCTION_DECL)
15506 gen_subprogram_die (member, type_die);
15507 else if (TREE_CODE (member) == FIELD_DECL)
15509 /* Ignore the nameless fields that are used to skip bits but handle
15510 C++ anonymous unions and structs. */
15511 if (DECL_NAME (member) != NULL_TREE
15512 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
15513 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
15515 gen_type_die (member_declared_type (member), type_die);
15516 gen_field_die (member, type_die);
15520 gen_variable_die (member, NULL_TREE, type_die);
15526 /* Generate the DWARF2 info for the "abstract" instance of a function which we
15527 may later generate inlined and/or out-of-line instances of. */
15530 dwarf2out_abstract_function (tree decl)
15532 dw_die_ref old_die;
15535 int was_abstract = DECL_ABSTRACT (decl);
15537 /* Make sure we have the actual abstract inline, not a clone. */
15538 decl = DECL_ORIGIN (decl);
15539 htab_empty (decl_loc_table);
15541 old_die = lookup_decl_die (decl);
15542 if (old_die && get_AT (old_die, DW_AT_inline))
15543 /* We've already generated the abstract instance. */
15546 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
15547 we don't get confused by DECL_ABSTRACT. */
15548 if (debug_info_level > DINFO_LEVEL_TERSE)
15550 context = decl_class_context (decl);
15552 gen_type_die_for_member
15553 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
15556 /* Pretend we've just finished compiling this function. */
15557 save_fn = current_function_decl;
15558 current_function_decl = decl;
15559 push_cfun (DECL_STRUCT_FUNCTION (decl));
15561 set_decl_abstract_flags (decl, 1);
15562 dwarf2out_decl (decl);
15563 if (! was_abstract)
15564 set_decl_abstract_flags (decl, 0);
15566 current_function_decl = save_fn;
15570 /* Helper function of premark_used_types() which gets called through
15571 htab_traverse_resize().
15573 Marks the DIE of a given type in *SLOT as perennial, so it never gets
15574 marked as unused by prune_unused_types. */
15576 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
15581 type = (tree) *slot;
15582 die = lookup_type_die (type);
15584 die->die_perennial_p = 1;
15588 /* Mark all members of used_types_hash as perennial. */
15590 premark_used_types (void)
15592 if (cfun && cfun->used_types_hash)
15593 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
15596 /* Generate a DIE to represent a declared function (either file-scope or
15600 gen_subprogram_die (tree decl, dw_die_ref context_die)
15602 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
15603 tree origin = decl_ultimate_origin (decl);
15604 dw_die_ref subr_die;
15607 dw_die_ref old_die = lookup_decl_die (decl);
15608 int declaration = (current_function_decl != decl
15609 || class_or_namespace_scope_p (context_die));
15611 premark_used_types ();
15613 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
15614 started to generate the abstract instance of an inline, decided to output
15615 its containing class, and proceeded to emit the declaration of the inline
15616 from the member list for the class. If so, DECLARATION takes priority;
15617 we'll get back to the abstract instance when done with the class. */
15619 /* The class-scope declaration DIE must be the primary DIE. */
15620 if (origin && declaration && class_or_namespace_scope_p (context_die))
15623 gcc_assert (!old_die);
15626 /* Now that the C++ front end lazily declares artificial member fns, we
15627 might need to retrofit the declaration into its class. */
15628 if (!declaration && !origin && !old_die
15629 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
15630 && !class_or_namespace_scope_p (context_die)
15631 && debug_info_level > DINFO_LEVEL_TERSE)
15632 old_die = force_decl_die (decl);
15634 if (origin != NULL)
15636 gcc_assert (!declaration || local_scope_p (context_die));
15638 /* Fixup die_parent for the abstract instance of a nested
15639 inline function. */
15640 if (old_die && old_die->die_parent == NULL)
15641 add_child_die (context_die, old_die);
15643 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
15644 add_abstract_origin_attribute (subr_die, origin);
15648 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
15649 struct dwarf_file_data * file_index = lookup_filename (s.file);
15651 if (!get_AT_flag (old_die, DW_AT_declaration)
15652 /* We can have a normal definition following an inline one in the
15653 case of redefinition of GNU C extern inlines.
15654 It seems reasonable to use AT_specification in this case. */
15655 && !get_AT (old_die, DW_AT_inline))
15657 /* Detect and ignore this case, where we are trying to output
15658 something we have already output. */
15662 /* If the definition comes from the same place as the declaration,
15663 maybe use the old DIE. We always want the DIE for this function
15664 that has the *_pc attributes to be under comp_unit_die so the
15665 debugger can find it. We also need to do this for abstract
15666 instances of inlines, since the spec requires the out-of-line copy
15667 to have the same parent. For local class methods, this doesn't
15668 apply; we just use the old DIE. */
15669 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
15670 && (DECL_ARTIFICIAL (decl)
15671 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
15672 && (get_AT_unsigned (old_die, DW_AT_decl_line)
15673 == (unsigned) s.line))))
15675 subr_die = old_die;
15677 /* Clear out the declaration attribute and the formal parameters.
15678 Do not remove all children, because it is possible that this
15679 declaration die was forced using force_decl_die(). In such
15680 cases die that forced declaration die (e.g. TAG_imported_module)
15681 is one of the children that we do not want to remove. */
15682 remove_AT (subr_die, DW_AT_declaration);
15683 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
15687 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
15688 add_AT_specification (subr_die, old_die);
15689 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
15690 add_AT_file (subr_die, DW_AT_decl_file, file_index);
15691 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
15692 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
15697 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
15699 if (TREE_PUBLIC (decl))
15700 add_AT_flag (subr_die, DW_AT_external, 1);
15702 add_name_and_src_coords_attributes (subr_die, decl);
15703 if (debug_info_level > DINFO_LEVEL_TERSE)
15705 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
15706 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
15707 0, 0, context_die);
15710 add_pure_or_virtual_attribute (subr_die, decl);
15711 if (DECL_ARTIFICIAL (decl))
15712 add_AT_flag (subr_die, DW_AT_artificial, 1);
15714 if (TREE_PROTECTED (decl))
15715 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
15716 else if (TREE_PRIVATE (decl))
15717 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
15722 if (!old_die || !get_AT (old_die, DW_AT_inline))
15724 add_AT_flag (subr_die, DW_AT_declaration, 1);
15726 /* If this is an explicit function declaration then generate
15727 a DW_AT_explicit attribute. */
15728 if (lang_hooks.decls.function_decl_explicit_p (decl))
15729 add_AT_flag (subr_die, DW_AT_explicit, 1);
15731 /* The first time we see a member function, it is in the context of
15732 the class to which it belongs. We make sure of this by emitting
15733 the class first. The next time is the definition, which is
15734 handled above. The two may come from the same source text.
15736 Note that force_decl_die() forces function declaration die. It is
15737 later reused to represent definition. */
15738 equate_decl_number_to_die (decl, subr_die);
15741 else if (DECL_ABSTRACT (decl))
15743 if (DECL_DECLARED_INLINE_P (decl))
15745 if (cgraph_function_possibly_inlined_p (decl))
15746 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
15748 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
15752 if (cgraph_function_possibly_inlined_p (decl))
15753 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
15755 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
15758 if (DECL_DECLARED_INLINE_P (decl)
15759 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
15760 add_AT_flag (subr_die, DW_AT_artificial, 1);
15762 equate_decl_number_to_die (decl, subr_die);
15764 else if (!DECL_EXTERNAL (decl))
15766 HOST_WIDE_INT cfa_fb_offset;
15768 if (!old_die || !get_AT (old_die, DW_AT_inline))
15769 equate_decl_number_to_die (decl, subr_die);
15771 if (!flag_reorder_blocks_and_partition)
15773 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
15774 current_function_funcdef_no);
15775 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
15776 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
15777 current_function_funcdef_no);
15778 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
15780 add_pubname (decl, subr_die);
15781 add_arange (decl, subr_die);
15784 { /* Do nothing for now; maybe need to duplicate die, one for
15785 hot section and one for cold section, then use the hot/cold
15786 section begin/end labels to generate the aranges... */
15788 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
15789 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
15790 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
15791 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
15793 add_pubname (decl, subr_die);
15794 add_arange (decl, subr_die);
15795 add_arange (decl, subr_die);
15799 #ifdef MIPS_DEBUGGING_INFO
15800 /* Add a reference to the FDE for this routine. */
15801 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
15804 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
15806 /* We define the "frame base" as the function's CFA. This is more
15807 convenient for several reasons: (1) It's stable across the prologue
15808 and epilogue, which makes it better than just a frame pointer,
15809 (2) With dwarf3, there exists a one-byte encoding that allows us
15810 to reference the .debug_frame data by proxy, but failing that,
15811 (3) We can at least reuse the code inspection and interpretation
15812 code that determines the CFA position at various points in the
15814 if (dwarf_version >= 3)
15816 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
15817 add_AT_loc (subr_die, DW_AT_frame_base, op);
15821 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
15822 if (list->dw_loc_next)
15823 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
15825 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
15828 /* Compute a displacement from the "steady-state frame pointer" to
15829 the CFA. The former is what all stack slots and argument slots
15830 will reference in the rtl; the later is what we've told the
15831 debugger about. We'll need to adjust all frame_base references
15832 by this displacement. */
15833 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
15835 if (cfun->static_chain_decl)
15836 add_AT_location_description (subr_die, DW_AT_static_link,
15837 loc_list_from_tree (cfun->static_chain_decl, 2));
15840 /* Generate child dies for template paramaters. */
15841 if (debug_info_level > DINFO_LEVEL_TERSE)
15842 gen_generic_params_dies (decl);
15844 /* Now output descriptions of the arguments for this function. This gets
15845 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
15846 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
15847 `...' at the end of the formal parameter list. In order to find out if
15848 there was a trailing ellipsis or not, we must instead look at the type
15849 associated with the FUNCTION_DECL. This will be a node of type
15850 FUNCTION_TYPE. If the chain of type nodes hanging off of this
15851 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
15852 an ellipsis at the end. */
15854 /* In the case where we are describing a mere function declaration, all we
15855 need to do here (and all we *can* do here) is to describe the *types* of
15856 its formal parameters. */
15857 if (debug_info_level <= DINFO_LEVEL_TERSE)
15859 else if (declaration)
15860 gen_formal_types_die (decl, subr_die);
15863 /* Generate DIEs to represent all known formal parameters. */
15864 tree arg_decls = DECL_ARGUMENTS (decl);
15867 /* When generating DIEs, generate the unspecified_parameters DIE
15868 instead if we come across the arg "__builtin_va_alist" */
15869 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
15870 if (TREE_CODE (parm) == PARM_DECL)
15872 if (DECL_NAME (parm)
15873 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
15874 "__builtin_va_alist"))
15875 gen_unspecified_parameters_die (parm, subr_die);
15877 gen_decl_die (parm, NULL, subr_die);
15880 /* Decide whether we need an unspecified_parameters DIE at the end.
15881 There are 2 more cases to do this for: 1) the ansi ... declaration -
15882 this is detectable when the end of the arg list is not a
15883 void_type_node 2) an unprototyped function declaration (not a
15884 definition). This just means that we have no info about the
15885 parameters at all. */
15886 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
15887 if (fn_arg_types != NULL)
15889 /* This is the prototyped case, check for.... */
15890 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
15891 gen_unspecified_parameters_die (decl, subr_die);
15893 else if (DECL_INITIAL (decl) == NULL_TREE)
15894 gen_unspecified_parameters_die (decl, subr_die);
15897 /* Output Dwarf info for all of the stuff within the body of the function
15898 (if it has one - it may be just a declaration). */
15899 outer_scope = DECL_INITIAL (decl);
15901 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
15902 a function. This BLOCK actually represents the outermost binding contour
15903 for the function, i.e. the contour in which the function's formal
15904 parameters and labels get declared. Curiously, it appears that the front
15905 end doesn't actually put the PARM_DECL nodes for the current function onto
15906 the BLOCK_VARS list for this outer scope, but are strung off of the
15907 DECL_ARGUMENTS list for the function instead.
15909 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
15910 the LABEL_DECL nodes for the function however, and we output DWARF info
15911 for those in decls_for_scope. Just within the `outer_scope' there will be
15912 a BLOCK node representing the function's outermost pair of curly braces,
15913 and any blocks used for the base and member initializers of a C++
15914 constructor function. */
15915 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
15917 /* Emit a DW_TAG_variable DIE for a named return value. */
15918 if (DECL_NAME (DECL_RESULT (decl)))
15919 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
15921 current_function_has_inlines = 0;
15922 decls_for_scope (outer_scope, subr_die, 0);
15924 #if 0 && defined (MIPS_DEBUGGING_INFO)
15925 if (current_function_has_inlines)
15927 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
15928 if (! comp_unit_has_inlines)
15930 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
15931 comp_unit_has_inlines = 1;
15936 /* Add the calling convention attribute if requested. */
15937 add_calling_convention_attribute (subr_die, decl);
15941 /* Returns a hash value for X (which really is a die_struct). */
15944 common_block_die_table_hash (const void *x)
15946 const_dw_die_ref d = (const_dw_die_ref) x;
15947 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
15950 /* Return nonzero if decl_id and die_parent of die_struct X is the same
15951 as decl_id and die_parent of die_struct Y. */
15954 common_block_die_table_eq (const void *x, const void *y)
15956 const_dw_die_ref d = (const_dw_die_ref) x;
15957 const_dw_die_ref e = (const_dw_die_ref) y;
15958 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
15961 /* Generate a DIE to represent a declared data object.
15962 Either DECL or ORIGIN must be non-null. */
15965 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
15969 tree decl_or_origin = decl ? decl : origin;
15970 dw_die_ref var_die;
15971 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
15972 dw_die_ref origin_die;
15973 int declaration = (DECL_EXTERNAL (decl_or_origin)
15974 /* If DECL is COMDAT and has not actually been
15975 emitted, we cannot take its address; there
15976 might end up being no definition anywhere in
15977 the program. For example, consider the C++
15981 struct S { static const int i = 7; };
15986 int f() { return S<int>::i; }
15988 Here, S<int>::i is not DECL_EXTERNAL, but no
15989 definition is required, so the compiler will
15990 not emit a definition. */
15991 || (TREE_CODE (decl_or_origin) == VAR_DECL
15992 && DECL_COMDAT (decl_or_origin)
15993 && !TREE_ASM_WRITTEN (decl_or_origin))
15994 || class_or_namespace_scope_p (context_die));
15997 origin = decl_ultimate_origin (decl);
15999 com_decl = fortran_common (decl_or_origin, &off);
16001 /* Symbol in common gets emitted as a child of the common block, in the form
16002 of a data member. */
16006 dw_die_ref com_die;
16007 dw_loc_list_ref loc;
16008 die_node com_die_arg;
16010 var_die = lookup_decl_die (decl_or_origin);
16013 if (get_AT (var_die, DW_AT_location) == NULL)
16015 loc = loc_list_from_tree (com_decl, off ? 1 : 2);
16020 /* Optimize the common case. */
16021 if (single_element_loc_list_p (loc)
16022 && loc->expr->dw_loc_opc == DW_OP_addr
16023 && loc->expr->dw_loc_next == NULL
16024 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
16026 loc->expr->dw_loc_oprnd1.v.val_addr
16027 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
16029 loc_list_plus_const (loc, off);
16031 add_AT_location_description (var_die, DW_AT_location, loc);
16032 remove_AT (var_die, DW_AT_declaration);
16038 if (common_block_die_table == NULL)
16039 common_block_die_table
16040 = htab_create_ggc (10, common_block_die_table_hash,
16041 common_block_die_table_eq, NULL);
16043 field = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
16044 com_die_arg.decl_id = DECL_UID (com_decl);
16045 com_die_arg.die_parent = context_die;
16046 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
16047 loc = loc_list_from_tree (com_decl, 2);
16048 if (com_die == NULL)
16051 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
16054 com_die = new_die (DW_TAG_common_block, context_die, decl);
16055 add_name_and_src_coords_attributes (com_die, com_decl);
16058 add_AT_location_description (com_die, DW_AT_location, loc);
16059 /* Avoid sharing the same loc descriptor between
16060 DW_TAG_common_block and DW_TAG_variable. */
16061 loc = loc_list_from_tree (com_decl, 2);
16063 else if (DECL_EXTERNAL (decl))
16064 add_AT_flag (com_die, DW_AT_declaration, 1);
16065 add_pubname_string (cnam, com_die); /* ??? needed? */
16066 com_die->decl_id = DECL_UID (com_decl);
16067 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
16068 *slot = (void *) com_die;
16070 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
16072 add_AT_location_description (com_die, DW_AT_location, loc);
16073 loc = loc_list_from_tree (com_decl, 2);
16074 remove_AT (com_die, DW_AT_declaration);
16076 var_die = new_die (DW_TAG_variable, com_die, decl);
16077 add_name_and_src_coords_attributes (var_die, decl);
16078 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
16079 TREE_THIS_VOLATILE (decl), context_die);
16080 add_AT_flag (var_die, DW_AT_external, 1);
16085 /* Optimize the common case. */
16086 if (single_element_loc_list_p (loc)
16087 && loc->expr->dw_loc_opc == DW_OP_addr
16088 && loc->expr->dw_loc_next == NULL
16089 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
16090 loc->expr->dw_loc_oprnd1.v.val_addr
16091 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
16093 loc_list_plus_const (loc, off);
16095 add_AT_location_description (var_die, DW_AT_location, loc);
16097 else if (DECL_EXTERNAL (decl))
16098 add_AT_flag (var_die, DW_AT_declaration, 1);
16099 equate_decl_number_to_die (decl, var_die);
16103 /* If the compiler emitted a definition for the DECL declaration
16104 and if we already emitted a DIE for it, don't emit a second
16105 DIE for it again. */
16108 && old_die->die_parent == context_die)
16111 /* For static data members, the declaration in the class is supposed
16112 to have DW_TAG_member tag; the specification should still be
16113 DW_TAG_variable referencing the DW_TAG_member DIE. */
16114 if (declaration && class_scope_p (context_die))
16115 var_die = new_die (DW_TAG_member, context_die, decl);
16117 var_die = new_die (DW_TAG_variable, context_die, decl);
16120 if (origin != NULL)
16121 origin_die = add_abstract_origin_attribute (var_die, origin);
16123 /* Loop unrolling can create multiple blocks that refer to the same
16124 static variable, so we must test for the DW_AT_declaration flag.
16126 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
16127 copy decls and set the DECL_ABSTRACT flag on them instead of
16130 ??? Duplicated blocks have been rewritten to use .debug_ranges.
16132 ??? The declare_in_namespace support causes us to get two DIEs for one
16133 variable, both of which are declarations. We want to avoid considering
16134 one to be a specification, so we must test that this DIE is not a
16136 else if (old_die && TREE_STATIC (decl) && ! declaration
16137 && get_AT_flag (old_die, DW_AT_declaration) == 1)
16139 /* This is a definition of a C++ class level static. */
16140 add_AT_specification (var_die, old_die);
16141 if (DECL_NAME (decl))
16143 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
16144 struct dwarf_file_data * file_index = lookup_filename (s.file);
16146 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
16147 add_AT_file (var_die, DW_AT_decl_file, file_index);
16149 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
16150 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
16155 tree type = TREE_TYPE (decl);
16157 add_name_and_src_coords_attributes (var_die, decl);
16158 if (decl_by_reference_p (decl))
16159 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
16161 add_type_attribute (var_die, type, TREE_READONLY (decl),
16162 TREE_THIS_VOLATILE (decl), context_die);
16164 if (TREE_PUBLIC (decl))
16165 add_AT_flag (var_die, DW_AT_external, 1);
16167 if (DECL_ARTIFICIAL (decl))
16168 add_AT_flag (var_die, DW_AT_artificial, 1);
16170 if (TREE_PROTECTED (decl))
16171 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
16172 else if (TREE_PRIVATE (decl))
16173 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
16177 add_AT_flag (var_die, DW_AT_declaration, 1);
16179 if (decl && (DECL_ABSTRACT (decl) || declaration))
16180 equate_decl_number_to_die (decl, var_die);
16183 && (! DECL_ABSTRACT (decl_or_origin)
16184 /* Local static vars are shared between all clones/inlines,
16185 so emit DW_AT_location on the abstract DIE if DECL_RTL is
16187 || (TREE_CODE (decl_or_origin) == VAR_DECL
16188 && TREE_STATIC (decl_or_origin)
16189 && DECL_RTL_SET_P (decl_or_origin)))
16190 /* When abstract origin already has DW_AT_location attribute, no need
16191 to add it again. */
16192 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
16194 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
16195 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
16196 defer_location (decl_or_origin, var_die);
16198 add_location_or_const_value_attribute (var_die,
16201 add_pubname (decl_or_origin, var_die);
16204 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
16207 /* Generate a DIE to represent a named constant. */
16210 gen_const_die (tree decl, dw_die_ref context_die)
16212 dw_die_ref const_die;
16213 tree type = TREE_TYPE (decl);
16215 const_die = new_die (DW_TAG_constant, context_die, decl);
16216 add_name_and_src_coords_attributes (const_die, decl);
16217 add_type_attribute (const_die, type, 1, 0, context_die);
16218 if (TREE_PUBLIC (decl))
16219 add_AT_flag (const_die, DW_AT_external, 1);
16220 if (DECL_ARTIFICIAL (decl))
16221 add_AT_flag (const_die, DW_AT_artificial, 1);
16222 tree_add_const_value_attribute_for_decl (const_die, decl);
16225 /* Generate a DIE to represent a label identifier. */
16228 gen_label_die (tree decl, dw_die_ref context_die)
16230 tree origin = decl_ultimate_origin (decl);
16231 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
16233 char label[MAX_ARTIFICIAL_LABEL_BYTES];
16235 if (origin != NULL)
16236 add_abstract_origin_attribute (lbl_die, origin);
16238 add_name_and_src_coords_attributes (lbl_die, decl);
16240 if (DECL_ABSTRACT (decl))
16241 equate_decl_number_to_die (decl, lbl_die);
16244 insn = DECL_RTL_IF_SET (decl);
16246 /* Deleted labels are programmer specified labels which have been
16247 eliminated because of various optimizations. We still emit them
16248 here so that it is possible to put breakpoints on them. */
16252 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
16254 /* When optimization is enabled (via -O) some parts of the compiler
16255 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
16256 represent source-level labels which were explicitly declared by
16257 the user. This really shouldn't be happening though, so catch
16258 it if it ever does happen. */
16259 gcc_assert (!INSN_DELETED_P (insn));
16261 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
16262 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
16267 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
16268 attributes to the DIE for a block STMT, to describe where the inlined
16269 function was called from. This is similar to add_src_coords_attributes. */
16272 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
16274 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
16276 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
16277 add_AT_unsigned (die, DW_AT_call_line, s.line);
16281 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
16282 Add low_pc and high_pc attributes to the DIE for a block STMT. */
16285 add_high_low_attributes (tree stmt, dw_die_ref die)
16287 char label[MAX_ARTIFICIAL_LABEL_BYTES];
16289 if (BLOCK_FRAGMENT_CHAIN (stmt))
16293 if (inlined_function_outer_scope_p (stmt))
16295 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
16296 BLOCK_NUMBER (stmt));
16297 add_AT_lbl_id (die, DW_AT_entry_pc, label);
16300 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
16302 chain = BLOCK_FRAGMENT_CHAIN (stmt);
16305 add_ranges (chain);
16306 chain = BLOCK_FRAGMENT_CHAIN (chain);
16313 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
16314 BLOCK_NUMBER (stmt));
16315 add_AT_lbl_id (die, DW_AT_low_pc, label);
16316 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
16317 BLOCK_NUMBER (stmt));
16318 add_AT_lbl_id (die, DW_AT_high_pc, label);
16322 /* Generate a DIE for a lexical block. */
16325 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
16327 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
16329 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
16330 add_high_low_attributes (stmt, stmt_die);
16332 decls_for_scope (stmt, stmt_die, depth);
16335 /* Generate a DIE for an inlined subprogram. */
16338 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
16342 /* The instance of function that is effectively being inlined shall not
16344 gcc_assert (! BLOCK_ABSTRACT (stmt));
16346 decl = block_ultimate_origin (stmt);
16348 /* Emit info for the abstract instance first, if we haven't yet. We
16349 must emit this even if the block is abstract, otherwise when we
16350 emit the block below (or elsewhere), we may end up trying to emit
16351 a die whose origin die hasn't been emitted, and crashing. */
16352 dwarf2out_abstract_function (decl);
16354 if (! BLOCK_ABSTRACT (stmt))
16356 dw_die_ref subr_die
16357 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
16359 add_abstract_origin_attribute (subr_die, decl);
16360 if (TREE_ASM_WRITTEN (stmt))
16361 add_high_low_attributes (stmt, subr_die);
16362 add_call_src_coords_attributes (stmt, subr_die);
16364 decls_for_scope (stmt, subr_die, depth);
16365 current_function_has_inlines = 1;
16369 /* Generate a DIE for a field in a record, or structure. */
16372 gen_field_die (tree decl, dw_die_ref context_die)
16374 dw_die_ref decl_die;
16376 if (TREE_TYPE (decl) == error_mark_node)
16379 decl_die = new_die (DW_TAG_member, context_die, decl);
16380 add_name_and_src_coords_attributes (decl_die, decl);
16381 add_type_attribute (decl_die, member_declared_type (decl),
16382 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
16385 if (DECL_BIT_FIELD_TYPE (decl))
16387 add_byte_size_attribute (decl_die, decl);
16388 add_bit_size_attribute (decl_die, decl);
16389 add_bit_offset_attribute (decl_die, decl);
16392 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
16393 add_data_member_location_attribute (decl_die, decl);
16395 if (DECL_ARTIFICIAL (decl))
16396 add_AT_flag (decl_die, DW_AT_artificial, 1);
16398 if (TREE_PROTECTED (decl))
16399 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
16400 else if (TREE_PRIVATE (decl))
16401 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
16403 /* Equate decl number to die, so that we can look up this decl later on. */
16404 equate_decl_number_to_die (decl, decl_die);
16408 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
16409 Use modified_type_die instead.
16410 We keep this code here just in case these types of DIEs may be needed to
16411 represent certain things in other languages (e.g. Pascal) someday. */
16414 gen_pointer_type_die (tree type, dw_die_ref context_die)
16417 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
16419 equate_type_number_to_die (type, ptr_die);
16420 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
16421 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
16424 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
16425 Use modified_type_die instead.
16426 We keep this code here just in case these types of DIEs may be needed to
16427 represent certain things in other languages (e.g. Pascal) someday. */
16430 gen_reference_type_die (tree type, dw_die_ref context_die)
16433 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
16435 equate_type_number_to_die (type, ref_die);
16436 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
16437 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
16441 /* Generate a DIE for a pointer to a member type. */
16444 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
16447 = new_die (DW_TAG_ptr_to_member_type,
16448 scope_die_for (type, context_die), type);
16450 equate_type_number_to_die (type, ptr_die);
16451 add_AT_die_ref (ptr_die, DW_AT_containing_type,
16452 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
16453 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
16456 /* Generate the DIE for the compilation unit. */
16459 gen_compile_unit_die (const char *filename)
16462 char producer[250];
16463 const char *language_string = lang_hooks.name;
16466 die = new_die (DW_TAG_compile_unit, NULL, NULL);
16470 add_name_attribute (die, filename);
16471 /* Don't add cwd for <built-in>. */
16472 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
16473 add_comp_dir_attribute (die);
16476 sprintf (producer, "%s %s", language_string, version_string);
16478 #ifdef MIPS_DEBUGGING_INFO
16479 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
16480 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
16481 not appear in the producer string, the debugger reaches the conclusion
16482 that the object file is stripped and has no debugging information.
16483 To get the MIPS/SGI debugger to believe that there is debugging
16484 information in the object file, we add a -g to the producer string. */
16485 if (debug_info_level > DINFO_LEVEL_TERSE)
16486 strcat (producer, " -g");
16489 add_AT_string (die, DW_AT_producer, producer);
16491 if (strcmp (language_string, "GNU C++") == 0)
16492 language = DW_LANG_C_plus_plus;
16493 else if (strcmp (language_string, "GNU Ada") == 0)
16494 language = DW_LANG_Ada95;
16495 else if (strcmp (language_string, "GNU F77") == 0)
16496 language = DW_LANG_Fortran77;
16497 else if (strcmp (language_string, "GNU Fortran") == 0)
16498 language = DW_LANG_Fortran95;
16499 else if (strcmp (language_string, "GNU Pascal") == 0)
16500 language = DW_LANG_Pascal83;
16501 else if (strcmp (language_string, "GNU Java") == 0)
16502 language = DW_LANG_Java;
16503 else if (strcmp (language_string, "GNU Objective-C") == 0)
16504 language = DW_LANG_ObjC;
16505 else if (strcmp (language_string, "GNU Objective-C++") == 0)
16506 language = DW_LANG_ObjC_plus_plus;
16508 language = DW_LANG_C89;
16510 add_AT_unsigned (die, DW_AT_language, language);
16514 /* Generate the DIE for a base class. */
16517 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
16519 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
16521 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
16522 add_data_member_location_attribute (die, binfo);
16524 if (BINFO_VIRTUAL_P (binfo))
16525 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
16527 if (access == access_public_node)
16528 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
16529 else if (access == access_protected_node)
16530 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
16533 /* Generate a DIE for a class member. */
16536 gen_member_die (tree type, dw_die_ref context_die)
16539 tree binfo = TYPE_BINFO (type);
16542 /* If this is not an incomplete type, output descriptions of each of its
16543 members. Note that as we output the DIEs necessary to represent the
16544 members of this record or union type, we will also be trying to output
16545 DIEs to represent the *types* of those members. However the `type'
16546 function (above) will specifically avoid generating type DIEs for member
16547 types *within* the list of member DIEs for this (containing) type except
16548 for those types (of members) which are explicitly marked as also being
16549 members of this (containing) type themselves. The g++ front- end can
16550 force any given type to be treated as a member of some other (containing)
16551 type by setting the TYPE_CONTEXT of the given (member) type to point to
16552 the TREE node representing the appropriate (containing) type. */
16554 /* First output info about the base classes. */
16557 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
16561 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
16562 gen_inheritance_die (base,
16563 (accesses ? VEC_index (tree, accesses, i)
16564 : access_public_node), context_die);
16567 /* Now output info about the data members and type members. */
16568 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
16570 /* If we thought we were generating minimal debug info for TYPE
16571 and then changed our minds, some of the member declarations
16572 may have already been defined. Don't define them again, but
16573 do put them in the right order. */
16575 child = lookup_decl_die (member);
16577 splice_child_die (context_die, child);
16579 gen_decl_die (member, NULL, context_die);
16582 /* Now output info about the function members (if any). */
16583 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
16585 /* Don't include clones in the member list. */
16586 if (DECL_ABSTRACT_ORIGIN (member))
16589 child = lookup_decl_die (member);
16591 splice_child_die (context_die, child);
16593 gen_decl_die (member, NULL, context_die);
16597 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
16598 is set, we pretend that the type was never defined, so we only get the
16599 member DIEs needed by later specification DIEs. */
16602 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
16603 enum debug_info_usage usage)
16605 dw_die_ref type_die = lookup_type_die (type);
16606 dw_die_ref scope_die = 0;
16608 int complete = (TYPE_SIZE (type)
16609 && (! TYPE_STUB_DECL (type)
16610 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
16611 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
16612 complete = complete && should_emit_struct_debug (type, usage);
16614 if (type_die && ! complete)
16617 if (TYPE_CONTEXT (type) != NULL_TREE
16618 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
16619 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
16622 scope_die = scope_die_for (type, context_die);
16624 if (! type_die || (nested && scope_die == comp_unit_die))
16625 /* First occurrence of type or toplevel definition of nested class. */
16627 dw_die_ref old_die = type_die;
16629 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
16630 ? record_type_tag (type) : DW_TAG_union_type,
16632 equate_type_number_to_die (type, type_die);
16634 add_AT_specification (type_die, old_die);
16636 add_name_attribute (type_die, type_tag (type));
16639 remove_AT (type_die, DW_AT_declaration);
16641 /* Generate child dies for template paramaters. */
16642 if (debug_info_level > DINFO_LEVEL_TERSE
16643 && COMPLETE_TYPE_P (type))
16644 gen_generic_params_dies (type);
16646 /* If this type has been completed, then give it a byte_size attribute and
16647 then give a list of members. */
16648 if (complete && !ns_decl)
16650 /* Prevent infinite recursion in cases where the type of some member of
16651 this type is expressed in terms of this type itself. */
16652 TREE_ASM_WRITTEN (type) = 1;
16653 add_byte_size_attribute (type_die, type);
16654 if (TYPE_STUB_DECL (type) != NULL_TREE)
16655 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
16657 /* If the first reference to this type was as the return type of an
16658 inline function, then it may not have a parent. Fix this now. */
16659 if (type_die->die_parent == NULL)
16660 add_child_die (scope_die, type_die);
16662 push_decl_scope (type);
16663 gen_member_die (type, type_die);
16666 /* GNU extension: Record what type our vtable lives in. */
16667 if (TYPE_VFIELD (type))
16669 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
16671 gen_type_die (vtype, context_die);
16672 add_AT_die_ref (type_die, DW_AT_containing_type,
16673 lookup_type_die (vtype));
16678 add_AT_flag (type_die, DW_AT_declaration, 1);
16680 /* We don't need to do this for function-local types. */
16681 if (TYPE_STUB_DECL (type)
16682 && ! decl_function_context (TYPE_STUB_DECL (type)))
16683 VEC_safe_push (tree, gc, incomplete_types, type);
16686 if (get_AT (type_die, DW_AT_name))
16687 add_pubtype (type, type_die);
16690 /* Generate a DIE for a subroutine _type_. */
16693 gen_subroutine_type_die (tree type, dw_die_ref context_die)
16695 tree return_type = TREE_TYPE (type);
16696 dw_die_ref subr_die
16697 = new_die (DW_TAG_subroutine_type,
16698 scope_die_for (type, context_die), type);
16700 equate_type_number_to_die (type, subr_die);
16701 add_prototyped_attribute (subr_die, type);
16702 add_type_attribute (subr_die, return_type, 0, 0, context_die);
16703 gen_formal_types_die (type, subr_die);
16705 if (get_AT (subr_die, DW_AT_name))
16706 add_pubtype (type, subr_die);
16709 /* Generate a DIE for a type definition. */
16712 gen_typedef_die (tree decl, dw_die_ref context_die)
16714 dw_die_ref type_die;
16717 if (TREE_ASM_WRITTEN (decl))
16720 TREE_ASM_WRITTEN (decl) = 1;
16721 type_die = new_die (DW_TAG_typedef, context_die, decl);
16722 origin = decl_ultimate_origin (decl);
16723 if (origin != NULL)
16724 add_abstract_origin_attribute (type_die, origin);
16729 add_name_and_src_coords_attributes (type_die, decl);
16730 if (DECL_ORIGINAL_TYPE (decl))
16732 type = DECL_ORIGINAL_TYPE (decl);
16734 gcc_assert (type != TREE_TYPE (decl));
16735 equate_type_number_to_die (TREE_TYPE (decl), type_die);
16738 type = TREE_TYPE (decl);
16740 add_type_attribute (type_die, type, TREE_READONLY (decl),
16741 TREE_THIS_VOLATILE (decl), context_die);
16744 if (DECL_ABSTRACT (decl))
16745 equate_decl_number_to_die (decl, type_die);
16747 if (get_AT (type_die, DW_AT_name))
16748 add_pubtype (decl, type_die);
16751 /* Generate a type description DIE. */
16754 gen_type_die_with_usage (tree type, dw_die_ref context_die,
16755 enum debug_info_usage usage)
16758 struct array_descr_info info;
16760 if (type == NULL_TREE || type == error_mark_node)
16763 /* If TYPE is a typedef type variant, let's generate debug info
16764 for the parent typedef which TYPE is a type of. */
16765 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
16766 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
16768 if (TREE_ASM_WRITTEN (type))
16771 /* Prevent broken recursion; we can't hand off to the same type. */
16772 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
16774 /* Use the DIE of the containing namespace as the parent DIE of
16775 the type description DIE we want to generate. */
16776 if (DECL_CONTEXT (TYPE_NAME (type))
16777 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
16778 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
16780 TREE_ASM_WRITTEN (type) = 1;
16781 gen_decl_die (TYPE_NAME (type), NULL, context_die);
16785 /* If this is an array type with hidden descriptor, handle it first. */
16786 if (!TREE_ASM_WRITTEN (type)
16787 && lang_hooks.types.get_array_descr_info
16788 && lang_hooks.types.get_array_descr_info (type, &info))
16790 gen_descr_array_type_die (type, &info, context_die);
16791 TREE_ASM_WRITTEN (type) = 1;
16795 /* We are going to output a DIE to represent the unqualified version
16796 of this type (i.e. without any const or volatile qualifiers) so
16797 get the main variant (i.e. the unqualified version) of this type
16798 now. (Vectors are special because the debugging info is in the
16799 cloned type itself). */
16800 if (TREE_CODE (type) != VECTOR_TYPE)
16801 type = type_main_variant (type);
16803 if (TREE_ASM_WRITTEN (type))
16806 switch (TREE_CODE (type))
16812 case REFERENCE_TYPE:
16813 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
16814 ensures that the gen_type_die recursion will terminate even if the
16815 type is recursive. Recursive types are possible in Ada. */
16816 /* ??? We could perhaps do this for all types before the switch
16818 TREE_ASM_WRITTEN (type) = 1;
16820 /* For these types, all that is required is that we output a DIE (or a
16821 set of DIEs) to represent the "basis" type. */
16822 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16823 DINFO_USAGE_IND_USE);
16827 /* This code is used for C++ pointer-to-data-member types.
16828 Output a description of the relevant class type. */
16829 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
16830 DINFO_USAGE_IND_USE);
16832 /* Output a description of the type of the object pointed to. */
16833 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16834 DINFO_USAGE_IND_USE);
16836 /* Now output a DIE to represent this pointer-to-data-member type
16838 gen_ptr_to_mbr_type_die (type, context_die);
16841 case FUNCTION_TYPE:
16842 /* Force out return type (in case it wasn't forced out already). */
16843 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16844 DINFO_USAGE_DIR_USE);
16845 gen_subroutine_type_die (type, context_die);
16849 /* Force out return type (in case it wasn't forced out already). */
16850 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16851 DINFO_USAGE_DIR_USE);
16852 gen_subroutine_type_die (type, context_die);
16856 gen_array_type_die (type, context_die);
16860 gen_array_type_die (type, context_die);
16863 case ENUMERAL_TYPE:
16866 case QUAL_UNION_TYPE:
16867 /* If this is a nested type whose containing class hasn't been written
16868 out yet, writing it out will cover this one, too. This does not apply
16869 to instantiations of member class templates; they need to be added to
16870 the containing class as they are generated. FIXME: This hurts the
16871 idea of combining type decls from multiple TUs, since we can't predict
16872 what set of template instantiations we'll get. */
16873 if (TYPE_CONTEXT (type)
16874 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
16875 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
16877 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
16879 if (TREE_ASM_WRITTEN (type))
16882 /* If that failed, attach ourselves to the stub. */
16883 push_decl_scope (TYPE_CONTEXT (type));
16884 context_die = lookup_type_die (TYPE_CONTEXT (type));
16887 else if (TYPE_CONTEXT (type) != NULL_TREE
16888 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
16890 /* If this type is local to a function that hasn't been written
16891 out yet, use a NULL context for now; it will be fixed up in
16892 decls_for_scope. */
16893 context_die = lookup_decl_die (TYPE_CONTEXT (type));
16898 context_die = declare_in_namespace (type, context_die);
16902 if (TREE_CODE (type) == ENUMERAL_TYPE)
16904 /* This might have been written out by the call to
16905 declare_in_namespace. */
16906 if (!TREE_ASM_WRITTEN (type))
16907 gen_enumeration_type_die (type, context_die);
16910 gen_struct_or_union_type_die (type, context_die, usage);
16915 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
16916 it up if it is ever completed. gen_*_type_die will set it for us
16917 when appropriate. */
16923 case FIXED_POINT_TYPE:
16926 /* No DIEs needed for fundamental types. */
16930 /* No Dwarf representation currently defined. */
16934 gcc_unreachable ();
16937 TREE_ASM_WRITTEN (type) = 1;
16941 gen_type_die (tree type, dw_die_ref context_die)
16943 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
16946 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
16947 things which are local to the given block. */
16950 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
16952 int must_output_die = 0;
16955 /* Ignore blocks that are NULL. */
16956 if (stmt == NULL_TREE)
16959 inlined_func = inlined_function_outer_scope_p (stmt);
16961 /* If the block is one fragment of a non-contiguous block, do not
16962 process the variables, since they will have been done by the
16963 origin block. Do process subblocks. */
16964 if (BLOCK_FRAGMENT_ORIGIN (stmt))
16968 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
16969 gen_block_die (sub, context_die, depth + 1);
16974 /* Determine if we need to output any Dwarf DIEs at all to represent this
16977 /* The outer scopes for inlinings *must* always be represented. We
16978 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
16979 must_output_die = 1;
16982 /* Determine if this block directly contains any "significant"
16983 local declarations which we will need to output DIEs for. */
16984 if (debug_info_level > DINFO_LEVEL_TERSE)
16985 /* We are not in terse mode so *any* local declaration counts
16986 as being a "significant" one. */
16987 must_output_die = ((BLOCK_VARS (stmt) != NULL
16988 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
16989 && (TREE_USED (stmt)
16990 || TREE_ASM_WRITTEN (stmt)
16991 || BLOCK_ABSTRACT (stmt)));
16992 else if ((TREE_USED (stmt)
16993 || TREE_ASM_WRITTEN (stmt)
16994 || BLOCK_ABSTRACT (stmt))
16995 && !dwarf2out_ignore_block (stmt))
16996 must_output_die = 1;
16999 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
17000 DIE for any block which contains no significant local declarations at
17001 all. Rather, in such cases we just call `decls_for_scope' so that any
17002 needed Dwarf info for any sub-blocks will get properly generated. Note
17003 that in terse mode, our definition of what constitutes a "significant"
17004 local declaration gets restricted to include only inlined function
17005 instances and local (nested) function definitions. */
17006 if (must_output_die)
17010 /* If STMT block is abstract, that means we have been called
17011 indirectly from dwarf2out_abstract_function.
17012 That function rightfully marks the descendent blocks (of
17013 the abstract function it is dealing with) as being abstract,
17014 precisely to prevent us from emitting any
17015 DW_TAG_inlined_subroutine DIE as a descendent
17016 of an abstract function instance. So in that case, we should
17017 not call gen_inlined_subroutine_die.
17019 Later though, when cgraph asks dwarf2out to emit info
17020 for the concrete instance of the function decl into which
17021 the concrete instance of STMT got inlined, the later will lead
17022 to the generation of a DW_TAG_inlined_subroutine DIE. */
17023 if (! BLOCK_ABSTRACT (stmt))
17024 gen_inlined_subroutine_die (stmt, context_die, depth);
17027 gen_lexical_block_die (stmt, context_die, depth);
17030 decls_for_scope (stmt, context_die, depth);
17033 /* Process variable DECL (or variable with origin ORIGIN) within
17034 block STMT and add it to CONTEXT_DIE. */
17036 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
17039 tree decl_or_origin = decl ? decl : origin;
17040 tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
17042 if (ultimate_origin)
17043 origin = ultimate_origin;
17045 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
17046 die = lookup_decl_die (decl_or_origin);
17047 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
17048 && TYPE_DECL_IS_STUB (decl_or_origin))
17049 die = lookup_type_die (TREE_TYPE (decl_or_origin));
17053 if (die != NULL && die->die_parent == NULL)
17054 add_child_die (context_die, die);
17055 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
17056 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
17057 stmt, context_die);
17059 gen_decl_die (decl, origin, context_die);
17062 /* Generate all of the decls declared within a given scope and (recursively)
17063 all of its sub-blocks. */
17066 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
17072 /* Ignore NULL blocks. */
17073 if (stmt == NULL_TREE)
17076 /* Output the DIEs to represent all of the data objects and typedefs
17077 declared directly within this block but not within any nested
17078 sub-blocks. Also, nested function and tag DIEs have been
17079 generated with a parent of NULL; fix that up now. */
17080 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
17081 process_scope_var (stmt, decl, NULL_TREE, context_die);
17082 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
17083 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
17086 /* If we're at -g1, we're not interested in subblocks. */
17087 if (debug_info_level <= DINFO_LEVEL_TERSE)
17090 /* Output the DIEs to represent all sub-blocks (and the items declared
17091 therein) of this block. */
17092 for (subblocks = BLOCK_SUBBLOCKS (stmt);
17094 subblocks = BLOCK_CHAIN (subblocks))
17095 gen_block_die (subblocks, context_die, depth + 1);
17098 /* Is this a typedef we can avoid emitting? */
17101 is_redundant_typedef (const_tree decl)
17103 if (TYPE_DECL_IS_STUB (decl))
17106 if (DECL_ARTIFICIAL (decl)
17107 && DECL_CONTEXT (decl)
17108 && is_tagged_type (DECL_CONTEXT (decl))
17109 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
17110 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
17111 /* Also ignore the artificial member typedef for the class name. */
17117 /* Returns the DIE for a context. */
17119 static inline dw_die_ref
17120 get_context_die (tree context)
17124 /* Find die that represents this context. */
17125 if (TYPE_P (context))
17126 return force_type_die (context);
17128 return force_decl_die (context);
17130 return comp_unit_die;
17133 /* Returns the DIE for decl. A DIE will always be returned. */
17136 force_decl_die (tree decl)
17138 dw_die_ref decl_die;
17139 unsigned saved_external_flag;
17140 tree save_fn = NULL_TREE;
17141 decl_die = lookup_decl_die (decl);
17144 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
17146 decl_die = lookup_decl_die (decl);
17150 switch (TREE_CODE (decl))
17152 case FUNCTION_DECL:
17153 /* Clear current_function_decl, so that gen_subprogram_die thinks
17154 that this is a declaration. At this point, we just want to force
17155 declaration die. */
17156 save_fn = current_function_decl;
17157 current_function_decl = NULL_TREE;
17158 gen_subprogram_die (decl, context_die);
17159 current_function_decl = save_fn;
17163 /* Set external flag to force declaration die. Restore it after
17164 gen_decl_die() call. */
17165 saved_external_flag = DECL_EXTERNAL (decl);
17166 DECL_EXTERNAL (decl) = 1;
17167 gen_decl_die (decl, NULL, context_die);
17168 DECL_EXTERNAL (decl) = saved_external_flag;
17171 case NAMESPACE_DECL:
17172 dwarf2out_decl (decl);
17176 gcc_unreachable ();
17179 /* We should be able to find the DIE now. */
17181 decl_die = lookup_decl_die (decl);
17182 gcc_assert (decl_die);
17188 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
17189 always returned. */
17192 force_type_die (tree type)
17194 dw_die_ref type_die;
17196 type_die = lookup_type_die (type);
17199 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
17201 type_die = modified_type_die (type, TYPE_READONLY (type),
17202 TYPE_VOLATILE (type), context_die);
17203 gcc_assert (type_die);
17208 /* Force out any required namespaces to be able to output DECL,
17209 and return the new context_die for it, if it's changed. */
17212 setup_namespace_context (tree thing, dw_die_ref context_die)
17214 tree context = (DECL_P (thing)
17215 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
17216 if (context && TREE_CODE (context) == NAMESPACE_DECL)
17217 /* Force out the namespace. */
17218 context_die = force_decl_die (context);
17220 return context_die;
17223 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
17224 type) within its namespace, if appropriate.
17226 For compatibility with older debuggers, namespace DIEs only contain
17227 declarations; all definitions are emitted at CU scope. */
17230 declare_in_namespace (tree thing, dw_die_ref context_die)
17232 dw_die_ref ns_context;
17234 if (debug_info_level <= DINFO_LEVEL_TERSE)
17235 return context_die;
17237 /* If this decl is from an inlined function, then don't try to emit it in its
17238 namespace, as we will get confused. It would have already been emitted
17239 when the abstract instance of the inline function was emitted anyways. */
17240 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
17241 return context_die;
17243 ns_context = setup_namespace_context (thing, context_die);
17245 if (ns_context != context_die)
17249 if (DECL_P (thing))
17250 gen_decl_die (thing, NULL, ns_context);
17252 gen_type_die (thing, ns_context);
17254 return context_die;
17257 /* Generate a DIE for a namespace or namespace alias. */
17260 gen_namespace_die (tree decl, dw_die_ref context_die)
17262 dw_die_ref namespace_die;
17264 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
17265 they are an alias of. */
17266 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
17268 /* Output a real namespace or module. */
17269 context_die = setup_namespace_context (decl, comp_unit_die);
17270 namespace_die = new_die (is_fortran ()
17271 ? DW_TAG_module : DW_TAG_namespace,
17272 context_die, decl);
17273 /* For Fortran modules defined in different CU don't add src coords. */
17274 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
17275 add_name_attribute (namespace_die, dwarf2_name (decl, 0));
17277 add_name_and_src_coords_attributes (namespace_die, decl);
17278 if (DECL_EXTERNAL (decl))
17279 add_AT_flag (namespace_die, DW_AT_declaration, 1);
17280 equate_decl_number_to_die (decl, namespace_die);
17284 /* Output a namespace alias. */
17286 /* Force out the namespace we are an alias of, if necessary. */
17287 dw_die_ref origin_die
17288 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
17290 if (DECL_CONTEXT (decl) == NULL_TREE
17291 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
17292 context_die = setup_namespace_context (decl, comp_unit_die);
17293 /* Now create the namespace alias DIE. */
17294 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
17295 add_name_and_src_coords_attributes (namespace_die, decl);
17296 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
17297 equate_decl_number_to_die (decl, namespace_die);
17301 /* Generate Dwarf debug information for a decl described by DECL. */
17304 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
17306 tree decl_or_origin = decl ? decl : origin;
17307 tree class_origin = NULL;
17309 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
17312 switch (TREE_CODE (decl_or_origin))
17318 if (!is_fortran ())
17320 /* The individual enumerators of an enum type get output when we output
17321 the Dwarf representation of the relevant enum type itself. */
17325 /* Emit its type. */
17326 gen_type_die (TREE_TYPE (decl), context_die);
17328 /* And its containing namespace. */
17329 context_die = declare_in_namespace (decl, context_die);
17331 gen_const_die (decl, context_die);
17334 case FUNCTION_DECL:
17335 /* Don't output any DIEs to represent mere function declarations,
17336 unless they are class members or explicit block externs. */
17337 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
17338 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
17339 && (current_function_decl == NULL_TREE
17340 || DECL_ARTIFICIAL (decl_or_origin)))
17345 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
17346 on local redeclarations of global functions. That seems broken. */
17347 if (current_function_decl != decl)
17348 /* This is only a declaration. */;
17351 /* If we're emitting a clone, emit info for the abstract instance. */
17352 if (origin || DECL_ORIGIN (decl) != decl)
17353 dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
17355 /* If we're emitting an out-of-line copy of an inline function,
17356 emit info for the abstract instance and set up to refer to it. */
17357 else if (cgraph_function_possibly_inlined_p (decl)
17358 && ! DECL_ABSTRACT (decl)
17359 && ! class_or_namespace_scope_p (context_die)
17360 /* dwarf2out_abstract_function won't emit a die if this is just
17361 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
17362 that case, because that works only if we have a die. */
17363 && DECL_INITIAL (decl) != NULL_TREE)
17365 dwarf2out_abstract_function (decl);
17366 set_decl_origin_self (decl);
17369 /* Otherwise we're emitting the primary DIE for this decl. */
17370 else if (debug_info_level > DINFO_LEVEL_TERSE)
17372 /* Before we describe the FUNCTION_DECL itself, make sure that we
17373 have described its return type. */
17374 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
17376 /* And its virtual context. */
17377 if (DECL_VINDEX (decl) != NULL_TREE)
17378 gen_type_die (DECL_CONTEXT (decl), context_die);
17380 /* And its containing type. */
17382 origin = decl_class_context (decl);
17383 if (origin != NULL_TREE)
17384 gen_type_die_for_member (origin, decl, context_die);
17386 /* And its containing namespace. */
17387 context_die = declare_in_namespace (decl, context_die);
17390 /* Now output a DIE to represent the function itself. */
17392 gen_subprogram_die (decl, context_die);
17396 /* If we are in terse mode, don't generate any DIEs to represent any
17397 actual typedefs. */
17398 if (debug_info_level <= DINFO_LEVEL_TERSE)
17401 /* In the special case of a TYPE_DECL node representing the declaration
17402 of some type tag, if the given TYPE_DECL is marked as having been
17403 instantiated from some other (original) TYPE_DECL node (e.g. one which
17404 was generated within the original definition of an inline function) we
17405 used to generate a special (abbreviated) DW_TAG_structure_type,
17406 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
17407 should be actually referencing those DIEs, as variable DIEs with that
17408 type would be emitted already in the abstract origin, so it was always
17409 removed during unused type prunning. Don't add anything in this
17411 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
17414 if (is_redundant_typedef (decl))
17415 gen_type_die (TREE_TYPE (decl), context_die);
17417 /* Output a DIE to represent the typedef itself. */
17418 gen_typedef_die (decl, context_die);
17422 if (debug_info_level >= DINFO_LEVEL_NORMAL)
17423 gen_label_die (decl, context_die);
17428 /* If we are in terse mode, don't generate any DIEs to represent any
17429 variable declarations or definitions. */
17430 if (debug_info_level <= DINFO_LEVEL_TERSE)
17433 /* Output any DIEs that are needed to specify the type of this data
17435 if (decl_by_reference_p (decl_or_origin))
17436 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
17438 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
17440 /* And its containing type. */
17441 class_origin = decl_class_context (decl_or_origin);
17442 if (class_origin != NULL_TREE)
17443 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
17445 /* And its containing namespace. */
17446 context_die = declare_in_namespace (decl_or_origin, context_die);
17448 /* Now output the DIE to represent the data object itself. This gets
17449 complicated because of the possibility that the VAR_DECL really
17450 represents an inlined instance of a formal parameter for an inline
17453 origin = decl_ultimate_origin (decl);
17454 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
17455 gen_formal_parameter_die (decl, origin, context_die);
17457 gen_variable_die (decl, origin, context_die);
17461 /* Ignore the nameless fields that are used to skip bits but handle C++
17462 anonymous unions and structs. */
17463 if (DECL_NAME (decl) != NULL_TREE
17464 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
17465 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
17467 gen_type_die (member_declared_type (decl), context_die);
17468 gen_field_die (decl, context_die);
17473 if (DECL_BY_REFERENCE (decl_or_origin))
17474 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
17476 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
17477 gen_formal_parameter_die (decl, origin, context_die);
17480 case NAMESPACE_DECL:
17481 case IMPORTED_DECL:
17482 gen_namespace_die (decl, context_die);
17486 /* Probably some frontend-internal decl. Assume we don't care. */
17487 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
17492 /* Output debug information for global decl DECL. Called from toplev.c after
17493 compilation proper has finished. */
17496 dwarf2out_global_decl (tree decl)
17498 /* Output DWARF2 information for file-scope tentative data object
17499 declarations, file-scope (extern) function declarations (which
17500 had no corresponding body) and file-scope tagged type declarations
17501 and definitions which have not yet been forced out. */
17502 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
17503 dwarf2out_decl (decl);
17506 /* Output debug information for type decl DECL. Called from toplev.c
17507 and from language front ends (to record built-in types). */
17509 dwarf2out_type_decl (tree decl, int local)
17512 dwarf2out_decl (decl);
17515 /* Output debug information for imported module or decl DECL.
17516 NAME is non-NULL name in the lexical block if the decl has been renamed.
17517 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
17518 that DECL belongs to.
17519 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
17521 dwarf2out_imported_module_or_decl_1 (tree decl,
17523 tree lexical_block,
17524 dw_die_ref lexical_block_die)
17526 expanded_location xloc;
17527 dw_die_ref imported_die = NULL;
17528 dw_die_ref at_import_die;
17530 if (TREE_CODE (decl) == IMPORTED_DECL)
17532 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
17533 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
17537 xloc = expand_location (input_location);
17539 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
17541 if (is_base_type (TREE_TYPE (decl)))
17542 at_import_die = base_type_die (TREE_TYPE (decl));
17544 at_import_die = force_type_die (TREE_TYPE (decl));
17545 /* For namespace N { typedef void T; } using N::T; base_type_die
17546 returns NULL, but DW_TAG_imported_declaration requires
17547 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
17548 if (!at_import_die)
17550 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
17551 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
17552 at_import_die = lookup_type_die (TREE_TYPE (decl));
17553 gcc_assert (at_import_die);
17558 at_import_die = lookup_decl_die (decl);
17559 if (!at_import_die)
17561 /* If we're trying to avoid duplicate debug info, we may not have
17562 emitted the member decl for this field. Emit it now. */
17563 if (TREE_CODE (decl) == FIELD_DECL)
17565 tree type = DECL_CONTEXT (decl);
17567 if (TYPE_CONTEXT (type)
17568 && TYPE_P (TYPE_CONTEXT (type))
17569 && !should_emit_struct_debug (TYPE_CONTEXT (type),
17570 DINFO_USAGE_DIR_USE))
17572 gen_type_die_for_member (type, decl,
17573 get_context_die (TYPE_CONTEXT (type)));
17575 at_import_die = force_decl_die (decl);
17579 if (TREE_CODE (decl) == NAMESPACE_DECL)
17580 imported_die = new_die (DW_TAG_imported_module,
17584 imported_die = new_die (DW_TAG_imported_declaration,
17588 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
17589 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
17591 add_AT_string (imported_die, DW_AT_name,
17592 IDENTIFIER_POINTER (name));
17593 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
17596 /* Output debug information for imported module or decl DECL.
17597 NAME is non-NULL name in context if the decl has been renamed.
17598 CHILD is true if decl is one of the renamed decls as part of
17599 importing whole module. */
17602 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
17605 /* dw_die_ref at_import_die; */
17606 dw_die_ref scope_die;
17608 if (debug_info_level <= DINFO_LEVEL_TERSE)
17613 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
17614 We need decl DIE for reference and scope die. First, get DIE for the decl
17617 /* Get the scope die for decl context. Use comp_unit_die for global module
17618 or decl. If die is not found for non globals, force new die. */
17620 && TYPE_P (context)
17621 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
17623 scope_die = get_context_die (context);
17627 gcc_assert (scope_die->die_child);
17628 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
17629 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
17630 scope_die = scope_die->die_child;
17633 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
17634 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
17638 /* Write the debugging output for DECL. */
17641 dwarf2out_decl (tree decl)
17643 dw_die_ref context_die = comp_unit_die;
17645 switch (TREE_CODE (decl))
17650 case FUNCTION_DECL:
17651 /* What we would really like to do here is to filter out all mere
17652 file-scope declarations of file-scope functions which are never
17653 referenced later within this translation unit (and keep all of ones
17654 that *are* referenced later on) but we aren't clairvoyant, so we have
17655 no idea which functions will be referenced in the future (i.e. later
17656 on within the current translation unit). So here we just ignore all
17657 file-scope function declarations which are not also definitions. If
17658 and when the debugger needs to know something about these functions,
17659 it will have to hunt around and find the DWARF information associated
17660 with the definition of the function.
17662 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
17663 nodes represent definitions and which ones represent mere
17664 declarations. We have to check DECL_INITIAL instead. That's because
17665 the C front-end supports some weird semantics for "extern inline"
17666 function definitions. These can get inlined within the current
17667 translation unit (and thus, we need to generate Dwarf info for their
17668 abstract instances so that the Dwarf info for the concrete inlined
17669 instances can have something to refer to) but the compiler never
17670 generates any out-of-lines instances of such things (despite the fact
17671 that they *are* definitions).
17673 The important point is that the C front-end marks these "extern
17674 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
17675 them anyway. Note that the C++ front-end also plays some similar games
17676 for inline function definitions appearing within include files which
17677 also contain `#pragma interface' pragmas. */
17678 if (DECL_INITIAL (decl) == NULL_TREE)
17681 /* If we're a nested function, initially use a parent of NULL; if we're
17682 a plain function, this will be fixed up in decls_for_scope. If
17683 we're a method, it will be ignored, since we already have a DIE. */
17684 if (decl_function_context (decl)
17685 /* But if we're in terse mode, we don't care about scope. */
17686 && debug_info_level > DINFO_LEVEL_TERSE)
17687 context_die = NULL;
17691 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
17692 declaration and if the declaration was never even referenced from
17693 within this entire compilation unit. We suppress these DIEs in
17694 order to save space in the .debug section (by eliminating entries
17695 which are probably useless). Note that we must not suppress
17696 block-local extern declarations (whether used or not) because that
17697 would screw-up the debugger's name lookup mechanism and cause it to
17698 miss things which really ought to be in scope at a given point. */
17699 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
17702 /* For local statics lookup proper context die. */
17703 if (TREE_STATIC (decl) && decl_function_context (decl))
17704 context_die = lookup_decl_die (DECL_CONTEXT (decl));
17706 /* If we are in terse mode, don't generate any DIEs to represent any
17707 variable declarations or definitions. */
17708 if (debug_info_level <= DINFO_LEVEL_TERSE)
17713 if (debug_info_level <= DINFO_LEVEL_TERSE)
17715 if (!is_fortran ())
17717 if (TREE_STATIC (decl) && decl_function_context (decl))
17718 context_die = lookup_decl_die (DECL_CONTEXT (decl));
17721 case NAMESPACE_DECL:
17722 case IMPORTED_DECL:
17723 if (debug_info_level <= DINFO_LEVEL_TERSE)
17725 if (lookup_decl_die (decl) != NULL)
17730 /* Don't emit stubs for types unless they are needed by other DIEs. */
17731 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
17734 /* Don't bother trying to generate any DIEs to represent any of the
17735 normal built-in types for the language we are compiling. */
17736 if (DECL_IS_BUILTIN (decl))
17738 /* OK, we need to generate one for `bool' so GDB knows what type
17739 comparisons have. */
17741 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
17742 && ! DECL_IGNORED_P (decl))
17743 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
17748 /* If we are in terse mode, don't generate any DIEs for types. */
17749 if (debug_info_level <= DINFO_LEVEL_TERSE)
17752 /* If we're a function-scope tag, initially use a parent of NULL;
17753 this will be fixed up in decls_for_scope. */
17754 if (decl_function_context (decl))
17755 context_die = NULL;
17763 gen_decl_die (decl, NULL, context_die);
17766 /* Output a marker (i.e. a label) for the beginning of the generated code for
17767 a lexical block. */
17770 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
17771 unsigned int blocknum)
17773 switch_to_section (current_function_section ());
17774 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
17777 /* Output a marker (i.e. a label) for the end of the generated code for a
17781 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
17783 switch_to_section (current_function_section ());
17784 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
17787 /* Returns nonzero if it is appropriate not to emit any debugging
17788 information for BLOCK, because it doesn't contain any instructions.
17790 Don't allow this for blocks with nested functions or local classes
17791 as we would end up with orphans, and in the presence of scheduling
17792 we may end up calling them anyway. */
17795 dwarf2out_ignore_block (const_tree block)
17800 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
17801 if (TREE_CODE (decl) == FUNCTION_DECL
17802 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
17804 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
17806 decl = BLOCK_NONLOCALIZED_VAR (block, i);
17807 if (TREE_CODE (decl) == FUNCTION_DECL
17808 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
17815 /* Hash table routines for file_hash. */
17818 file_table_eq (const void *p1_p, const void *p2_p)
17820 const struct dwarf_file_data *const p1 =
17821 (const struct dwarf_file_data *) p1_p;
17822 const char *const p2 = (const char *) p2_p;
17823 return strcmp (p1->filename, p2) == 0;
17827 file_table_hash (const void *p_p)
17829 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
17830 return htab_hash_string (p->filename);
17833 /* Lookup FILE_NAME (in the list of filenames that we know about here in
17834 dwarf2out.c) and return its "index". The index of each (known) filename is
17835 just a unique number which is associated with only that one filename. We
17836 need such numbers for the sake of generating labels (in the .debug_sfnames
17837 section) and references to those files numbers (in the .debug_srcinfo
17838 and.debug_macinfo sections). If the filename given as an argument is not
17839 found in our current list, add it to the list and assign it the next
17840 available unique index number. In order to speed up searches, we remember
17841 the index of the filename was looked up last. This handles the majority of
17844 static struct dwarf_file_data *
17845 lookup_filename (const char *file_name)
17848 struct dwarf_file_data * created;
17850 /* Check to see if the file name that was searched on the previous
17851 call matches this file name. If so, return the index. */
17852 if (file_table_last_lookup
17853 && (file_name == file_table_last_lookup->filename
17854 || strcmp (file_table_last_lookup->filename, file_name) == 0))
17855 return file_table_last_lookup;
17857 /* Didn't match the previous lookup, search the table. */
17858 slot = htab_find_slot_with_hash (file_table, file_name,
17859 htab_hash_string (file_name), INSERT);
17861 return (struct dwarf_file_data *) *slot;
17863 created = GGC_NEW (struct dwarf_file_data);
17864 created->filename = file_name;
17865 created->emitted_number = 0;
17870 /* If the assembler will construct the file table, then translate the compiler
17871 internal file table number into the assembler file table number, and emit
17872 a .file directive if we haven't already emitted one yet. The file table
17873 numbers are different because we prune debug info for unused variables and
17874 types, which may include filenames. */
17877 maybe_emit_file (struct dwarf_file_data * fd)
17879 if (! fd->emitted_number)
17881 if (last_emitted_file)
17882 fd->emitted_number = last_emitted_file->emitted_number + 1;
17884 fd->emitted_number = 1;
17885 last_emitted_file = fd;
17887 if (DWARF2_ASM_LINE_DEBUG_INFO)
17889 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
17890 output_quoted_string (asm_out_file,
17891 remap_debug_filename (fd->filename));
17892 fputc ('\n', asm_out_file);
17896 return fd->emitted_number;
17899 /* Schedule generation of a DW_AT_const_value attribute to DIE.
17900 That generation should happen after function debug info has been
17901 generated. The value of the attribute is the constant value of ARG. */
17904 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
17906 die_arg_entry entry;
17911 if (!tmpl_value_parm_die_table)
17912 tmpl_value_parm_die_table
17913 = VEC_alloc (die_arg_entry, gc, 32);
17917 VEC_safe_push (die_arg_entry, gc,
17918 tmpl_value_parm_die_table,
17922 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
17923 by append_entry_to_tmpl_value_parm_die_table. This function must
17924 be called after function DIEs have been generated. */
17927 gen_remaining_tmpl_value_param_die_attribute (void)
17929 if (tmpl_value_parm_die_table)
17935 VEC_iterate (die_arg_entry, tmpl_value_parm_die_table, i, e);
17937 tree_add_const_value_attribute (e->die, e->arg);
17942 /* Replace DW_AT_name for the decl with name. */
17945 dwarf2out_set_name (tree decl, tree name)
17950 die = TYPE_SYMTAB_DIE (decl);
17954 attr = get_AT (die, DW_AT_name);
17957 struct indirect_string_node *node;
17959 node = find_AT_string (dwarf2_name (name, 0));
17960 /* replace the string. */
17961 attr->dw_attr_val.v.val_str = node;
17965 add_name_attribute (die, dwarf2_name (name, 0));
17968 /* Called by the final INSN scan whenever we see a var location. We
17969 use it to drop labels in the right places, and throw the location in
17970 our lookup table. */
17973 dwarf2out_var_location (rtx loc_note)
17975 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
17976 struct var_loc_node *newloc;
17978 static const char *last_label;
17979 static const char *last_postcall_label;
17980 static bool last_in_cold_section_p;
17983 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
17986 next_real = next_real_insn (loc_note);
17987 /* If there are no instructions which would be affected by this note,
17988 don't do anything. */
17989 if (next_real == NULL_RTX)
17992 newloc = GGC_CNEW (struct var_loc_node);
17993 /* If there were no real insns between note we processed last time
17994 and this note, use the label we emitted last time. */
17995 if (last_var_location_insn == NULL_RTX
17996 || last_var_location_insn != next_real
17997 || last_in_cold_section_p != in_cold_section_p)
17999 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
18000 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
18002 last_label = ggc_strdup (loclabel);
18003 if (!NOTE_DURING_CALL_P (loc_note))
18004 last_postcall_label = NULL;
18006 newloc->var_loc_note = loc_note;
18007 newloc->next = NULL;
18009 if (!NOTE_DURING_CALL_P (loc_note))
18010 newloc->label = last_label;
18013 if (!last_postcall_label)
18015 sprintf (loclabel, "%s-1", last_label);
18016 last_postcall_label = ggc_strdup (loclabel);
18018 newloc->label = last_postcall_label;
18021 if (cfun && in_cold_section_p)
18022 newloc->section_label = crtl->subsections.cold_section_label;
18024 newloc->section_label = text_section_label;
18026 last_var_location_insn = next_real;
18027 last_in_cold_section_p = in_cold_section_p;
18028 decl = NOTE_VAR_LOCATION_DECL (loc_note);
18029 add_var_loc_to_decl (decl, newloc);
18032 /* We need to reset the locations at the beginning of each
18033 function. We can't do this in the end_function hook, because the
18034 declarations that use the locations won't have been output when
18035 that hook is called. Also compute have_multiple_function_sections here. */
18038 dwarf2out_begin_function (tree fun)
18040 htab_empty (decl_loc_table);
18042 if (function_section (fun) != text_section)
18043 have_multiple_function_sections = true;
18045 dwarf2out_note_section_used ();
18048 /* Output a label to mark the beginning of a source code line entry
18049 and record information relating to this source line, in
18050 'line_info_table' for later output of the .debug_line section. */
18053 dwarf2out_source_line (unsigned int line, const char *filename,
18054 int discriminator, bool is_stmt)
18056 static bool last_is_stmt = true;
18058 if (debug_info_level >= DINFO_LEVEL_NORMAL
18061 int file_num = maybe_emit_file (lookup_filename (filename));
18063 switch_to_section (current_function_section ());
18065 /* If requested, emit something human-readable. */
18066 if (flag_debug_asm)
18067 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
18070 if (DWARF2_ASM_LINE_DEBUG_INFO)
18072 /* Emit the .loc directive understood by GNU as. */
18073 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
18074 if (is_stmt != last_is_stmt)
18076 fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
18077 last_is_stmt = is_stmt;
18079 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
18080 fprintf (asm_out_file, " discriminator %d", discriminator);
18081 fputc ('\n', asm_out_file);
18083 /* Indicate that line number info exists. */
18084 line_info_table_in_use++;
18086 else if (function_section (current_function_decl) != text_section)
18088 dw_separate_line_info_ref line_info;
18089 targetm.asm_out.internal_label (asm_out_file,
18090 SEPARATE_LINE_CODE_LABEL,
18091 separate_line_info_table_in_use);
18093 /* Expand the line info table if necessary. */
18094 if (separate_line_info_table_in_use
18095 == separate_line_info_table_allocated)
18097 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
18098 separate_line_info_table
18099 = GGC_RESIZEVEC (dw_separate_line_info_entry,
18100 separate_line_info_table,
18101 separate_line_info_table_allocated);
18102 memset (separate_line_info_table
18103 + separate_line_info_table_in_use,
18105 (LINE_INFO_TABLE_INCREMENT
18106 * sizeof (dw_separate_line_info_entry)));
18109 /* Add the new entry at the end of the line_info_table. */
18111 = &separate_line_info_table[separate_line_info_table_in_use++];
18112 line_info->dw_file_num = file_num;
18113 line_info->dw_line_num = line;
18114 line_info->function = current_function_funcdef_no;
18118 dw_line_info_ref line_info;
18120 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
18121 line_info_table_in_use);
18123 /* Expand the line info table if necessary. */
18124 if (line_info_table_in_use == line_info_table_allocated)
18126 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
18128 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
18129 line_info_table_allocated);
18130 memset (line_info_table + line_info_table_in_use, 0,
18131 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
18134 /* Add the new entry at the end of the line_info_table. */
18135 line_info = &line_info_table[line_info_table_in_use++];
18136 line_info->dw_file_num = file_num;
18137 line_info->dw_line_num = line;
18142 /* Record the beginning of a new source file. */
18145 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
18147 if (flag_eliminate_dwarf2_dups)
18149 /* Record the beginning of the file for break_out_includes. */
18150 dw_die_ref bincl_die;
18152 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
18153 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
18156 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18158 int file_num = maybe_emit_file (lookup_filename (filename));
18160 switch_to_section (debug_macinfo_section);
18161 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
18162 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
18165 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
18169 /* Record the end of a source file. */
18172 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
18174 if (flag_eliminate_dwarf2_dups)
18175 /* Record the end of the file for break_out_includes. */
18176 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
18178 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18180 switch_to_section (debug_macinfo_section);
18181 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
18185 /* Called from debug_define in toplev.c. The `buffer' parameter contains
18186 the tail part of the directive line, i.e. the part which is past the
18187 initial whitespace, #, whitespace, directive-name, whitespace part. */
18190 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
18191 const char *buffer ATTRIBUTE_UNUSED)
18193 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18195 switch_to_section (debug_macinfo_section);
18196 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
18197 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
18198 dw2_asm_output_nstring (buffer, -1, "The macro");
18202 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
18203 the tail part of the directive line, i.e. the part which is past the
18204 initial whitespace, #, whitespace, directive-name, whitespace part. */
18207 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
18208 const char *buffer ATTRIBUTE_UNUSED)
18210 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18212 switch_to_section (debug_macinfo_section);
18213 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
18214 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
18215 dw2_asm_output_nstring (buffer, -1, "The macro");
18219 /* Set up for Dwarf output at the start of compilation. */
18222 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
18224 /* Allocate the file_table. */
18225 file_table = htab_create_ggc (50, file_table_hash,
18226 file_table_eq, NULL);
18228 /* Allocate the decl_die_table. */
18229 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
18230 decl_die_table_eq, NULL);
18232 /* Allocate the decl_loc_table. */
18233 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
18234 decl_loc_table_eq, NULL);
18236 /* Allocate the initial hunk of the decl_scope_table. */
18237 decl_scope_table = VEC_alloc (tree, gc, 256);
18239 /* Allocate the initial hunk of the abbrev_die_table. */
18240 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
18241 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
18242 /* Zero-th entry is allocated, but unused. */
18243 abbrev_die_table_in_use = 1;
18245 /* Allocate the initial hunk of the line_info_table. */
18246 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
18247 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
18249 /* Zero-th entry is allocated, but unused. */
18250 line_info_table_in_use = 1;
18252 /* Allocate the pubtypes and pubnames vectors. */
18253 pubname_table = VEC_alloc (pubname_entry, gc, 32);
18254 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
18256 /* Generate the initial DIE for the .debug section. Note that the (string)
18257 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
18258 will (typically) be a relative pathname and that this pathname should be
18259 taken as being relative to the directory from which the compiler was
18260 invoked when the given (base) source file was compiled. We will fill
18261 in this value in dwarf2out_finish. */
18262 comp_unit_die = gen_compile_unit_die (NULL);
18264 incomplete_types = VEC_alloc (tree, gc, 64);
18266 used_rtx_array = VEC_alloc (rtx, gc, 32);
18268 debug_info_section = get_section (DEBUG_INFO_SECTION,
18269 SECTION_DEBUG, NULL);
18270 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
18271 SECTION_DEBUG, NULL);
18272 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
18273 SECTION_DEBUG, NULL);
18274 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
18275 SECTION_DEBUG, NULL);
18276 debug_line_section = get_section (DEBUG_LINE_SECTION,
18277 SECTION_DEBUG, NULL);
18278 debug_loc_section = get_section (DEBUG_LOC_SECTION,
18279 SECTION_DEBUG, NULL);
18280 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
18281 SECTION_DEBUG, NULL);
18282 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
18283 SECTION_DEBUG, NULL);
18284 debug_str_section = get_section (DEBUG_STR_SECTION,
18285 DEBUG_STR_SECTION_FLAGS, NULL);
18286 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
18287 SECTION_DEBUG, NULL);
18288 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
18289 SECTION_DEBUG, NULL);
18291 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
18292 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
18293 DEBUG_ABBREV_SECTION_LABEL, 0);
18294 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
18295 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
18296 COLD_TEXT_SECTION_LABEL, 0);
18297 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
18299 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
18300 DEBUG_INFO_SECTION_LABEL, 0);
18301 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
18302 DEBUG_LINE_SECTION_LABEL, 0);
18303 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
18304 DEBUG_RANGES_SECTION_LABEL, 0);
18305 switch_to_section (debug_abbrev_section);
18306 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
18307 switch_to_section (debug_info_section);
18308 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
18309 switch_to_section (debug_line_section);
18310 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
18312 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18314 switch_to_section (debug_macinfo_section);
18315 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
18316 DEBUG_MACINFO_SECTION_LABEL, 0);
18317 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
18320 switch_to_section (text_section);
18321 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
18322 if (flag_reorder_blocks_and_partition)
18324 cold_text_section = unlikely_text_section ();
18325 switch_to_section (cold_text_section);
18326 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
18330 /* A helper function for dwarf2out_finish called through
18331 htab_traverse. Emit one queued .debug_str string. */
18334 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
18336 struct indirect_string_node *node = (struct indirect_string_node *) *h;
18338 if (node->label && node->refcount)
18340 switch_to_section (debug_str_section);
18341 ASM_OUTPUT_LABEL (asm_out_file, node->label);
18342 assemble_string (node->str, strlen (node->str) + 1);
18348 #if ENABLE_ASSERT_CHECKING
18349 /* Verify that all marks are clear. */
18352 verify_marks_clear (dw_die_ref die)
18356 gcc_assert (! die->die_mark);
18357 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
18359 #endif /* ENABLE_ASSERT_CHECKING */
18361 /* Clear the marks for a die and its children.
18362 Be cool if the mark isn't set. */
18365 prune_unmark_dies (dw_die_ref die)
18371 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
18374 /* Given DIE that we're marking as used, find any other dies
18375 it references as attributes and mark them as used. */
18378 prune_unused_types_walk_attribs (dw_die_ref die)
18383 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
18385 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
18387 /* A reference to another DIE.
18388 Make sure that it will get emitted. */
18389 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
18391 /* Set the string's refcount to 0 so that prune_unused_types_mark
18392 accounts properly for it. */
18393 if (AT_class (a) == dw_val_class_str)
18394 a->dw_attr_val.v.val_str->refcount = 0;
18399 /* Mark DIE as being used. If DOKIDS is true, then walk down
18400 to DIE's children. */
18403 prune_unused_types_mark (dw_die_ref die, int dokids)
18407 if (die->die_mark == 0)
18409 /* We haven't done this node yet. Mark it as used. */
18412 /* We also have to mark its parents as used.
18413 (But we don't want to mark our parents' kids due to this.) */
18414 if (die->die_parent)
18415 prune_unused_types_mark (die->die_parent, 0);
18417 /* Mark any referenced nodes. */
18418 prune_unused_types_walk_attribs (die);
18420 /* If this node is a specification,
18421 also mark the definition, if it exists. */
18422 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
18423 prune_unused_types_mark (die->die_definition, 1);
18426 if (dokids && die->die_mark != 2)
18428 /* We need to walk the children, but haven't done so yet.
18429 Remember that we've walked the kids. */
18432 /* If this is an array type, we need to make sure our
18433 kids get marked, even if they're types. */
18434 if (die->die_tag == DW_TAG_array_type)
18435 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
18437 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
18441 /* For local classes, look if any static member functions were emitted
18442 and if so, mark them. */
18445 prune_unused_types_walk_local_classes (dw_die_ref die)
18449 if (die->die_mark == 2)
18452 switch (die->die_tag)
18454 case DW_TAG_structure_type:
18455 case DW_TAG_union_type:
18456 case DW_TAG_class_type:
18459 case DW_TAG_subprogram:
18460 if (!get_AT_flag (die, DW_AT_declaration)
18461 || die->die_definition != NULL)
18462 prune_unused_types_mark (die, 1);
18469 /* Mark children. */
18470 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
18473 /* Walk the tree DIE and mark types that we actually use. */
18476 prune_unused_types_walk (dw_die_ref die)
18480 /* Don't do anything if this node is already marked and
18481 children have been marked as well. */
18482 if (die->die_mark == 2)
18485 switch (die->die_tag)
18487 case DW_TAG_structure_type:
18488 case DW_TAG_union_type:
18489 case DW_TAG_class_type:
18490 if (die->die_perennial_p)
18493 for (c = die->die_parent; c; c = c->die_parent)
18494 if (c->die_tag == DW_TAG_subprogram)
18497 /* Finding used static member functions inside of classes
18498 is needed just for local classes, because for other classes
18499 static member function DIEs with DW_AT_specification
18500 are emitted outside of the DW_TAG_*_type. If we ever change
18501 it, we'd need to call this even for non-local classes. */
18503 prune_unused_types_walk_local_classes (die);
18505 /* It's a type node --- don't mark it. */
18508 case DW_TAG_const_type:
18509 case DW_TAG_packed_type:
18510 case DW_TAG_pointer_type:
18511 case DW_TAG_reference_type:
18512 case DW_TAG_volatile_type:
18513 case DW_TAG_typedef:
18514 case DW_TAG_array_type:
18515 case DW_TAG_interface_type:
18516 case DW_TAG_friend:
18517 case DW_TAG_variant_part:
18518 case DW_TAG_enumeration_type:
18519 case DW_TAG_subroutine_type:
18520 case DW_TAG_string_type:
18521 case DW_TAG_set_type:
18522 case DW_TAG_subrange_type:
18523 case DW_TAG_ptr_to_member_type:
18524 case DW_TAG_file_type:
18525 if (die->die_perennial_p)
18528 /* It's a type node --- don't mark it. */
18532 /* Mark everything else. */
18536 if (die->die_mark == 0)
18540 /* Now, mark any dies referenced from here. */
18541 prune_unused_types_walk_attribs (die);
18546 /* Mark children. */
18547 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
18550 /* Increment the string counts on strings referred to from DIE's
18554 prune_unused_types_update_strings (dw_die_ref die)
18559 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
18560 if (AT_class (a) == dw_val_class_str)
18562 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
18564 /* Avoid unnecessarily putting strings that are used less than
18565 twice in the hash table. */
18567 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
18570 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
18571 htab_hash_string (s->str),
18573 gcc_assert (*slot == NULL);
18579 /* Remove from the tree DIE any dies that aren't marked. */
18582 prune_unused_types_prune (dw_die_ref die)
18586 gcc_assert (die->die_mark);
18587 prune_unused_types_update_strings (die);
18589 if (! die->die_child)
18592 c = die->die_child;
18594 dw_die_ref prev = c;
18595 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
18596 if (c == die->die_child)
18598 /* No marked children between 'prev' and the end of the list. */
18600 /* No marked children at all. */
18601 die->die_child = NULL;
18604 prev->die_sib = c->die_sib;
18605 die->die_child = prev;
18610 if (c != prev->die_sib)
18612 prune_unused_types_prune (c);
18613 } while (c != die->die_child);
18616 /* A helper function for dwarf2out_finish called through
18617 htab_traverse. Clear .debug_str strings that we haven't already
18618 decided to emit. */
18621 prune_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
18623 struct indirect_string_node *node = (struct indirect_string_node *) *h;
18625 if (!node->label || !node->refcount)
18626 htab_clear_slot (debug_str_hash, h);
18631 /* Remove dies representing declarations that we never use. */
18634 prune_unused_types (void)
18637 limbo_die_node *node;
18640 #if ENABLE_ASSERT_CHECKING
18641 /* All the marks should already be clear. */
18642 verify_marks_clear (comp_unit_die);
18643 for (node = limbo_die_list; node; node = node->next)
18644 verify_marks_clear (node->die);
18645 #endif /* ENABLE_ASSERT_CHECKING */
18647 /* Set the mark on nodes that are actually used. */
18648 prune_unused_types_walk (comp_unit_die);
18649 for (node = limbo_die_list; node; node = node->next)
18650 prune_unused_types_walk (node->die);
18652 /* Also set the mark on nodes referenced from the
18653 pubname_table or arange_table. */
18654 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
18655 prune_unused_types_mark (pub->die, 1);
18656 for (i = 0; i < arange_table_in_use; i++)
18657 prune_unused_types_mark (arange_table[i], 1);
18659 /* Get rid of nodes that aren't marked; and update the string counts. */
18660 if (debug_str_hash && debug_str_hash_forced)
18661 htab_traverse (debug_str_hash, prune_indirect_string, NULL);
18662 else if (debug_str_hash)
18663 htab_empty (debug_str_hash);
18664 prune_unused_types_prune (comp_unit_die);
18665 for (node = limbo_die_list; node; node = node->next)
18666 prune_unused_types_prune (node->die);
18668 /* Leave the marks clear. */
18669 prune_unmark_dies (comp_unit_die);
18670 for (node = limbo_die_list; node; node = node->next)
18671 prune_unmark_dies (node->die);
18674 /* Set the parameter to true if there are any relative pathnames in
18677 file_table_relative_p (void ** slot, void *param)
18679 bool *p = (bool *) param;
18680 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
18681 if (!IS_ABSOLUTE_PATH (d->filename))
18689 /* Move a DW_AT_MIPS_linkage_name attribute just added to dw_die_ref
18690 to the location it would have been added, should we know its
18691 DECL_ASSEMBLER_NAME when we added other attributes. This will
18692 probably improve compactness of debug info, removing equivalent
18693 abbrevs, and hide any differences caused by deferring the
18694 computation of the assembler name, triggered by e.g. PCH. */
18697 move_linkage_attr (dw_die_ref die)
18699 unsigned ix = VEC_length (dw_attr_node, die->die_attr);
18700 dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1);
18702 gcc_assert (linkage.dw_attr == DW_AT_MIPS_linkage_name);
18706 dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1);
18708 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
18712 if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
18714 VEC_pop (dw_attr_node, die->die_attr);
18715 VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
18719 /* Output stuff that dwarf requires at the end of every file,
18720 and generate the DWARF-2 debugging info. */
18723 dwarf2out_finish (const char *filename)
18725 limbo_die_node *node, *next_node;
18726 dw_die_ref die = 0;
18729 gen_remaining_tmpl_value_param_die_attribute ();
18731 /* Add the name for the main input file now. We delayed this from
18732 dwarf2out_init to avoid complications with PCH. */
18733 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
18734 if (!IS_ABSOLUTE_PATH (filename))
18735 add_comp_dir_attribute (comp_unit_die);
18736 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
18739 htab_traverse (file_table, file_table_relative_p, &p);
18741 add_comp_dir_attribute (comp_unit_die);
18744 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
18746 add_location_or_const_value_attribute (
18747 VEC_index (deferred_locations, deferred_locations_list, i)->die,
18748 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
18752 /* Traverse the limbo die list, and add parent/child links. The only
18753 dies without parents that should be here are concrete instances of
18754 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
18755 For concrete instances, we can get the parent die from the abstract
18757 for (node = limbo_die_list; node; node = next_node)
18759 next_node = node->next;
18762 if (die->die_parent == NULL)
18764 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
18767 add_child_die (origin->die_parent, die);
18768 else if (die == comp_unit_die)
18770 else if (errorcount > 0 || sorrycount > 0)
18771 /* It's OK to be confused by errors in the input. */
18772 add_child_die (comp_unit_die, die);
18775 /* In certain situations, the lexical block containing a
18776 nested function can be optimized away, which results
18777 in the nested function die being orphaned. Likewise
18778 with the return type of that nested function. Force
18779 this to be a child of the containing function.
18781 It may happen that even the containing function got fully
18782 inlined and optimized out. In that case we are lost and
18783 assign the empty child. This should not be big issue as
18784 the function is likely unreachable too. */
18785 tree context = NULL_TREE;
18787 gcc_assert (node->created_for);
18789 if (DECL_P (node->created_for))
18790 context = DECL_CONTEXT (node->created_for);
18791 else if (TYPE_P (node->created_for))
18792 context = TYPE_CONTEXT (node->created_for);
18794 gcc_assert (context
18795 && (TREE_CODE (context) == FUNCTION_DECL
18796 || TREE_CODE (context) == NAMESPACE_DECL));
18798 origin = lookup_decl_die (context);
18800 add_child_die (origin, die);
18802 add_child_die (comp_unit_die, die);
18807 limbo_die_list = NULL;
18809 for (node = deferred_asm_name; node; node = node->next)
18811 tree decl = node->created_for;
18812 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
18814 add_AT_string (node->die, DW_AT_MIPS_linkage_name,
18815 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
18816 move_linkage_attr (node->die);
18820 deferred_asm_name = NULL;
18822 /* Walk through the list of incomplete types again, trying once more to
18823 emit full debugging info for them. */
18824 retry_incomplete_types ();
18826 if (flag_eliminate_unused_debug_types)
18827 prune_unused_types ();
18829 /* Generate separate CUs for each of the include files we've seen.
18830 They will go into limbo_die_list. */
18831 if (flag_eliminate_dwarf2_dups)
18832 break_out_includes (comp_unit_die);
18834 /* Traverse the DIE's and add add sibling attributes to those DIE's
18835 that have children. */
18836 add_sibling_attributes (comp_unit_die);
18837 for (node = limbo_die_list; node; node = node->next)
18838 add_sibling_attributes (node->die);
18840 /* Output a terminator label for the .text section. */
18841 switch_to_section (text_section);
18842 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
18843 if (flag_reorder_blocks_and_partition)
18845 switch_to_section (unlikely_text_section ());
18846 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
18849 /* We can only use the low/high_pc attributes if all of the code was
18851 if (!have_multiple_function_sections)
18853 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
18854 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
18859 unsigned fde_idx = 0;
18861 /* We need to give .debug_loc and .debug_ranges an appropriate
18862 "base address". Use zero so that these addresses become
18863 absolute. Historically, we've emitted the unexpected
18864 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
18865 Emit both to give time for other tools to adapt. */
18866 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
18867 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
18869 add_AT_range_list (comp_unit_die, DW_AT_ranges,
18870 add_ranges_by_labels (text_section_label,
18872 if (flag_reorder_blocks_and_partition)
18873 add_ranges_by_labels (cold_text_section_label,
18876 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
18878 dw_fde_ref fde = &fde_table[fde_idx];
18880 if (fde->dw_fde_switched_sections)
18882 if (!fde->in_std_section)
18883 add_ranges_by_labels (fde->dw_fde_hot_section_label,
18884 fde->dw_fde_hot_section_end_label);
18885 if (!fde->cold_in_std_section)
18886 add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
18887 fde->dw_fde_unlikely_section_end_label);
18889 else if (!fde->in_std_section)
18890 add_ranges_by_labels (fde->dw_fde_begin,
18897 /* Output location list section if necessary. */
18898 if (have_location_lists)
18900 /* Output the location lists info. */
18901 switch_to_section (debug_loc_section);
18902 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
18903 DEBUG_LOC_SECTION_LABEL, 0);
18904 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
18905 output_location_lists (die);
18908 if (debug_info_level >= DINFO_LEVEL_NORMAL)
18909 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
18910 debug_line_section_label);
18912 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18913 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
18915 /* Output all of the compilation units. We put the main one last so that
18916 the offsets are available to output_pubnames. */
18917 for (node = limbo_die_list; node; node = node->next)
18918 output_comp_unit (node->die, 0);
18920 /* Output the main compilation unit if non-empty or if .debug_macinfo
18921 has been emitted. */
18922 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
18924 /* Output the abbreviation table. */
18925 switch_to_section (debug_abbrev_section);
18926 output_abbrev_section ();
18928 /* Output public names table if necessary. */
18929 if (!VEC_empty (pubname_entry, pubname_table))
18931 switch_to_section (debug_pubnames_section);
18932 output_pubnames (pubname_table);
18935 /* Output public types table if necessary. */
18936 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
18937 It shouldn't hurt to emit it always, since pure DWARF2 consumers
18938 simply won't look for the section. */
18939 if (!VEC_empty (pubname_entry, pubtype_table))
18941 switch_to_section (debug_pubtypes_section);
18942 output_pubnames (pubtype_table);
18945 /* Output the address range information. We only put functions in the arange
18946 table, so don't write it out if we don't have any. */
18947 if (fde_table_in_use)
18949 switch_to_section (debug_aranges_section);
18953 /* Output ranges section if necessary. */
18954 if (ranges_table_in_use)
18956 switch_to_section (debug_ranges_section);
18957 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
18961 /* Output the source line correspondence table. We must do this
18962 even if there is no line information. Otherwise, on an empty
18963 translation unit, we will generate a present, but empty,
18964 .debug_info section. IRIX 6.5 `nm' will then complain when
18965 examining the file. This is done late so that any filenames
18966 used by the debug_info section are marked as 'used'. */
18967 if (! DWARF2_ASM_LINE_DEBUG_INFO)
18969 switch_to_section (debug_line_section);
18970 output_line_info ();
18973 /* Have to end the macro section. */
18974 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18976 switch_to_section (debug_macinfo_section);
18977 dw2_asm_output_data (1, 0, "End compilation unit");
18980 /* If we emitted any DW_FORM_strp form attribute, output the string
18982 if (debug_str_hash)
18983 htab_traverse (debug_str_hash, output_indirect_string, NULL);
18987 /* This should never be used, but its address is needed for comparisons. */
18988 const struct gcc_debug_hooks dwarf2_debug_hooks =
18994 0, /* start_source_file */
18995 0, /* end_source_file */
18996 0, /* begin_block */
18998 0, /* ignore_block */
18999 0, /* source_line */
19000 0, /* begin_prologue */
19001 0, /* end_prologue */
19002 0, /* end_epilogue */
19003 0, /* begin_function */
19004 0, /* end_function */
19005 0, /* function_decl */
19006 0, /* global_decl */
19008 0, /* imported_module_or_decl */
19009 0, /* deferred_inline_function */
19010 0, /* outlining_inline_function */
19012 0, /* handle_pch */
19013 0, /* var_location */
19014 0, /* switch_text_section */
19016 0 /* start_end_main_source_file */
19019 #endif /* DWARF2_DEBUGGING_INFO */
19021 #include "gt-dwarf2out.h"