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 #ifdef DWARF2_DEBUGGING_INFO
94 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
96 static rtx last_var_location_insn;
99 #ifdef VMS_DEBUGGING_INFO
100 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
102 /* Define this macro to be a nonzero value if the directory specifications
103 which are output in the debug info should end with a separator. */
104 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
105 /* Define this macro to evaluate to a nonzero value if GCC should refrain
106 from generating indirect strings in DWARF2 debug information, for instance
107 if your target is stuck with an old version of GDB that is unable to
108 process them properly or uses VMS Debug. */
109 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
111 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
115 #ifndef DWARF2_FRAME_INFO
116 # ifdef DWARF2_DEBUGGING_INFO
117 # define DWARF2_FRAME_INFO \
118 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
120 # define DWARF2_FRAME_INFO 0
124 /* Map register numbers held in the call frame info that gcc has
125 collected using DWARF_FRAME_REGNUM to those that should be output in
126 .debug_frame and .eh_frame. */
127 #ifndef DWARF2_FRAME_REG_OUT
128 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
131 /* Save the result of dwarf2out_do_frame across PCH. */
132 static GTY(()) bool saved_do_cfi_asm = 0;
134 /* Decide whether we want to emit frame unwind information for the current
138 dwarf2out_do_frame (void)
140 /* We want to emit correct CFA location expressions or lists, so we
141 have to return true if we're going to output debug info, even if
142 we're not going to output frame or unwind info. */
143 return (write_symbols == DWARF2_DEBUG
144 || write_symbols == VMS_AND_DWARF2_DEBUG
145 || DWARF2_FRAME_INFO || saved_do_cfi_asm
146 #ifdef DWARF2_UNWIND_INFO
147 || (DWARF2_UNWIND_INFO
148 && (flag_unwind_tables
149 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
154 /* Decide whether to emit frame unwind via assembler directives. */
157 dwarf2out_do_cfi_asm (void)
161 #ifdef MIPS_DEBUGGING_INFO
164 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
166 if (saved_do_cfi_asm)
168 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
171 /* Make sure the personality encoding is one the assembler can support.
172 In particular, aligned addresses can't be handled. */
173 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
174 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
176 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
177 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
180 saved_do_cfi_asm = true;
184 /* The size of the target's pointer type. */
186 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
189 /* Array of RTXes referenced by the debugging information, which therefore
190 must be kept around forever. */
191 static GTY(()) VEC(rtx,gc) *used_rtx_array;
193 /* A pointer to the base of a list of incomplete types which might be
194 completed at some later time. incomplete_types_list needs to be a
195 VEC(tree,gc) because we want to tell the garbage collector about
197 static GTY(()) VEC(tree,gc) *incomplete_types;
199 /* A pointer to the base of a table of references to declaration
200 scopes. This table is a display which tracks the nesting
201 of declaration scopes at the current scope and containing
202 scopes. This table is used to find the proper place to
203 define type declaration DIE's. */
204 static GTY(()) VEC(tree,gc) *decl_scope_table;
206 /* Pointers to various DWARF2 sections. */
207 static GTY(()) section *debug_info_section;
208 static GTY(()) section *debug_abbrev_section;
209 static GTY(()) section *debug_aranges_section;
210 static GTY(()) section *debug_macinfo_section;
211 static GTY(()) section *debug_line_section;
212 static GTY(()) section *debug_loc_section;
213 static GTY(()) section *debug_pubnames_section;
214 static GTY(()) section *debug_pubtypes_section;
215 static GTY(()) section *debug_str_section;
216 static GTY(()) section *debug_ranges_section;
217 static GTY(()) section *debug_frame_section;
219 /* How to start an assembler comment. */
220 #ifndef ASM_COMMENT_START
221 #define ASM_COMMENT_START ";#"
224 typedef struct dw_cfi_struct *dw_cfi_ref;
225 typedef struct dw_fde_struct *dw_fde_ref;
226 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
228 /* Call frames are described using a sequence of Call Frame
229 Information instructions. The register number, offset
230 and address fields are provided as possible operands;
231 their use is selected by the opcode field. */
233 enum dw_cfi_oprnd_type {
235 dw_cfi_oprnd_reg_num,
241 typedef union GTY(()) dw_cfi_oprnd_struct {
242 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
243 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
244 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
245 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
249 typedef struct GTY(()) dw_cfi_struct {
250 dw_cfi_ref dw_cfi_next;
251 enum dwarf_call_frame_info dw_cfi_opc;
252 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
254 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
259 /* This is how we define the location of the CFA. We use to handle it
260 as REG + OFFSET all the time, but now it can be more complex.
261 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
262 Instead of passing around REG and OFFSET, we pass a copy
263 of this structure. */
264 typedef struct GTY(()) cfa_loc {
265 HOST_WIDE_INT offset;
266 HOST_WIDE_INT base_offset;
268 BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
269 BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
272 /* All call frame descriptions (FDE's) in the GCC generated DWARF
273 refer to a single Common Information Entry (CIE), defined at
274 the beginning of the .debug_frame section. This use of a single
275 CIE obviates the need to keep track of multiple CIE's
276 in the DWARF generation routines below. */
278 typedef struct GTY(()) dw_fde_struct {
280 const char *dw_fde_begin;
281 const char *dw_fde_current_label;
282 const char *dw_fde_end;
283 const char *dw_fde_hot_section_label;
284 const char *dw_fde_hot_section_end_label;
285 const char *dw_fde_unlikely_section_label;
286 const char *dw_fde_unlikely_section_end_label;
287 dw_cfi_ref dw_fde_cfi;
288 dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections. */
289 unsigned funcdef_number;
290 HOST_WIDE_INT stack_realignment;
291 /* Dynamic realign argument pointer register. */
292 unsigned int drap_reg;
293 /* Virtual dynamic realign argument pointer register. */
294 unsigned int vdrap_reg;
295 unsigned all_throwers_are_sibcalls : 1;
296 unsigned nothrow : 1;
297 unsigned uses_eh_lsda : 1;
298 /* Whether we did stack realign in this call frame. */
299 unsigned stack_realign : 1;
300 /* Whether dynamic realign argument pointer register has been saved. */
301 unsigned drap_reg_saved: 1;
302 /* True iff dw_fde_begin label is in text_section or cold_text_section. */
303 unsigned in_std_section : 1;
304 /* True iff dw_fde_unlikely_section_label is in text_section or
305 cold_text_section. */
306 unsigned cold_in_std_section : 1;
307 /* True iff switched sections. */
308 unsigned dw_fde_switched_sections : 1;
309 /* True iff switching from cold to hot section. */
310 unsigned dw_fde_switched_cold_to_hot : 1;
314 /* Maximum size (in bytes) of an artificially generated label. */
315 #define MAX_ARTIFICIAL_LABEL_BYTES 30
317 /* The size of addresses as they appear in the Dwarf 2 data.
318 Some architectures use word addresses to refer to code locations,
319 but Dwarf 2 info always uses byte addresses. On such machines,
320 Dwarf 2 addresses need to be larger than the architecture's
322 #ifndef DWARF2_ADDR_SIZE
323 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
326 /* The size in bytes of a DWARF field indicating an offset or length
327 relative to a debug info section, specified to be 4 bytes in the
328 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
331 #ifndef DWARF_OFFSET_SIZE
332 #define DWARF_OFFSET_SIZE 4
335 /* According to the (draft) DWARF 3 specification, the initial length
336 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
337 bytes are 0xffffffff, followed by the length stored in the next 8
340 However, the SGI/MIPS ABI uses an initial length which is equal to
341 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
343 #ifndef DWARF_INITIAL_LENGTH_SIZE
344 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
347 /* Round SIZE up to the nearest BOUNDARY. */
348 #define DWARF_ROUND(SIZE,BOUNDARY) \
349 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
351 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
352 #ifndef DWARF_CIE_DATA_ALIGNMENT
353 #ifdef STACK_GROWS_DOWNWARD
354 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
356 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
360 /* CIE identifier. */
361 #if HOST_BITS_PER_WIDE_INT >= 64
362 #define DWARF_CIE_ID \
363 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
365 #define DWARF_CIE_ID DW_CIE_ID
368 /* A pointer to the base of a table that contains frame description
369 information for each routine. */
370 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
372 /* Number of elements currently allocated for fde_table. */
373 static GTY(()) unsigned fde_table_allocated;
375 /* Number of elements in fde_table currently in use. */
376 static GTY(()) unsigned fde_table_in_use;
378 /* Size (in elements) of increments by which we may expand the
380 #define FDE_TABLE_INCREMENT 256
382 /* Get the current fde_table entry we should use. */
384 static inline dw_fde_ref
387 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
390 /* A list of call frame insns for the CIE. */
391 static GTY(()) dw_cfi_ref cie_cfi_head;
393 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
394 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
395 attribute that accelerates the lookup of the FDE associated
396 with the subprogram. This variable holds the table index of the FDE
397 associated with the current function (body) definition. */
398 static unsigned current_funcdef_fde;
401 struct GTY(()) indirect_string_node {
403 unsigned int refcount;
404 enum dwarf_form form;
408 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
410 /* True if the compilation unit has location entries that reference
412 static GTY(()) bool debug_str_hash_forced = false;
414 static GTY(()) int dw2_string_counter;
415 static GTY(()) unsigned long dwarf2out_cfi_label_num;
417 /* True if the compilation unit places functions in more than one section. */
418 static GTY(()) bool have_multiple_function_sections = false;
420 /* Whether the default text and cold text sections have been used at all. */
422 static GTY(()) bool text_section_used = false;
423 static GTY(()) bool cold_text_section_used = false;
425 /* The default cold text section. */
426 static GTY(()) section *cold_text_section;
428 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
430 /* Forward declarations for functions defined in this file. */
432 static char *stripattributes (const char *);
433 static const char *dwarf_cfi_name (unsigned);
434 static dw_cfi_ref new_cfi (void);
435 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
436 static void add_fde_cfi (const char *, dw_cfi_ref);
437 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
438 static void lookup_cfa (dw_cfa_location *);
439 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
440 #ifdef DWARF2_UNWIND_INFO
441 static void initial_return_save (rtx);
443 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
445 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
446 static void output_cfi_directive (dw_cfi_ref);
447 static void output_call_frame_info (int);
448 static void dwarf2out_note_section_used (void);
449 static void dwarf2out_stack_adjust (rtx, bool);
450 static void dwarf2out_args_size_adjust (HOST_WIDE_INT, const char *);
451 static void flush_queued_reg_saves (void);
452 static bool clobbers_queued_reg_save (const_rtx);
453 static void dwarf2out_frame_debug_expr (rtx, const char *);
455 /* Support for complex CFA locations. */
456 static void output_cfa_loc (dw_cfi_ref);
457 static void output_cfa_loc_raw (dw_cfi_ref);
458 static void get_cfa_from_loc_descr (dw_cfa_location *,
459 struct dw_loc_descr_struct *);
460 static struct dw_loc_descr_struct *build_cfa_loc
461 (dw_cfa_location *, HOST_WIDE_INT);
462 static struct dw_loc_descr_struct *build_cfa_aligned_loc
463 (HOST_WIDE_INT, HOST_WIDE_INT);
464 static void def_cfa_1 (const char *, dw_cfa_location *);
466 /* How to start an assembler comment. */
467 #ifndef ASM_COMMENT_START
468 #define ASM_COMMENT_START ";#"
471 /* Data and reference forms for relocatable data. */
472 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
473 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
475 #ifndef DEBUG_FRAME_SECTION
476 #define DEBUG_FRAME_SECTION ".debug_frame"
479 #ifndef FUNC_BEGIN_LABEL
480 #define FUNC_BEGIN_LABEL "LFB"
483 #ifndef FUNC_END_LABEL
484 #define FUNC_END_LABEL "LFE"
487 #ifndef FRAME_BEGIN_LABEL
488 #define FRAME_BEGIN_LABEL "Lframe"
490 #define CIE_AFTER_SIZE_LABEL "LSCIE"
491 #define CIE_END_LABEL "LECIE"
492 #define FDE_LABEL "LSFDE"
493 #define FDE_AFTER_SIZE_LABEL "LASFDE"
494 #define FDE_END_LABEL "LEFDE"
495 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
496 #define LINE_NUMBER_END_LABEL "LELT"
497 #define LN_PROLOG_AS_LABEL "LASLTP"
498 #define LN_PROLOG_END_LABEL "LELTP"
499 #define DIE_LABEL_PREFIX "DW"
501 /* The DWARF 2 CFA column which tracks the return address. Normally this
502 is the column for PC, or the first column after all of the hard
504 #ifndef DWARF_FRAME_RETURN_COLUMN
506 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
508 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
512 /* The mapping from gcc register number to DWARF 2 CFA column number. By
513 default, we just provide columns for all registers. */
514 #ifndef DWARF_FRAME_REGNUM
515 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
518 /* Hook used by __throw. */
521 expand_builtin_dwarf_sp_column (void)
523 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
524 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
527 /* Return a pointer to a copy of the section string name S with all
528 attributes stripped off, and an asterisk prepended (for assemble_name). */
531 stripattributes (const char *s)
533 char *stripped = XNEWVEC (char, strlen (s) + 2);
538 while (*s && *s != ',')
545 /* MEM is a memory reference for the register size table, each element of
546 which has mode MODE. Initialize column C as a return address column. */
549 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
551 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
552 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
553 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
556 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
558 static inline HOST_WIDE_INT
559 div_data_align (HOST_WIDE_INT off)
561 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
562 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
566 /* Return true if we need a signed version of a given opcode
567 (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended). */
570 need_data_align_sf_opcode (HOST_WIDE_INT off)
572 return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
575 /* Generate code to initialize the register size table. */
578 expand_builtin_init_dwarf_reg_sizes (tree address)
581 enum machine_mode mode = TYPE_MODE (char_type_node);
582 rtx addr = expand_normal (address);
583 rtx mem = gen_rtx_MEM (BLKmode, addr);
584 bool wrote_return_column = false;
586 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
588 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
590 if (rnum < DWARF_FRAME_REGISTERS)
592 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
593 enum machine_mode save_mode = reg_raw_mode[i];
596 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
597 save_mode = choose_hard_reg_mode (i, 1, true);
598 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
600 if (save_mode == VOIDmode)
602 wrote_return_column = true;
604 size = GET_MODE_SIZE (save_mode);
608 emit_move_insn (adjust_address (mem, mode, offset),
609 gen_int_mode (size, mode));
613 if (!wrote_return_column)
614 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
616 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
617 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
620 targetm.init_dwarf_reg_sizes_extra (address);
623 /* Convert a DWARF call frame info. operation to its string name */
626 dwarf_cfi_name (unsigned int cfi_opc)
630 case DW_CFA_advance_loc:
631 return "DW_CFA_advance_loc";
633 return "DW_CFA_offset";
635 return "DW_CFA_restore";
639 return "DW_CFA_set_loc";
640 case DW_CFA_advance_loc1:
641 return "DW_CFA_advance_loc1";
642 case DW_CFA_advance_loc2:
643 return "DW_CFA_advance_loc2";
644 case DW_CFA_advance_loc4:
645 return "DW_CFA_advance_loc4";
646 case DW_CFA_offset_extended:
647 return "DW_CFA_offset_extended";
648 case DW_CFA_restore_extended:
649 return "DW_CFA_restore_extended";
650 case DW_CFA_undefined:
651 return "DW_CFA_undefined";
652 case DW_CFA_same_value:
653 return "DW_CFA_same_value";
654 case DW_CFA_register:
655 return "DW_CFA_register";
656 case DW_CFA_remember_state:
657 return "DW_CFA_remember_state";
658 case DW_CFA_restore_state:
659 return "DW_CFA_restore_state";
661 return "DW_CFA_def_cfa";
662 case DW_CFA_def_cfa_register:
663 return "DW_CFA_def_cfa_register";
664 case DW_CFA_def_cfa_offset:
665 return "DW_CFA_def_cfa_offset";
668 case DW_CFA_def_cfa_expression:
669 return "DW_CFA_def_cfa_expression";
670 case DW_CFA_expression:
671 return "DW_CFA_expression";
672 case DW_CFA_offset_extended_sf:
673 return "DW_CFA_offset_extended_sf";
674 case DW_CFA_def_cfa_sf:
675 return "DW_CFA_def_cfa_sf";
676 case DW_CFA_def_cfa_offset_sf:
677 return "DW_CFA_def_cfa_offset_sf";
679 /* SGI/MIPS specific */
680 case DW_CFA_MIPS_advance_loc8:
681 return "DW_CFA_MIPS_advance_loc8";
684 case DW_CFA_GNU_window_save:
685 return "DW_CFA_GNU_window_save";
686 case DW_CFA_GNU_args_size:
687 return "DW_CFA_GNU_args_size";
688 case DW_CFA_GNU_negative_offset_extended:
689 return "DW_CFA_GNU_negative_offset_extended";
692 return "DW_CFA_<unknown>";
696 /* Return a pointer to a newly allocated Call Frame Instruction. */
698 static inline dw_cfi_ref
701 dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
703 cfi->dw_cfi_next = NULL;
704 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
705 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
710 /* Add a Call Frame Instruction to list of instructions. */
713 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
716 dw_fde_ref fde = current_fde ();
718 /* When DRAP is used, CFA is defined with an expression. Redefine
719 CFA may lead to a different CFA value. */
720 /* ??? Of course, this heuristic fails when we're annotating epilogues,
721 because of course we'll always want to redefine the CFA back to the
722 stack pointer on the way out. Where should we move this check? */
723 if (0 && fde && fde->drap_reg != INVALID_REGNUM)
724 switch (cfi->dw_cfi_opc)
726 case DW_CFA_def_cfa_register:
727 case DW_CFA_def_cfa_offset:
728 case DW_CFA_def_cfa_offset_sf:
730 case DW_CFA_def_cfa_sf:
737 /* Find the end of the chain. */
738 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
744 /* Generate a new label for the CFI info to refer to. FORCE is true
745 if a label needs to be output even when using .cfi_* directives. */
748 dwarf2out_cfi_label (bool force)
750 static char label[20];
752 if (!force && dwarf2out_do_cfi_asm ())
754 /* In this case, we will be emitting the asm directive instead of
755 the label, so just return a placeholder to keep the rest of the
757 strcpy (label, "<do not output>");
761 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
762 ASM_OUTPUT_LABEL (asm_out_file, label);
768 /* True if remember_state should be emitted before following CFI directive. */
769 static bool emit_cfa_remember;
771 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
772 or to the CIE if LABEL is NULL. */
775 add_fde_cfi (const char *label, dw_cfi_ref cfi)
777 dw_cfi_ref *list_head;
779 if (emit_cfa_remember)
781 dw_cfi_ref cfi_remember;
783 /* Emit the state save. */
784 emit_cfa_remember = false;
785 cfi_remember = new_cfi ();
786 cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
787 add_fde_cfi (label, cfi_remember);
790 list_head = &cie_cfi_head;
792 if (dwarf2out_do_cfi_asm ())
796 dw_fde_ref fde = current_fde ();
798 gcc_assert (fde != NULL);
800 /* We still have to add the cfi to the list so that lookup_cfa
801 works later on. When -g2 and above we even need to force
802 emitting of CFI labels and add to list a DW_CFA_set_loc for
803 convert_cfa_to_fb_loc_list purposes. If we're generating
804 DWARF3 output we use DW_OP_call_frame_cfa and so don't use
805 convert_cfa_to_fb_loc_list. */
806 if (dwarf_version == 2
807 && debug_info_level > DINFO_LEVEL_TERSE
808 && (write_symbols == DWARF2_DEBUG
809 || write_symbols == VMS_AND_DWARF2_DEBUG))
811 switch (cfi->dw_cfi_opc)
813 case DW_CFA_def_cfa_offset:
814 case DW_CFA_def_cfa_offset_sf:
815 case DW_CFA_def_cfa_register:
817 case DW_CFA_def_cfa_sf:
818 case DW_CFA_def_cfa_expression:
819 case DW_CFA_restore_state:
820 if (*label == 0 || strcmp (label, "<do not output>") == 0)
821 label = dwarf2out_cfi_label (true);
823 if (fde->dw_fde_current_label == NULL
824 || strcmp (label, fde->dw_fde_current_label) != 0)
828 label = xstrdup (label);
830 /* Set the location counter to the new label. */
832 /* It doesn't metter whether DW_CFA_set_loc
833 or DW_CFA_advance_loc4 is added here, those aren't
834 emitted into assembly, only looked up by
835 convert_cfa_to_fb_loc_list. */
836 xcfi->dw_cfi_opc = DW_CFA_set_loc;
837 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
838 add_cfi (&fde->dw_fde_cfi, xcfi);
839 fde->dw_fde_current_label = label;
847 output_cfi_directive (cfi);
849 list_head = &fde->dw_fde_cfi;
851 /* ??? If this is a CFI for the CIE, we don't emit. This
852 assumes that the standard CIE contents that the assembler
853 uses matches the standard CIE contents that the compiler
854 uses. This is probably a bad assumption. I'm not quite
855 sure how to address this for now. */
859 dw_fde_ref fde = current_fde ();
861 gcc_assert (fde != NULL);
864 label = dwarf2out_cfi_label (false);
866 if (fde->dw_fde_current_label == NULL
867 || strcmp (label, fde->dw_fde_current_label) != 0)
871 label = xstrdup (label);
873 /* Set the location counter to the new label. */
875 /* If we have a current label, advance from there, otherwise
876 set the location directly using set_loc. */
877 xcfi->dw_cfi_opc = fde->dw_fde_current_label
878 ? DW_CFA_advance_loc4
880 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
881 add_cfi (&fde->dw_fde_cfi, xcfi);
883 fde->dw_fde_current_label = label;
886 list_head = &fde->dw_fde_cfi;
889 add_cfi (list_head, cfi);
892 /* Subroutine of lookup_cfa. */
895 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
897 switch (cfi->dw_cfi_opc)
899 case DW_CFA_def_cfa_offset:
900 case DW_CFA_def_cfa_offset_sf:
901 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
903 case DW_CFA_def_cfa_register:
904 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
907 case DW_CFA_def_cfa_sf:
908 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
909 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
911 case DW_CFA_def_cfa_expression:
912 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
915 case DW_CFA_remember_state:
916 gcc_assert (!remember->in_use);
918 remember->in_use = 1;
920 case DW_CFA_restore_state:
921 gcc_assert (remember->in_use);
923 remember->in_use = 0;
931 /* Find the previous value for the CFA. */
934 lookup_cfa (dw_cfa_location *loc)
938 dw_cfa_location remember;
940 memset (loc, 0, sizeof (*loc));
941 loc->reg = INVALID_REGNUM;
944 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
945 lookup_cfa_1 (cfi, loc, &remember);
947 fde = current_fde ();
949 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
950 lookup_cfa_1 (cfi, loc, &remember);
953 /* The current rule for calculating the DWARF2 canonical frame address. */
954 static dw_cfa_location cfa;
956 /* The register used for saving registers to the stack, and its offset
958 static dw_cfa_location cfa_store;
960 /* The current save location around an epilogue. */
961 static dw_cfa_location cfa_remember;
963 /* The running total of the size of arguments pushed onto the stack. */
964 static HOST_WIDE_INT args_size;
966 /* The last args_size we actually output. */
967 static HOST_WIDE_INT old_args_size;
969 /* Entry point to update the canonical frame address (CFA).
970 LABEL is passed to add_fde_cfi. The value of CFA is now to be
971 calculated from REG+OFFSET. */
974 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
981 def_cfa_1 (label, &loc);
984 /* Determine if two dw_cfa_location structures define the same data. */
987 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
989 return (loc1->reg == loc2->reg
990 && loc1->offset == loc2->offset
991 && loc1->indirect == loc2->indirect
992 && (loc1->indirect == 0
993 || loc1->base_offset == loc2->base_offset));
996 /* This routine does the actual work. The CFA is now calculated from
997 the dw_cfa_location structure. */
1000 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1003 dw_cfa_location old_cfa, loc;
1008 if (cfa_store.reg == loc.reg && loc.indirect == 0)
1009 cfa_store.offset = loc.offset;
1011 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1012 lookup_cfa (&old_cfa);
1014 /* If nothing changed, no need to issue any call frame instructions. */
1015 if (cfa_equal_p (&loc, &old_cfa))
1020 if (loc.reg == old_cfa.reg && !loc.indirect)
1022 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1023 the CFA register did not change but the offset did. The data
1024 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1025 in the assembler via the .cfi_def_cfa_offset directive. */
1027 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1029 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1030 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1033 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
1034 else if (loc.offset == old_cfa.offset
1035 && old_cfa.reg != INVALID_REGNUM
1038 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1039 indicating the CFA register has changed to <register> but the
1040 offset has not changed. */
1041 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1042 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1046 else if (loc.indirect == 0)
1048 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1049 indicating the CFA register has changed to <register> with
1050 the specified offset. The data factoring for DW_CFA_def_cfa_sf
1051 happens in output_cfi, or in the assembler via the .cfi_def_cfa
1054 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1056 cfi->dw_cfi_opc = DW_CFA_def_cfa;
1057 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1058 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1062 /* Construct a DW_CFA_def_cfa_expression instruction to
1063 calculate the CFA using a full location expression since no
1064 register-offset pair is available. */
1065 struct dw_loc_descr_struct *loc_list;
1067 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1068 loc_list = build_cfa_loc (&loc, 0);
1069 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1072 add_fde_cfi (label, cfi);
1075 /* Add the CFI for saving a register. REG is the CFA column number.
1076 LABEL is passed to add_fde_cfi.
1077 If SREG is -1, the register is saved at OFFSET from the CFA;
1078 otherwise it is saved in SREG. */
1081 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1083 dw_cfi_ref cfi = new_cfi ();
1084 dw_fde_ref fde = current_fde ();
1086 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1088 /* When stack is aligned, store REG using DW_CFA_expression with
1091 && fde->stack_realign
1092 && sreg == INVALID_REGNUM)
1094 cfi->dw_cfi_opc = DW_CFA_expression;
1095 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = reg;
1096 cfi->dw_cfi_oprnd1.dw_cfi_loc
1097 = build_cfa_aligned_loc (offset, fde->stack_realignment);
1099 else if (sreg == INVALID_REGNUM)
1101 if (need_data_align_sf_opcode (offset))
1102 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1103 else if (reg & ~0x3f)
1104 cfi->dw_cfi_opc = DW_CFA_offset_extended;
1106 cfi->dw_cfi_opc = DW_CFA_offset;
1107 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1109 else if (sreg == reg)
1110 cfi->dw_cfi_opc = DW_CFA_same_value;
1113 cfi->dw_cfi_opc = DW_CFA_register;
1114 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1117 add_fde_cfi (label, cfi);
1120 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1121 This CFI tells the unwinder that it needs to restore the window registers
1122 from the previous frame's window save area.
1124 ??? Perhaps we should note in the CIE where windows are saved (instead of
1125 assuming 0(cfa)) and what registers are in the window. */
1128 dwarf2out_window_save (const char *label)
1130 dw_cfi_ref cfi = new_cfi ();
1132 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1133 add_fde_cfi (label, cfi);
1136 /* Add a CFI to update the running total of the size of arguments
1137 pushed onto the stack. */
1140 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1144 if (size == old_args_size)
1147 old_args_size = size;
1150 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1151 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1152 add_fde_cfi (label, cfi);
1155 /* Entry point for saving a register to the stack. REG is the GCC register
1156 number. LABEL and OFFSET are passed to reg_save. */
1159 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1161 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1164 /* Entry point for saving the return address in the stack.
1165 LABEL and OFFSET are passed to reg_save. */
1168 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1170 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1173 /* Entry point for saving the return address in a register.
1174 LABEL and SREG are passed to reg_save. */
1177 dwarf2out_return_reg (const char *label, unsigned int sreg)
1179 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1182 #ifdef DWARF2_UNWIND_INFO
1183 /* Record the initial position of the return address. RTL is
1184 INCOMING_RETURN_ADDR_RTX. */
1187 initial_return_save (rtx rtl)
1189 unsigned int reg = INVALID_REGNUM;
1190 HOST_WIDE_INT offset = 0;
1192 switch (GET_CODE (rtl))
1195 /* RA is in a register. */
1196 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1200 /* RA is on the stack. */
1201 rtl = XEXP (rtl, 0);
1202 switch (GET_CODE (rtl))
1205 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1210 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1211 offset = INTVAL (XEXP (rtl, 1));
1215 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1216 offset = -INTVAL (XEXP (rtl, 1));
1226 /* The return address is at some offset from any value we can
1227 actually load. For instance, on the SPARC it is in %i7+8. Just
1228 ignore the offset for now; it doesn't matter for unwinding frames. */
1229 gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1230 initial_return_save (XEXP (rtl, 0));
1237 if (reg != DWARF_FRAME_RETURN_COLUMN)
1238 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1242 /* Given a SET, calculate the amount of stack adjustment it
1245 static HOST_WIDE_INT
1246 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1247 HOST_WIDE_INT cur_offset)
1249 const_rtx src = SET_SRC (pattern);
1250 const_rtx dest = SET_DEST (pattern);
1251 HOST_WIDE_INT offset = 0;
1254 if (dest == stack_pointer_rtx)
1256 code = GET_CODE (src);
1258 /* Assume (set (reg sp) (reg whatever)) sets args_size
1260 if (code == REG && src != stack_pointer_rtx)
1262 offset = -cur_args_size;
1263 #ifndef STACK_GROWS_DOWNWARD
1266 return offset - cur_offset;
1269 if (! (code == PLUS || code == MINUS)
1270 || XEXP (src, 0) != stack_pointer_rtx
1271 || !CONST_INT_P (XEXP (src, 1)))
1274 /* (set (reg sp) (plus (reg sp) (const_int))) */
1275 offset = INTVAL (XEXP (src, 1));
1281 if (MEM_P (src) && !MEM_P (dest))
1285 /* (set (mem (pre_dec (reg sp))) (foo)) */
1286 src = XEXP (dest, 0);
1287 code = GET_CODE (src);
1293 if (XEXP (src, 0) == stack_pointer_rtx)
1295 rtx val = XEXP (XEXP (src, 1), 1);
1296 /* We handle only adjustments by constant amount. */
1297 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1298 && CONST_INT_P (val));
1299 offset = -INTVAL (val);
1306 if (XEXP (src, 0) == stack_pointer_rtx)
1308 offset = GET_MODE_SIZE (GET_MODE (dest));
1315 if (XEXP (src, 0) == stack_pointer_rtx)
1317 offset = -GET_MODE_SIZE (GET_MODE (dest));
1332 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1333 indexed by INSN_UID. */
1335 static HOST_WIDE_INT *barrier_args_size;
1337 /* Helper function for compute_barrier_args_size. Handle one insn. */
1339 static HOST_WIDE_INT
1340 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1341 VEC (rtx, heap) **next)
1343 HOST_WIDE_INT offset = 0;
1346 if (! RTX_FRAME_RELATED_P (insn))
1348 if (prologue_epilogue_contains (insn))
1350 else if (GET_CODE (PATTERN (insn)) == SET)
1351 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1352 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1353 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1355 /* There may be stack adjustments inside compound insns. Search
1357 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1358 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1359 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1360 cur_args_size, offset);
1365 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1369 expr = XEXP (expr, 0);
1370 if (GET_CODE (expr) == PARALLEL
1371 || GET_CODE (expr) == SEQUENCE)
1372 for (i = 1; i < XVECLEN (expr, 0); i++)
1374 rtx elem = XVECEXP (expr, 0, i);
1376 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1377 offset += stack_adjust_offset (elem, cur_args_size, offset);
1382 #ifndef STACK_GROWS_DOWNWARD
1386 cur_args_size += offset;
1387 if (cur_args_size < 0)
1392 rtx dest = JUMP_LABEL (insn);
1396 if (barrier_args_size [INSN_UID (dest)] < 0)
1398 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1399 VEC_safe_push (rtx, heap, *next, dest);
1404 return cur_args_size;
1407 /* Walk the whole function and compute args_size on BARRIERs. */
1410 compute_barrier_args_size (void)
1412 int max_uid = get_max_uid (), i;
1414 VEC (rtx, heap) *worklist, *next, *tmp;
1416 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1417 for (i = 0; i < max_uid; i++)
1418 barrier_args_size[i] = -1;
1420 worklist = VEC_alloc (rtx, heap, 20);
1421 next = VEC_alloc (rtx, heap, 20);
1422 insn = get_insns ();
1423 barrier_args_size[INSN_UID (insn)] = 0;
1424 VEC_quick_push (rtx, worklist, insn);
1427 while (!VEC_empty (rtx, worklist))
1429 rtx prev, body, first_insn;
1430 HOST_WIDE_INT cur_args_size;
1432 first_insn = insn = VEC_pop (rtx, worklist);
1433 cur_args_size = barrier_args_size[INSN_UID (insn)];
1434 prev = prev_nonnote_insn (insn);
1435 if (prev && BARRIER_P (prev))
1436 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1438 for (; insn; insn = NEXT_INSN (insn))
1440 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1442 if (BARRIER_P (insn))
1447 if (insn == first_insn)
1449 else if (barrier_args_size[INSN_UID (insn)] < 0)
1451 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1456 /* The insns starting with this label have been
1457 already scanned or are in the worklist. */
1462 body = PATTERN (insn);
1463 if (GET_CODE (body) == SEQUENCE)
1465 HOST_WIDE_INT dest_args_size = cur_args_size;
1466 for (i = 1; i < XVECLEN (body, 0); i++)
1467 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1468 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1470 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1471 dest_args_size, &next);
1474 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1475 cur_args_size, &next);
1477 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1478 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1479 dest_args_size, &next);
1482 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1483 cur_args_size, &next);
1487 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1491 if (VEC_empty (rtx, next))
1494 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1498 VEC_truncate (rtx, next, 0);
1501 VEC_free (rtx, heap, worklist);
1502 VEC_free (rtx, heap, next);
1506 /* Check INSN to see if it looks like a push or a stack adjustment, and
1507 make a note of it if it does. EH uses this information to find out how
1508 much extra space it needs to pop off the stack. */
1511 dwarf2out_stack_adjust (rtx insn, bool after_p)
1513 HOST_WIDE_INT offset;
1517 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1518 with this function. Proper support would require all frame-related
1519 insns to be marked, and to be able to handle saving state around
1520 epilogues textually in the middle of the function. */
1521 if (prologue_epilogue_contains (insn))
1524 /* If INSN is an instruction from target of an annulled branch, the
1525 effects are for the target only and so current argument size
1526 shouldn't change at all. */
1528 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1529 && INSN_FROM_TARGET_P (insn))
1532 /* If only calls can throw, and we have a frame pointer,
1533 save up adjustments until we see the CALL_INSN. */
1534 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1536 if (CALL_P (insn) && !after_p)
1538 /* Extract the size of the args from the CALL rtx itself. */
1539 insn = PATTERN (insn);
1540 if (GET_CODE (insn) == PARALLEL)
1541 insn = XVECEXP (insn, 0, 0);
1542 if (GET_CODE (insn) == SET)
1543 insn = SET_SRC (insn);
1544 gcc_assert (GET_CODE (insn) == CALL);
1545 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1550 if (CALL_P (insn) && !after_p)
1552 if (!flag_asynchronous_unwind_tables)
1553 dwarf2out_args_size ("", args_size);
1556 else if (BARRIER_P (insn))
1558 /* Don't call compute_barrier_args_size () if the only
1559 BARRIER is at the end of function. */
1560 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1561 compute_barrier_args_size ();
1562 if (barrier_args_size == NULL)
1566 offset = barrier_args_size[INSN_UID (insn)];
1571 offset -= args_size;
1572 #ifndef STACK_GROWS_DOWNWARD
1576 else if (GET_CODE (PATTERN (insn)) == SET)
1577 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1578 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1579 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1581 /* There may be stack adjustments inside compound insns. Search
1583 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1584 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1585 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1594 label = dwarf2out_cfi_label (false);
1595 dwarf2out_args_size_adjust (offset, label);
1598 /* Adjust args_size based on stack adjustment OFFSET. */
1601 dwarf2out_args_size_adjust (HOST_WIDE_INT offset, const char *label)
1603 if (cfa.reg == STACK_POINTER_REGNUM)
1604 cfa.offset += offset;
1606 if (cfa_store.reg == STACK_POINTER_REGNUM)
1607 cfa_store.offset += offset;
1609 #ifndef STACK_GROWS_DOWNWARD
1613 args_size += offset;
1617 def_cfa_1 (label, &cfa);
1618 if (flag_asynchronous_unwind_tables)
1619 dwarf2out_args_size (label, args_size);
1624 /* We delay emitting a register save until either (a) we reach the end
1625 of the prologue or (b) the register is clobbered. This clusters
1626 register saves so that there are fewer pc advances. */
1628 struct GTY(()) queued_reg_save {
1629 struct queued_reg_save *next;
1631 HOST_WIDE_INT cfa_offset;
1635 static GTY(()) struct queued_reg_save *queued_reg_saves;
1637 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1638 struct GTY(()) reg_saved_in_data {
1643 /* A list of registers saved in other registers.
1644 The list intentionally has a small maximum capacity of 4; if your
1645 port needs more than that, you might consider implementing a
1646 more efficient data structure. */
1647 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1648 static GTY(()) size_t num_regs_saved_in_regs;
1650 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1651 static const char *last_reg_save_label;
1653 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1654 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1657 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1659 struct queued_reg_save *q;
1661 /* Duplicates waste space, but it's also necessary to remove them
1662 for correctness, since the queue gets output in reverse
1664 for (q = queued_reg_saves; q != NULL; q = q->next)
1665 if (REGNO (q->reg) == REGNO (reg))
1670 q = GGC_NEW (struct queued_reg_save);
1671 q->next = queued_reg_saves;
1672 queued_reg_saves = q;
1676 q->cfa_offset = offset;
1677 q->saved_reg = sreg;
1679 last_reg_save_label = label;
1682 /* Output all the entries in QUEUED_REG_SAVES. */
1685 flush_queued_reg_saves (void)
1687 struct queued_reg_save *q;
1689 for (q = queued_reg_saves; q; q = q->next)
1692 unsigned int reg, sreg;
1694 for (i = 0; i < num_regs_saved_in_regs; i++)
1695 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1697 if (q->saved_reg && i == num_regs_saved_in_regs)
1699 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1700 num_regs_saved_in_regs++;
1702 if (i != num_regs_saved_in_regs)
1704 regs_saved_in_regs[i].orig_reg = q->reg;
1705 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1708 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1710 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1712 sreg = INVALID_REGNUM;
1713 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1716 queued_reg_saves = NULL;
1717 last_reg_save_label = NULL;
1720 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1721 location for? Or, does it clobber a register which we've previously
1722 said that some other register is saved in, and for which we now
1723 have a new location for? */
1726 clobbers_queued_reg_save (const_rtx insn)
1728 struct queued_reg_save *q;
1730 for (q = queued_reg_saves; q; q = q->next)
1733 if (modified_in_p (q->reg, insn))
1735 for (i = 0; i < num_regs_saved_in_regs; i++)
1736 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1737 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1744 /* Entry point for saving the first register into the second. */
1747 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1750 unsigned int regno, sregno;
1752 for (i = 0; i < num_regs_saved_in_regs; i++)
1753 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1755 if (i == num_regs_saved_in_regs)
1757 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1758 num_regs_saved_in_regs++;
1760 regs_saved_in_regs[i].orig_reg = reg;
1761 regs_saved_in_regs[i].saved_in_reg = sreg;
1763 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1764 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1765 reg_save (label, regno, sregno, 0);
1768 /* What register, if any, is currently saved in REG? */
1771 reg_saved_in (rtx reg)
1773 unsigned int regn = REGNO (reg);
1775 struct queued_reg_save *q;
1777 for (q = queued_reg_saves; q; q = q->next)
1778 if (q->saved_reg && regn == REGNO (q->saved_reg))
1781 for (i = 0; i < num_regs_saved_in_regs; i++)
1782 if (regs_saved_in_regs[i].saved_in_reg
1783 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1784 return regs_saved_in_regs[i].orig_reg;
1790 /* A temporary register holding an integral value used in adjusting SP
1791 or setting up the store_reg. The "offset" field holds the integer
1792 value, not an offset. */
1793 static dw_cfa_location cfa_temp;
1795 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1798 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1800 memset (&cfa, 0, sizeof (cfa));
1802 switch (GET_CODE (pat))
1805 cfa.reg = REGNO (XEXP (pat, 0));
1806 cfa.offset = INTVAL (XEXP (pat, 1));
1810 cfa.reg = REGNO (pat);
1814 /* Recurse and define an expression. */
1818 def_cfa_1 (label, &cfa);
1821 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1824 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1828 gcc_assert (GET_CODE (pat) == SET);
1829 dest = XEXP (pat, 0);
1830 src = XEXP (pat, 1);
1832 switch (GET_CODE (src))
1835 gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1836 cfa.offset -= INTVAL (XEXP (src, 1));
1846 cfa.reg = REGNO (dest);
1847 gcc_assert (cfa.indirect == 0);
1849 def_cfa_1 (label, &cfa);
1852 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1855 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1857 HOST_WIDE_INT offset;
1858 rtx src, addr, span;
1860 src = XEXP (set, 1);
1861 addr = XEXP (set, 0);
1862 gcc_assert (MEM_P (addr));
1863 addr = XEXP (addr, 0);
1865 /* As documented, only consider extremely simple addresses. */
1866 switch (GET_CODE (addr))
1869 gcc_assert (REGNO (addr) == cfa.reg);
1870 offset = -cfa.offset;
1873 gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1874 offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1880 span = targetm.dwarf_register_span (src);
1882 /* ??? We'd like to use queue_reg_save, but we need to come up with
1883 a different flushing heuristic for epilogues. */
1885 reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1888 /* We have a PARALLEL describing where the contents of SRC live.
1889 Queue register saves for each piece of the PARALLEL. */
1892 HOST_WIDE_INT span_offset = offset;
1894 gcc_assert (GET_CODE (span) == PARALLEL);
1896 limit = XVECLEN (span, 0);
1897 for (par_index = 0; par_index < limit; par_index++)
1899 rtx elem = XVECEXP (span, 0, par_index);
1901 reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1902 INVALID_REGNUM, span_offset);
1903 span_offset += GET_MODE_SIZE (GET_MODE (elem));
1908 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
1911 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1914 unsigned sregno, dregno;
1916 src = XEXP (set, 1);
1917 dest = XEXP (set, 0);
1920 sregno = DWARF_FRAME_RETURN_COLUMN;
1922 sregno = DWARF_FRAME_REGNUM (REGNO (src));
1924 dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1926 /* ??? We'd like to use queue_reg_save, but we need to come up with
1927 a different flushing heuristic for epilogues. */
1928 reg_save (label, sregno, dregno, 0);
1931 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
1934 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
1936 dw_cfi_ref cfi = new_cfi ();
1937 unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
1939 cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
1940 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
1942 add_fde_cfi (label, cfi);
1945 /* Record call frame debugging information for an expression EXPR,
1946 which either sets SP or FP (adjusting how we calculate the frame
1947 address) or saves a register to the stack or another register.
1948 LABEL indicates the address of EXPR.
1950 This function encodes a state machine mapping rtxes to actions on
1951 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1952 users need not read the source code.
1954 The High-Level Picture
1956 Changes in the register we use to calculate the CFA: Currently we
1957 assume that if you copy the CFA register into another register, we
1958 should take the other one as the new CFA register; this seems to
1959 work pretty well. If it's wrong for some target, it's simple
1960 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1962 Changes in the register we use for saving registers to the stack:
1963 This is usually SP, but not always. Again, we deduce that if you
1964 copy SP into another register (and SP is not the CFA register),
1965 then the new register is the one we will be using for register
1966 saves. This also seems to work.
1968 Register saves: There's not much guesswork about this one; if
1969 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1970 register save, and the register used to calculate the destination
1971 had better be the one we think we're using for this purpose.
1972 It's also assumed that a copy from a call-saved register to another
1973 register is saving that register if RTX_FRAME_RELATED_P is set on
1974 that instruction. If the copy is from a call-saved register to
1975 the *same* register, that means that the register is now the same
1976 value as in the caller.
1978 Except: If the register being saved is the CFA register, and the
1979 offset is nonzero, we are saving the CFA, so we assume we have to
1980 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1981 the intent is to save the value of SP from the previous frame.
1983 In addition, if a register has previously been saved to a different
1986 Invariants / Summaries of Rules
1988 cfa current rule for calculating the CFA. It usually
1989 consists of a register and an offset.
1990 cfa_store register used by prologue code to save things to the stack
1991 cfa_store.offset is the offset from the value of
1992 cfa_store.reg to the actual CFA
1993 cfa_temp register holding an integral value. cfa_temp.offset
1994 stores the value, which will be used to adjust the
1995 stack pointer. cfa_temp is also used like cfa_store,
1996 to track stores to the stack via fp or a temp reg.
1998 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1999 with cfa.reg as the first operand changes the cfa.reg and its
2000 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
2003 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
2004 expression yielding a constant. This sets cfa_temp.reg
2005 and cfa_temp.offset.
2007 Rule 5: Create a new register cfa_store used to save items to the
2010 Rules 10-14: Save a register to the stack. Define offset as the
2011 difference of the original location and cfa_store's
2012 location (or cfa_temp's location if cfa_temp is used).
2014 Rules 16-20: If AND operation happens on sp in prologue, we assume
2015 stack is realigned. We will use a group of DW_OP_XXX
2016 expressions to represent the location of the stored
2017 register instead of CFA+offset.
2021 "{a,b}" indicates a choice of a xor b.
2022 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2025 (set <reg1> <reg2>:cfa.reg)
2026 effects: cfa.reg = <reg1>
2027 cfa.offset unchanged
2028 cfa_temp.reg = <reg1>
2029 cfa_temp.offset = cfa.offset
2032 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2033 {<const_int>,<reg>:cfa_temp.reg}))
2034 effects: cfa.reg = sp if fp used
2035 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2036 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2037 if cfa_store.reg==sp
2040 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2041 effects: cfa.reg = fp
2042 cfa_offset += +/- <const_int>
2045 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2046 constraints: <reg1> != fp
2048 effects: cfa.reg = <reg1>
2049 cfa_temp.reg = <reg1>
2050 cfa_temp.offset = cfa.offset
2053 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2054 constraints: <reg1> != fp
2056 effects: cfa_store.reg = <reg1>
2057 cfa_store.offset = cfa.offset - cfa_temp.offset
2060 (set <reg> <const_int>)
2061 effects: cfa_temp.reg = <reg>
2062 cfa_temp.offset = <const_int>
2065 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2066 effects: cfa_temp.reg = <reg1>
2067 cfa_temp.offset |= <const_int>
2070 (set <reg> (high <exp>))
2074 (set <reg> (lo_sum <exp> <const_int>))
2075 effects: cfa_temp.reg = <reg>
2076 cfa_temp.offset = <const_int>
2079 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2080 effects: cfa_store.offset -= <const_int>
2081 cfa.offset = cfa_store.offset if cfa.reg == sp
2083 cfa.base_offset = -cfa_store.offset
2086 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2087 effects: cfa_store.offset += -/+ mode_size(mem)
2088 cfa.offset = cfa_store.offset if cfa.reg == sp
2090 cfa.base_offset = -cfa_store.offset
2093 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2096 effects: cfa.reg = <reg1>
2097 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2100 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2101 effects: cfa.reg = <reg1>
2102 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2105 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2106 effects: cfa.reg = <reg1>
2107 cfa.base_offset = -cfa_temp.offset
2108 cfa_temp.offset -= mode_size(mem)
2111 (set <reg> {unspec, unspec_volatile})
2112 effects: target-dependent
2115 (set sp (and: sp <const_int>))
2116 constraints: cfa_store.reg == sp
2117 effects: current_fde.stack_realign = 1
2118 cfa_store.offset = 0
2119 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2122 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2123 effects: cfa_store.offset += -/+ mode_size(mem)
2126 (set (mem ({pre_inc, pre_dec} sp)) fp)
2127 constraints: fde->stack_realign == 1
2128 effects: cfa_store.offset = 0
2129 cfa.reg != HARD_FRAME_POINTER_REGNUM
2132 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2133 constraints: fde->stack_realign == 1
2135 && cfa.indirect == 0
2136 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2137 effects: Use DW_CFA_def_cfa_expression to define cfa
2138 cfa.reg == fde->drap_reg
2141 (set reg fde->drap_reg)
2142 constraints: fde->vdrap_reg == INVALID_REGNUM
2143 effects: fde->vdrap_reg = reg.
2144 (set mem fde->drap_reg)
2145 constraints: fde->drap_reg_saved == 1
2149 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2151 rtx src, dest, span;
2152 HOST_WIDE_INT offset;
2155 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2156 the PARALLEL independently. The first element is always processed if
2157 it is a SET. This is for backward compatibility. Other elements
2158 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2159 flag is set in them. */
2160 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2163 int limit = XVECLEN (expr, 0);
2166 /* PARALLELs have strict read-modify-write semantics, so we
2167 ought to evaluate every rvalue before changing any lvalue.
2168 It's cumbersome to do that in general, but there's an
2169 easy approximation that is enough for all current users:
2170 handle register saves before register assignments. */
2171 if (GET_CODE (expr) == PARALLEL)
2172 for (par_index = 0; par_index < limit; par_index++)
2174 elem = XVECEXP (expr, 0, par_index);
2175 if (GET_CODE (elem) == SET
2176 && MEM_P (SET_DEST (elem))
2177 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2178 dwarf2out_frame_debug_expr (elem, label);
2181 for (par_index = 0; par_index < limit; par_index++)
2183 elem = XVECEXP (expr, 0, par_index);
2184 if (GET_CODE (elem) == SET
2185 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2186 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2187 dwarf2out_frame_debug_expr (elem, label);
2188 else if (GET_CODE (elem) == SET
2190 && !RTX_FRAME_RELATED_P (elem))
2192 /* Stack adjustment combining might combine some post-prologue
2193 stack adjustment into a prologue stack adjustment. */
2194 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2197 dwarf2out_args_size_adjust (offset, label);
2203 gcc_assert (GET_CODE (expr) == SET);
2205 src = SET_SRC (expr);
2206 dest = SET_DEST (expr);
2210 rtx rsi = reg_saved_in (src);
2215 fde = current_fde ();
2219 && fde->drap_reg == REGNO (src)
2220 && (fde->drap_reg_saved
2224 /* If we are saving dynamic realign argument pointer to a
2225 register, the destination is virtual dynamic realign
2226 argument pointer. It may be used to access argument. */
2229 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2230 fde->vdrap_reg = REGNO (dest);
2235 switch (GET_CODE (dest))
2238 switch (GET_CODE (src))
2240 /* Setting FP from SP. */
2242 if (cfa.reg == (unsigned) REGNO (src))
2245 /* Update the CFA rule wrt SP or FP. Make sure src is
2246 relative to the current CFA register.
2248 We used to require that dest be either SP or FP, but the
2249 ARM copies SP to a temporary register, and from there to
2250 FP. So we just rely on the backends to only set
2251 RTX_FRAME_RELATED_P on appropriate insns. */
2252 cfa.reg = REGNO (dest);
2253 cfa_temp.reg = cfa.reg;
2254 cfa_temp.offset = cfa.offset;
2258 /* Saving a register in a register. */
2259 gcc_assert (!fixed_regs [REGNO (dest)]
2260 /* For the SPARC and its register window. */
2261 || (DWARF_FRAME_REGNUM (REGNO (src))
2262 == DWARF_FRAME_RETURN_COLUMN));
2264 /* After stack is aligned, we can only save SP in FP
2265 if drap register is used. In this case, we have
2266 to restore stack pointer with the CFA value and we
2267 don't generate this DWARF information. */
2269 && fde->stack_realign
2270 && REGNO (src) == STACK_POINTER_REGNUM)
2271 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2272 && fde->drap_reg != INVALID_REGNUM
2273 && cfa.reg != REGNO (src));
2275 queue_reg_save (label, src, dest, 0);
2282 if (dest == stack_pointer_rtx)
2286 switch (GET_CODE (XEXP (src, 1)))
2289 offset = INTVAL (XEXP (src, 1));
2292 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2294 offset = cfa_temp.offset;
2300 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2302 /* Restoring SP from FP in the epilogue. */
2303 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2304 cfa.reg = STACK_POINTER_REGNUM;
2306 else if (GET_CODE (src) == LO_SUM)
2307 /* Assume we've set the source reg of the LO_SUM from sp. */
2310 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2312 if (GET_CODE (src) != MINUS)
2314 if (cfa.reg == STACK_POINTER_REGNUM)
2315 cfa.offset += offset;
2316 if (cfa_store.reg == STACK_POINTER_REGNUM)
2317 cfa_store.offset += offset;
2319 else if (dest == hard_frame_pointer_rtx)
2322 /* Either setting the FP from an offset of the SP,
2323 or adjusting the FP */
2324 gcc_assert (frame_pointer_needed);
2326 gcc_assert (REG_P (XEXP (src, 0))
2327 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2328 && CONST_INT_P (XEXP (src, 1)));
2329 offset = INTVAL (XEXP (src, 1));
2330 if (GET_CODE (src) != MINUS)
2332 cfa.offset += offset;
2333 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2337 gcc_assert (GET_CODE (src) != MINUS);
2340 if (REG_P (XEXP (src, 0))
2341 && REGNO (XEXP (src, 0)) == cfa.reg
2342 && CONST_INT_P (XEXP (src, 1)))
2344 /* Setting a temporary CFA register that will be copied
2345 into the FP later on. */
2346 offset = - INTVAL (XEXP (src, 1));
2347 cfa.offset += offset;
2348 cfa.reg = REGNO (dest);
2349 /* Or used to save regs to the stack. */
2350 cfa_temp.reg = cfa.reg;
2351 cfa_temp.offset = cfa.offset;
2355 else if (REG_P (XEXP (src, 0))
2356 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2357 && XEXP (src, 1) == stack_pointer_rtx)
2359 /* Setting a scratch register that we will use instead
2360 of SP for saving registers to the stack. */
2361 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2362 cfa_store.reg = REGNO (dest);
2363 cfa_store.offset = cfa.offset - cfa_temp.offset;
2367 else if (GET_CODE (src) == LO_SUM
2368 && CONST_INT_P (XEXP (src, 1)))
2370 cfa_temp.reg = REGNO (dest);
2371 cfa_temp.offset = INTVAL (XEXP (src, 1));
2380 cfa_temp.reg = REGNO (dest);
2381 cfa_temp.offset = INTVAL (src);
2386 gcc_assert (REG_P (XEXP (src, 0))
2387 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2388 && CONST_INT_P (XEXP (src, 1)));
2390 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2391 cfa_temp.reg = REGNO (dest);
2392 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2395 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2396 which will fill in all of the bits. */
2403 case UNSPEC_VOLATILE:
2404 gcc_assert (targetm.dwarf_handle_frame_unspec);
2405 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2410 /* If this AND operation happens on stack pointer in prologue,
2411 we assume the stack is realigned and we extract the
2413 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2415 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2416 fde->stack_realign = 1;
2417 fde->stack_realignment = INTVAL (XEXP (src, 1));
2418 cfa_store.offset = 0;
2420 if (cfa.reg != STACK_POINTER_REGNUM
2421 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2422 fde->drap_reg = cfa.reg;
2430 def_cfa_1 (label, &cfa);
2435 /* Saving a register to the stack. Make sure dest is relative to the
2437 switch (GET_CODE (XEXP (dest, 0)))
2442 /* We can't handle variable size modifications. */
2443 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2445 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2447 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2448 && cfa_store.reg == STACK_POINTER_REGNUM);
2450 cfa_store.offset += offset;
2451 if (cfa.reg == STACK_POINTER_REGNUM)
2452 cfa.offset = cfa_store.offset;
2454 offset = -cfa_store.offset;
2460 offset = GET_MODE_SIZE (GET_MODE (dest));
2461 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2464 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2465 == STACK_POINTER_REGNUM)
2466 && cfa_store.reg == STACK_POINTER_REGNUM);
2468 cfa_store.offset += offset;
2470 /* Rule 18: If stack is aligned, we will use FP as a
2471 reference to represent the address of the stored
2474 && fde->stack_realign
2475 && src == hard_frame_pointer_rtx)
2477 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2478 cfa_store.offset = 0;
2481 if (cfa.reg == STACK_POINTER_REGNUM)
2482 cfa.offset = cfa_store.offset;
2484 offset = -cfa_store.offset;
2488 /* With an offset. */
2495 gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2496 && REG_P (XEXP (XEXP (dest, 0), 0)));
2497 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2498 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2501 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2503 if (cfa_store.reg == (unsigned) regno)
2504 offset -= cfa_store.offset;
2507 gcc_assert (cfa_temp.reg == (unsigned) regno);
2508 offset -= cfa_temp.offset;
2514 /* Without an offset. */
2517 int regno = REGNO (XEXP (dest, 0));
2519 if (cfa_store.reg == (unsigned) regno)
2520 offset = -cfa_store.offset;
2523 gcc_assert (cfa_temp.reg == (unsigned) regno);
2524 offset = -cfa_temp.offset;
2531 gcc_assert (cfa_temp.reg
2532 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2533 offset = -cfa_temp.offset;
2534 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2542 /* If the source operand of this MEM operation is not a
2543 register, basically the source is return address. Here
2544 we only care how much stack grew and we don't save it. */
2548 if (REGNO (src) != STACK_POINTER_REGNUM
2549 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2550 && (unsigned) REGNO (src) == cfa.reg)
2552 /* We're storing the current CFA reg into the stack. */
2554 if (cfa.offset == 0)
2557 /* If stack is aligned, putting CFA reg into stack means
2558 we can no longer use reg + offset to represent CFA.
2559 Here we use DW_CFA_def_cfa_expression instead. The
2560 result of this expression equals to the original CFA
2563 && fde->stack_realign
2564 && cfa.indirect == 0
2565 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2567 dw_cfa_location cfa_exp;
2569 gcc_assert (fde->drap_reg == cfa.reg);
2571 cfa_exp.indirect = 1;
2572 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2573 cfa_exp.base_offset = offset;
2576 fde->drap_reg_saved = 1;
2578 def_cfa_1 (label, &cfa_exp);
2582 /* If the source register is exactly the CFA, assume
2583 we're saving SP like any other register; this happens
2585 def_cfa_1 (label, &cfa);
2586 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2591 /* Otherwise, we'll need to look in the stack to
2592 calculate the CFA. */
2593 rtx x = XEXP (dest, 0);
2597 gcc_assert (REG_P (x));
2599 cfa.reg = REGNO (x);
2600 cfa.base_offset = offset;
2602 def_cfa_1 (label, &cfa);
2607 def_cfa_1 (label, &cfa);
2609 span = targetm.dwarf_register_span (src);
2612 queue_reg_save (label, src, NULL_RTX, offset);
2615 /* We have a PARALLEL describing where the contents of SRC
2616 live. Queue register saves for each piece of the
2620 HOST_WIDE_INT span_offset = offset;
2622 gcc_assert (GET_CODE (span) == PARALLEL);
2624 limit = XVECLEN (span, 0);
2625 for (par_index = 0; par_index < limit; par_index++)
2627 rtx elem = XVECEXP (span, 0, par_index);
2629 queue_reg_save (label, elem, NULL_RTX, span_offset);
2630 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2641 /* Record call frame debugging information for INSN, which either
2642 sets SP or FP (adjusting how we calculate the frame address) or saves a
2643 register to the stack. If INSN is NULL_RTX, initialize our state.
2645 If AFTER_P is false, we're being called before the insn is emitted,
2646 otherwise after. Call instructions get invoked twice. */
2649 dwarf2out_frame_debug (rtx insn, bool after_p)
2653 bool handled_one = false;
2655 if (insn == NULL_RTX)
2659 /* Flush any queued register saves. */
2660 flush_queued_reg_saves ();
2662 /* Set up state for generating call frame debug info. */
2665 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2667 cfa.reg = STACK_POINTER_REGNUM;
2670 cfa_temp.offset = 0;
2672 for (i = 0; i < num_regs_saved_in_regs; i++)
2674 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2675 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2677 num_regs_saved_in_regs = 0;
2679 if (barrier_args_size)
2681 XDELETEVEC (barrier_args_size);
2682 barrier_args_size = NULL;
2687 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2688 flush_queued_reg_saves ();
2690 if (! RTX_FRAME_RELATED_P (insn))
2692 if (!ACCUMULATE_OUTGOING_ARGS)
2693 dwarf2out_stack_adjust (insn, after_p);
2697 label = dwarf2out_cfi_label (false);
2699 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2700 switch (REG_NOTE_KIND (note))
2702 case REG_FRAME_RELATED_EXPR:
2703 insn = XEXP (note, 0);
2706 case REG_CFA_DEF_CFA:
2707 dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2711 case REG_CFA_ADJUST_CFA:
2716 if (GET_CODE (n) == PARALLEL)
2717 n = XVECEXP (n, 0, 0);
2719 dwarf2out_frame_debug_adjust_cfa (n, label);
2723 case REG_CFA_OFFSET:
2726 n = single_set (insn);
2727 dwarf2out_frame_debug_cfa_offset (n, label);
2731 case REG_CFA_REGISTER:
2736 if (GET_CODE (n) == PARALLEL)
2737 n = XVECEXP (n, 0, 0);
2739 dwarf2out_frame_debug_cfa_register (n, label);
2743 case REG_CFA_RESTORE:
2748 if (GET_CODE (n) == PARALLEL)
2749 n = XVECEXP (n, 0, 0);
2752 dwarf2out_frame_debug_cfa_restore (n, label);
2762 insn = PATTERN (insn);
2764 dwarf2out_frame_debug_expr (insn, label);
2767 /* Determine if we need to save and restore CFI information around this
2768 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2769 we do need to save/restore, then emit the save now, and insert a
2770 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2773 dwarf2out_begin_epilogue (rtx insn)
2775 bool saw_frp = false;
2778 /* Scan forward to the return insn, noticing if there are possible
2779 frame related insns. */
2780 for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2785 /* Look for both regular and sibcalls to end the block. */
2786 if (returnjump_p (i))
2788 if (CALL_P (i) && SIBLING_CALL_P (i))
2791 if (GET_CODE (PATTERN (i)) == SEQUENCE)
2794 rtx seq = PATTERN (i);
2796 if (returnjump_p (XVECEXP (seq, 0, 0)))
2798 if (CALL_P (XVECEXP (seq, 0, 0))
2799 && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2802 for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2803 if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2807 if (RTX_FRAME_RELATED_P (i))
2811 /* If the port doesn't emit epilogue unwind info, we don't need a
2812 save/restore pair. */
2816 /* Otherwise, search forward to see if the return insn was the last
2817 basic block of the function. If so, we don't need save/restore. */
2818 gcc_assert (i != NULL);
2819 i = next_real_insn (i);
2823 /* Insert the restore before that next real insn in the stream, and before
2824 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2825 properly nested. This should be after any label or alignment. This
2826 will be pushed into the CFI stream by the function below. */
2829 rtx p = PREV_INSN (i);
2832 if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2836 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2838 emit_cfa_remember = true;
2840 /* And emulate the state save. */
2841 gcc_assert (!cfa_remember.in_use);
2843 cfa_remember.in_use = 1;
2846 /* A "subroutine" of dwarf2out_begin_epilogue. Emit the restore required. */
2849 dwarf2out_frame_debug_restore_state (void)
2851 dw_cfi_ref cfi = new_cfi ();
2852 const char *label = dwarf2out_cfi_label (false);
2854 cfi->dw_cfi_opc = DW_CFA_restore_state;
2855 add_fde_cfi (label, cfi);
2857 gcc_assert (cfa_remember.in_use);
2859 cfa_remember.in_use = 0;
2864 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2865 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2866 (enum dwarf_call_frame_info cfi);
2868 static enum dw_cfi_oprnd_type
2869 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2874 case DW_CFA_GNU_window_save:
2875 case DW_CFA_remember_state:
2876 case DW_CFA_restore_state:
2877 return dw_cfi_oprnd_unused;
2879 case DW_CFA_set_loc:
2880 case DW_CFA_advance_loc1:
2881 case DW_CFA_advance_loc2:
2882 case DW_CFA_advance_loc4:
2883 case DW_CFA_MIPS_advance_loc8:
2884 return dw_cfi_oprnd_addr;
2887 case DW_CFA_offset_extended:
2888 case DW_CFA_def_cfa:
2889 case DW_CFA_offset_extended_sf:
2890 case DW_CFA_def_cfa_sf:
2891 case DW_CFA_restore:
2892 case DW_CFA_restore_extended:
2893 case DW_CFA_undefined:
2894 case DW_CFA_same_value:
2895 case DW_CFA_def_cfa_register:
2896 case DW_CFA_register:
2897 return dw_cfi_oprnd_reg_num;
2899 case DW_CFA_def_cfa_offset:
2900 case DW_CFA_GNU_args_size:
2901 case DW_CFA_def_cfa_offset_sf:
2902 return dw_cfi_oprnd_offset;
2904 case DW_CFA_def_cfa_expression:
2905 case DW_CFA_expression:
2906 return dw_cfi_oprnd_loc;
2913 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2914 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2915 (enum dwarf_call_frame_info cfi);
2917 static enum dw_cfi_oprnd_type
2918 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2922 case DW_CFA_def_cfa:
2923 case DW_CFA_def_cfa_sf:
2925 case DW_CFA_offset_extended_sf:
2926 case DW_CFA_offset_extended:
2927 return dw_cfi_oprnd_offset;
2929 case DW_CFA_register:
2930 return dw_cfi_oprnd_reg_num;
2933 return dw_cfi_oprnd_unused;
2937 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2939 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
2940 switch to the data section instead, and write out a synthetic start label
2941 for collect2 the first time around. */
2944 switch_to_eh_frame_section (bool back)
2948 #ifdef EH_FRAME_SECTION_NAME
2949 if (eh_frame_section == 0)
2953 if (EH_TABLES_CAN_BE_READ_ONLY)
2959 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2961 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2963 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2965 flags = ((! flag_pic
2966 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2967 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2968 && (per_encoding & 0x70) != DW_EH_PE_absptr
2969 && (per_encoding & 0x70) != DW_EH_PE_aligned
2970 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2971 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2972 ? 0 : SECTION_WRITE);
2975 flags = SECTION_WRITE;
2976 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2980 if (eh_frame_section)
2981 switch_to_section (eh_frame_section);
2984 /* We have no special eh_frame section. Put the information in
2985 the data section and emit special labels to guide collect2. */
2986 switch_to_section (data_section);
2990 label = get_file_function_name ("F");
2991 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2992 targetm.asm_out.globalize_label (asm_out_file,
2993 IDENTIFIER_POINTER (label));
2994 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2999 /* Switch [BACK] to the eh or debug frame table section, depending on
3003 switch_to_frame_table_section (int for_eh, bool back)
3006 switch_to_eh_frame_section (back);
3009 if (!debug_frame_section)
3010 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3011 SECTION_DEBUG, NULL);
3012 switch_to_section (debug_frame_section);
3016 /* Output a Call Frame Information opcode and its operand(s). */
3019 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3024 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3025 dw2_asm_output_data (1, (cfi->dw_cfi_opc
3026 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3027 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3028 ((unsigned HOST_WIDE_INT)
3029 cfi->dw_cfi_oprnd1.dw_cfi_offset));
3030 else if (cfi->dw_cfi_opc == DW_CFA_offset)
3032 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3033 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3034 "DW_CFA_offset, column 0x%lx", r);
3035 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3036 dw2_asm_output_data_uleb128 (off, NULL);
3038 else if (cfi->dw_cfi_opc == DW_CFA_restore)
3040 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3041 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3042 "DW_CFA_restore, column 0x%lx", r);
3046 dw2_asm_output_data (1, cfi->dw_cfi_opc,
3047 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3049 switch (cfi->dw_cfi_opc)
3051 case DW_CFA_set_loc:
3053 dw2_asm_output_encoded_addr_rtx (
3054 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3055 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3058 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3059 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3060 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3063 case DW_CFA_advance_loc1:
3064 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3065 fde->dw_fde_current_label, NULL);
3066 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3069 case DW_CFA_advance_loc2:
3070 dw2_asm_output_delta (2, 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_loc4:
3076 dw2_asm_output_delta (4, 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_MIPS_advance_loc8:
3082 dw2_asm_output_delta (8, 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_offset_extended:
3088 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3089 dw2_asm_output_data_uleb128 (r, NULL);
3090 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3091 dw2_asm_output_data_uleb128 (off, NULL);
3094 case DW_CFA_def_cfa:
3095 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3096 dw2_asm_output_data_uleb128 (r, NULL);
3097 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3100 case DW_CFA_offset_extended_sf:
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 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3104 dw2_asm_output_data_sleb128 (off, NULL);
3107 case DW_CFA_def_cfa_sf:
3108 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3109 dw2_asm_output_data_uleb128 (r, NULL);
3110 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3111 dw2_asm_output_data_sleb128 (off, NULL);
3114 case DW_CFA_restore_extended:
3115 case DW_CFA_undefined:
3116 case DW_CFA_same_value:
3117 case DW_CFA_def_cfa_register:
3118 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3119 dw2_asm_output_data_uleb128 (r, NULL);
3122 case DW_CFA_register:
3123 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3124 dw2_asm_output_data_uleb128 (r, NULL);
3125 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3126 dw2_asm_output_data_uleb128 (r, NULL);
3129 case DW_CFA_def_cfa_offset:
3130 case DW_CFA_GNU_args_size:
3131 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3134 case DW_CFA_def_cfa_offset_sf:
3135 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3136 dw2_asm_output_data_sleb128 (off, NULL);
3139 case DW_CFA_GNU_window_save:
3142 case DW_CFA_def_cfa_expression:
3143 case DW_CFA_expression:
3144 output_cfa_loc (cfi);
3147 case DW_CFA_GNU_negative_offset_extended:
3148 /* Obsoleted by DW_CFA_offset_extended_sf. */
3157 /* Similar, but do it via assembler directives instead. */
3160 output_cfi_directive (dw_cfi_ref cfi)
3162 unsigned long r, r2;
3164 switch (cfi->dw_cfi_opc)
3166 case DW_CFA_advance_loc:
3167 case DW_CFA_advance_loc1:
3168 case DW_CFA_advance_loc2:
3169 case DW_CFA_advance_loc4:
3170 case DW_CFA_MIPS_advance_loc8:
3171 case DW_CFA_set_loc:
3172 /* Should only be created by add_fde_cfi in a code path not
3173 followed when emitting via directives. The assembler is
3174 going to take care of this for us. */
3178 case DW_CFA_offset_extended:
3179 case DW_CFA_offset_extended_sf:
3180 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3181 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3182 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3185 case DW_CFA_restore:
3186 case DW_CFA_restore_extended:
3187 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3188 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3191 case DW_CFA_undefined:
3192 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3193 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3196 case DW_CFA_same_value:
3197 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3198 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3201 case DW_CFA_def_cfa:
3202 case DW_CFA_def_cfa_sf:
3203 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3204 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3205 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3208 case DW_CFA_def_cfa_register:
3209 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3210 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3213 case DW_CFA_register:
3214 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3215 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3216 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3219 case DW_CFA_def_cfa_offset:
3220 case DW_CFA_def_cfa_offset_sf:
3221 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3222 HOST_WIDE_INT_PRINT_DEC"\n",
3223 cfi->dw_cfi_oprnd1.dw_cfi_offset);
3226 case DW_CFA_remember_state:
3227 fprintf (asm_out_file, "\t.cfi_remember_state\n");
3229 case DW_CFA_restore_state:
3230 fprintf (asm_out_file, "\t.cfi_restore_state\n");
3233 case DW_CFA_GNU_args_size:
3234 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size);
3235 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3237 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3238 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3239 fputc ('\n', asm_out_file);
3242 case DW_CFA_GNU_window_save:
3243 fprintf (asm_out_file, "\t.cfi_window_save\n");
3246 case DW_CFA_def_cfa_expression:
3247 case DW_CFA_expression:
3248 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", cfi->dw_cfi_opc);
3249 output_cfa_loc_raw (cfi);
3250 fputc ('\n', asm_out_file);
3258 DEF_VEC_P (dw_cfi_ref);
3259 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
3261 /* Output CFIs to bring current FDE to the same state as after executing
3262 CFIs in CFI chain. DO_CFI_ASM is true if .cfi_* directives shall
3263 be emitted, false otherwise. If it is false, FDE and FOR_EH are the
3264 other arguments to pass to output_cfi. */
3267 output_cfis (dw_cfi_ref cfi, bool do_cfi_asm, dw_fde_ref fde, bool for_eh)
3269 struct dw_cfi_struct cfi_buf;
3271 dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3272 VEC (dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3273 unsigned int len, idx;
3275 for (;; cfi = cfi->dw_cfi_next)
3276 switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3278 case DW_CFA_advance_loc:
3279 case DW_CFA_advance_loc1:
3280 case DW_CFA_advance_loc2:
3281 case DW_CFA_advance_loc4:
3282 case DW_CFA_MIPS_advance_loc8:
3283 case DW_CFA_set_loc:
3284 /* All advances should be ignored. */
3286 case DW_CFA_remember_state:
3288 dw_cfi_ref args_size = cfi_args_size;
3290 /* Skip everything between .cfi_remember_state and
3291 .cfi_restore_state. */
3292 for (cfi2 = cfi->dw_cfi_next; cfi2; cfi2 = cfi2->dw_cfi_next)
3293 if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3295 else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3298 gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3305 cfi_args_size = args_size;
3309 case DW_CFA_GNU_args_size:
3310 cfi_args_size = cfi;
3312 case DW_CFA_GNU_window_save:
3315 case DW_CFA_offset_extended:
3316 case DW_CFA_offset_extended_sf:
3317 case DW_CFA_restore:
3318 case DW_CFA_restore_extended:
3319 case DW_CFA_undefined:
3320 case DW_CFA_same_value:
3321 case DW_CFA_register:
3322 case DW_CFA_val_offset:
3323 case DW_CFA_val_offset_sf:
3324 case DW_CFA_expression:
3325 case DW_CFA_val_expression:
3326 case DW_CFA_GNU_negative_offset_extended:
3327 if (VEC_length (dw_cfi_ref, regs) <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3328 VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3329 cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3330 VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, cfi);
3332 case DW_CFA_def_cfa:
3333 case DW_CFA_def_cfa_sf:
3334 case DW_CFA_def_cfa_expression:
3336 cfi_cfa_offset = cfi;
3338 case DW_CFA_def_cfa_register:
3341 case DW_CFA_def_cfa_offset:
3342 case DW_CFA_def_cfa_offset_sf:
3343 cfi_cfa_offset = cfi;
3346 gcc_assert (cfi == NULL);
3348 len = VEC_length (dw_cfi_ref, regs);
3349 for (idx = 0; idx < len; idx++)
3351 cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3353 && cfi2->dw_cfi_opc != DW_CFA_restore
3354 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3357 output_cfi_directive (cfi2);
3359 output_cfi (cfi2, fde, for_eh);
3362 if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3364 gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3366 switch (cfi_cfa_offset->dw_cfi_opc)
3368 case DW_CFA_def_cfa_offset:
3369 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3370 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3372 case DW_CFA_def_cfa_offset_sf:
3373 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3374 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3376 case DW_CFA_def_cfa:
3377 case DW_CFA_def_cfa_sf:
3378 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3379 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3386 else if (cfi_cfa_offset)
3387 cfi_cfa = cfi_cfa_offset;
3391 output_cfi_directive (cfi_cfa);
3393 output_cfi (cfi_cfa, fde, for_eh);
3396 cfi_cfa_offset = NULL;
3398 && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3401 output_cfi_directive (cfi_args_size);
3403 output_cfi (cfi_args_size, fde, for_eh);
3405 cfi_args_size = NULL;
3408 VEC_free (dw_cfi_ref, heap, regs);
3411 else if (do_cfi_asm)
3412 output_cfi_directive (cfi);
3414 output_cfi (cfi, fde, for_eh);
3421 /* Output one FDE. */
3424 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3425 char *section_start_label, int fde_encoding, char *augmentation,
3426 bool any_lsda_needed, int lsda_encoding)
3428 const char *begin, *end;
3429 static unsigned int j;
3430 char l1[20], l2[20];
3433 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh,
3435 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3437 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3438 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3439 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3440 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3441 " indicating 64-bit DWARF extension");
3442 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3444 ASM_OUTPUT_LABEL (asm_out_file, l1);
3447 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3449 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3450 debug_frame_section, "FDE CIE offset");
3452 if (!fde->dw_fde_switched_sections)
3454 begin = fde->dw_fde_begin;
3455 end = fde->dw_fde_end;
3459 /* For the first section, prefer dw_fde_begin over
3460 dw_fde_{hot,cold}_section_label, as the latter
3461 might be separated from the real start of the
3462 function by alignment padding. */
3464 begin = fde->dw_fde_begin;
3465 else if (fde->dw_fde_switched_cold_to_hot)
3466 begin = fde->dw_fde_hot_section_label;
3468 begin = fde->dw_fde_unlikely_section_label;
3469 if (second ^ fde->dw_fde_switched_cold_to_hot)
3470 end = fde->dw_fde_unlikely_section_end_label;
3472 end = fde->dw_fde_hot_section_end_label;
3477 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
3478 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3479 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
3480 "FDE initial location");
3481 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3482 end, begin, "FDE address range");
3486 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
3487 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
3490 if (augmentation[0])
3492 if (any_lsda_needed)
3494 int size = size_of_encoded_value (lsda_encoding);
3496 if (lsda_encoding == DW_EH_PE_aligned)
3498 int offset = ( 4 /* Length */
3499 + 4 /* CIE offset */
3500 + 2 * size_of_encoded_value (fde_encoding)
3501 + 1 /* Augmentation size */ );
3502 int pad = -offset & (PTR_SIZE - 1);
3505 gcc_assert (size_of_uleb128 (size) == 1);
3508 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3510 if (fde->uses_eh_lsda)
3512 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
3513 fde->funcdef_number);
3514 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
3515 gen_rtx_SYMBOL_REF (Pmode, l1),
3517 "Language Specific Data Area");
3521 if (lsda_encoding == DW_EH_PE_aligned)
3522 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3523 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
3524 "Language Specific Data Area (none)");
3528 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3531 /* Loop through the Call Frame Instructions associated with
3533 fde->dw_fde_current_label = begin;
3534 if (!fde->dw_fde_switched_sections)
3535 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3536 output_cfi (cfi, fde, for_eh);
3539 if (fde->dw_fde_switch_cfi)
3540 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3542 output_cfi (cfi, fde, for_eh);
3543 if (cfi == fde->dw_fde_switch_cfi)
3549 dw_cfi_ref cfi_next = fde->dw_fde_cfi;
3551 if (fde->dw_fde_switch_cfi)
3553 cfi_next = fde->dw_fde_switch_cfi->dw_cfi_next;
3554 fde->dw_fde_switch_cfi->dw_cfi_next = NULL;
3555 output_cfis (fde->dw_fde_cfi, false, fde, for_eh);
3556 fde->dw_fde_switch_cfi->dw_cfi_next = cfi_next;
3558 for (cfi = cfi_next; cfi != NULL; cfi = cfi->dw_cfi_next)
3559 output_cfi (cfi, fde, for_eh);
3562 /* If we are to emit a ref/link from function bodies to their frame tables,
3563 do it now. This is typically performed to make sure that tables
3564 associated with functions are dragged with them and not discarded in
3565 garbage collecting links. We need to do this on a per function basis to
3566 cope with -ffunction-sections. */
3568 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3569 /* Switch to the function section, emit the ref to the tables, and
3570 switch *back* into the table section. */
3571 switch_to_section (function_section (fde->decl));
3572 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
3573 switch_to_frame_table_section (for_eh, true);
3576 /* Pad the FDE out to an address sized boundary. */
3577 ASM_OUTPUT_ALIGN (asm_out_file,
3578 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3579 ASM_OUTPUT_LABEL (asm_out_file, l2);
3584 /* Output the call frame information used to record information
3585 that relates to calculating the frame pointer, and records the
3586 location of saved registers. */
3589 output_call_frame_info (int for_eh)
3594 char l1[20], l2[20], section_start_label[20];
3595 bool any_lsda_needed = false;
3596 char augmentation[6];
3597 int augmentation_size;
3598 int fde_encoding = DW_EH_PE_absptr;
3599 int per_encoding = DW_EH_PE_absptr;
3600 int lsda_encoding = DW_EH_PE_absptr;
3604 /* Don't emit a CIE if there won't be any FDEs. */
3605 if (fde_table_in_use == 0)
3608 /* Nothing to do if the assembler's doing it all. */
3609 if (dwarf2out_do_cfi_asm ())
3612 /* If we make FDEs linkonce, we may have to emit an empty label for
3613 an FDE that wouldn't otherwise be emitted. We want to avoid
3614 having an FDE kept around when the function it refers to is
3615 discarded. Example where this matters: a primary function
3616 template in C++ requires EH information, but an explicit
3617 specialization doesn't. */
3618 if (TARGET_USES_WEAK_UNWIND_INFO
3619 && ! flag_asynchronous_unwind_tables
3622 for (i = 0; i < fde_table_in_use; i++)
3623 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
3624 && !fde_table[i].uses_eh_lsda
3625 && ! DECL_WEAK (fde_table[i].decl))
3626 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
3627 for_eh, /* empty */ 1);
3629 /* If we don't have any functions we'll want to unwind out of, don't
3630 emit any EH unwind information. Note that if exceptions aren't
3631 enabled, we won't have collected nothrow information, and if we
3632 asked for asynchronous tables, we always want this info. */
3635 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
3637 for (i = 0; i < fde_table_in_use; i++)
3638 if (fde_table[i].uses_eh_lsda)
3639 any_eh_needed = any_lsda_needed = true;
3640 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3641 any_eh_needed = true;
3642 else if (! fde_table[i].nothrow
3643 && ! fde_table[i].all_throwers_are_sibcalls)
3644 any_eh_needed = true;
3646 if (! any_eh_needed)
3650 /* We're going to be generating comments, so turn on app. */
3654 /* Switch to the proper frame section, first time. */
3655 switch_to_frame_table_section (for_eh, false);
3657 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3658 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3660 /* Output the CIE. */
3661 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3662 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3663 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3664 dw2_asm_output_data (4, 0xffffffff,
3665 "Initial length escape value indicating 64-bit DWARF extension");
3666 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3667 "Length of Common Information Entry");
3668 ASM_OUTPUT_LABEL (asm_out_file, l1);
3670 /* Now that the CIE pointer is PC-relative for EH,
3671 use 0 to identify the CIE. */
3672 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3673 (for_eh ? 0 : DWARF_CIE_ID),
3674 "CIE Identifier Tag");
3676 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3677 use CIE version 1, unless that would produce incorrect results
3678 due to overflowing the return register column. */
3679 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3681 if (return_reg >= 256 || dwarf_version > 2)
3683 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
3685 augmentation[0] = 0;
3686 augmentation_size = 0;
3692 z Indicates that a uleb128 is present to size the
3693 augmentation section.
3694 L Indicates the encoding (and thus presence) of
3695 an LSDA pointer in the FDE augmentation.
3696 R Indicates a non-default pointer encoding for
3698 P Indicates the presence of an encoding + language
3699 personality routine in the CIE augmentation. */
3701 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3702 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3703 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3705 p = augmentation + 1;
3706 if (eh_personality_libfunc)
3709 augmentation_size += 1 + size_of_encoded_value (per_encoding);
3710 assemble_external_libcall (eh_personality_libfunc);
3712 if (any_lsda_needed)
3715 augmentation_size += 1;
3717 if (fde_encoding != DW_EH_PE_absptr)
3720 augmentation_size += 1;
3722 if (p > augmentation + 1)
3724 augmentation[0] = 'z';
3728 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3729 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
3731 int offset = ( 4 /* Length */
3733 + 1 /* CIE version */
3734 + strlen (augmentation) + 1 /* Augmentation */
3735 + size_of_uleb128 (1) /* Code alignment */
3736 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3738 + 1 /* Augmentation size */
3739 + 1 /* Personality encoding */ );
3740 int pad = -offset & (PTR_SIZE - 1);
3742 augmentation_size += pad;
3744 /* Augmentations should be small, so there's scarce need to
3745 iterate for a solution. Die if we exceed one uleb128 byte. */
3746 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3750 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3751 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3752 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3753 "CIE Data Alignment Factor");
3755 if (dw_cie_version == 1)
3756 dw2_asm_output_data (1, return_reg, "CIE RA Column");
3758 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3760 if (augmentation[0])
3762 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3763 if (eh_personality_libfunc)
3765 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3766 eh_data_format_name (per_encoding));
3767 dw2_asm_output_encoded_addr_rtx (per_encoding,
3768 eh_personality_libfunc,
3772 if (any_lsda_needed)
3773 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3774 eh_data_format_name (lsda_encoding));
3776 if (fde_encoding != DW_EH_PE_absptr)
3777 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3778 eh_data_format_name (fde_encoding));
3781 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3782 output_cfi (cfi, NULL, for_eh);
3784 /* Pad the CIE out to an address sized boundary. */
3785 ASM_OUTPUT_ALIGN (asm_out_file,
3786 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3787 ASM_OUTPUT_LABEL (asm_out_file, l2);
3789 /* Loop through all of the FDE's. */
3790 for (i = 0; i < fde_table_in_use; i++)
3793 fde = &fde_table[i];
3795 /* Don't emit EH unwind info for leaf functions that don't need it. */
3796 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3797 && (fde->nothrow || fde->all_throwers_are_sibcalls)
3798 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3799 && !fde->uses_eh_lsda)
3802 for (k = 0; k < (fde->dw_fde_switched_sections ? 2 : 1); k++)
3803 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
3804 augmentation, any_lsda_needed, lsda_encoding);
3807 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3808 dw2_asm_output_data (4, 0, "End of Table");
3809 #ifdef MIPS_DEBUGGING_INFO
3810 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3811 get a value of 0. Putting .align 0 after the label fixes it. */
3812 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3815 /* Turn off app to make assembly quicker. */
3820 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
3823 dwarf2out_do_cfi_startproc (bool second)
3828 fprintf (asm_out_file, "\t.cfi_startproc\n");
3830 if (eh_personality_libfunc)
3832 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3833 ref = eh_personality_libfunc;
3835 /* ??? The GAS support isn't entirely consistent. We have to
3836 handle indirect support ourselves, but PC-relative is done
3837 in the assembler. Further, the assembler can't handle any
3838 of the weirder relocation types. */
3839 if (enc & DW_EH_PE_indirect)
3840 ref = dw2_force_const_mem (ref, true);
3842 fprintf (asm_out_file, "\t.cfi_personality 0x%x,", enc);
3843 output_addr_const (asm_out_file, ref);
3844 fputc ('\n', asm_out_file);
3847 if (crtl->uses_eh_lsda)
3851 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3852 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
3853 current_function_funcdef_no);
3854 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3855 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3857 if (enc & DW_EH_PE_indirect)
3858 ref = dw2_force_const_mem (ref, true);
3860 fprintf (asm_out_file, "\t.cfi_lsda 0x%x,", enc);
3861 output_addr_const (asm_out_file, ref);
3862 fputc ('\n', asm_out_file);
3866 /* Output a marker (i.e. a label) for the beginning of a function, before
3870 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3871 const char *file ATTRIBUTE_UNUSED)
3873 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3878 current_function_func_begin_label = NULL;
3880 #ifdef TARGET_UNWIND_INFO
3881 /* ??? current_function_func_begin_label is also used by except.c
3882 for call-site information. We must emit this label if it might
3884 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3885 && ! dwarf2out_do_frame ())
3888 if (! dwarf2out_do_frame ())
3892 fnsec = function_section (current_function_decl);
3893 switch_to_section (fnsec);
3894 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3895 current_function_funcdef_no);
3896 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3897 current_function_funcdef_no);
3898 dup_label = xstrdup (label);
3899 current_function_func_begin_label = dup_label;
3901 #ifdef TARGET_UNWIND_INFO
3902 /* We can elide the fde allocation if we're not emitting debug info. */
3903 if (! dwarf2out_do_frame ())
3907 /* Expand the fde table if necessary. */
3908 if (fde_table_in_use == fde_table_allocated)
3910 fde_table_allocated += FDE_TABLE_INCREMENT;
3911 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3912 memset (fde_table + fde_table_in_use, 0,
3913 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3916 /* Record the FDE associated with this function. */
3917 current_funcdef_fde = fde_table_in_use;
3919 /* Add the new FDE at the end of the fde_table. */
3920 fde = &fde_table[fde_table_in_use++];
3921 fde->decl = current_function_decl;
3922 fde->dw_fde_begin = dup_label;
3923 fde->dw_fde_current_label = dup_label;
3924 fde->dw_fde_hot_section_label = NULL;
3925 fde->dw_fde_hot_section_end_label = NULL;
3926 fde->dw_fde_unlikely_section_label = NULL;
3927 fde->dw_fde_unlikely_section_end_label = NULL;
3928 fde->dw_fde_switched_sections = 0;
3929 fde->dw_fde_switched_cold_to_hot = 0;
3930 fde->dw_fde_end = NULL;
3931 fde->dw_fde_cfi = NULL;
3932 fde->dw_fde_switch_cfi = NULL;
3933 fde->funcdef_number = current_function_funcdef_no;
3934 fde->nothrow = crtl->nothrow;
3935 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3936 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3937 fde->drap_reg = INVALID_REGNUM;
3938 fde->vdrap_reg = INVALID_REGNUM;
3939 if (flag_reorder_blocks_and_partition)
3941 section *unlikelysec;
3942 if (first_function_block_is_cold)
3943 fde->in_std_section = 1;
3946 = (fnsec == text_section
3947 || (cold_text_section && fnsec == cold_text_section));
3948 unlikelysec = unlikely_text_section ();
3949 fde->cold_in_std_section
3950 = (unlikelysec == text_section
3951 || (cold_text_section && unlikelysec == cold_text_section));
3956 = (fnsec == text_section
3957 || (cold_text_section && fnsec == cold_text_section));
3958 fde->cold_in_std_section = 0;
3961 args_size = old_args_size = 0;
3963 /* We only want to output line number information for the genuine dwarf2
3964 prologue case, not the eh frame case. */
3965 #ifdef DWARF2_DEBUGGING_INFO
3967 dwarf2out_source_line (line, file, 0, true);
3970 if (dwarf2out_do_cfi_asm ())
3971 dwarf2out_do_cfi_startproc (false);
3974 /* Output a marker (i.e. a label) for the absolute end of the generated code
3975 for a function definition. This gets called *after* the epilogue code has
3979 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
3980 const char *file ATTRIBUTE_UNUSED)
3983 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3985 #ifdef DWARF2_DEBUGGING_INFO
3986 last_var_location_insn = NULL_RTX;
3989 if (dwarf2out_do_cfi_asm ())
3990 fprintf (asm_out_file, "\t.cfi_endproc\n");
3992 /* Output a label to mark the endpoint of the code generated for this
3994 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
3995 current_function_funcdef_no);
3996 ASM_OUTPUT_LABEL (asm_out_file, label);
3997 fde = current_fde ();
3998 gcc_assert (fde != NULL);
3999 fde->dw_fde_end = xstrdup (label);
4003 dwarf2out_frame_init (void)
4005 /* Allocate the initial hunk of the fde_table. */
4006 fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
4007 fde_table_allocated = FDE_TABLE_INCREMENT;
4008 fde_table_in_use = 0;
4010 /* Generate the CFA instructions common to all FDE's. Do it now for the
4011 sake of lookup_cfa. */
4013 /* On entry, the Canonical Frame Address is at SP. */
4014 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
4016 #ifdef DWARF2_UNWIND_INFO
4017 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
4018 initial_return_save (INCOMING_RETURN_ADDR_RTX);
4023 dwarf2out_frame_finish (void)
4025 /* Output call frame information. */
4026 if (DWARF2_FRAME_INFO)
4027 output_call_frame_info (0);
4029 #ifndef TARGET_UNWIND_INFO
4030 /* Output another copy for the unwinder. */
4031 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
4032 output_call_frame_info (1);
4036 /* Note that the current function section is being used for code. */
4039 dwarf2out_note_section_used (void)
4041 section *sec = current_function_section ();
4042 if (sec == text_section)
4043 text_section_used = true;
4044 else if (sec == cold_text_section)
4045 cold_text_section_used = true;
4049 dwarf2out_switch_text_section (void)
4051 dw_fde_ref fde = current_fde ();
4053 gcc_assert (cfun && fde && !fde->dw_fde_switched_sections);
4055 fde->dw_fde_switched_sections = 1;
4056 fde->dw_fde_switched_cold_to_hot = !in_cold_section_p;
4058 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
4059 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
4060 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
4061 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
4062 have_multiple_function_sections = true;
4064 /* Reset the current label on switching text sections, so that we
4065 don't attempt to advance_loc4 between labels in different sections. */
4066 fde->dw_fde_current_label = NULL;
4068 /* There is no need to mark used sections when not debugging. */
4069 if (cold_text_section != NULL)
4070 dwarf2out_note_section_used ();
4072 if (dwarf2out_do_cfi_asm ())
4073 fprintf (asm_out_file, "\t.cfi_endproc\n");
4075 /* Now do the real section switch. */
4076 switch_to_section (current_function_section ());
4078 if (dwarf2out_do_cfi_asm ())
4080 dwarf2out_do_cfi_startproc (true);
4081 /* As this is a different FDE, insert all current CFI instructions
4083 output_cfis (fde->dw_fde_cfi, true, fde, true);
4087 dw_cfi_ref cfi = fde->dw_fde_cfi;
4089 cfi = fde->dw_fde_cfi;
4091 while (cfi->dw_cfi_next != NULL)
4092 cfi = cfi->dw_cfi_next;
4093 fde->dw_fde_switch_cfi = cfi;
4098 /* And now, the subset of the debugging information support code necessary
4099 for emitting location expressions. */
4101 /* Data about a single source file. */
4102 struct GTY(()) dwarf_file_data {
4103 const char * filename;
4107 typedef struct dw_val_struct *dw_val_ref;
4108 typedef struct die_struct *dw_die_ref;
4109 typedef const struct die_struct *const_dw_die_ref;
4110 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
4111 typedef struct dw_loc_list_struct *dw_loc_list_ref;
4113 typedef struct GTY(()) deferred_locations_struct
4117 } deferred_locations;
4119 DEF_VEC_O(deferred_locations);
4120 DEF_VEC_ALLOC_O(deferred_locations,gc);
4122 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
4124 /* Each DIE may have a series of attribute/value pairs. Values
4125 can take on several forms. The forms that are used in this
4126 implementation are listed below. */
4131 dw_val_class_offset,
4133 dw_val_class_loc_list,
4134 dw_val_class_range_list,
4136 dw_val_class_unsigned_const,
4137 dw_val_class_long_long,
4140 dw_val_class_die_ref,
4141 dw_val_class_fde_ref,
4142 dw_val_class_lbl_id,
4143 dw_val_class_lineptr,
4145 dw_val_class_macptr,
4149 /* Describe a floating point constant value, or a vector constant value. */
4151 typedef struct GTY(()) dw_vec_struct {
4152 unsigned char * GTY((length ("%h.length"))) array;
4158 /* The dw_val_node describes an attribute's value, as it is
4159 represented internally. */
4161 typedef struct GTY(()) dw_val_struct {
4162 enum dw_val_class val_class;
4163 union dw_val_struct_union
4165 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
4166 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
4167 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
4168 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
4169 HOST_WIDE_INT GTY ((default)) val_int;
4170 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
4171 rtx GTY ((tag ("dw_val_class_long_long"))) val_long_long;
4172 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
4173 struct dw_val_die_union
4177 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
4178 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
4179 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
4180 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
4181 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
4182 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
4184 GTY ((desc ("%1.val_class"))) v;
4188 /* Locations in memory are described using a sequence of stack machine
4191 typedef struct GTY(()) dw_loc_descr_struct {
4192 dw_loc_descr_ref dw_loc_next;
4193 ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
4194 /* Used to distinguish DW_OP_addr with a direct symbol relocation
4195 from DW_OP_addr with a dtp-relative symbol relocation. */
4196 unsigned int dtprel : 1;
4198 dw_val_node dw_loc_oprnd1;
4199 dw_val_node dw_loc_oprnd2;
4203 /* Location lists are ranges + location descriptions for that range,
4204 so you can track variables that are in different places over
4205 their entire life. */
4206 typedef struct GTY(()) dw_loc_list_struct {
4207 dw_loc_list_ref dw_loc_next;
4208 const char *begin; /* Label for begin address of range */
4209 const char *end; /* Label for end address of range */
4210 char *ll_symbol; /* Label for beginning of location list.
4211 Only on head of list */
4212 const char *section; /* Section this loclist is relative to */
4213 dw_loc_descr_ref expr;
4216 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
4218 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4220 /* Convert a DWARF stack opcode into its string name. */
4223 dwarf_stack_op_name (unsigned int op)
4228 return "DW_OP_addr";
4230 return "DW_OP_deref";
4232 return "DW_OP_const1u";
4234 return "DW_OP_const1s";
4236 return "DW_OP_const2u";
4238 return "DW_OP_const2s";
4240 return "DW_OP_const4u";
4242 return "DW_OP_const4s";
4244 return "DW_OP_const8u";
4246 return "DW_OP_const8s";
4248 return "DW_OP_constu";
4250 return "DW_OP_consts";
4254 return "DW_OP_drop";
4256 return "DW_OP_over";
4258 return "DW_OP_pick";
4260 return "DW_OP_swap";
4264 return "DW_OP_xderef";
4272 return "DW_OP_minus";
4284 return "DW_OP_plus";
4285 case DW_OP_plus_uconst:
4286 return "DW_OP_plus_uconst";
4292 return "DW_OP_shra";
4310 return "DW_OP_skip";
4312 return "DW_OP_lit0";
4314 return "DW_OP_lit1";
4316 return "DW_OP_lit2";
4318 return "DW_OP_lit3";
4320 return "DW_OP_lit4";
4322 return "DW_OP_lit5";
4324 return "DW_OP_lit6";
4326 return "DW_OP_lit7";
4328 return "DW_OP_lit8";
4330 return "DW_OP_lit9";
4332 return "DW_OP_lit10";
4334 return "DW_OP_lit11";
4336 return "DW_OP_lit12";
4338 return "DW_OP_lit13";
4340 return "DW_OP_lit14";
4342 return "DW_OP_lit15";
4344 return "DW_OP_lit16";
4346 return "DW_OP_lit17";
4348 return "DW_OP_lit18";
4350 return "DW_OP_lit19";
4352 return "DW_OP_lit20";
4354 return "DW_OP_lit21";
4356 return "DW_OP_lit22";
4358 return "DW_OP_lit23";
4360 return "DW_OP_lit24";
4362 return "DW_OP_lit25";
4364 return "DW_OP_lit26";
4366 return "DW_OP_lit27";
4368 return "DW_OP_lit28";
4370 return "DW_OP_lit29";
4372 return "DW_OP_lit30";
4374 return "DW_OP_lit31";
4376 return "DW_OP_reg0";
4378 return "DW_OP_reg1";
4380 return "DW_OP_reg2";
4382 return "DW_OP_reg3";
4384 return "DW_OP_reg4";
4386 return "DW_OP_reg5";
4388 return "DW_OP_reg6";
4390 return "DW_OP_reg7";
4392 return "DW_OP_reg8";
4394 return "DW_OP_reg9";
4396 return "DW_OP_reg10";
4398 return "DW_OP_reg11";
4400 return "DW_OP_reg12";
4402 return "DW_OP_reg13";
4404 return "DW_OP_reg14";
4406 return "DW_OP_reg15";
4408 return "DW_OP_reg16";
4410 return "DW_OP_reg17";
4412 return "DW_OP_reg18";
4414 return "DW_OP_reg19";
4416 return "DW_OP_reg20";
4418 return "DW_OP_reg21";
4420 return "DW_OP_reg22";
4422 return "DW_OP_reg23";
4424 return "DW_OP_reg24";
4426 return "DW_OP_reg25";
4428 return "DW_OP_reg26";
4430 return "DW_OP_reg27";
4432 return "DW_OP_reg28";
4434 return "DW_OP_reg29";
4436 return "DW_OP_reg30";
4438 return "DW_OP_reg31";
4440 return "DW_OP_breg0";
4442 return "DW_OP_breg1";
4444 return "DW_OP_breg2";
4446 return "DW_OP_breg3";
4448 return "DW_OP_breg4";
4450 return "DW_OP_breg5";
4452 return "DW_OP_breg6";
4454 return "DW_OP_breg7";
4456 return "DW_OP_breg8";
4458 return "DW_OP_breg9";
4460 return "DW_OP_breg10";
4462 return "DW_OP_breg11";
4464 return "DW_OP_breg12";
4466 return "DW_OP_breg13";
4468 return "DW_OP_breg14";
4470 return "DW_OP_breg15";
4472 return "DW_OP_breg16";
4474 return "DW_OP_breg17";
4476 return "DW_OP_breg18";
4478 return "DW_OP_breg19";
4480 return "DW_OP_breg20";
4482 return "DW_OP_breg21";
4484 return "DW_OP_breg22";
4486 return "DW_OP_breg23";
4488 return "DW_OP_breg24";
4490 return "DW_OP_breg25";
4492 return "DW_OP_breg26";
4494 return "DW_OP_breg27";
4496 return "DW_OP_breg28";
4498 return "DW_OP_breg29";
4500 return "DW_OP_breg30";
4502 return "DW_OP_breg31";
4504 return "DW_OP_regx";
4506 return "DW_OP_fbreg";
4508 return "DW_OP_bregx";
4510 return "DW_OP_piece";
4511 case DW_OP_deref_size:
4512 return "DW_OP_deref_size";
4513 case DW_OP_xderef_size:
4514 return "DW_OP_xderef_size";
4518 case DW_OP_push_object_address:
4519 return "DW_OP_push_object_address";
4521 return "DW_OP_call2";
4523 return "DW_OP_call4";
4524 case DW_OP_call_ref:
4525 return "DW_OP_call_ref";
4526 case DW_OP_implicit_value:
4527 return "DW_OP_implicit_value";
4528 case DW_OP_stack_value:
4529 return "DW_OP_stack_value";
4530 case DW_OP_form_tls_address:
4531 return "DW_OP_form_tls_address";
4532 case DW_OP_call_frame_cfa:
4533 return "DW_OP_call_frame_cfa";
4534 case DW_OP_bit_piece:
4535 return "DW_OP_bit_piece";
4537 case DW_OP_GNU_push_tls_address:
4538 return "DW_OP_GNU_push_tls_address";
4539 case DW_OP_GNU_uninit:
4540 return "DW_OP_GNU_uninit";
4541 case DW_OP_GNU_encoded_addr:
4542 return "DW_OP_GNU_encoded_addr";
4545 return "OP_<unknown>";
4549 /* Return a pointer to a newly allocated location description. Location
4550 descriptions are simple expression terms that can be strung
4551 together to form more complicated location (address) descriptions. */
4553 static inline dw_loc_descr_ref
4554 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
4555 unsigned HOST_WIDE_INT oprnd2)
4557 dw_loc_descr_ref descr = GGC_CNEW (dw_loc_descr_node);
4559 descr->dw_loc_opc = op;
4560 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4561 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4562 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4563 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4568 /* Return a pointer to a newly allocated location description for
4571 static inline dw_loc_descr_ref
4572 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
4575 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
4578 return new_loc_descr (DW_OP_bregx, reg, offset);
4581 /* Add a location description term to a location description expression. */
4584 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
4586 dw_loc_descr_ref *d;
4588 /* Find the end of the chain. */
4589 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4595 /* Add a constant OFFSET to a location expression. */
4598 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
4600 dw_loc_descr_ref loc;
4603 gcc_assert (*list_head != NULL);
4608 /* Find the end of the chain. */
4609 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
4613 if (loc->dw_loc_opc == DW_OP_fbreg
4614 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
4615 p = &loc->dw_loc_oprnd1.v.val_int;
4616 else if (loc->dw_loc_opc == DW_OP_bregx)
4617 p = &loc->dw_loc_oprnd2.v.val_int;
4619 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4620 offset. Don't optimize if an signed integer overflow would happen. */
4622 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
4623 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
4626 else if (offset > 0)
4627 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4631 loc->dw_loc_next = int_loc_descriptor (offset);
4632 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_plus, 0, 0));
4636 /* Return the size of a location descriptor. */
4638 static unsigned long
4639 size_of_loc_descr (dw_loc_descr_ref loc)
4641 unsigned long size = 1;
4643 switch (loc->dw_loc_opc)
4646 size += DWARF2_ADDR_SIZE;
4665 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4668 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4673 case DW_OP_plus_uconst:
4674 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4712 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4715 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4718 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4721 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4722 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4725 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4727 case DW_OP_deref_size:
4728 case DW_OP_xderef_size:
4737 case DW_OP_call_ref:
4738 size += DWARF2_ADDR_SIZE;
4740 case DW_OP_implicit_value:
4741 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
4742 + loc->dw_loc_oprnd1.v.val_unsigned;
4751 /* Return the size of a series of location descriptors. */
4753 static unsigned long
4754 size_of_locs (dw_loc_descr_ref loc)
4759 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4760 field, to avoid writing to a PCH file. */
4761 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4763 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4765 size += size_of_loc_descr (l);
4770 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4772 l->dw_loc_addr = size;
4773 size += size_of_loc_descr (l);
4779 #ifdef DWARF2_DEBUGGING_INFO
4780 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4783 /* Output location description stack opcode's operands (if any). */
4786 output_loc_operands (dw_loc_descr_ref loc)
4788 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4789 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4791 switch (loc->dw_loc_opc)
4793 #ifdef DWARF2_DEBUGGING_INFO
4796 dw2_asm_output_data (2, val1->v.val_int, NULL);
4800 dw2_asm_output_data (4, val1->v.val_int, NULL);
4804 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
4805 dw2_asm_output_data (8, val1->v.val_int, NULL);
4812 gcc_assert (val1->val_class == dw_val_class_loc);
4813 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4815 dw2_asm_output_data (2, offset, NULL);
4818 case DW_OP_implicit_value:
4819 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4820 switch (val2->val_class)
4822 case dw_val_class_const:
4823 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
4825 case dw_val_class_vec:
4827 unsigned int elt_size = val2->v.val_vec.elt_size;
4828 unsigned int len = val2->v.val_vec.length;
4832 if (elt_size > sizeof (HOST_WIDE_INT))
4837 for (i = 0, p = val2->v.val_vec.array;
4840 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
4841 "fp or vector constant word %u", i);
4844 case dw_val_class_long_long:
4846 unsigned HOST_WIDE_INT first, second;
4848 if (WORDS_BIG_ENDIAN)
4850 first = CONST_DOUBLE_HIGH (val2->v.val_long_long);
4851 second = CONST_DOUBLE_LOW (val2->v.val_long_long);
4855 first = CONST_DOUBLE_LOW (val2->v.val_long_long);
4856 second = CONST_DOUBLE_HIGH (val2->v.val_long_long);
4858 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
4859 first, "long long constant");
4860 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
4864 case dw_val_class_addr:
4865 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
4866 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
4881 case DW_OP_implicit_value:
4882 /* We currently don't make any attempt to make sure these are
4883 aligned properly like we do for the main unwind info, so
4884 don't support emitting things larger than a byte if we're
4885 only doing unwinding. */
4890 dw2_asm_output_data (1, val1->v.val_int, NULL);
4893 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4896 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4899 dw2_asm_output_data (1, val1->v.val_int, NULL);
4901 case DW_OP_plus_uconst:
4902 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4936 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4939 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4942 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4945 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4946 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
4949 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4951 case DW_OP_deref_size:
4952 case DW_OP_xderef_size:
4953 dw2_asm_output_data (1, val1->v.val_int, NULL);
4959 if (targetm.asm_out.output_dwarf_dtprel)
4961 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
4964 fputc ('\n', asm_out_file);
4971 #ifdef DWARF2_DEBUGGING_INFO
4972 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
4980 /* Other codes have no operands. */
4985 /* Output a sequence of location operations. */
4988 output_loc_sequence (dw_loc_descr_ref loc)
4990 for (; loc != NULL; loc = loc->dw_loc_next)
4992 /* Output the opcode. */
4993 dw2_asm_output_data (1, loc->dw_loc_opc,
4994 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
4996 /* Output the operand(s) (if any). */
4997 output_loc_operands (loc);
5001 /* Output location description stack opcode's operands (if any).
5002 The output is single bytes on a line, suitable for .cfi_escape. */
5005 output_loc_operands_raw (dw_loc_descr_ref loc)
5007 dw_val_ref val1 = &loc->dw_loc_oprnd1;
5008 dw_val_ref val2 = &loc->dw_loc_oprnd2;
5010 switch (loc->dw_loc_opc)
5013 case DW_OP_implicit_value:
5014 /* We cannot output addresses in .cfi_escape, only bytes. */
5020 case DW_OP_deref_size:
5021 case DW_OP_xderef_size:
5022 fputc (',', asm_out_file);
5023 dw2_asm_output_data_raw (1, val1->v.val_int);
5028 fputc (',', asm_out_file);
5029 dw2_asm_output_data_raw (2, val1->v.val_int);
5034 fputc (',', asm_out_file);
5035 dw2_asm_output_data_raw (4, val1->v.val_int);
5040 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5041 fputc (',', asm_out_file);
5042 dw2_asm_output_data_raw (8, val1->v.val_int);
5050 gcc_assert (val1->val_class == dw_val_class_loc);
5051 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5053 fputc (',', asm_out_file);
5054 dw2_asm_output_data_raw (2, offset);
5059 case DW_OP_plus_uconst:
5062 fputc (',', asm_out_file);
5063 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5100 fputc (',', asm_out_file);
5101 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
5105 fputc (',', asm_out_file);
5106 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5107 fputc (',', asm_out_file);
5108 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
5112 /* Other codes have no operands. */
5118 output_loc_sequence_raw (dw_loc_descr_ref loc)
5122 /* Output the opcode. */
5123 fprintf (asm_out_file, "0x%x", loc->dw_loc_opc);
5124 output_loc_operands_raw (loc);
5126 if (!loc->dw_loc_next)
5128 loc = loc->dw_loc_next;
5130 fputc (',', asm_out_file);
5134 /* This routine will generate the correct assembly data for a location
5135 description based on a cfi entry with a complex address. */
5138 output_cfa_loc (dw_cfi_ref cfi)
5140 dw_loc_descr_ref loc;
5143 if (cfi->dw_cfi_opc == DW_CFA_expression)
5144 dw2_asm_output_data (1, cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL);
5146 /* Output the size of the block. */
5147 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5148 size = size_of_locs (loc);
5149 dw2_asm_output_data_uleb128 (size, NULL);
5151 /* Now output the operations themselves. */
5152 output_loc_sequence (loc);
5155 /* Similar, but used for .cfi_escape. */
5158 output_cfa_loc_raw (dw_cfi_ref cfi)
5160 dw_loc_descr_ref loc;
5163 if (cfi->dw_cfi_opc == DW_CFA_expression)
5164 fprintf (asm_out_file, "0x%x,", cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
5166 /* Output the size of the block. */
5167 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5168 size = size_of_locs (loc);
5169 dw2_asm_output_data_uleb128_raw (size);
5170 fputc (',', asm_out_file);
5172 /* Now output the operations themselves. */
5173 output_loc_sequence_raw (loc);
5176 /* This function builds a dwarf location descriptor sequence from a
5177 dw_cfa_location, adding the given OFFSET to the result of the
5180 static struct dw_loc_descr_struct *
5181 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
5183 struct dw_loc_descr_struct *head, *tmp;
5185 offset += cfa->offset;
5189 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
5190 head->dw_loc_oprnd1.val_class = dw_val_class_const;
5191 tmp = new_loc_descr (DW_OP_deref, 0, 0);
5192 add_loc_descr (&head, tmp);
5195 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
5196 add_loc_descr (&head, tmp);
5200 head = new_reg_loc_descr (cfa->reg, offset);
5205 /* This function builds a dwarf location descriptor sequence for
5206 the address at OFFSET from the CFA when stack is aligned to
5209 static struct dw_loc_descr_struct *
5210 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
5212 struct dw_loc_descr_struct *head;
5213 unsigned int dwarf_fp
5214 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
5216 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
5217 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
5219 head = new_reg_loc_descr (dwarf_fp, 0);
5220 add_loc_descr (&head, int_loc_descriptor (alignment));
5221 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
5222 loc_descr_plus_const (&head, offset);
5225 head = new_reg_loc_descr (dwarf_fp, offset);
5229 /* This function fills in aa dw_cfa_location structure from a dwarf location
5230 descriptor sequence. */
5233 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
5235 struct dw_loc_descr_struct *ptr;
5237 cfa->base_offset = 0;
5241 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
5243 enum dwarf_location_atom op = ptr->dw_loc_opc;
5279 cfa->reg = op - DW_OP_reg0;
5282 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5316 cfa->reg = op - DW_OP_breg0;
5317 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
5320 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5321 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
5326 case DW_OP_plus_uconst:
5327 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
5330 internal_error ("DW_LOC_OP %s not implemented",
5331 dwarf_stack_op_name (ptr->dw_loc_opc));
5335 #endif /* .debug_frame support */
5337 /* And now, the support for symbolic debugging information. */
5338 #ifdef DWARF2_DEBUGGING_INFO
5340 /* .debug_str support. */
5341 static int output_indirect_string (void **, void *);
5343 static void dwarf2out_init (const char *);
5344 static void dwarf2out_finish (const char *);
5345 static void dwarf2out_define (unsigned int, const char *);
5346 static void dwarf2out_undef (unsigned int, const char *);
5347 static void dwarf2out_start_source_file (unsigned, const char *);
5348 static void dwarf2out_end_source_file (unsigned);
5349 static void dwarf2out_begin_block (unsigned, unsigned);
5350 static void dwarf2out_end_block (unsigned, unsigned);
5351 static bool dwarf2out_ignore_block (const_tree);
5352 static void dwarf2out_global_decl (tree);
5353 static void dwarf2out_type_decl (tree, int);
5354 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
5355 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
5357 static void dwarf2out_abstract_function (tree);
5358 static void dwarf2out_var_location (rtx);
5359 static void dwarf2out_begin_function (tree);
5360 static void dwarf2out_set_name (tree, tree);
5362 /* The debug hooks structure. */
5364 const struct gcc_debug_hooks dwarf2_debug_hooks =
5370 dwarf2out_start_source_file,
5371 dwarf2out_end_source_file,
5372 dwarf2out_begin_block,
5373 dwarf2out_end_block,
5374 dwarf2out_ignore_block,
5375 dwarf2out_source_line,
5376 dwarf2out_begin_prologue,
5377 debug_nothing_int_charstar, /* end_prologue */
5378 dwarf2out_end_epilogue,
5379 dwarf2out_begin_function,
5380 debug_nothing_int, /* end_function */
5381 dwarf2out_decl, /* function_decl */
5382 dwarf2out_global_decl,
5383 dwarf2out_type_decl, /* type_decl */
5384 dwarf2out_imported_module_or_decl,
5385 debug_nothing_tree, /* deferred_inline_function */
5386 /* The DWARF 2 backend tries to reduce debugging bloat by not
5387 emitting the abstract description of inline functions until
5388 something tries to reference them. */
5389 dwarf2out_abstract_function, /* outlining_inline_function */
5390 debug_nothing_rtx, /* label */
5391 debug_nothing_int, /* handle_pch */
5392 dwarf2out_var_location,
5393 dwarf2out_switch_text_section,
5395 1 /* start_end_main_source_file */
5399 /* NOTE: In the comments in this file, many references are made to
5400 "Debugging Information Entries". This term is abbreviated as `DIE'
5401 throughout the remainder of this file. */
5403 /* An internal representation of the DWARF output is built, and then
5404 walked to generate the DWARF debugging info. The walk of the internal
5405 representation is done after the entire program has been compiled.
5406 The types below are used to describe the internal representation. */
5408 /* Various DIE's use offsets relative to the beginning of the
5409 .debug_info section to refer to each other. */
5411 typedef long int dw_offset;
5413 /* Define typedefs here to avoid circular dependencies. */
5415 typedef struct dw_attr_struct *dw_attr_ref;
5416 typedef struct dw_line_info_struct *dw_line_info_ref;
5417 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
5418 typedef struct pubname_struct *pubname_ref;
5419 typedef struct dw_ranges_struct *dw_ranges_ref;
5420 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
5422 /* Each entry in the line_info_table maintains the file and
5423 line number associated with the label generated for that
5424 entry. The label gives the PC value associated with
5425 the line number entry. */
5427 typedef struct GTY(()) dw_line_info_struct {
5428 unsigned long dw_file_num;
5429 unsigned long dw_line_num;
5433 /* Line information for functions in separate sections; each one gets its
5435 typedef struct GTY(()) dw_separate_line_info_struct {
5436 unsigned long dw_file_num;
5437 unsigned long dw_line_num;
5438 unsigned long function;
5440 dw_separate_line_info_entry;
5442 /* Each DIE attribute has a field specifying the attribute kind,
5443 a link to the next attribute in the chain, and an attribute value.
5444 Attributes are typically linked below the DIE they modify. */
5446 typedef struct GTY(()) dw_attr_struct {
5447 enum dwarf_attribute dw_attr;
5448 dw_val_node dw_attr_val;
5452 DEF_VEC_O(dw_attr_node);
5453 DEF_VEC_ALLOC_O(dw_attr_node,gc);
5455 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
5456 The children of each node form a circular list linked by
5457 die_sib. die_child points to the node *before* the "first" child node. */
5459 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
5460 enum dwarf_tag die_tag;
5462 VEC(dw_attr_node,gc) * die_attr;
5463 dw_die_ref die_parent;
5464 dw_die_ref die_child;
5466 dw_die_ref die_definition; /* ref from a specification to its definition */
5467 dw_offset die_offset;
5468 unsigned long die_abbrev;
5470 /* Die is used and must not be pruned as unused. */
5471 int die_perennial_p;
5472 unsigned int decl_id;
5476 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
5477 #define FOR_EACH_CHILD(die, c, expr) do { \
5478 c = die->die_child; \
5482 } while (c != die->die_child); \
5485 /* The pubname structure */
5487 typedef struct GTY(()) pubname_struct {
5493 DEF_VEC_O(pubname_entry);
5494 DEF_VEC_ALLOC_O(pubname_entry, gc);
5496 struct GTY(()) dw_ranges_struct {
5497 /* If this is positive, it's a block number, otherwise it's a
5498 bitwise-negated index into dw_ranges_by_label. */
5502 struct GTY(()) dw_ranges_by_label_struct {
5507 /* The limbo die list structure. */
5508 typedef struct GTY(()) limbo_die_struct {
5511 struct limbo_die_struct *next;
5515 /* How to start an assembler comment. */
5516 #ifndef ASM_COMMENT_START
5517 #define ASM_COMMENT_START ";#"
5520 /* Define a macro which returns nonzero for a TYPE_DECL which was
5521 implicitly generated for a tagged type.
5523 Note that unlike the gcc front end (which generates a NULL named
5524 TYPE_DECL node for each complete tagged type, each array type, and
5525 each function type node created) the g++ front end generates a
5526 _named_ TYPE_DECL node for each tagged type node created.
5527 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
5528 generate a DW_TAG_typedef DIE for them. */
5530 #define TYPE_DECL_IS_STUB(decl) \
5531 (DECL_NAME (decl) == NULL_TREE \
5532 || (DECL_ARTIFICIAL (decl) \
5533 && is_tagged_type (TREE_TYPE (decl)) \
5534 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
5535 /* This is necessary for stub decls that \
5536 appear in nested inline functions. */ \
5537 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
5538 && (decl_ultimate_origin (decl) \
5539 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
5541 /* Information concerning the compilation unit's programming
5542 language, and compiler version. */
5544 /* Fixed size portion of the DWARF compilation unit header. */
5545 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
5546 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
5548 /* Fixed size portion of public names info. */
5549 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
5551 /* Fixed size portion of the address range info. */
5552 #define DWARF_ARANGES_HEADER_SIZE \
5553 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5554 DWARF2_ADDR_SIZE * 2) \
5555 - DWARF_INITIAL_LENGTH_SIZE)
5557 /* Size of padding portion in the address range info. It must be
5558 aligned to twice the pointer size. */
5559 #define DWARF_ARANGES_PAD_SIZE \
5560 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5561 DWARF2_ADDR_SIZE * 2) \
5562 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
5564 /* Use assembler line directives if available. */
5565 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
5566 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
5567 #define DWARF2_ASM_LINE_DEBUG_INFO 1
5569 #define DWARF2_ASM_LINE_DEBUG_INFO 0
5573 /* Minimum line offset in a special line info. opcode.
5574 This value was chosen to give a reasonable range of values. */
5575 #define DWARF_LINE_BASE -10
5577 /* First special line opcode - leave room for the standard opcodes. */
5578 #define DWARF_LINE_OPCODE_BASE 10
5580 /* Range of line offsets in a special line info. opcode. */
5581 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
5583 /* Flag that indicates the initial value of the is_stmt_start flag.
5584 In the present implementation, we do not mark any lines as
5585 the beginning of a source statement, because that information
5586 is not made available by the GCC front-end. */
5587 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
5589 #ifdef DWARF2_DEBUGGING_INFO
5590 /* This location is used by calc_die_sizes() to keep track
5591 the offset of each DIE within the .debug_info section. */
5592 static unsigned long next_die_offset;
5595 /* Record the root of the DIE's built for the current compilation unit. */
5596 static GTY(()) dw_die_ref comp_unit_die;
5598 /* A list of DIEs with a NULL parent waiting to be relocated. */
5599 static GTY(()) limbo_die_node *limbo_die_list;
5601 /* A list of DIEs for which we may have to generate
5602 DW_AT_MIPS_linkage_name once their DECL_ASSEMBLER_NAMEs are
5604 static GTY(()) limbo_die_node *deferred_asm_name;
5606 /* Filenames referenced by this compilation unit. */
5607 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
5609 /* A hash table of references to DIE's that describe declarations.
5610 The key is a DECL_UID() which is a unique number identifying each decl. */
5611 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
5613 /* A hash table of references to DIE's that describe COMMON blocks.
5614 The key is DECL_UID() ^ die_parent. */
5615 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
5617 typedef struct GTY(()) die_arg_entry_struct {
5622 DEF_VEC_O(die_arg_entry);
5623 DEF_VEC_ALLOC_O(die_arg_entry,gc);
5625 /* Node of the variable location list. */
5626 struct GTY ((chain_next ("%h.next"))) var_loc_node {
5627 rtx GTY (()) var_loc_note;
5628 const char * GTY (()) label;
5629 const char * GTY (()) section_label;
5630 struct var_loc_node * GTY (()) next;
5633 /* Variable location list. */
5634 struct GTY (()) var_loc_list_def {
5635 struct var_loc_node * GTY (()) first;
5637 /* Do not mark the last element of the chained list because
5638 it is marked through the chain. */
5639 struct var_loc_node * GTY ((skip ("%h"))) last;
5641 /* DECL_UID of the variable decl. */
5642 unsigned int decl_id;
5644 typedef struct var_loc_list_def var_loc_list;
5647 /* Table of decl location linked lists. */
5648 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
5650 /* A pointer to the base of a list of references to DIE's that
5651 are uniquely identified by their tag, presence/absence of
5652 children DIE's, and list of attribute/value pairs. */
5653 static GTY((length ("abbrev_die_table_allocated")))
5654 dw_die_ref *abbrev_die_table;
5656 /* Number of elements currently allocated for abbrev_die_table. */
5657 static GTY(()) unsigned abbrev_die_table_allocated;
5659 /* Number of elements in type_die_table currently in use. */
5660 static GTY(()) unsigned abbrev_die_table_in_use;
5662 /* Size (in elements) of increments by which we may expand the
5663 abbrev_die_table. */
5664 #define ABBREV_DIE_TABLE_INCREMENT 256
5666 /* A pointer to the base of a table that contains line information
5667 for each source code line in .text in the compilation unit. */
5668 static GTY((length ("line_info_table_allocated")))
5669 dw_line_info_ref line_info_table;
5671 /* Number of elements currently allocated for line_info_table. */
5672 static GTY(()) unsigned line_info_table_allocated;
5674 /* Number of elements in line_info_table currently in use. */
5675 static GTY(()) unsigned line_info_table_in_use;
5677 /* A pointer to the base of a table that contains line information
5678 for each source code line outside of .text in the compilation unit. */
5679 static GTY ((length ("separate_line_info_table_allocated")))
5680 dw_separate_line_info_ref separate_line_info_table;
5682 /* Number of elements currently allocated for separate_line_info_table. */
5683 static GTY(()) unsigned separate_line_info_table_allocated;
5685 /* Number of elements in separate_line_info_table currently in use. */
5686 static GTY(()) unsigned separate_line_info_table_in_use;
5688 /* Size (in elements) of increments by which we may expand the
5690 #define LINE_INFO_TABLE_INCREMENT 1024
5692 /* A pointer to the base of a table that contains a list of publicly
5693 accessible names. */
5694 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
5696 /* A pointer to the base of a table that contains a list of publicly
5697 accessible types. */
5698 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
5700 /* Array of dies for which we should generate .debug_arange info. */
5701 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
5703 /* Number of elements currently allocated for arange_table. */
5704 static GTY(()) unsigned arange_table_allocated;
5706 /* Number of elements in arange_table currently in use. */
5707 static GTY(()) unsigned arange_table_in_use;
5709 /* Size (in elements) of increments by which we may expand the
5711 #define ARANGE_TABLE_INCREMENT 64
5713 /* Array of dies for which we should generate .debug_ranges info. */
5714 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
5716 /* Number of elements currently allocated for ranges_table. */
5717 static GTY(()) unsigned ranges_table_allocated;
5719 /* Number of elements in ranges_table currently in use. */
5720 static GTY(()) unsigned ranges_table_in_use;
5722 /* Array of pairs of labels referenced in ranges_table. */
5723 static GTY ((length ("ranges_by_label_allocated")))
5724 dw_ranges_by_label_ref ranges_by_label;
5726 /* Number of elements currently allocated for ranges_by_label. */
5727 static GTY(()) unsigned ranges_by_label_allocated;
5729 /* Number of elements in ranges_by_label currently in use. */
5730 static GTY(()) unsigned ranges_by_label_in_use;
5732 /* Size (in elements) of increments by which we may expand the
5734 #define RANGES_TABLE_INCREMENT 64
5736 /* Whether we have location lists that need outputting */
5737 static GTY(()) bool have_location_lists;
5739 /* Unique label counter. */
5740 static GTY(()) unsigned int loclabel_num;
5742 #ifdef DWARF2_DEBUGGING_INFO
5743 /* Record whether the function being analyzed contains inlined functions. */
5744 static int current_function_has_inlines;
5746 #if 0 && defined (MIPS_DEBUGGING_INFO)
5747 static int comp_unit_has_inlines;
5750 /* The last file entry emitted by maybe_emit_file(). */
5751 static GTY(()) struct dwarf_file_data * last_emitted_file;
5753 /* Number of internal labels generated by gen_internal_sym(). */
5754 static GTY(()) int label_num;
5756 /* Cached result of previous call to lookup_filename. */
5757 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
5759 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
5761 #ifdef DWARF2_DEBUGGING_INFO
5763 /* Offset from the "steady-state frame pointer" to the frame base,
5764 within the current function. */
5765 static HOST_WIDE_INT frame_pointer_fb_offset;
5767 /* Forward declarations for functions defined in this file. */
5769 static int is_pseudo_reg (const_rtx);
5770 static tree type_main_variant (tree);
5771 static int is_tagged_type (const_tree);
5772 static const char *dwarf_tag_name (unsigned);
5773 static const char *dwarf_attr_name (unsigned);
5774 static const char *dwarf_form_name (unsigned);
5775 static tree decl_ultimate_origin (const_tree);
5776 static tree decl_class_context (tree);
5777 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
5778 static inline enum dw_val_class AT_class (dw_attr_ref);
5779 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
5780 static inline unsigned AT_flag (dw_attr_ref);
5781 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
5782 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
5783 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
5784 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
5785 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, rtx);
5786 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
5787 unsigned int, unsigned char *);
5788 static hashval_t debug_str_do_hash (const void *);
5789 static int debug_str_eq (const void *, const void *);
5790 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
5791 static inline const char *AT_string (dw_attr_ref);
5792 static enum dwarf_form AT_string_form (dw_attr_ref);
5793 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
5794 static void add_AT_specification (dw_die_ref, dw_die_ref);
5795 static inline dw_die_ref AT_ref (dw_attr_ref);
5796 static inline int AT_ref_external (dw_attr_ref);
5797 static inline void set_AT_ref_external (dw_attr_ref, int);
5798 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
5799 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
5800 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
5801 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
5803 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
5804 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
5805 static inline rtx AT_addr (dw_attr_ref);
5806 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
5807 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
5808 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
5809 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
5810 unsigned HOST_WIDE_INT);
5811 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
5813 static inline const char *AT_lbl (dw_attr_ref);
5814 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
5815 static const char *get_AT_low_pc (dw_die_ref);
5816 static const char *get_AT_hi_pc (dw_die_ref);
5817 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
5818 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
5819 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
5820 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
5821 static bool is_c_family (void);
5822 static bool is_cxx (void);
5823 static bool is_java (void);
5824 static bool is_fortran (void);
5825 static bool is_ada (void);
5826 static void remove_AT (dw_die_ref, enum dwarf_attribute);
5827 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
5828 static void add_child_die (dw_die_ref, dw_die_ref);
5829 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
5830 static dw_die_ref lookup_type_die (tree);
5831 static void equate_type_number_to_die (tree, dw_die_ref);
5832 static hashval_t decl_die_table_hash (const void *);
5833 static int decl_die_table_eq (const void *, const void *);
5834 static dw_die_ref lookup_decl_die (tree);
5835 static hashval_t common_block_die_table_hash (const void *);
5836 static int common_block_die_table_eq (const void *, const void *);
5837 static hashval_t decl_loc_table_hash (const void *);
5838 static int decl_loc_table_eq (const void *, const void *);
5839 static var_loc_list *lookup_decl_loc (const_tree);
5840 static void equate_decl_number_to_die (tree, dw_die_ref);
5841 static void add_var_loc_to_decl (tree, struct var_loc_node *);
5842 static void print_spaces (FILE *);
5843 static void print_die (dw_die_ref, FILE *);
5844 static void print_dwarf_line_table (FILE *);
5845 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
5846 static dw_die_ref pop_compile_unit (dw_die_ref);
5847 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
5848 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
5849 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
5850 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
5851 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
5852 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
5853 static int same_die_p (dw_die_ref, dw_die_ref, int *);
5854 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
5855 static void compute_section_prefix (dw_die_ref);
5856 static int is_type_die (dw_die_ref);
5857 static int is_comdat_die (dw_die_ref);
5858 static int is_symbol_die (dw_die_ref);
5859 static void assign_symbol_names (dw_die_ref);
5860 static void break_out_includes (dw_die_ref);
5861 static hashval_t htab_cu_hash (const void *);
5862 static int htab_cu_eq (const void *, const void *);
5863 static void htab_cu_del (void *);
5864 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
5865 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
5866 static void add_sibling_attributes (dw_die_ref);
5867 static void build_abbrev_table (dw_die_ref);
5868 static void output_location_lists (dw_die_ref);
5869 static int constant_size (unsigned HOST_WIDE_INT);
5870 static unsigned long size_of_die (dw_die_ref);
5871 static void calc_die_sizes (dw_die_ref);
5872 static void mark_dies (dw_die_ref);
5873 static void unmark_dies (dw_die_ref);
5874 static void unmark_all_dies (dw_die_ref);
5875 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
5876 static unsigned long size_of_aranges (void);
5877 static enum dwarf_form value_format (dw_attr_ref);
5878 static void output_value_format (dw_attr_ref);
5879 static void output_abbrev_section (void);
5880 static void output_die_symbol (dw_die_ref);
5881 static void output_die (dw_die_ref);
5882 static void output_compilation_unit_header (void);
5883 static void output_comp_unit (dw_die_ref, int);
5884 static const char *dwarf2_name (tree, int);
5885 static void add_pubname (tree, dw_die_ref);
5886 static void add_pubname_string (const char *, dw_die_ref);
5887 static void add_pubtype (tree, dw_die_ref);
5888 static void output_pubnames (VEC (pubname_entry,gc) *);
5889 static void add_arange (tree, dw_die_ref);
5890 static void output_aranges (void);
5891 static unsigned int add_ranges_num (int);
5892 static unsigned int add_ranges (const_tree);
5893 static unsigned int add_ranges_by_labels (const char *, const char *);
5894 static void output_ranges (void);
5895 static void output_line_info (void);
5896 static void output_file_names (void);
5897 static dw_die_ref base_type_die (tree);
5898 static int is_base_type (tree);
5899 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
5900 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
5901 static dw_die_ref generic_parameter_die (tree, tree, dw_die_ref, int);
5902 static int type_is_enum (const_tree);
5903 static unsigned int dbx_reg_number (const_rtx);
5904 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
5905 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
5906 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
5907 enum var_init_status);
5908 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
5909 enum var_init_status);
5910 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
5911 enum var_init_status);
5912 static int is_based_loc (const_rtx);
5913 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
5914 enum var_init_status);
5915 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
5916 enum var_init_status);
5917 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
5918 enum var_init_status);
5919 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
5920 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
5921 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
5922 static tree field_type (const_tree);
5923 static unsigned int simple_type_align_in_bits (const_tree);
5924 static unsigned int simple_decl_align_in_bits (const_tree);
5925 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
5926 static HOST_WIDE_INT field_byte_offset (const_tree);
5927 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
5929 static void add_data_member_location_attribute (dw_die_ref, tree);
5930 static void add_const_value_attribute (dw_die_ref, rtx);
5931 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
5932 static void insert_float (const_rtx, unsigned char *);
5933 static rtx rtl_for_decl_location (tree);
5934 static void add_location_or_const_value_attribute (dw_die_ref, tree,
5935 enum dwarf_attribute);
5936 static void tree_add_const_value_attribute (dw_die_ref, tree);
5937 static void tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
5938 static void add_name_attribute (dw_die_ref, const char *);
5939 static void add_comp_dir_attribute (dw_die_ref);
5940 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
5941 static void add_subscript_info (dw_die_ref, tree, bool);
5942 static void add_byte_size_attribute (dw_die_ref, tree);
5943 static void add_bit_offset_attribute (dw_die_ref, tree);
5944 static void add_bit_size_attribute (dw_die_ref, tree);
5945 static void add_prototyped_attribute (dw_die_ref, tree);
5946 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
5947 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
5948 static void add_src_coords_attributes (dw_die_ref, tree);
5949 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
5950 static void push_decl_scope (tree);
5951 static void pop_decl_scope (void);
5952 static dw_die_ref scope_die_for (tree, dw_die_ref);
5953 static inline int local_scope_p (dw_die_ref);
5954 static inline int class_scope_p (dw_die_ref);
5955 static inline int class_or_namespace_scope_p (dw_die_ref);
5956 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
5957 static void add_calling_convention_attribute (dw_die_ref, tree);
5958 static const char *type_tag (const_tree);
5959 static tree member_declared_type (const_tree);
5961 static const char *decl_start_label (tree);
5963 static void gen_array_type_die (tree, dw_die_ref);
5964 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
5966 static void gen_entry_point_die (tree, dw_die_ref);
5968 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
5969 static dw_die_ref gen_formal_parameter_die (tree, tree, dw_die_ref);
5970 static void gen_unspecified_parameters_die (tree, dw_die_ref);
5971 static void gen_formal_types_die (tree, dw_die_ref);
5972 static void gen_subprogram_die (tree, dw_die_ref);
5973 static void gen_variable_die (tree, tree, dw_die_ref);
5974 static void gen_const_die (tree, dw_die_ref);
5975 static void gen_label_die (tree, dw_die_ref);
5976 static void gen_lexical_block_die (tree, dw_die_ref, int);
5977 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
5978 static void gen_field_die (tree, dw_die_ref);
5979 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
5980 static dw_die_ref gen_compile_unit_die (const char *);
5981 static void gen_inheritance_die (tree, tree, dw_die_ref);
5982 static void gen_member_die (tree, dw_die_ref);
5983 static void gen_struct_or_union_type_die (tree, dw_die_ref,
5984 enum debug_info_usage);
5985 static void gen_subroutine_type_die (tree, dw_die_ref);
5986 static void gen_typedef_die (tree, dw_die_ref);
5987 static void gen_type_die (tree, dw_die_ref);
5988 static void gen_block_die (tree, dw_die_ref, int);
5989 static void decls_for_scope (tree, dw_die_ref, int);
5990 static int is_redundant_typedef (const_tree);
5991 static inline dw_die_ref get_context_die (tree);
5992 static void gen_namespace_die (tree, dw_die_ref);
5993 static void gen_decl_die (tree, tree, dw_die_ref);
5994 static dw_die_ref force_decl_die (tree);
5995 static dw_die_ref force_type_die (tree);
5996 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
5997 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
5998 static struct dwarf_file_data * lookup_filename (const char *);
5999 static void retry_incomplete_types (void);
6000 static void gen_type_die_for_member (tree, tree, dw_die_ref);
6001 static tree make_ith_pack_parameter_name (tree, int);
6002 static void gen_generic_params_dies (tree);
6003 static void splice_child_die (dw_die_ref, dw_die_ref);
6004 static int file_info_cmp (const void *, const void *);
6005 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
6006 const char *, const char *, unsigned);
6007 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
6008 const char *, const char *,
6010 static void output_loc_list (dw_loc_list_ref);
6011 static char *gen_internal_sym (const char *);
6013 static void prune_unmark_dies (dw_die_ref);
6014 static void prune_unused_types_mark (dw_die_ref, int);
6015 static void prune_unused_types_walk (dw_die_ref);
6016 static void prune_unused_types_walk_attribs (dw_die_ref);
6017 static void prune_unused_types_prune (dw_die_ref);
6018 static void prune_unused_types (void);
6019 static int maybe_emit_file (struct dwarf_file_data *fd);
6020 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
6021 static void gen_remaining_tmpl_value_param_die_attribute (void);
6023 /* Section names used to hold DWARF debugging information. */
6024 #ifndef DEBUG_INFO_SECTION
6025 #define DEBUG_INFO_SECTION ".debug_info"
6027 #ifndef DEBUG_ABBREV_SECTION
6028 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
6030 #ifndef DEBUG_ARANGES_SECTION
6031 #define DEBUG_ARANGES_SECTION ".debug_aranges"
6033 #ifndef DEBUG_MACINFO_SECTION
6034 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
6036 #ifndef DEBUG_LINE_SECTION
6037 #define DEBUG_LINE_SECTION ".debug_line"
6039 #ifndef DEBUG_LOC_SECTION
6040 #define DEBUG_LOC_SECTION ".debug_loc"
6042 #ifndef DEBUG_PUBNAMES_SECTION
6043 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
6045 #ifndef DEBUG_PUBTYPES_SECTION
6046 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
6048 #ifndef DEBUG_STR_SECTION
6049 #define DEBUG_STR_SECTION ".debug_str"
6051 #ifndef DEBUG_RANGES_SECTION
6052 #define DEBUG_RANGES_SECTION ".debug_ranges"
6055 /* Standard ELF section names for compiled code and data. */
6056 #ifndef TEXT_SECTION_NAME
6057 #define TEXT_SECTION_NAME ".text"
6060 /* Section flags for .debug_str section. */
6061 #define DEBUG_STR_SECTION_FLAGS \
6062 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
6063 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
6066 /* Labels we insert at beginning sections we can reference instead of
6067 the section names themselves. */
6069 #ifndef TEXT_SECTION_LABEL
6070 #define TEXT_SECTION_LABEL "Ltext"
6072 #ifndef COLD_TEXT_SECTION_LABEL
6073 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
6075 #ifndef DEBUG_LINE_SECTION_LABEL
6076 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
6078 #ifndef DEBUG_INFO_SECTION_LABEL
6079 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
6081 #ifndef DEBUG_ABBREV_SECTION_LABEL
6082 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
6084 #ifndef DEBUG_LOC_SECTION_LABEL
6085 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
6087 #ifndef DEBUG_RANGES_SECTION_LABEL
6088 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
6090 #ifndef DEBUG_MACINFO_SECTION_LABEL
6091 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
6094 /* Definitions of defaults for formats and names of various special
6095 (artificial) labels which may be generated within this file (when the -g
6096 options is used and DWARF2_DEBUGGING_INFO is in effect.
6097 If necessary, these may be overridden from within the tm.h file, but
6098 typically, overriding these defaults is unnecessary. */
6100 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6101 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6102 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6103 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6104 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6105 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6106 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6107 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6108 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6109 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
6111 #ifndef TEXT_END_LABEL
6112 #define TEXT_END_LABEL "Letext"
6114 #ifndef COLD_END_LABEL
6115 #define COLD_END_LABEL "Letext_cold"
6117 #ifndef BLOCK_BEGIN_LABEL
6118 #define BLOCK_BEGIN_LABEL "LBB"
6120 #ifndef BLOCK_END_LABEL
6121 #define BLOCK_END_LABEL "LBE"
6123 #ifndef LINE_CODE_LABEL
6124 #define LINE_CODE_LABEL "LM"
6126 #ifndef SEPARATE_LINE_CODE_LABEL
6127 #define SEPARATE_LINE_CODE_LABEL "LSM"
6131 /* We allow a language front-end to designate a function that is to be
6132 called to "demangle" any name before it is put into a DIE. */
6134 static const char *(*demangle_name_func) (const char *);
6137 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
6139 demangle_name_func = func;
6142 /* Test if rtl node points to a pseudo register. */
6145 is_pseudo_reg (const_rtx rtl)
6147 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
6148 || (GET_CODE (rtl) == SUBREG
6149 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
6152 /* Return a reference to a type, with its const and volatile qualifiers
6156 type_main_variant (tree type)
6158 type = TYPE_MAIN_VARIANT (type);
6160 /* ??? There really should be only one main variant among any group of
6161 variants of a given type (and all of the MAIN_VARIANT values for all
6162 members of the group should point to that one type) but sometimes the C
6163 front-end messes this up for array types, so we work around that bug
6165 if (TREE_CODE (type) == ARRAY_TYPE)
6166 while (type != TYPE_MAIN_VARIANT (type))
6167 type = TYPE_MAIN_VARIANT (type);
6172 /* Return nonzero if the given type node represents a tagged type. */
6175 is_tagged_type (const_tree type)
6177 enum tree_code code = TREE_CODE (type);
6179 return (code == RECORD_TYPE || code == UNION_TYPE
6180 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
6183 /* Convert a DIE tag into its string name. */
6186 dwarf_tag_name (unsigned int tag)
6190 case DW_TAG_padding:
6191 return "DW_TAG_padding";
6192 case DW_TAG_array_type:
6193 return "DW_TAG_array_type";
6194 case DW_TAG_class_type:
6195 return "DW_TAG_class_type";
6196 case DW_TAG_entry_point:
6197 return "DW_TAG_entry_point";
6198 case DW_TAG_enumeration_type:
6199 return "DW_TAG_enumeration_type";
6200 case DW_TAG_formal_parameter:
6201 return "DW_TAG_formal_parameter";
6202 case DW_TAG_imported_declaration:
6203 return "DW_TAG_imported_declaration";
6205 return "DW_TAG_label";
6206 case DW_TAG_lexical_block:
6207 return "DW_TAG_lexical_block";
6209 return "DW_TAG_member";
6210 case DW_TAG_pointer_type:
6211 return "DW_TAG_pointer_type";
6212 case DW_TAG_reference_type:
6213 return "DW_TAG_reference_type";
6214 case DW_TAG_compile_unit:
6215 return "DW_TAG_compile_unit";
6216 case DW_TAG_string_type:
6217 return "DW_TAG_string_type";
6218 case DW_TAG_structure_type:
6219 return "DW_TAG_structure_type";
6220 case DW_TAG_subroutine_type:
6221 return "DW_TAG_subroutine_type";
6222 case DW_TAG_typedef:
6223 return "DW_TAG_typedef";
6224 case DW_TAG_union_type:
6225 return "DW_TAG_union_type";
6226 case DW_TAG_unspecified_parameters:
6227 return "DW_TAG_unspecified_parameters";
6228 case DW_TAG_variant:
6229 return "DW_TAG_variant";
6230 case DW_TAG_common_block:
6231 return "DW_TAG_common_block";
6232 case DW_TAG_common_inclusion:
6233 return "DW_TAG_common_inclusion";
6234 case DW_TAG_inheritance:
6235 return "DW_TAG_inheritance";
6236 case DW_TAG_inlined_subroutine:
6237 return "DW_TAG_inlined_subroutine";
6239 return "DW_TAG_module";
6240 case DW_TAG_ptr_to_member_type:
6241 return "DW_TAG_ptr_to_member_type";
6242 case DW_TAG_set_type:
6243 return "DW_TAG_set_type";
6244 case DW_TAG_subrange_type:
6245 return "DW_TAG_subrange_type";
6246 case DW_TAG_with_stmt:
6247 return "DW_TAG_with_stmt";
6248 case DW_TAG_access_declaration:
6249 return "DW_TAG_access_declaration";
6250 case DW_TAG_base_type:
6251 return "DW_TAG_base_type";
6252 case DW_TAG_catch_block:
6253 return "DW_TAG_catch_block";
6254 case DW_TAG_const_type:
6255 return "DW_TAG_const_type";
6256 case DW_TAG_constant:
6257 return "DW_TAG_constant";
6258 case DW_TAG_enumerator:
6259 return "DW_TAG_enumerator";
6260 case DW_TAG_file_type:
6261 return "DW_TAG_file_type";
6263 return "DW_TAG_friend";
6264 case DW_TAG_namelist:
6265 return "DW_TAG_namelist";
6266 case DW_TAG_namelist_item:
6267 return "DW_TAG_namelist_item";
6268 case DW_TAG_packed_type:
6269 return "DW_TAG_packed_type";
6270 case DW_TAG_subprogram:
6271 return "DW_TAG_subprogram";
6272 case DW_TAG_template_type_param:
6273 return "DW_TAG_template_type_param";
6274 case DW_TAG_template_value_param:
6275 return "DW_TAG_template_value_param";
6276 case DW_TAG_thrown_type:
6277 return "DW_TAG_thrown_type";
6278 case DW_TAG_try_block:
6279 return "DW_TAG_try_block";
6280 case DW_TAG_variant_part:
6281 return "DW_TAG_variant_part";
6282 case DW_TAG_variable:
6283 return "DW_TAG_variable";
6284 case DW_TAG_volatile_type:
6285 return "DW_TAG_volatile_type";
6286 case DW_TAG_dwarf_procedure:
6287 return "DW_TAG_dwarf_procedure";
6288 case DW_TAG_restrict_type:
6289 return "DW_TAG_restrict_type";
6290 case DW_TAG_interface_type:
6291 return "DW_TAG_interface_type";
6292 case DW_TAG_namespace:
6293 return "DW_TAG_namespace";
6294 case DW_TAG_imported_module:
6295 return "DW_TAG_imported_module";
6296 case DW_TAG_unspecified_type:
6297 return "DW_TAG_unspecified_type";
6298 case DW_TAG_partial_unit:
6299 return "DW_TAG_partial_unit";
6300 case DW_TAG_imported_unit:
6301 return "DW_TAG_imported_unit";
6302 case DW_TAG_condition:
6303 return "DW_TAG_condition";
6304 case DW_TAG_shared_type:
6305 return "DW_TAG_shared_type";
6306 case DW_TAG_MIPS_loop:
6307 return "DW_TAG_MIPS_loop";
6308 case DW_TAG_format_label:
6309 return "DW_TAG_format_label";
6310 case DW_TAG_function_template:
6311 return "DW_TAG_function_template";
6312 case DW_TAG_class_template:
6313 return "DW_TAG_class_template";
6314 case DW_TAG_GNU_BINCL:
6315 return "DW_TAG_GNU_BINCL";
6316 case DW_TAG_GNU_EINCL:
6317 return "DW_TAG_GNU_EINCL";
6318 case DW_TAG_GNU_template_template_param:
6319 return "DW_TAG_GNU_template_template_param";
6321 return "DW_TAG_<unknown>";
6325 /* Convert a DWARF attribute code into its string name. */
6328 dwarf_attr_name (unsigned int attr)
6333 return "DW_AT_sibling";
6334 case DW_AT_location:
6335 return "DW_AT_location";
6337 return "DW_AT_name";
6338 case DW_AT_ordering:
6339 return "DW_AT_ordering";
6340 case DW_AT_subscr_data:
6341 return "DW_AT_subscr_data";
6342 case DW_AT_byte_size:
6343 return "DW_AT_byte_size";
6344 case DW_AT_bit_offset:
6345 return "DW_AT_bit_offset";
6346 case DW_AT_bit_size:
6347 return "DW_AT_bit_size";
6348 case DW_AT_element_list:
6349 return "DW_AT_element_list";
6350 case DW_AT_stmt_list:
6351 return "DW_AT_stmt_list";
6353 return "DW_AT_low_pc";
6355 return "DW_AT_high_pc";
6356 case DW_AT_language:
6357 return "DW_AT_language";
6359 return "DW_AT_member";
6361 return "DW_AT_discr";
6362 case DW_AT_discr_value:
6363 return "DW_AT_discr_value";
6364 case DW_AT_visibility:
6365 return "DW_AT_visibility";
6367 return "DW_AT_import";
6368 case DW_AT_string_length:
6369 return "DW_AT_string_length";
6370 case DW_AT_common_reference:
6371 return "DW_AT_common_reference";
6372 case DW_AT_comp_dir:
6373 return "DW_AT_comp_dir";
6374 case DW_AT_const_value:
6375 return "DW_AT_const_value";
6376 case DW_AT_containing_type:
6377 return "DW_AT_containing_type";
6378 case DW_AT_default_value:
6379 return "DW_AT_default_value";
6381 return "DW_AT_inline";
6382 case DW_AT_is_optional:
6383 return "DW_AT_is_optional";
6384 case DW_AT_lower_bound:
6385 return "DW_AT_lower_bound";
6386 case DW_AT_producer:
6387 return "DW_AT_producer";
6388 case DW_AT_prototyped:
6389 return "DW_AT_prototyped";
6390 case DW_AT_return_addr:
6391 return "DW_AT_return_addr";
6392 case DW_AT_start_scope:
6393 return "DW_AT_start_scope";
6394 case DW_AT_bit_stride:
6395 return "DW_AT_bit_stride";
6396 case DW_AT_upper_bound:
6397 return "DW_AT_upper_bound";
6398 case DW_AT_abstract_origin:
6399 return "DW_AT_abstract_origin";
6400 case DW_AT_accessibility:
6401 return "DW_AT_accessibility";
6402 case DW_AT_address_class:
6403 return "DW_AT_address_class";
6404 case DW_AT_artificial:
6405 return "DW_AT_artificial";
6406 case DW_AT_base_types:
6407 return "DW_AT_base_types";
6408 case DW_AT_calling_convention:
6409 return "DW_AT_calling_convention";
6411 return "DW_AT_count";
6412 case DW_AT_data_member_location:
6413 return "DW_AT_data_member_location";
6414 case DW_AT_decl_column:
6415 return "DW_AT_decl_column";
6416 case DW_AT_decl_file:
6417 return "DW_AT_decl_file";
6418 case DW_AT_decl_line:
6419 return "DW_AT_decl_line";
6420 case DW_AT_declaration:
6421 return "DW_AT_declaration";
6422 case DW_AT_discr_list:
6423 return "DW_AT_discr_list";
6424 case DW_AT_encoding:
6425 return "DW_AT_encoding";
6426 case DW_AT_external:
6427 return "DW_AT_external";
6428 case DW_AT_explicit:
6429 return "DW_AT_explicit";
6430 case DW_AT_frame_base:
6431 return "DW_AT_frame_base";
6433 return "DW_AT_friend";
6434 case DW_AT_identifier_case:
6435 return "DW_AT_identifier_case";
6436 case DW_AT_macro_info:
6437 return "DW_AT_macro_info";
6438 case DW_AT_namelist_items:
6439 return "DW_AT_namelist_items";
6440 case DW_AT_priority:
6441 return "DW_AT_priority";
6443 return "DW_AT_segment";
6444 case DW_AT_specification:
6445 return "DW_AT_specification";
6446 case DW_AT_static_link:
6447 return "DW_AT_static_link";
6449 return "DW_AT_type";
6450 case DW_AT_use_location:
6451 return "DW_AT_use_location";
6452 case DW_AT_variable_parameter:
6453 return "DW_AT_variable_parameter";
6454 case DW_AT_virtuality:
6455 return "DW_AT_virtuality";
6456 case DW_AT_vtable_elem_location:
6457 return "DW_AT_vtable_elem_location";
6459 case DW_AT_allocated:
6460 return "DW_AT_allocated";
6461 case DW_AT_associated:
6462 return "DW_AT_associated";
6463 case DW_AT_data_location:
6464 return "DW_AT_data_location";
6465 case DW_AT_byte_stride:
6466 return "DW_AT_byte_stride";
6467 case DW_AT_entry_pc:
6468 return "DW_AT_entry_pc";
6469 case DW_AT_use_UTF8:
6470 return "DW_AT_use_UTF8";
6471 case DW_AT_extension:
6472 return "DW_AT_extension";
6474 return "DW_AT_ranges";
6475 case DW_AT_trampoline:
6476 return "DW_AT_trampoline";
6477 case DW_AT_call_column:
6478 return "DW_AT_call_column";
6479 case DW_AT_call_file:
6480 return "DW_AT_call_file";
6481 case DW_AT_call_line:
6482 return "DW_AT_call_line";
6484 case DW_AT_MIPS_fde:
6485 return "DW_AT_MIPS_fde";
6486 case DW_AT_MIPS_loop_begin:
6487 return "DW_AT_MIPS_loop_begin";
6488 case DW_AT_MIPS_tail_loop_begin:
6489 return "DW_AT_MIPS_tail_loop_begin";
6490 case DW_AT_MIPS_epilog_begin:
6491 return "DW_AT_MIPS_epilog_begin";
6492 case DW_AT_MIPS_loop_unroll_factor:
6493 return "DW_AT_MIPS_loop_unroll_factor";
6494 case DW_AT_MIPS_software_pipeline_depth:
6495 return "DW_AT_MIPS_software_pipeline_depth";
6496 case DW_AT_MIPS_linkage_name:
6497 return "DW_AT_MIPS_linkage_name";
6498 case DW_AT_MIPS_stride:
6499 return "DW_AT_MIPS_stride";
6500 case DW_AT_MIPS_abstract_name:
6501 return "DW_AT_MIPS_abstract_name";
6502 case DW_AT_MIPS_clone_origin:
6503 return "DW_AT_MIPS_clone_origin";
6504 case DW_AT_MIPS_has_inlines:
6505 return "DW_AT_MIPS_has_inlines";
6507 case DW_AT_sf_names:
6508 return "DW_AT_sf_names";
6509 case DW_AT_src_info:
6510 return "DW_AT_src_info";
6511 case DW_AT_mac_info:
6512 return "DW_AT_mac_info";
6513 case DW_AT_src_coords:
6514 return "DW_AT_src_coords";
6515 case DW_AT_body_begin:
6516 return "DW_AT_body_begin";
6517 case DW_AT_body_end:
6518 return "DW_AT_body_end";
6519 case DW_AT_GNU_vector:
6520 return "DW_AT_GNU_vector";
6521 case DW_AT_GNU_template_name:
6522 return "DW_AT_GNU_template_name";
6524 case DW_AT_VMS_rtnbeg_pd_address:
6525 return "DW_AT_VMS_rtnbeg_pd_address";
6528 return "DW_AT_<unknown>";
6532 /* Convert a DWARF value form code into its string name. */
6535 dwarf_form_name (unsigned int form)
6540 return "DW_FORM_addr";
6541 case DW_FORM_block2:
6542 return "DW_FORM_block2";
6543 case DW_FORM_block4:
6544 return "DW_FORM_block4";
6546 return "DW_FORM_data2";
6548 return "DW_FORM_data4";
6550 return "DW_FORM_data8";
6551 case DW_FORM_string:
6552 return "DW_FORM_string";
6554 return "DW_FORM_block";
6555 case DW_FORM_block1:
6556 return "DW_FORM_block1";
6558 return "DW_FORM_data1";
6560 return "DW_FORM_flag";
6562 return "DW_FORM_sdata";
6564 return "DW_FORM_strp";
6566 return "DW_FORM_udata";
6567 case DW_FORM_ref_addr:
6568 return "DW_FORM_ref_addr";
6570 return "DW_FORM_ref1";
6572 return "DW_FORM_ref2";
6574 return "DW_FORM_ref4";
6576 return "DW_FORM_ref8";
6577 case DW_FORM_ref_udata:
6578 return "DW_FORM_ref_udata";
6579 case DW_FORM_indirect:
6580 return "DW_FORM_indirect";
6582 return "DW_FORM_<unknown>";
6586 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
6587 instance of an inlined instance of a decl which is local to an inline
6588 function, so we have to trace all of the way back through the origin chain
6589 to find out what sort of node actually served as the original seed for the
6593 decl_ultimate_origin (const_tree decl)
6595 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
6598 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
6599 nodes in the function to point to themselves; ignore that if
6600 we're trying to output the abstract instance of this function. */
6601 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
6604 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
6605 most distant ancestor, this should never happen. */
6606 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
6608 return DECL_ABSTRACT_ORIGIN (decl);
6611 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
6612 of a virtual function may refer to a base class, so we check the 'this'
6616 decl_class_context (tree decl)
6618 tree context = NULL_TREE;
6620 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
6621 context = DECL_CONTEXT (decl);
6623 context = TYPE_MAIN_VARIANT
6624 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
6626 if (context && !TYPE_P (context))
6627 context = NULL_TREE;
6632 /* Add an attribute/value pair to a DIE. */
6635 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
6637 /* Maybe this should be an assert? */
6641 if (die->die_attr == NULL)
6642 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
6643 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
6646 static inline enum dw_val_class
6647 AT_class (dw_attr_ref a)
6649 return a->dw_attr_val.val_class;
6652 /* Add a flag value attribute to a DIE. */
6655 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
6659 attr.dw_attr = attr_kind;
6660 attr.dw_attr_val.val_class = dw_val_class_flag;
6661 attr.dw_attr_val.v.val_flag = flag;
6662 add_dwarf_attr (die, &attr);
6665 static inline unsigned
6666 AT_flag (dw_attr_ref a)
6668 gcc_assert (a && AT_class (a) == dw_val_class_flag);
6669 return a->dw_attr_val.v.val_flag;
6672 /* Add a signed integer attribute value to a DIE. */
6675 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
6679 attr.dw_attr = attr_kind;
6680 attr.dw_attr_val.val_class = dw_val_class_const;
6681 attr.dw_attr_val.v.val_int = int_val;
6682 add_dwarf_attr (die, &attr);
6685 static inline HOST_WIDE_INT
6686 AT_int (dw_attr_ref a)
6688 gcc_assert (a && AT_class (a) == dw_val_class_const);
6689 return a->dw_attr_val.v.val_int;
6692 /* Add an unsigned integer attribute value to a DIE. */
6695 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
6696 unsigned HOST_WIDE_INT unsigned_val)
6700 attr.dw_attr = attr_kind;
6701 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
6702 attr.dw_attr_val.v.val_unsigned = unsigned_val;
6703 add_dwarf_attr (die, &attr);
6706 static inline unsigned HOST_WIDE_INT
6707 AT_unsigned (dw_attr_ref a)
6709 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
6710 return a->dw_attr_val.v.val_unsigned;
6713 /* Add an unsigned double integer attribute value to a DIE. */
6716 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
6717 rtx val_const_double)
6721 attr.dw_attr = attr_kind;
6722 attr.dw_attr_val.val_class = dw_val_class_long_long;
6723 attr.dw_attr_val.v.val_long_long = val_const_double;
6724 add_dwarf_attr (die, &attr);
6727 /* Add a floating point attribute value to a DIE and return it. */
6730 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
6731 unsigned int length, unsigned int elt_size, unsigned char *array)
6735 attr.dw_attr = attr_kind;
6736 attr.dw_attr_val.val_class = dw_val_class_vec;
6737 attr.dw_attr_val.v.val_vec.length = length;
6738 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
6739 attr.dw_attr_val.v.val_vec.array = array;
6740 add_dwarf_attr (die, &attr);
6743 /* Hash and equality functions for debug_str_hash. */
6746 debug_str_do_hash (const void *x)
6748 return htab_hash_string (((const struct indirect_string_node *)x)->str);
6752 debug_str_eq (const void *x1, const void *x2)
6754 return strcmp ((((const struct indirect_string_node *)x1)->str),
6755 (const char *)x2) == 0;
6758 /* Add STR to the indirect string hash table. */
6760 static struct indirect_string_node *
6761 find_AT_string (const char *str)
6763 struct indirect_string_node *node;
6766 if (! debug_str_hash)
6767 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
6768 debug_str_eq, NULL);
6770 slot = htab_find_slot_with_hash (debug_str_hash, str,
6771 htab_hash_string (str), INSERT);
6774 node = (struct indirect_string_node *)
6775 ggc_alloc_cleared (sizeof (struct indirect_string_node));
6776 node->str = ggc_strdup (str);
6780 node = (struct indirect_string_node *) *slot;
6786 /* Add a string attribute value to a DIE. */
6789 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
6792 struct indirect_string_node *node;
6794 node = find_AT_string (str);
6796 attr.dw_attr = attr_kind;
6797 attr.dw_attr_val.val_class = dw_val_class_str;
6798 attr.dw_attr_val.v.val_str = node;
6799 add_dwarf_attr (die, &attr);
6802 /* Create a label for an indirect string node, ensuring it is going to
6803 be output, unless its reference count goes down to zero. */
6806 gen_label_for_indirect_string (struct indirect_string_node *node)
6813 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
6814 ++dw2_string_counter;
6815 node->label = xstrdup (label);
6818 /* Create a SYMBOL_REF rtx whose value is the initial address of a
6819 debug string STR. */
6822 get_debug_string_label (const char *str)
6824 struct indirect_string_node *node = find_AT_string (str);
6826 debug_str_hash_forced = true;
6828 gen_label_for_indirect_string (node);
6830 return gen_rtx_SYMBOL_REF (Pmode, node->label);
6833 static inline const char *
6834 AT_string (dw_attr_ref a)
6836 gcc_assert (a && AT_class (a) == dw_val_class_str);
6837 return a->dw_attr_val.v.val_str->str;
6840 /* Find out whether a string should be output inline in DIE
6841 or out-of-line in .debug_str section. */
6843 static enum dwarf_form
6844 AT_string_form (dw_attr_ref a)
6846 struct indirect_string_node *node;
6849 gcc_assert (a && AT_class (a) == dw_val_class_str);
6851 node = a->dw_attr_val.v.val_str;
6855 len = strlen (node->str) + 1;
6857 /* If the string is shorter or equal to the size of the reference, it is
6858 always better to put it inline. */
6859 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
6860 return node->form = DW_FORM_string;
6862 /* If we cannot expect the linker to merge strings in .debug_str
6863 section, only put it into .debug_str if it is worth even in this
6865 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
6866 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
6867 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
6868 return node->form = DW_FORM_string;
6870 gen_label_for_indirect_string (node);
6872 return node->form = DW_FORM_strp;
6875 /* Add a DIE reference attribute value to a DIE. */
6878 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
6882 attr.dw_attr = attr_kind;
6883 attr.dw_attr_val.val_class = dw_val_class_die_ref;
6884 attr.dw_attr_val.v.val_die_ref.die = targ_die;
6885 attr.dw_attr_val.v.val_die_ref.external = 0;
6886 add_dwarf_attr (die, &attr);
6889 /* Add an AT_specification attribute to a DIE, and also make the back
6890 pointer from the specification to the definition. */
6893 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
6895 add_AT_die_ref (die, DW_AT_specification, targ_die);
6896 gcc_assert (!targ_die->die_definition);
6897 targ_die->die_definition = die;
6900 static inline dw_die_ref
6901 AT_ref (dw_attr_ref a)
6903 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6904 return a->dw_attr_val.v.val_die_ref.die;
6908 AT_ref_external (dw_attr_ref a)
6910 if (a && AT_class (a) == dw_val_class_die_ref)
6911 return a->dw_attr_val.v.val_die_ref.external;
6917 set_AT_ref_external (dw_attr_ref a, int i)
6919 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6920 a->dw_attr_val.v.val_die_ref.external = i;
6923 /* Add an FDE reference attribute value to a DIE. */
6926 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
6930 attr.dw_attr = attr_kind;
6931 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
6932 attr.dw_attr_val.v.val_fde_index = targ_fde;
6933 add_dwarf_attr (die, &attr);
6936 /* Add a location description attribute value to a DIE. */
6939 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
6943 attr.dw_attr = attr_kind;
6944 attr.dw_attr_val.val_class = dw_val_class_loc;
6945 attr.dw_attr_val.v.val_loc = loc;
6946 add_dwarf_attr (die, &attr);
6949 static inline dw_loc_descr_ref
6950 AT_loc (dw_attr_ref a)
6952 gcc_assert (a && AT_class (a) == dw_val_class_loc);
6953 return a->dw_attr_val.v.val_loc;
6957 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
6961 attr.dw_attr = attr_kind;
6962 attr.dw_attr_val.val_class = dw_val_class_loc_list;
6963 attr.dw_attr_val.v.val_loc_list = loc_list;
6964 add_dwarf_attr (die, &attr);
6965 have_location_lists = true;
6968 static inline dw_loc_list_ref
6969 AT_loc_list (dw_attr_ref a)
6971 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
6972 return a->dw_attr_val.v.val_loc_list;
6975 /* Add an address constant attribute value to a DIE. */
6978 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
6982 attr.dw_attr = attr_kind;
6983 attr.dw_attr_val.val_class = dw_val_class_addr;
6984 attr.dw_attr_val.v.val_addr = addr;
6985 add_dwarf_attr (die, &attr);
6988 /* Get the RTX from to an address DIE attribute. */
6991 AT_addr (dw_attr_ref a)
6993 gcc_assert (a && AT_class (a) == dw_val_class_addr);
6994 return a->dw_attr_val.v.val_addr;
6997 /* Add a file attribute value to a DIE. */
7000 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
7001 struct dwarf_file_data *fd)
7005 attr.dw_attr = attr_kind;
7006 attr.dw_attr_val.val_class = dw_val_class_file;
7007 attr.dw_attr_val.v.val_file = fd;
7008 add_dwarf_attr (die, &attr);
7011 /* Get the dwarf_file_data from a file DIE attribute. */
7013 static inline struct dwarf_file_data *
7014 AT_file (dw_attr_ref a)
7016 gcc_assert (a && AT_class (a) == dw_val_class_file);
7017 return a->dw_attr_val.v.val_file;
7020 /* Add a label identifier attribute value to a DIE. */
7023 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
7027 attr.dw_attr = attr_kind;
7028 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
7029 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
7030 add_dwarf_attr (die, &attr);
7033 /* Add a section offset attribute value to a DIE, an offset into the
7034 debug_line section. */
7037 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7042 attr.dw_attr = attr_kind;
7043 attr.dw_attr_val.val_class = dw_val_class_lineptr;
7044 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7045 add_dwarf_attr (die, &attr);
7048 /* Add a section offset attribute value to a DIE, an offset into the
7049 debug_macinfo section. */
7052 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7057 attr.dw_attr = attr_kind;
7058 attr.dw_attr_val.val_class = dw_val_class_macptr;
7059 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7060 add_dwarf_attr (die, &attr);
7063 /* Add an offset attribute value to a DIE. */
7066 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
7067 unsigned HOST_WIDE_INT offset)
7071 attr.dw_attr = attr_kind;
7072 attr.dw_attr_val.val_class = dw_val_class_offset;
7073 attr.dw_attr_val.v.val_offset = offset;
7074 add_dwarf_attr (die, &attr);
7077 /* Add an range_list attribute value to a DIE. */
7080 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
7081 long unsigned int offset)
7085 attr.dw_attr = attr_kind;
7086 attr.dw_attr_val.val_class = dw_val_class_range_list;
7087 attr.dw_attr_val.v.val_offset = offset;
7088 add_dwarf_attr (die, &attr);
7091 static inline const char *
7092 AT_lbl (dw_attr_ref a)
7094 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
7095 || AT_class (a) == dw_val_class_lineptr
7096 || AT_class (a) == dw_val_class_macptr));
7097 return a->dw_attr_val.v.val_lbl_id;
7100 /* Get the attribute of type attr_kind. */
7103 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7107 dw_die_ref spec = NULL;
7112 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7113 if (a->dw_attr == attr_kind)
7115 else if (a->dw_attr == DW_AT_specification
7116 || a->dw_attr == DW_AT_abstract_origin)
7120 return get_AT (spec, attr_kind);
7125 /* Return the "low pc" attribute value, typically associated with a subprogram
7126 DIE. Return null if the "low pc" attribute is either not present, or if it
7127 cannot be represented as an assembler label identifier. */
7129 static inline const char *
7130 get_AT_low_pc (dw_die_ref die)
7132 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
7134 return a ? AT_lbl (a) : NULL;
7137 /* Return the "high pc" attribute value, typically associated with a subprogram
7138 DIE. Return null if the "high pc" attribute is either not present, or if it
7139 cannot be represented as an assembler label identifier. */
7141 static inline const char *
7142 get_AT_hi_pc (dw_die_ref die)
7144 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
7146 return a ? AT_lbl (a) : NULL;
7149 /* Return the value of the string attribute designated by ATTR_KIND, or
7150 NULL if it is not present. */
7152 static inline const char *
7153 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
7155 dw_attr_ref a = get_AT (die, attr_kind);
7157 return a ? AT_string (a) : NULL;
7160 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
7161 if it is not present. */
7164 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
7166 dw_attr_ref a = get_AT (die, attr_kind);
7168 return a ? AT_flag (a) : 0;
7171 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
7172 if it is not present. */
7174 static inline unsigned
7175 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
7177 dw_attr_ref a = get_AT (die, attr_kind);
7179 return a ? AT_unsigned (a) : 0;
7182 static inline dw_die_ref
7183 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
7185 dw_attr_ref a = get_AT (die, attr_kind);
7187 return a ? AT_ref (a) : NULL;
7190 static inline struct dwarf_file_data *
7191 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
7193 dw_attr_ref a = get_AT (die, attr_kind);
7195 return a ? AT_file (a) : NULL;
7198 /* Return TRUE if the language is C or C++. */
7203 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7205 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
7206 || lang == DW_LANG_C99
7207 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
7210 /* Return TRUE if the language is C++. */
7215 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7217 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
7220 /* Return TRUE if the language is Fortran. */
7225 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7227 return (lang == DW_LANG_Fortran77
7228 || lang == DW_LANG_Fortran90
7229 || lang == DW_LANG_Fortran95);
7232 /* Return TRUE if the language is Java. */
7237 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7239 return lang == DW_LANG_Java;
7242 /* Return TRUE if the language is Ada. */
7247 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7249 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
7252 /* Remove the specified attribute if present. */
7255 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7263 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7264 if (a->dw_attr == attr_kind)
7266 if (AT_class (a) == dw_val_class_str)
7267 if (a->dw_attr_val.v.val_str->refcount)
7268 a->dw_attr_val.v.val_str->refcount--;
7270 /* VEC_ordered_remove should help reduce the number of abbrevs
7272 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
7277 /* Remove CHILD from its parent. PREV must have the property that
7278 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
7281 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
7283 gcc_assert (child->die_parent == prev->die_parent);
7284 gcc_assert (prev->die_sib == child);
7287 gcc_assert (child->die_parent->die_child == child);
7291 prev->die_sib = child->die_sib;
7292 if (child->die_parent->die_child == child)
7293 child->die_parent->die_child = prev;
7296 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
7300 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
7306 dw_die_ref prev = c;
7308 while (c->die_tag == tag)
7310 remove_child_with_prev (c, prev);
7311 /* Might have removed every child. */
7312 if (c == c->die_sib)
7316 } while (c != die->die_child);
7319 /* Add a CHILD_DIE as the last child of DIE. */
7322 add_child_die (dw_die_ref die, dw_die_ref child_die)
7324 /* FIXME this should probably be an assert. */
7325 if (! die || ! child_die)
7327 gcc_assert (die != child_die);
7329 child_die->die_parent = die;
7332 child_die->die_sib = die->die_child->die_sib;
7333 die->die_child->die_sib = child_die;
7336 child_die->die_sib = child_die;
7337 die->die_child = child_die;
7340 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
7341 is the specification, to the end of PARENT's list of children.
7342 This is done by removing and re-adding it. */
7345 splice_child_die (dw_die_ref parent, dw_die_ref child)
7349 /* We want the declaration DIE from inside the class, not the
7350 specification DIE at toplevel. */
7351 if (child->die_parent != parent)
7353 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
7359 gcc_assert (child->die_parent == parent
7360 || (child->die_parent
7361 == get_AT_ref (parent, DW_AT_specification)));
7363 for (p = child->die_parent->die_child; ; p = p->die_sib)
7364 if (p->die_sib == child)
7366 remove_child_with_prev (child, p);
7370 add_child_die (parent, child);
7373 /* Return a pointer to a newly created DIE node. */
7375 static inline dw_die_ref
7376 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
7378 dw_die_ref die = GGC_CNEW (die_node);
7380 die->die_tag = tag_value;
7382 if (parent_die != NULL)
7383 add_child_die (parent_die, die);
7386 limbo_die_node *limbo_node;
7388 limbo_node = GGC_CNEW (limbo_die_node);
7389 limbo_node->die = die;
7390 limbo_node->created_for = t;
7391 limbo_node->next = limbo_die_list;
7392 limbo_die_list = limbo_node;
7398 /* Return the DIE associated with the given type specifier. */
7400 static inline dw_die_ref
7401 lookup_type_die (tree type)
7403 return TYPE_SYMTAB_DIE (type);
7406 /* Equate a DIE to a given type specifier. */
7409 equate_type_number_to_die (tree type, dw_die_ref type_die)
7411 TYPE_SYMTAB_DIE (type) = type_die;
7414 /* Returns a hash value for X (which really is a die_struct). */
7417 decl_die_table_hash (const void *x)
7419 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
7422 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
7425 decl_die_table_eq (const void *x, const void *y)
7427 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
7430 /* Return the DIE associated with a given declaration. */
7432 static inline dw_die_ref
7433 lookup_decl_die (tree decl)
7435 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
7438 /* Returns a hash value for X (which really is a var_loc_list). */
7441 decl_loc_table_hash (const void *x)
7443 return (hashval_t) ((const var_loc_list *) x)->decl_id;
7446 /* Return nonzero if decl_id of var_loc_list X is the same as
7450 decl_loc_table_eq (const void *x, const void *y)
7452 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
7455 /* Return the var_loc list associated with a given declaration. */
7457 static inline var_loc_list *
7458 lookup_decl_loc (const_tree decl)
7460 return (var_loc_list *)
7461 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
7464 /* Equate a DIE to a particular declaration. */
7467 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
7469 unsigned int decl_id = DECL_UID (decl);
7472 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
7474 decl_die->decl_id = decl_id;
7477 /* Add a variable location node to the linked list for DECL. */
7480 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
7482 unsigned int decl_id = DECL_UID (decl);
7486 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
7489 temp = GGC_CNEW (var_loc_list);
7490 temp->decl_id = decl_id;
7494 temp = (var_loc_list *) *slot;
7498 /* If the current location is the same as the end of the list,
7499 and either both or neither of the locations is uninitialized,
7500 we have nothing to do. */
7501 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
7502 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
7503 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7504 != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
7505 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7506 == VAR_INIT_STATUS_UNINITIALIZED)
7507 || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
7508 == VAR_INIT_STATUS_UNINITIALIZED))))
7510 /* Add LOC to the end of list and update LAST. */
7511 temp->last->next = loc;
7515 /* Do not add empty location to the beginning of the list. */
7516 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
7523 /* Keep track of the number of spaces used to indent the
7524 output of the debugging routines that print the structure of
7525 the DIE internal representation. */
7526 static int print_indent;
7528 /* Indent the line the number of spaces given by print_indent. */
7531 print_spaces (FILE *outfile)
7533 fprintf (outfile, "%*s", print_indent, "");
7536 /* Print the information associated with a given DIE, and its children.
7537 This routine is a debugging aid only. */
7540 print_die (dw_die_ref die, FILE *outfile)
7546 print_spaces (outfile);
7547 fprintf (outfile, "DIE %4ld: %s\n",
7548 die->die_offset, dwarf_tag_name (die->die_tag));
7549 print_spaces (outfile);
7550 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
7551 fprintf (outfile, " offset: %ld\n", die->die_offset);
7553 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7555 print_spaces (outfile);
7556 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
7558 switch (AT_class (a))
7560 case dw_val_class_addr:
7561 fprintf (outfile, "address");
7563 case dw_val_class_offset:
7564 fprintf (outfile, "offset");
7566 case dw_val_class_loc:
7567 fprintf (outfile, "location descriptor");
7569 case dw_val_class_loc_list:
7570 fprintf (outfile, "location list -> label:%s",
7571 AT_loc_list (a)->ll_symbol);
7573 case dw_val_class_range_list:
7574 fprintf (outfile, "range list");
7576 case dw_val_class_const:
7577 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
7579 case dw_val_class_unsigned_const:
7580 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
7582 case dw_val_class_long_long:
7583 fprintf (outfile, "constant (" HOST_WIDE_INT_PRINT_UNSIGNED
7584 "," HOST_WIDE_INT_PRINT_UNSIGNED ")",
7585 CONST_DOUBLE_HIGH (a->dw_attr_val.v.val_long_long),
7586 CONST_DOUBLE_LOW (a->dw_attr_val.v.val_long_long));
7588 case dw_val_class_vec:
7589 fprintf (outfile, "floating-point or vector constant");
7591 case dw_val_class_flag:
7592 fprintf (outfile, "%u", AT_flag (a));
7594 case dw_val_class_die_ref:
7595 if (AT_ref (a) != NULL)
7597 if (AT_ref (a)->die_symbol)
7598 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
7600 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
7603 fprintf (outfile, "die -> <null>");
7605 case dw_val_class_lbl_id:
7606 case dw_val_class_lineptr:
7607 case dw_val_class_macptr:
7608 fprintf (outfile, "label: %s", AT_lbl (a));
7610 case dw_val_class_str:
7611 if (AT_string (a) != NULL)
7612 fprintf (outfile, "\"%s\"", AT_string (a));
7614 fprintf (outfile, "<null>");
7616 case dw_val_class_file:
7617 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
7618 AT_file (a)->emitted_number);
7624 fprintf (outfile, "\n");
7627 if (die->die_child != NULL)
7630 FOR_EACH_CHILD (die, c, print_die (c, outfile));
7633 if (print_indent == 0)
7634 fprintf (outfile, "\n");
7637 /* Print the contents of the source code line number correspondence table.
7638 This routine is a debugging aid only. */
7641 print_dwarf_line_table (FILE *outfile)
7644 dw_line_info_ref line_info;
7646 fprintf (outfile, "\n\nDWARF source line information\n");
7647 for (i = 1; i < line_info_table_in_use; i++)
7649 line_info = &line_info_table[i];
7650 fprintf (outfile, "%5d: %4ld %6ld\n", i,
7651 line_info->dw_file_num,
7652 line_info->dw_line_num);
7655 fprintf (outfile, "\n\n");
7658 /* Print the information collected for a given DIE. */
7661 debug_dwarf_die (dw_die_ref die)
7663 print_die (die, stderr);
7666 /* Print all DWARF information collected for the compilation unit.
7667 This routine is a debugging aid only. */
7673 print_die (comp_unit_die, stderr);
7674 if (! DWARF2_ASM_LINE_DEBUG_INFO)
7675 print_dwarf_line_table (stderr);
7678 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
7679 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
7680 DIE that marks the start of the DIEs for this include file. */
7683 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
7685 const char *filename = get_AT_string (bincl_die, DW_AT_name);
7686 dw_die_ref new_unit = gen_compile_unit_die (filename);
7688 new_unit->die_sib = old_unit;
7692 /* Close an include-file CU and reopen the enclosing one. */
7695 pop_compile_unit (dw_die_ref old_unit)
7697 dw_die_ref new_unit = old_unit->die_sib;
7699 old_unit->die_sib = NULL;
7703 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7704 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
7706 /* Calculate the checksum of a location expression. */
7709 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
7713 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
7715 CHECKSUM (loc->dw_loc_oprnd1);
7716 CHECKSUM (loc->dw_loc_oprnd2);
7719 /* Calculate the checksum of an attribute. */
7722 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
7724 dw_loc_descr_ref loc;
7727 CHECKSUM (at->dw_attr);
7729 /* We don't care that this was compiled with a different compiler
7730 snapshot; if the output is the same, that's what matters. */
7731 if (at->dw_attr == DW_AT_producer)
7734 switch (AT_class (at))
7736 case dw_val_class_const:
7737 CHECKSUM (at->dw_attr_val.v.val_int);
7739 case dw_val_class_unsigned_const:
7740 CHECKSUM (at->dw_attr_val.v.val_unsigned);
7742 case dw_val_class_long_long:
7743 CHECKSUM (CONST_DOUBLE_HIGH (at->dw_attr_val.v.val_long_long));
7744 CHECKSUM (CONST_DOUBLE_LOW (at->dw_attr_val.v.val_long_long));
7746 case dw_val_class_vec:
7747 CHECKSUM (at->dw_attr_val.v.val_vec);
7749 case dw_val_class_flag:
7750 CHECKSUM (at->dw_attr_val.v.val_flag);
7752 case dw_val_class_str:
7753 CHECKSUM_STRING (AT_string (at));
7756 case dw_val_class_addr:
7758 gcc_assert (GET_CODE (r) == SYMBOL_REF);
7759 CHECKSUM_STRING (XSTR (r, 0));
7762 case dw_val_class_offset:
7763 CHECKSUM (at->dw_attr_val.v.val_offset);
7766 case dw_val_class_loc:
7767 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
7768 loc_checksum (loc, ctx);
7771 case dw_val_class_die_ref:
7772 die_checksum (AT_ref (at), ctx, mark);
7775 case dw_val_class_fde_ref:
7776 case dw_val_class_lbl_id:
7777 case dw_val_class_lineptr:
7778 case dw_val_class_macptr:
7781 case dw_val_class_file:
7782 CHECKSUM_STRING (AT_file (at)->filename);
7790 /* Calculate the checksum of a DIE. */
7793 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
7799 /* To avoid infinite recursion. */
7802 CHECKSUM (die->die_mark);
7805 die->die_mark = ++(*mark);
7807 CHECKSUM (die->die_tag);
7809 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7810 attr_checksum (a, ctx, mark);
7812 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
7816 #undef CHECKSUM_STRING
7818 /* Do the location expressions look same? */
7820 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
7822 return loc1->dw_loc_opc == loc2->dw_loc_opc
7823 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
7824 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
7827 /* Do the values look the same? */
7829 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
7831 dw_loc_descr_ref loc1, loc2;
7834 if (v1->val_class != v2->val_class)
7837 switch (v1->val_class)
7839 case dw_val_class_const:
7840 return v1->v.val_int == v2->v.val_int;
7841 case dw_val_class_unsigned_const:
7842 return v1->v.val_unsigned == v2->v.val_unsigned;
7843 case dw_val_class_long_long:
7844 return CONST_DOUBLE_HIGH (v1->v.val_long_long)
7845 == CONST_DOUBLE_HIGH (v2->v.val_long_long)
7846 && CONST_DOUBLE_LOW (v1->v.val_long_long)
7847 == CONST_DOUBLE_LOW (v2->v.val_long_long);
7848 case dw_val_class_vec:
7849 if (v1->v.val_vec.length != v2->v.val_vec.length
7850 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
7852 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
7853 v1->v.val_vec.length * v1->v.val_vec.elt_size))
7856 case dw_val_class_flag:
7857 return v1->v.val_flag == v2->v.val_flag;
7858 case dw_val_class_str:
7859 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
7861 case dw_val_class_addr:
7862 r1 = v1->v.val_addr;
7863 r2 = v2->v.val_addr;
7864 if (GET_CODE (r1) != GET_CODE (r2))
7866 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
7867 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
7869 case dw_val_class_offset:
7870 return v1->v.val_offset == v2->v.val_offset;
7872 case dw_val_class_loc:
7873 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
7875 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7876 if (!same_loc_p (loc1, loc2, mark))
7878 return !loc1 && !loc2;
7880 case dw_val_class_die_ref:
7881 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7883 case dw_val_class_fde_ref:
7884 case dw_val_class_lbl_id:
7885 case dw_val_class_lineptr:
7886 case dw_val_class_macptr:
7889 case dw_val_class_file:
7890 return v1->v.val_file == v2->v.val_file;
7897 /* Do the attributes look the same? */
7900 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
7902 if (at1->dw_attr != at2->dw_attr)
7905 /* We don't care that this was compiled with a different compiler
7906 snapshot; if the output is the same, that's what matters. */
7907 if (at1->dw_attr == DW_AT_producer)
7910 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7913 /* Do the dies look the same? */
7916 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7922 /* To avoid infinite recursion. */
7924 return die1->die_mark == die2->die_mark;
7925 die1->die_mark = die2->die_mark = ++(*mark);
7927 if (die1->die_tag != die2->die_tag)
7930 if (VEC_length (dw_attr_node, die1->die_attr)
7931 != VEC_length (dw_attr_node, die2->die_attr))
7934 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
7935 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
7938 c1 = die1->die_child;
7939 c2 = die2->die_child;
7948 if (!same_die_p (c1, c2, mark))
7952 if (c1 == die1->die_child)
7954 if (c2 == die2->die_child)
7964 /* Do the dies look the same? Wrapper around same_die_p. */
7967 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
7970 int ret = same_die_p (die1, die2, &mark);
7972 unmark_all_dies (die1);
7973 unmark_all_dies (die2);
7978 /* The prefix to attach to symbols on DIEs in the current comdat debug
7980 static char *comdat_symbol_id;
7982 /* The index of the current symbol within the current comdat CU. */
7983 static unsigned int comdat_symbol_number;
7985 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7986 children, and set comdat_symbol_id accordingly. */
7989 compute_section_prefix (dw_die_ref unit_die)
7991 const char *die_name = get_AT_string (unit_die, DW_AT_name);
7992 const char *base = die_name ? lbasename (die_name) : "anonymous";
7993 char *name = XALLOCAVEC (char, strlen (base) + 64);
7996 unsigned char checksum[16];
7999 /* Compute the checksum of the DIE, then append part of it as hex digits to
8000 the name filename of the unit. */
8002 md5_init_ctx (&ctx);
8004 die_checksum (unit_die, &ctx, &mark);
8005 unmark_all_dies (unit_die);
8006 md5_finish_ctx (&ctx, checksum);
8008 sprintf (name, "%s.", base);
8009 clean_symbol_name (name);
8011 p = name + strlen (name);
8012 for (i = 0; i < 4; i++)
8014 sprintf (p, "%.2x", checksum[i]);
8018 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
8019 comdat_symbol_number = 0;
8022 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
8025 is_type_die (dw_die_ref die)
8027 switch (die->die_tag)
8029 case DW_TAG_array_type:
8030 case DW_TAG_class_type:
8031 case DW_TAG_interface_type:
8032 case DW_TAG_enumeration_type:
8033 case DW_TAG_pointer_type:
8034 case DW_TAG_reference_type:
8035 case DW_TAG_string_type:
8036 case DW_TAG_structure_type:
8037 case DW_TAG_subroutine_type:
8038 case DW_TAG_union_type:
8039 case DW_TAG_ptr_to_member_type:
8040 case DW_TAG_set_type:
8041 case DW_TAG_subrange_type:
8042 case DW_TAG_base_type:
8043 case DW_TAG_const_type:
8044 case DW_TAG_file_type:
8045 case DW_TAG_packed_type:
8046 case DW_TAG_volatile_type:
8047 case DW_TAG_typedef:
8054 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
8055 Basically, we want to choose the bits that are likely to be shared between
8056 compilations (types) and leave out the bits that are specific to individual
8057 compilations (functions). */
8060 is_comdat_die (dw_die_ref c)
8062 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
8063 we do for stabs. The advantage is a greater likelihood of sharing between
8064 objects that don't include headers in the same order (and therefore would
8065 put the base types in a different comdat). jason 8/28/00 */
8067 if (c->die_tag == DW_TAG_base_type)
8070 if (c->die_tag == DW_TAG_pointer_type
8071 || c->die_tag == DW_TAG_reference_type
8072 || c->die_tag == DW_TAG_const_type
8073 || c->die_tag == DW_TAG_volatile_type)
8075 dw_die_ref t = get_AT_ref (c, DW_AT_type);
8077 return t ? is_comdat_die (t) : 0;
8080 return is_type_die (c);
8083 /* Returns 1 iff C is the sort of DIE that might be referred to from another
8084 compilation unit. */
8087 is_symbol_die (dw_die_ref c)
8089 return (is_type_die (c)
8090 || (get_AT (c, DW_AT_declaration)
8091 && !get_AT (c, DW_AT_specification))
8092 || c->die_tag == DW_TAG_namespace
8093 || c->die_tag == DW_TAG_module);
8097 gen_internal_sym (const char *prefix)
8101 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
8102 return xstrdup (buf);
8105 /* Assign symbols to all worthy DIEs under DIE. */
8108 assign_symbol_names (dw_die_ref die)
8112 if (is_symbol_die (die))
8114 if (comdat_symbol_id)
8116 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
8118 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
8119 comdat_symbol_id, comdat_symbol_number++);
8120 die->die_symbol = xstrdup (p);
8123 die->die_symbol = gen_internal_sym ("LDIE");
8126 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
8129 struct cu_hash_table_entry
8132 unsigned min_comdat_num, max_comdat_num;
8133 struct cu_hash_table_entry *next;
8136 /* Routines to manipulate hash table of CUs. */
8138 htab_cu_hash (const void *of)
8140 const struct cu_hash_table_entry *const entry =
8141 (const struct cu_hash_table_entry *) of;
8143 return htab_hash_string (entry->cu->die_symbol);
8147 htab_cu_eq (const void *of1, const void *of2)
8149 const struct cu_hash_table_entry *const entry1 =
8150 (const struct cu_hash_table_entry *) of1;
8151 const struct die_struct *const entry2 = (const struct die_struct *) of2;
8153 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
8157 htab_cu_del (void *what)
8159 struct cu_hash_table_entry *next,
8160 *entry = (struct cu_hash_table_entry *) what;
8170 /* Check whether we have already seen this CU and set up SYM_NUM
8173 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
8175 struct cu_hash_table_entry dummy;
8176 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
8178 dummy.max_comdat_num = 0;
8180 slot = (struct cu_hash_table_entry **)
8181 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
8185 for (; entry; last = entry, entry = entry->next)
8187 if (same_die_p_wrap (cu, entry->cu))
8193 *sym_num = entry->min_comdat_num;
8197 entry = XCNEW (struct cu_hash_table_entry);
8199 entry->min_comdat_num = *sym_num = last->max_comdat_num;
8200 entry->next = *slot;
8206 /* Record SYM_NUM to record of CU in HTABLE. */
8208 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
8210 struct cu_hash_table_entry **slot, *entry;
8212 slot = (struct cu_hash_table_entry **)
8213 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
8217 entry->max_comdat_num = sym_num;
8220 /* Traverse the DIE (which is always comp_unit_die), and set up
8221 additional compilation units for each of the include files we see
8222 bracketed by BINCL/EINCL. */
8225 break_out_includes (dw_die_ref die)
8228 dw_die_ref unit = NULL;
8229 limbo_die_node *node, **pnode;
8230 htab_t cu_hash_table;
8234 dw_die_ref prev = c;
8236 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
8237 || (unit && is_comdat_die (c)))
8239 dw_die_ref next = c->die_sib;
8241 /* This DIE is for a secondary CU; remove it from the main one. */
8242 remove_child_with_prev (c, prev);
8244 if (c->die_tag == DW_TAG_GNU_BINCL)
8245 unit = push_new_compile_unit (unit, c);
8246 else if (c->die_tag == DW_TAG_GNU_EINCL)
8247 unit = pop_compile_unit (unit);
8249 add_child_die (unit, c);
8251 if (c == die->die_child)
8254 } while (c != die->die_child);
8257 /* We can only use this in debugging, since the frontend doesn't check
8258 to make sure that we leave every include file we enter. */
8262 assign_symbol_names (die);
8263 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
8264 for (node = limbo_die_list, pnode = &limbo_die_list;
8270 compute_section_prefix (node->die);
8271 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
8272 &comdat_symbol_number);
8273 assign_symbol_names (node->die);
8275 *pnode = node->next;
8278 pnode = &node->next;
8279 record_comdat_symbol_number (node->die, cu_hash_table,
8280 comdat_symbol_number);
8283 htab_delete (cu_hash_table);
8286 /* Traverse the DIE and add a sibling attribute if it may have the
8287 effect of speeding up access to siblings. To save some space,
8288 avoid generating sibling attributes for DIE's without children. */
8291 add_sibling_attributes (dw_die_ref die)
8295 if (! die->die_child)
8298 if (die->die_parent && die != die->die_parent->die_child)
8299 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
8301 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
8304 /* Output all location lists for the DIE and its children. */
8307 output_location_lists (dw_die_ref die)
8313 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8314 if (AT_class (a) == dw_val_class_loc_list)
8315 output_loc_list (AT_loc_list (a));
8317 FOR_EACH_CHILD (die, c, output_location_lists (c));
8320 /* The format of each DIE (and its attribute value pairs) is encoded in an
8321 abbreviation table. This routine builds the abbreviation table and assigns
8322 a unique abbreviation id for each abbreviation entry. The children of each
8323 die are visited recursively. */
8326 build_abbrev_table (dw_die_ref die)
8328 unsigned long abbrev_id;
8329 unsigned int n_alloc;
8334 /* Scan the DIE references, and mark as external any that refer to
8335 DIEs from other CUs (i.e. those which are not marked). */
8336 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8337 if (AT_class (a) == dw_val_class_die_ref
8338 && AT_ref (a)->die_mark == 0)
8340 gcc_assert (AT_ref (a)->die_symbol);
8341 set_AT_ref_external (a, 1);
8344 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8346 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
8347 dw_attr_ref die_a, abbrev_a;
8351 if (abbrev->die_tag != die->die_tag)
8353 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
8356 if (VEC_length (dw_attr_node, abbrev->die_attr)
8357 != VEC_length (dw_attr_node, die->die_attr))
8360 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
8362 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
8363 if ((abbrev_a->dw_attr != die_a->dw_attr)
8364 || (value_format (abbrev_a) != value_format (die_a)))
8374 if (abbrev_id >= abbrev_die_table_in_use)
8376 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
8378 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
8379 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
8382 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
8383 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
8384 abbrev_die_table_allocated = n_alloc;
8387 ++abbrev_die_table_in_use;
8388 abbrev_die_table[abbrev_id] = die;
8391 die->die_abbrev = abbrev_id;
8392 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
8395 /* Return the power-of-two number of bytes necessary to represent VALUE. */
8398 constant_size (unsigned HOST_WIDE_INT value)
8405 log = floor_log2 (value);
8408 log = 1 << (floor_log2 (log) + 1);
8413 /* Return the size of a DIE as it is represented in the
8414 .debug_info section. */
8416 static unsigned long
8417 size_of_die (dw_die_ref die)
8419 unsigned long size = 0;
8423 size += size_of_uleb128 (die->die_abbrev);
8424 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8426 switch (AT_class (a))
8428 case dw_val_class_addr:
8429 size += DWARF2_ADDR_SIZE;
8431 case dw_val_class_offset:
8432 size += DWARF_OFFSET_SIZE;
8434 case dw_val_class_loc:
8436 unsigned long lsize = size_of_locs (AT_loc (a));
8439 size += constant_size (lsize);
8443 case dw_val_class_loc_list:
8444 size += DWARF_OFFSET_SIZE;
8446 case dw_val_class_range_list:
8447 size += DWARF_OFFSET_SIZE;
8449 case dw_val_class_const:
8450 size += size_of_sleb128 (AT_int (a));
8452 case dw_val_class_unsigned_const:
8453 size += constant_size (AT_unsigned (a));
8455 case dw_val_class_long_long:
8456 size += 1 + 2*HOST_BITS_PER_WIDE_INT/HOST_BITS_PER_CHAR; /* block */
8458 case dw_val_class_vec:
8459 size += constant_size (a->dw_attr_val.v.val_vec.length
8460 * a->dw_attr_val.v.val_vec.elt_size)
8461 + a->dw_attr_val.v.val_vec.length
8462 * a->dw_attr_val.v.val_vec.elt_size; /* block */
8464 case dw_val_class_flag:
8467 case dw_val_class_die_ref:
8468 /* In DWARF2, DW_FORM_ref_addr is sized by target address length,
8469 whereas in DWARF3 it's always sized as an offset. */
8470 if (AT_ref_external (a) && dwarf_version == 2)
8471 size += DWARF2_ADDR_SIZE;
8473 size += DWARF_OFFSET_SIZE;
8475 case dw_val_class_fde_ref:
8476 size += DWARF_OFFSET_SIZE;
8478 case dw_val_class_lbl_id:
8479 size += DWARF2_ADDR_SIZE;
8481 case dw_val_class_lineptr:
8482 case dw_val_class_macptr:
8483 size += DWARF_OFFSET_SIZE;
8485 case dw_val_class_str:
8486 if (AT_string_form (a) == DW_FORM_strp)
8487 size += DWARF_OFFSET_SIZE;
8489 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
8491 case dw_val_class_file:
8492 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
8502 /* Size the debugging information associated with a given DIE. Visits the
8503 DIE's children recursively. Updates the global variable next_die_offset, on
8504 each time through. Uses the current value of next_die_offset to update the
8505 die_offset field in each DIE. */
8508 calc_die_sizes (dw_die_ref die)
8512 die->die_offset = next_die_offset;
8513 next_die_offset += size_of_die (die);
8515 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
8517 if (die->die_child != NULL)
8518 /* Count the null byte used to terminate sibling lists. */
8519 next_die_offset += 1;
8522 /* Set the marks for a die and its children. We do this so
8523 that we know whether or not a reference needs to use FORM_ref_addr; only
8524 DIEs in the same CU will be marked. We used to clear out the offset
8525 and use that as the flag, but ran into ordering problems. */
8528 mark_dies (dw_die_ref die)
8532 gcc_assert (!die->die_mark);
8535 FOR_EACH_CHILD (die, c, mark_dies (c));
8538 /* Clear the marks for a die and its children. */
8541 unmark_dies (dw_die_ref die)
8545 gcc_assert (die->die_mark);
8548 FOR_EACH_CHILD (die, c, unmark_dies (c));
8551 /* Clear the marks for a die, its children and referred dies. */
8554 unmark_all_dies (dw_die_ref die)
8564 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
8566 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8567 if (AT_class (a) == dw_val_class_die_ref)
8568 unmark_all_dies (AT_ref (a));
8571 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8572 generated for the compilation unit. */
8574 static unsigned long
8575 size_of_pubnames (VEC (pubname_entry, gc) * names)
8581 size = DWARF_PUBNAMES_HEADER_SIZE;
8582 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
8583 if (names != pubtype_table
8584 || p->die->die_offset != 0
8585 || !flag_eliminate_unused_debug_types)
8586 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
8588 size += DWARF_OFFSET_SIZE;
8592 /* Return the size of the information in the .debug_aranges section. */
8594 static unsigned long
8595 size_of_aranges (void)
8599 size = DWARF_ARANGES_HEADER_SIZE;
8601 /* Count the address/length pair for this compilation unit. */
8602 if (text_section_used)
8603 size += 2 * DWARF2_ADDR_SIZE;
8604 if (cold_text_section_used)
8605 size += 2 * DWARF2_ADDR_SIZE;
8606 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
8608 /* Count the two zero words used to terminated the address range table. */
8609 size += 2 * DWARF2_ADDR_SIZE;
8613 /* Select the encoding of an attribute value. */
8615 static enum dwarf_form
8616 value_format (dw_attr_ref a)
8618 switch (a->dw_attr_val.val_class)
8620 case dw_val_class_addr:
8621 return DW_FORM_addr;
8622 case dw_val_class_range_list:
8623 case dw_val_class_offset:
8624 case dw_val_class_loc_list:
8625 switch (DWARF_OFFSET_SIZE)
8628 return DW_FORM_data4;
8630 return DW_FORM_data8;
8634 case dw_val_class_loc:
8635 switch (constant_size (size_of_locs (AT_loc (a))))
8638 return DW_FORM_block1;
8640 return DW_FORM_block2;
8644 case dw_val_class_const:
8645 return DW_FORM_sdata;
8646 case dw_val_class_unsigned_const:
8647 switch (constant_size (AT_unsigned (a)))
8650 return DW_FORM_data1;
8652 return DW_FORM_data2;
8654 return DW_FORM_data4;
8656 return DW_FORM_data8;
8660 case dw_val_class_long_long:
8661 return DW_FORM_block1;
8662 case dw_val_class_vec:
8663 switch (constant_size (a->dw_attr_val.v.val_vec.length
8664 * a->dw_attr_val.v.val_vec.elt_size))
8667 return DW_FORM_block1;
8669 return DW_FORM_block2;
8671 return DW_FORM_block4;
8675 case dw_val_class_flag:
8676 return DW_FORM_flag;
8677 case dw_val_class_die_ref:
8678 if (AT_ref_external (a))
8679 return DW_FORM_ref_addr;
8682 case dw_val_class_fde_ref:
8683 return DW_FORM_data;
8684 case dw_val_class_lbl_id:
8685 return DW_FORM_addr;
8686 case dw_val_class_lineptr:
8687 case dw_val_class_macptr:
8688 return DW_FORM_data;
8689 case dw_val_class_str:
8690 return AT_string_form (a);
8691 case dw_val_class_file:
8692 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
8695 return DW_FORM_data1;
8697 return DW_FORM_data2;
8699 return DW_FORM_data4;
8709 /* Output the encoding of an attribute value. */
8712 output_value_format (dw_attr_ref a)
8714 enum dwarf_form form = value_format (a);
8716 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
8719 /* Output the .debug_abbrev section which defines the DIE abbreviation
8723 output_abbrev_section (void)
8725 unsigned long abbrev_id;
8727 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8729 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
8733 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
8734 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
8735 dwarf_tag_name (abbrev->die_tag));
8737 if (abbrev->die_child != NULL)
8738 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
8740 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
8742 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
8745 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
8746 dwarf_attr_name (a_attr->dw_attr));
8747 output_value_format (a_attr);
8750 dw2_asm_output_data (1, 0, NULL);
8751 dw2_asm_output_data (1, 0, NULL);
8754 /* Terminate the table. */
8755 dw2_asm_output_data (1, 0, NULL);
8758 /* Output a symbol we can use to refer to this DIE from another CU. */
8761 output_die_symbol (dw_die_ref die)
8763 char *sym = die->die_symbol;
8768 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
8769 /* We make these global, not weak; if the target doesn't support
8770 .linkonce, it doesn't support combining the sections, so debugging
8772 targetm.asm_out.globalize_label (asm_out_file, sym);
8774 ASM_OUTPUT_LABEL (asm_out_file, sym);
8777 /* Return a new location list, given the begin and end range, and the
8778 expression. gensym tells us whether to generate a new internal symbol for
8779 this location list node, which is done for the head of the list only. */
8781 static inline dw_loc_list_ref
8782 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
8783 const char *section, unsigned int gensym)
8785 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
8787 retlist->begin = begin;
8789 retlist->expr = expr;
8790 retlist->section = section;
8792 retlist->ll_symbol = gen_internal_sym ("LLST");
8797 /* Add a location description expression to a location list. */
8800 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
8801 const char *begin, const char *end,
8802 const char *section)
8806 /* Find the end of the chain. */
8807 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
8810 /* Add a new location list node to the list. */
8811 *d = new_loc_list (descr, begin, end, section, 0);
8814 /* Output the location list given to us. */
8817 output_loc_list (dw_loc_list_ref list_head)
8819 dw_loc_list_ref curr = list_head;
8821 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
8823 /* Walk the location list, and output each range + expression. */
8824 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
8827 /* Don't output an entry that starts and ends at the same address. */
8828 if (strcmp (curr->begin, curr->end) == 0)
8830 if (!have_multiple_function_sections)
8832 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
8833 "Location list begin address (%s)",
8834 list_head->ll_symbol);
8835 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
8836 "Location list end address (%s)",
8837 list_head->ll_symbol);
8841 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
8842 "Location list begin address (%s)",
8843 list_head->ll_symbol);
8844 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
8845 "Location list end address (%s)",
8846 list_head->ll_symbol);
8848 size = size_of_locs (curr->expr);
8850 /* Output the block length for this list of location operations. */
8851 gcc_assert (size <= 0xffff);
8852 dw2_asm_output_data (2, size, "%s", "Location expression size");
8854 output_loc_sequence (curr->expr);
8857 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8858 "Location list terminator begin (%s)",
8859 list_head->ll_symbol);
8860 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8861 "Location list terminator end (%s)",
8862 list_head->ll_symbol);
8865 /* Output the DIE and its attributes. Called recursively to generate
8866 the definitions of each child DIE. */
8869 output_die (dw_die_ref die)
8876 /* If someone in another CU might refer to us, set up a symbol for
8877 them to point to. */
8878 if (die->die_symbol)
8879 output_die_symbol (die);
8881 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
8882 (unsigned long)die->die_offset,
8883 dwarf_tag_name (die->die_tag));
8885 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8887 const char *name = dwarf_attr_name (a->dw_attr);
8889 switch (AT_class (a))
8891 case dw_val_class_addr:
8892 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8895 case dw_val_class_offset:
8896 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8900 case dw_val_class_range_list:
8902 char *p = strchr (ranges_section_label, '\0');
8904 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8905 a->dw_attr_val.v.val_offset);
8906 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8907 debug_ranges_section, "%s", name);
8912 case dw_val_class_loc:
8913 size = size_of_locs (AT_loc (a));
8915 /* Output the block length for this list of location operations. */
8916 dw2_asm_output_data (constant_size (size), size, "%s", name);
8918 output_loc_sequence (AT_loc (a));
8921 case dw_val_class_const:
8922 /* ??? It would be slightly more efficient to use a scheme like is
8923 used for unsigned constants below, but gdb 4.x does not sign
8924 extend. Gdb 5.x does sign extend. */
8925 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8928 case dw_val_class_unsigned_const:
8929 dw2_asm_output_data (constant_size (AT_unsigned (a)),
8930 AT_unsigned (a), "%s", name);
8933 case dw_val_class_long_long:
8935 unsigned HOST_WIDE_INT first, second;
8937 dw2_asm_output_data (1,
8938 2 * HOST_BITS_PER_WIDE_INT
8939 / HOST_BITS_PER_CHAR,
8942 if (WORDS_BIG_ENDIAN)
8944 first = CONST_DOUBLE_HIGH (a->dw_attr_val.v.val_long_long);
8945 second = CONST_DOUBLE_LOW (a->dw_attr_val.v.val_long_long);
8949 first = CONST_DOUBLE_LOW (a->dw_attr_val.v.val_long_long);
8950 second = CONST_DOUBLE_HIGH (a->dw_attr_val.v.val_long_long);
8953 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8954 first, "long long constant");
8955 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
8960 case dw_val_class_vec:
8962 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8963 unsigned int len = a->dw_attr_val.v.val_vec.length;
8967 dw2_asm_output_data (constant_size (len * elt_size),
8968 len * elt_size, "%s", name);
8969 if (elt_size > sizeof (HOST_WIDE_INT))
8974 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8977 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8978 "fp or vector constant word %u", i);
8982 case dw_val_class_flag:
8983 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8986 case dw_val_class_loc_list:
8988 char *sym = AT_loc_list (a)->ll_symbol;
8991 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8996 case dw_val_class_die_ref:
8997 if (AT_ref_external (a))
8999 char *sym = AT_ref (a)->die_symbol;
9004 /* In DWARF2, DW_FORM_ref_addr is sized by target address
9005 length, whereas in DWARF3 it's always sized as an offset. */
9006 if (dwarf_version == 2)
9007 size = DWARF2_ADDR_SIZE;
9009 size = DWARF_OFFSET_SIZE;
9010 dw2_asm_output_offset (size, sym, debug_info_section, "%s", name);
9014 gcc_assert (AT_ref (a)->die_offset);
9015 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
9020 case dw_val_class_fde_ref:
9024 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
9025 a->dw_attr_val.v.val_fde_index * 2);
9026 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
9031 case dw_val_class_lbl_id:
9032 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
9035 case dw_val_class_lineptr:
9036 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9037 debug_line_section, "%s", name);
9040 case dw_val_class_macptr:
9041 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
9042 debug_macinfo_section, "%s", name);
9045 case dw_val_class_str:
9046 if (AT_string_form (a) == DW_FORM_strp)
9047 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
9048 a->dw_attr_val.v.val_str->label,
9050 "%s: \"%s\"", name, AT_string (a));
9052 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
9055 case dw_val_class_file:
9057 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
9059 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
9060 a->dw_attr_val.v.val_file->filename);
9069 FOR_EACH_CHILD (die, c, output_die (c));
9071 /* Add null byte to terminate sibling list. */
9072 if (die->die_child != NULL)
9073 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
9074 (unsigned long) die->die_offset);
9077 /* Output the compilation unit that appears at the beginning of the
9078 .debug_info section, and precedes the DIE descriptions. */
9081 output_compilation_unit_header (void)
9083 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9084 dw2_asm_output_data (4, 0xffffffff,
9085 "Initial length escape value indicating 64-bit DWARF extension");
9086 dw2_asm_output_data (DWARF_OFFSET_SIZE,
9087 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
9088 "Length of Compilation Unit Info");
9089 dw2_asm_output_data (2, dwarf_version, "DWARF version number");
9090 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
9091 debug_abbrev_section,
9092 "Offset Into Abbrev. Section");
9093 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
9096 /* Output the compilation unit DIE and its children. */
9099 output_comp_unit (dw_die_ref die, int output_if_empty)
9101 const char *secname;
9104 /* Unless we are outputting main CU, we may throw away empty ones. */
9105 if (!output_if_empty && die->die_child == NULL)
9108 /* Even if there are no children of this DIE, we must output the information
9109 about the compilation unit. Otherwise, on an empty translation unit, we
9110 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
9111 will then complain when examining the file. First mark all the DIEs in
9112 this CU so we know which get local refs. */
9115 build_abbrev_table (die);
9117 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9118 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
9119 calc_die_sizes (die);
9121 oldsym = die->die_symbol;
9124 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
9126 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
9128 die->die_symbol = NULL;
9129 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
9132 switch_to_section (debug_info_section);
9134 /* Output debugging information. */
9135 output_compilation_unit_header ();
9138 /* Leave the marks on the main CU, so we can check them in
9143 die->die_symbol = oldsym;
9147 /* Return the DWARF2/3 pubname associated with a decl. */
9150 dwarf2_name (tree decl, int scope)
9152 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
9155 /* Add a new entry to .debug_pubnames if appropriate. */
9158 add_pubname_string (const char *str, dw_die_ref die)
9163 e.name = xstrdup (str);
9164 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
9168 add_pubname (tree decl, dw_die_ref die)
9170 if (TREE_PUBLIC (decl))
9171 add_pubname_string (dwarf2_name (decl, 1), die);
9174 /* Add a new entry to .debug_pubtypes if appropriate. */
9177 add_pubtype (tree decl, dw_die_ref die)
9182 if ((TREE_PUBLIC (decl)
9183 || die->die_parent == comp_unit_die)
9184 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
9189 if (TYPE_NAME (decl))
9191 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
9192 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
9193 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
9194 && DECL_NAME (TYPE_NAME (decl)))
9195 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
9197 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
9201 e.name = xstrdup (dwarf2_name (decl, 1));
9203 /* If we don't have a name for the type, there's no point in adding
9205 if (e.name && e.name[0] != '\0')
9206 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
9210 /* Output the public names table used to speed up access to externally
9211 visible names; or the public types table used to find type definitions. */
9214 output_pubnames (VEC (pubname_entry, gc) * names)
9217 unsigned long pubnames_length = size_of_pubnames (names);
9220 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9221 dw2_asm_output_data (4, 0xffffffff,
9222 "Initial length escape value indicating 64-bit DWARF extension");
9223 if (names == pubname_table)
9224 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
9225 "Length of Public Names Info");
9227 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
9228 "Length of Public Type Names Info");
9229 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
9230 dw2_asm_output_data (2, 2, "DWARF Version");
9231 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9233 "Offset of Compilation Unit Info");
9234 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
9235 "Compilation Unit Length");
9237 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
9239 /* We shouldn't see pubnames for DIEs outside of the main CU. */
9240 if (names == pubname_table)
9241 gcc_assert (pub->die->die_mark);
9243 if (names != pubtype_table
9244 || pub->die->die_offset != 0
9245 || !flag_eliminate_unused_debug_types)
9247 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
9250 dw2_asm_output_nstring (pub->name, -1, "external name");
9254 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
9257 /* Add a new entry to .debug_aranges if appropriate. */
9260 add_arange (tree decl, dw_die_ref die)
9262 if (! DECL_SECTION_NAME (decl))
9265 if (arange_table_in_use == arange_table_allocated)
9267 arange_table_allocated += ARANGE_TABLE_INCREMENT;
9268 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
9269 arange_table_allocated);
9270 memset (arange_table + arange_table_in_use, 0,
9271 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
9274 arange_table[arange_table_in_use++] = die;
9277 /* Output the information that goes into the .debug_aranges table.
9278 Namely, define the beginning and ending address range of the
9279 text section generated for this compilation unit. */
9282 output_aranges (void)
9285 unsigned long aranges_length = size_of_aranges ();
9287 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9288 dw2_asm_output_data (4, 0xffffffff,
9289 "Initial length escape value indicating 64-bit DWARF extension");
9290 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
9291 "Length of Address Ranges Info");
9292 /* Version number for aranges is still 2, even in DWARF3. */
9293 dw2_asm_output_data (2, 2, "DWARF Version");
9294 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
9296 "Offset of Compilation Unit Info");
9297 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
9298 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
9300 /* We need to align to twice the pointer size here. */
9301 if (DWARF_ARANGES_PAD_SIZE)
9303 /* Pad using a 2 byte words so that padding is correct for any
9305 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
9306 2 * DWARF2_ADDR_SIZE);
9307 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
9308 dw2_asm_output_data (2, 0, NULL);
9311 /* It is necessary not to output these entries if the sections were
9312 not used; if the sections were not used, the length will be 0 and
9313 the address may end up as 0 if the section is discarded by ld
9314 --gc-sections, leaving an invalid (0, 0) entry that can be
9315 confused with the terminator. */
9316 if (text_section_used)
9318 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
9319 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
9320 text_section_label, "Length");
9322 if (cold_text_section_used)
9324 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
9326 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
9327 cold_text_section_label, "Length");
9330 for (i = 0; i < arange_table_in_use; i++)
9332 dw_die_ref die = arange_table[i];
9334 /* We shouldn't see aranges for DIEs outside of the main CU. */
9335 gcc_assert (die->die_mark);
9337 if (die->die_tag == DW_TAG_subprogram)
9339 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
9341 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
9342 get_AT_low_pc (die), "Length");
9346 /* A static variable; extract the symbol from DW_AT_location.
9347 Note that this code isn't currently hit, as we only emit
9348 aranges for functions (jason 9/23/99). */
9349 dw_attr_ref a = get_AT (die, DW_AT_location);
9350 dw_loc_descr_ref loc;
9352 gcc_assert (a && AT_class (a) == dw_val_class_loc);
9355 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
9357 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
9358 loc->dw_loc_oprnd1.v.val_addr, "Address");
9359 dw2_asm_output_data (DWARF2_ADDR_SIZE,
9360 get_AT_unsigned (die, DW_AT_byte_size),
9365 /* Output the terminator words. */
9366 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9367 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9370 /* Add a new entry to .debug_ranges. Return the offset at which it
9374 add_ranges_num (int num)
9376 unsigned int in_use = ranges_table_in_use;
9378 if (in_use == ranges_table_allocated)
9380 ranges_table_allocated += RANGES_TABLE_INCREMENT;
9381 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
9382 ranges_table_allocated);
9383 memset (ranges_table + ranges_table_in_use, 0,
9384 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
9387 ranges_table[in_use].num = num;
9388 ranges_table_in_use = in_use + 1;
9390 return in_use * 2 * DWARF2_ADDR_SIZE;
9393 /* Add a new entry to .debug_ranges corresponding to a block, or a
9394 range terminator if BLOCK is NULL. */
9397 add_ranges (const_tree block)
9399 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
9402 /* Add a new entry to .debug_ranges corresponding to a pair of
9406 add_ranges_by_labels (const char *begin, const char *end)
9408 unsigned int in_use = ranges_by_label_in_use;
9410 if (in_use == ranges_by_label_allocated)
9412 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
9413 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
9415 ranges_by_label_allocated);
9416 memset (ranges_by_label + ranges_by_label_in_use, 0,
9417 RANGES_TABLE_INCREMENT
9418 * sizeof (struct dw_ranges_by_label_struct));
9421 ranges_by_label[in_use].begin = begin;
9422 ranges_by_label[in_use].end = end;
9423 ranges_by_label_in_use = in_use + 1;
9425 return add_ranges_num (-(int)in_use - 1);
9429 output_ranges (void)
9432 static const char *const start_fmt = "Offset 0x%x";
9433 const char *fmt = start_fmt;
9435 for (i = 0; i < ranges_table_in_use; i++)
9437 int block_num = ranges_table[i].num;
9441 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
9442 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
9444 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
9445 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
9447 /* If all code is in the text section, then the compilation
9448 unit base address defaults to DW_AT_low_pc, which is the
9449 base of the text section. */
9450 if (!have_multiple_function_sections)
9452 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
9454 fmt, i * 2 * DWARF2_ADDR_SIZE);
9455 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
9456 text_section_label, NULL);
9459 /* Otherwise, the compilation unit base address is zero,
9460 which allows us to use absolute addresses, and not worry
9461 about whether the target supports cross-section
9465 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
9466 fmt, i * 2 * DWARF2_ADDR_SIZE);
9467 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
9473 /* Negative block_num stands for an index into ranges_by_label. */
9474 else if (block_num < 0)
9476 int lab_idx = - block_num - 1;
9478 if (!have_multiple_function_sections)
9482 /* If we ever use add_ranges_by_labels () for a single
9483 function section, all we have to do is to take out
9485 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9486 ranges_by_label[lab_idx].begin,
9488 fmt, i * 2 * DWARF2_ADDR_SIZE);
9489 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
9490 ranges_by_label[lab_idx].end,
9491 text_section_label, NULL);
9496 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9497 ranges_by_label[lab_idx].begin,
9498 fmt, i * 2 * DWARF2_ADDR_SIZE);
9499 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9500 ranges_by_label[lab_idx].end,
9506 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9507 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9513 /* Data structure containing information about input files. */
9516 const char *path; /* Complete file name. */
9517 const char *fname; /* File name part. */
9518 int length; /* Length of entire string. */
9519 struct dwarf_file_data * file_idx; /* Index in input file table. */
9520 int dir_idx; /* Index in directory table. */
9523 /* Data structure containing information about directories with source
9527 const char *path; /* Path including directory name. */
9528 int length; /* Path length. */
9529 int prefix; /* Index of directory entry which is a prefix. */
9530 int count; /* Number of files in this directory. */
9531 int dir_idx; /* Index of directory used as base. */
9534 /* Callback function for file_info comparison. We sort by looking at
9535 the directories in the path. */
9538 file_info_cmp (const void *p1, const void *p2)
9540 const struct file_info *const s1 = (const struct file_info *) p1;
9541 const struct file_info *const s2 = (const struct file_info *) p2;
9542 const unsigned char *cp1;
9543 const unsigned char *cp2;
9545 /* Take care of file names without directories. We need to make sure that
9546 we return consistent values to qsort since some will get confused if
9547 we return the same value when identical operands are passed in opposite
9548 orders. So if neither has a directory, return 0 and otherwise return
9549 1 or -1 depending on which one has the directory. */
9550 if ((s1->path == s1->fname || s2->path == s2->fname))
9551 return (s2->path == s2->fname) - (s1->path == s1->fname);
9553 cp1 = (const unsigned char *) s1->path;
9554 cp2 = (const unsigned char *) s2->path;
9560 /* Reached the end of the first path? If so, handle like above. */
9561 if ((cp1 == (const unsigned char *) s1->fname)
9562 || (cp2 == (const unsigned char *) s2->fname))
9563 return ((cp2 == (const unsigned char *) s2->fname)
9564 - (cp1 == (const unsigned char *) s1->fname));
9566 /* Character of current path component the same? */
9567 else if (*cp1 != *cp2)
9572 struct file_name_acquire_data
9574 struct file_info *files;
9579 /* Traversal function for the hash table. */
9582 file_name_acquire (void ** slot, void *data)
9584 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
9585 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
9586 struct file_info *fi;
9589 gcc_assert (fnad->max_files >= d->emitted_number);
9591 if (! d->emitted_number)
9594 gcc_assert (fnad->max_files != fnad->used_files);
9596 fi = fnad->files + fnad->used_files++;
9598 /* Skip all leading "./". */
9600 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
9603 /* Create a new array entry. */
9605 fi->length = strlen (f);
9608 /* Search for the file name part. */
9609 f = strrchr (f, DIR_SEPARATOR);
9610 #if defined (DIR_SEPARATOR_2)
9612 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
9616 if (f == NULL || f < g)
9622 fi->fname = f == NULL ? fi->path : f + 1;
9626 /* Output the directory table and the file name table. We try to minimize
9627 the total amount of memory needed. A heuristic is used to avoid large
9628 slowdowns with many input files. */
9631 output_file_names (void)
9633 struct file_name_acquire_data fnad;
9635 struct file_info *files;
9636 struct dir_info *dirs;
9645 if (!last_emitted_file)
9647 dw2_asm_output_data (1, 0, "End directory table");
9648 dw2_asm_output_data (1, 0, "End file name table");
9652 numfiles = last_emitted_file->emitted_number;
9654 /* Allocate the various arrays we need. */
9655 files = XALLOCAVEC (struct file_info, numfiles);
9656 dirs = XALLOCAVEC (struct dir_info, numfiles);
9659 fnad.used_files = 0;
9660 fnad.max_files = numfiles;
9661 htab_traverse (file_table, file_name_acquire, &fnad);
9662 gcc_assert (fnad.used_files == fnad.max_files);
9664 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
9666 /* Find all the different directories used. */
9667 dirs[0].path = files[0].path;
9668 dirs[0].length = files[0].fname - files[0].path;
9669 dirs[0].prefix = -1;
9671 dirs[0].dir_idx = 0;
9672 files[0].dir_idx = 0;
9675 for (i = 1; i < numfiles; i++)
9676 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
9677 && memcmp (dirs[ndirs - 1].path, files[i].path,
9678 dirs[ndirs - 1].length) == 0)
9680 /* Same directory as last entry. */
9681 files[i].dir_idx = ndirs - 1;
9682 ++dirs[ndirs - 1].count;
9688 /* This is a new directory. */
9689 dirs[ndirs].path = files[i].path;
9690 dirs[ndirs].length = files[i].fname - files[i].path;
9691 dirs[ndirs].count = 1;
9692 dirs[ndirs].dir_idx = ndirs;
9693 files[i].dir_idx = ndirs;
9695 /* Search for a prefix. */
9696 dirs[ndirs].prefix = -1;
9697 for (j = 0; j < ndirs; j++)
9698 if (dirs[j].length < dirs[ndirs].length
9699 && dirs[j].length > 1
9700 && (dirs[ndirs].prefix == -1
9701 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
9702 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
9703 dirs[ndirs].prefix = j;
9708 /* Now to the actual work. We have to find a subset of the directories which
9709 allow expressing the file name using references to the directory table
9710 with the least amount of characters. We do not do an exhaustive search
9711 where we would have to check out every combination of every single
9712 possible prefix. Instead we use a heuristic which provides nearly optimal
9713 results in most cases and never is much off. */
9714 saved = XALLOCAVEC (int, ndirs);
9715 savehere = XALLOCAVEC (int, ndirs);
9717 memset (saved, '\0', ndirs * sizeof (saved[0]));
9718 for (i = 0; i < ndirs; i++)
9723 /* We can always save some space for the current directory. But this
9724 does not mean it will be enough to justify adding the directory. */
9725 savehere[i] = dirs[i].length;
9726 total = (savehere[i] - saved[i]) * dirs[i].count;
9728 for (j = i + 1; j < ndirs; j++)
9731 if (saved[j] < dirs[i].length)
9733 /* Determine whether the dirs[i] path is a prefix of the
9738 while (k != -1 && k != (int) i)
9743 /* Yes it is. We can possibly save some memory by
9744 writing the filenames in dirs[j] relative to
9746 savehere[j] = dirs[i].length;
9747 total += (savehere[j] - saved[j]) * dirs[j].count;
9752 /* Check whether we can save enough to justify adding the dirs[i]
9754 if (total > dirs[i].length + 1)
9756 /* It's worthwhile adding. */
9757 for (j = i; j < ndirs; j++)
9758 if (savehere[j] > 0)
9760 /* Remember how much we saved for this directory so far. */
9761 saved[j] = savehere[j];
9763 /* Remember the prefix directory. */
9764 dirs[j].dir_idx = i;
9769 /* Emit the directory name table. */
9771 idx_offset = dirs[0].length > 0 ? 1 : 0;
9772 for (i = 1 - idx_offset; i < ndirs; i++)
9773 dw2_asm_output_nstring (dirs[i].path,
9775 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
9776 "Directory Entry: 0x%x", i + idx_offset);
9778 dw2_asm_output_data (1, 0, "End directory table");
9780 /* We have to emit them in the order of emitted_number since that's
9781 used in the debug info generation. To do this efficiently we
9782 generate a back-mapping of the indices first. */
9783 backmap = XALLOCAVEC (int, numfiles);
9784 for (i = 0; i < numfiles; i++)
9785 backmap[files[i].file_idx->emitted_number - 1] = i;
9787 /* Now write all the file names. */
9788 for (i = 0; i < numfiles; i++)
9790 int file_idx = backmap[i];
9791 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
9793 #ifdef VMS_DEBUGGING_INFO
9794 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
9796 /* Setting these fields can lead to debugger miscomparisons,
9797 but VMS Debug requires them to be set correctly. */
9802 int maxfilelen = strlen (files[file_idx].path)
9803 + dirs[dir_idx].length
9804 + MAX_VMS_VERSION_LEN + 1;
9805 char *filebuf = XALLOCAVEC (char, maxfilelen);
9807 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
9808 snprintf (filebuf, maxfilelen, "%s;%d",
9809 files[file_idx].path + dirs[dir_idx].length, ver);
9811 dw2_asm_output_nstring
9812 (filebuf, -1, "File Entry: 0x%x", (unsigned) i + 1);
9814 /* Include directory index. */
9815 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
9817 /* Modification time. */
9818 dw2_asm_output_data_uleb128
9819 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
9823 /* File length in bytes. */
9824 dw2_asm_output_data_uleb128
9825 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
9829 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
9830 "File Entry: 0x%x", (unsigned) i + 1);
9832 /* Include directory index. */
9833 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
9835 /* Modification time. */
9836 dw2_asm_output_data_uleb128 (0, NULL);
9838 /* File length in bytes. */
9839 dw2_asm_output_data_uleb128 (0, NULL);
9843 dw2_asm_output_data (1, 0, "End file name table");
9847 /* Output the source line number correspondence information. This
9848 information goes into the .debug_line section. */
9851 output_line_info (void)
9853 char l1[20], l2[20], p1[20], p2[20];
9854 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
9855 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
9858 unsigned long lt_index;
9859 unsigned long current_line;
9862 unsigned long current_file;
9863 unsigned long function;
9865 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
9866 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
9867 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
9868 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
9870 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9871 dw2_asm_output_data (4, 0xffffffff,
9872 "Initial length escape value indicating 64-bit DWARF extension");
9873 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
9874 "Length of Source Line Info");
9875 ASM_OUTPUT_LABEL (asm_out_file, l1);
9877 dw2_asm_output_data (2, dwarf_version, "DWARF Version");
9878 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
9879 ASM_OUTPUT_LABEL (asm_out_file, p1);
9881 /* Define the architecture-dependent minimum instruction length (in
9882 bytes). In this implementation of DWARF, this field is used for
9883 information purposes only. Since GCC generates assembly language,
9884 we have no a priori knowledge of how many instruction bytes are
9885 generated for each source line, and therefore can use only the
9886 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
9887 commands. Accordingly, we fix this as `1', which is "correct
9888 enough" for all architectures, and don't let the target override. */
9889 dw2_asm_output_data (1, 1,
9890 "Minimum Instruction Length");
9892 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
9893 "Default is_stmt_start flag");
9894 dw2_asm_output_data (1, DWARF_LINE_BASE,
9895 "Line Base Value (Special Opcodes)");
9896 dw2_asm_output_data (1, DWARF_LINE_RANGE,
9897 "Line Range Value (Special Opcodes)");
9898 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
9899 "Special Opcode Base");
9901 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
9905 case DW_LNS_advance_pc:
9906 case DW_LNS_advance_line:
9907 case DW_LNS_set_file:
9908 case DW_LNS_set_column:
9909 case DW_LNS_fixed_advance_pc:
9917 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
9921 /* Write out the information about the files we use. */
9922 output_file_names ();
9923 ASM_OUTPUT_LABEL (asm_out_file, p2);
9925 /* We used to set the address register to the first location in the text
9926 section here, but that didn't accomplish anything since we already
9927 have a line note for the opening brace of the first function. */
9929 /* Generate the line number to PC correspondence table, encoded as
9930 a series of state machine operations. */
9934 if (cfun && in_cold_section_p)
9935 strcpy (prev_line_label, crtl->subsections.cold_section_label);
9937 strcpy (prev_line_label, text_section_label);
9938 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
9940 dw_line_info_ref line_info = &line_info_table[lt_index];
9943 /* Disable this optimization for now; GDB wants to see two line notes
9944 at the beginning of a function so it can find the end of the
9947 /* Don't emit anything for redundant notes. Just updating the
9948 address doesn't accomplish anything, because we already assume
9949 that anything after the last address is this line. */
9950 if (line_info->dw_line_num == current_line
9951 && line_info->dw_file_num == current_file)
9955 /* Emit debug info for the address of the current line.
9957 Unfortunately, we have little choice here currently, and must always
9958 use the most general form. GCC does not know the address delta
9959 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9960 attributes which will give an upper bound on the address range. We
9961 could perhaps use length attributes to determine when it is safe to
9962 use DW_LNS_fixed_advance_pc. */
9964 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
9967 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
9968 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9969 "DW_LNS_fixed_advance_pc");
9970 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9974 /* This can handle any delta. This takes
9975 4+DWARF2_ADDR_SIZE bytes. */
9976 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9977 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9978 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9979 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9982 strcpy (prev_line_label, line_label);
9984 /* Emit debug info for the source file of the current line, if
9985 different from the previous line. */
9986 if (line_info->dw_file_num != current_file)
9988 current_file = line_info->dw_file_num;
9989 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9990 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9993 /* Emit debug info for the current line number, choosing the encoding
9994 that uses the least amount of space. */
9995 if (line_info->dw_line_num != current_line)
9997 line_offset = line_info->dw_line_num - current_line;
9998 line_delta = line_offset - DWARF_LINE_BASE;
9999 current_line = line_info->dw_line_num;
10000 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
10001 /* This can handle deltas from -10 to 234, using the current
10002 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
10004 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
10005 "line %lu", current_line);
10008 /* This can handle any delta. This takes at least 4 bytes,
10009 depending on the value being encoded. */
10010 dw2_asm_output_data (1, DW_LNS_advance_line,
10011 "advance to line %lu", current_line);
10012 dw2_asm_output_data_sleb128 (line_offset, NULL);
10013 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10017 /* We still need to start a new row, so output a copy insn. */
10018 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10021 /* Emit debug info for the address of the end of the function. */
10024 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
10025 "DW_LNS_fixed_advance_pc");
10026 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
10030 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10031 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10032 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10033 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
10036 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
10037 dw2_asm_output_data_uleb128 (1, NULL);
10038 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
10043 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
10045 dw_separate_line_info_ref line_info
10046 = &separate_line_info_table[lt_index];
10049 /* Don't emit anything for redundant notes. */
10050 if (line_info->dw_line_num == current_line
10051 && line_info->dw_file_num == current_file
10052 && line_info->function == function)
10056 /* Emit debug info for the address of the current line. If this is
10057 a new function, or the first line of a function, then we need
10058 to handle it differently. */
10059 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
10061 if (function != line_info->function)
10063 function = line_info->function;
10065 /* Set the address register to the first line in the function. */
10066 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10067 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10068 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10069 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10073 /* ??? See the DW_LNS_advance_pc comment above. */
10076 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
10077 "DW_LNS_fixed_advance_pc");
10078 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
10082 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10083 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10084 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10085 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10089 strcpy (prev_line_label, line_label);
10091 /* Emit debug info for the source file of the current line, if
10092 different from the previous line. */
10093 if (line_info->dw_file_num != current_file)
10095 current_file = line_info->dw_file_num;
10096 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
10097 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
10100 /* Emit debug info for the current line number, choosing the encoding
10101 that uses the least amount of space. */
10102 if (line_info->dw_line_num != current_line)
10104 line_offset = line_info->dw_line_num - current_line;
10105 line_delta = line_offset - DWARF_LINE_BASE;
10106 current_line = line_info->dw_line_num;
10107 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
10108 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
10109 "line %lu", current_line);
10112 dw2_asm_output_data (1, DW_LNS_advance_line,
10113 "advance to line %lu", current_line);
10114 dw2_asm_output_data_sleb128 (line_offset, NULL);
10115 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10119 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
10127 /* If we're done with a function, end its sequence. */
10128 if (lt_index == separate_line_info_table_in_use
10129 || separate_line_info_table[lt_index].function != function)
10134 /* Emit debug info for the address of the end of the function. */
10135 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
10138 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
10139 "DW_LNS_fixed_advance_pc");
10140 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
10144 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
10145 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
10146 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
10147 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
10150 /* Output the marker for the end of this sequence. */
10151 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
10152 dw2_asm_output_data_uleb128 (1, NULL);
10153 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
10157 /* Output the marker for the end of the line number info. */
10158 ASM_OUTPUT_LABEL (asm_out_file, l2);
10161 /* Given a pointer to a tree node for some base type, return a pointer to
10162 a DIE that describes the given type.
10164 This routine must only be called for GCC type nodes that correspond to
10165 Dwarf base (fundamental) types. */
10168 base_type_die (tree type)
10170 dw_die_ref base_type_result;
10171 enum dwarf_type encoding;
10173 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
10176 /* If this is a subtype that should not be emitted as a subrange type,
10177 use the base type. See subrange_type_for_debug_p. */
10178 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
10179 type = TREE_TYPE (type);
10181 switch (TREE_CODE (type))
10184 if (TYPE_STRING_FLAG (type))
10186 if (TYPE_UNSIGNED (type))
10187 encoding = DW_ATE_unsigned_char;
10189 encoding = DW_ATE_signed_char;
10191 else if (TYPE_UNSIGNED (type))
10192 encoding = DW_ATE_unsigned;
10194 encoding = DW_ATE_signed;
10198 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
10199 encoding = DW_ATE_decimal_float;
10201 encoding = DW_ATE_float;
10204 case FIXED_POINT_TYPE:
10205 if (TYPE_UNSIGNED (type))
10206 encoding = DW_ATE_unsigned_fixed;
10208 encoding = DW_ATE_signed_fixed;
10211 /* Dwarf2 doesn't know anything about complex ints, so use
10212 a user defined type for it. */
10214 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
10215 encoding = DW_ATE_complex_float;
10217 encoding = DW_ATE_lo_user;
10221 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
10222 encoding = DW_ATE_boolean;
10226 /* No other TREE_CODEs are Dwarf fundamental types. */
10227 gcc_unreachable ();
10230 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
10232 /* This probably indicates a bug. */
10233 if (! TYPE_NAME (type))
10234 add_name_attribute (base_type_result, "__unknown__");
10236 add_AT_unsigned (base_type_result, DW_AT_byte_size,
10237 int_size_in_bytes (type));
10238 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
10240 return base_type_result;
10243 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
10244 given input type is a Dwarf "fundamental" type. Otherwise return null. */
10247 is_base_type (tree type)
10249 switch (TREE_CODE (type))
10255 case FIXED_POINT_TYPE:
10263 case QUAL_UNION_TYPE:
10264 case ENUMERAL_TYPE:
10265 case FUNCTION_TYPE:
10268 case REFERENCE_TYPE:
10275 gcc_unreachable ();
10281 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
10282 node, return the size in bits for the type if it is a constant, or else
10283 return the alignment for the type if the type's size is not constant, or
10284 else return BITS_PER_WORD if the type actually turns out to be an
10285 ERROR_MARK node. */
10287 static inline unsigned HOST_WIDE_INT
10288 simple_type_size_in_bits (const_tree type)
10290 if (TREE_CODE (type) == ERROR_MARK)
10291 return BITS_PER_WORD;
10292 else if (TYPE_SIZE (type) == NULL_TREE)
10294 else if (host_integerp (TYPE_SIZE (type), 1))
10295 return tree_low_cst (TYPE_SIZE (type), 1);
10297 return TYPE_ALIGN (type);
10300 /* Given a pointer to a tree node for a subrange type, return a pointer
10301 to a DIE that describes the given type. */
10304 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
10306 dw_die_ref subrange_die;
10307 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
10309 if (context_die == NULL)
10310 context_die = comp_unit_die;
10312 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
10314 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
10316 /* The size of the subrange type and its base type do not match,
10317 so we need to generate a size attribute for the subrange type. */
10318 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
10322 add_bound_info (subrange_die, DW_AT_lower_bound, low);
10324 add_bound_info (subrange_die, DW_AT_upper_bound, high);
10326 return subrange_die;
10329 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
10330 entry that chains various modifiers in front of the given type. */
10333 modified_type_die (tree type, int is_const_type, int is_volatile_type,
10334 dw_die_ref context_die)
10336 enum tree_code code = TREE_CODE (type);
10337 dw_die_ref mod_type_die;
10338 dw_die_ref sub_die = NULL;
10339 tree item_type = NULL;
10340 tree qualified_type;
10341 tree name, low, high;
10343 if (code == ERROR_MARK)
10346 /* See if we already have the appropriately qualified variant of
10349 = get_qualified_type (type,
10350 ((is_const_type ? TYPE_QUAL_CONST : 0)
10351 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
10353 /* If we do, then we can just use its DIE, if it exists. */
10354 if (qualified_type)
10356 mod_type_die = lookup_type_die (qualified_type);
10358 return mod_type_die;
10361 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
10363 /* Handle C typedef types. */
10364 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
10366 tree dtype = TREE_TYPE (name);
10368 if (qualified_type == dtype)
10370 /* For a named type, use the typedef. */
10371 gen_type_die (qualified_type, context_die);
10372 return lookup_type_die (qualified_type);
10374 else if (is_const_type < TYPE_READONLY (dtype)
10375 || is_volatile_type < TYPE_VOLATILE (dtype)
10376 || (is_const_type <= TYPE_READONLY (dtype)
10377 && is_volatile_type <= TYPE_VOLATILE (dtype)
10378 && DECL_ORIGINAL_TYPE (name) != type))
10379 /* cv-unqualified version of named type. Just use the unnamed
10380 type to which it refers. */
10381 return modified_type_die (DECL_ORIGINAL_TYPE (name),
10382 is_const_type, is_volatile_type,
10384 /* Else cv-qualified version of named type; fall through. */
10389 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
10390 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
10392 else if (is_volatile_type)
10394 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
10395 sub_die = modified_type_die (type, 0, 0, context_die);
10397 else if (code == POINTER_TYPE)
10399 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
10400 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10401 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10402 item_type = TREE_TYPE (type);
10404 else if (code == REFERENCE_TYPE)
10406 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
10407 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
10408 simple_type_size_in_bits (type) / BITS_PER_UNIT);
10409 item_type = TREE_TYPE (type);
10411 else if (code == INTEGER_TYPE
10412 && TREE_TYPE (type) != NULL_TREE
10413 && subrange_type_for_debug_p (type, &low, &high))
10415 mod_type_die = subrange_type_die (type, low, high, context_die);
10416 item_type = TREE_TYPE (type);
10418 else if (is_base_type (type))
10419 mod_type_die = base_type_die (type);
10422 gen_type_die (type, context_die);
10424 /* We have to get the type_main_variant here (and pass that to the
10425 `lookup_type_die' routine) because the ..._TYPE node we have
10426 might simply be a *copy* of some original type node (where the
10427 copy was created to help us keep track of typedef names) and
10428 that copy might have a different TYPE_UID from the original
10430 if (TREE_CODE (type) != VECTOR_TYPE)
10431 return lookup_type_die (type_main_variant (type));
10433 /* Vectors have the debugging information in the type,
10434 not the main variant. */
10435 return lookup_type_die (type);
10438 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
10439 don't output a DW_TAG_typedef, since there isn't one in the
10440 user's program; just attach a DW_AT_name to the type. */
10442 && (TREE_CODE (name) != TYPE_DECL
10443 || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
10445 if (TREE_CODE (name) == TYPE_DECL)
10446 /* Could just call add_name_and_src_coords_attributes here,
10447 but since this is a builtin type it doesn't have any
10448 useful source coordinates anyway. */
10449 name = DECL_NAME (name);
10450 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
10453 if (qualified_type)
10454 equate_type_number_to_die (qualified_type, mod_type_die);
10457 /* We must do this after the equate_type_number_to_die call, in case
10458 this is a recursive type. This ensures that the modified_type_die
10459 recursion will terminate even if the type is recursive. Recursive
10460 types are possible in Ada. */
10461 sub_die = modified_type_die (item_type,
10462 TYPE_READONLY (item_type),
10463 TYPE_VOLATILE (item_type),
10466 if (sub_die != NULL)
10467 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
10469 return mod_type_die;
10472 /* Generate a new name for the parameter pack name NAME (an
10473 IDENTIFIER_NODE) that incorporates its */
10476 make_ith_pack_parameter_name (tree name, int i)
10478 /* Munge the name to include the parameter index. */
10479 #define NUMBUF_LEN 128
10480 char numbuf[NUMBUF_LEN];
10484 snprintf (numbuf, NUMBUF_LEN, "%i", i);
10485 newname_len = IDENTIFIER_LENGTH (name)
10486 + strlen (numbuf) + 2;
10487 newname = (char*) alloca (newname_len);
10488 snprintf (newname, newname_len,
10489 "%s#%i", IDENTIFIER_POINTER (name), i);
10490 return get_identifier (newname);
10493 /* Generate DIEs for the generic parameters of T.
10494 T must be either a generic type or a generic function.
10495 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
10498 gen_generic_params_dies (tree t)
10502 dw_die_ref die = NULL;
10504 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
10508 die = lookup_type_die (t);
10509 else if (DECL_P (t))
10510 die = lookup_decl_die (t);
10514 parms = lang_hooks.get_innermost_generic_parms (t);
10516 /* T has no generic parameter. It means T is neither a generic type
10517 or function. End of story. */
10520 parms_num = TREE_VEC_LENGTH (parms);
10521 args = lang_hooks.get_innermost_generic_args (t);
10522 for (i = 0; i < parms_num; i++)
10526 parm = TREE_VEC_ELT (parms, i);
10527 arg = TREE_VEC_ELT (args, i);
10528 if (parm && TREE_VALUE (parm) && arg)
10531 lang_hooks.types.get_argument_pack_elems (arg);
10534 /* So ARG is an argument pack and the elements of that pack
10535 are stored in PACK_ELEMS. */
10538 len = TREE_VEC_LENGTH (pack_elems);
10539 for (i = 0; i < len; i++)
10540 generic_parameter_die (TREE_VALUE (parm),
10541 TREE_VEC_ELT (pack_elems, i),
10544 else /* Arg is not an argument pack. */
10545 generic_parameter_die (TREE_VALUE (parm),
10547 -1/* Not a param pack. */);
10552 /* Create and return a DIE for PARM which should be
10553 the representation of a generic type parameter.
10554 For instance, in the C++ front end, PARM would be a template parameter.
10555 ARG is the argument to PARM.
10556 PARENT_DIE is the parent DIE which the new created DIE should be added to,
10558 PACK_ELEM_INDEX is >= 0 if PARM is a generic parameter pack, and if ARG
10559 is one of the unpacked elements of the parameter PACK. In that case,
10560 PACK_ELEM_INDEX is the index of ARG in the parameter pack. */
10563 generic_parameter_die (tree parm, tree arg, dw_die_ref parent_die,
10564 int pack_elem_index)
10566 dw_die_ref tmpl_die = NULL;
10567 const char *name = NULL;
10569 if (!parm || !DECL_NAME (parm) || !arg)
10572 /* We support non-type generic parameters and arguments,
10573 type generic parameters and arguments, as well as
10574 generic generic parameters (a.k.a. template template parameters in C++)
10576 if (TREE_CODE (parm) == PARM_DECL)
10577 /* PARM is a nontype generic parameter */
10578 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
10579 else if (TREE_CODE (parm) == TYPE_DECL)
10580 /* PARM is a type generic parameter. */
10581 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
10582 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10583 /* PARM is a generic generic parameter.
10584 Its DIE is a GNU extension. It shall have a
10585 DW_AT_name attribute to represent the name of the template template
10586 parameter, and a DW_AT_GNU_template_name attribute to represent the
10587 name of the template template argument. */
10588 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
10591 gcc_unreachable ();
10597 if (pack_elem_index >= 0)
10599 /* PARM is an element of a parameter pack.
10600 Generate a name for it. */
10601 tree identifier = make_ith_pack_parameter_name (DECL_NAME (parm),
10604 name = IDENTIFIER_POINTER (identifier);
10607 name = IDENTIFIER_POINTER (DECL_NAME (parm));
10610 add_AT_string (tmpl_die, DW_AT_name, name);
10612 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
10614 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
10615 TMPL_DIE should have a child DW_AT_type attribute that is set
10616 to the type of the argument to PARM, which is ARG.
10617 If PARM is a type generic parameter, TMPL_DIE should have a
10618 child DW_AT_type that is set to ARG. */
10619 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
10620 add_type_attribute (tmpl_die, tmpl_type, 0,
10621 TREE_THIS_VOLATILE (tmpl_type),
10626 /* So TMPL_DIE is a DIE representing a
10627 a generic generic template parameter, a.k.a template template
10628 parameter in C++ and arg is a template. */
10630 /* The DW_AT_GNU_template_name attribute of the DIE must be set
10631 to the name of the argument. */
10632 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
10633 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
10636 if (TREE_CODE (parm) == PARM_DECL)
10637 /* So PARM is a non-type generic parameter.
10638 DWARF3 5.6.8 says we must set a DW_AT_const_value child
10639 attribute of TMPL_DIE which value represents the value
10641 We must be careful here:
10642 The value of ARG might reference some function decls.
10643 We might currently be emitting debug info for a generic
10644 type and types are emitted before function decls, we don't
10645 know if the function decls referenced by ARG will actually be
10646 emitted after cgraph computations.
10647 So must defer the generation of the DW_AT_const_value to
10648 after cgraph is ready. */
10649 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
10655 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
10656 an enumerated type. */
10659 type_is_enum (const_tree type)
10661 return TREE_CODE (type) == ENUMERAL_TYPE;
10664 /* Return the DBX register number described by a given RTL node. */
10666 static unsigned int
10667 dbx_reg_number (const_rtx rtl)
10669 unsigned regno = REGNO (rtl);
10671 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
10673 #ifdef LEAF_REG_REMAP
10674 if (current_function_uses_only_leaf_regs)
10676 int leaf_reg = LEAF_REG_REMAP (regno);
10677 if (leaf_reg != -1)
10678 regno = (unsigned) leaf_reg;
10682 return DBX_REGISTER_NUMBER (regno);
10685 /* Optionally add a DW_OP_piece term to a location description expression.
10686 DW_OP_piece is only added if the location description expression already
10687 doesn't end with DW_OP_piece. */
10690 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
10692 dw_loc_descr_ref loc;
10694 if (*list_head != NULL)
10696 /* Find the end of the chain. */
10697 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
10700 if (loc->dw_loc_opc != DW_OP_piece)
10701 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
10705 /* Return a location descriptor that designates a machine register or
10706 zero if there is none. */
10708 static dw_loc_descr_ref
10709 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
10713 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
10716 regs = targetm.dwarf_register_span (rtl);
10718 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
10719 return multiple_reg_loc_descriptor (rtl, regs, initialized);
10721 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
10724 /* Return a location descriptor that designates a machine register for
10725 a given hard register number. */
10727 static dw_loc_descr_ref
10728 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
10730 dw_loc_descr_ref reg_loc_descr;
10734 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
10736 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
10738 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10739 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10741 return reg_loc_descr;
10744 /* Given an RTL of a register, return a location descriptor that
10745 designates a value that spans more than one register. */
10747 static dw_loc_descr_ref
10748 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
10749 enum var_init_status initialized)
10751 int nregs, size, i;
10753 dw_loc_descr_ref loc_result = NULL;
10756 #ifdef LEAF_REG_REMAP
10757 if (current_function_uses_only_leaf_regs)
10759 int leaf_reg = LEAF_REG_REMAP (reg);
10760 if (leaf_reg != -1)
10761 reg = (unsigned) leaf_reg;
10764 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
10765 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
10767 /* Simple, contiguous registers. */
10768 if (regs == NULL_RTX)
10770 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
10775 dw_loc_descr_ref t;
10777 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
10778 VAR_INIT_STATUS_INITIALIZED);
10779 add_loc_descr (&loc_result, t);
10780 add_loc_descr_op_piece (&loc_result, size);
10786 /* Now onto stupid register sets in non contiguous locations. */
10788 gcc_assert (GET_CODE (regs) == PARALLEL);
10790 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10793 for (i = 0; i < XVECLEN (regs, 0); ++i)
10795 dw_loc_descr_ref t;
10797 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
10798 VAR_INIT_STATUS_INITIALIZED);
10799 add_loc_descr (&loc_result, t);
10800 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10801 add_loc_descr_op_piece (&loc_result, size);
10804 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10805 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10809 #endif /* DWARF2_DEBUGGING_INFO */
10811 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
10813 /* Return a location descriptor that designates a constant. */
10815 static dw_loc_descr_ref
10816 int_loc_descriptor (HOST_WIDE_INT i)
10818 enum dwarf_location_atom op;
10820 /* Pick the smallest representation of a constant, rather than just
10821 defaulting to the LEB encoding. */
10825 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
10826 else if (i <= 0xff)
10827 op = DW_OP_const1u;
10828 else if (i <= 0xffff)
10829 op = DW_OP_const2u;
10830 else if (HOST_BITS_PER_WIDE_INT == 32
10831 || i <= 0xffffffff)
10832 op = DW_OP_const4u;
10839 op = DW_OP_const1s;
10840 else if (i >= -0x8000)
10841 op = DW_OP_const2s;
10842 else if (HOST_BITS_PER_WIDE_INT == 32
10843 || i >= -0x80000000)
10844 op = DW_OP_const4s;
10849 return new_loc_descr (op, i, 0);
10853 #ifdef DWARF2_DEBUGGING_INFO
10855 /* Return a location descriptor that designates a base+offset location. */
10857 static dw_loc_descr_ref
10858 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
10859 enum var_init_status initialized)
10861 unsigned int regno;
10862 dw_loc_descr_ref result;
10863 dw_fde_ref fde = current_fde ();
10865 /* We only use "frame base" when we're sure we're talking about the
10866 post-prologue local stack frame. We do this by *not* running
10867 register elimination until this point, and recognizing the special
10868 argument pointer and soft frame pointer rtx's. */
10869 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
10871 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10875 if (GET_CODE (elim) == PLUS)
10877 offset += INTVAL (XEXP (elim, 1));
10878 elim = XEXP (elim, 0);
10880 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
10881 && (elim == hard_frame_pointer_rtx
10882 || elim == stack_pointer_rtx))
10883 || elim == (frame_pointer_needed
10884 ? hard_frame_pointer_rtx
10885 : stack_pointer_rtx));
10887 /* If drap register is used to align stack, use frame
10888 pointer + offset to access stack variables. If stack
10889 is aligned without drap, use stack pointer + offset to
10890 access stack variables. */
10891 if (crtl->stack_realign_tried
10892 && reg == frame_pointer_rtx)
10895 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
10896 ? HARD_FRAME_POINTER_REGNUM
10897 : STACK_POINTER_REGNUM);
10898 return new_reg_loc_descr (base_reg, offset);
10901 offset += frame_pointer_fb_offset;
10902 return new_loc_descr (DW_OP_fbreg, offset, 0);
10906 && fde->drap_reg != INVALID_REGNUM
10907 && (fde->drap_reg == REGNO (reg)
10908 || fde->vdrap_reg == REGNO (reg)))
10910 /* Use cfa+offset to represent the location of arguments passed
10911 on stack when drap is used to align stack. */
10912 return new_loc_descr (DW_OP_fbreg, offset, 0);
10915 regno = dbx_reg_number (reg);
10917 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
10920 result = new_loc_descr (DW_OP_bregx, regno, offset);
10922 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10923 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10928 /* Return true if this RTL expression describes a base+offset calculation. */
10931 is_based_loc (const_rtx rtl)
10933 return (GET_CODE (rtl) == PLUS
10934 && ((REG_P (XEXP (rtl, 0))
10935 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
10936 && CONST_INT_P (XEXP (rtl, 1)))));
10939 /* Return a descriptor that describes the concatenation of N locations
10940 used to form the address of a memory location. */
10942 static dw_loc_descr_ref
10943 concatn_mem_loc_descriptor (rtx concatn, enum machine_mode mode,
10944 enum var_init_status initialized)
10947 dw_loc_descr_ref cc_loc_result = NULL;
10948 unsigned int n = XVECLEN (concatn, 0);
10950 for (i = 0; i < n; ++i)
10952 dw_loc_descr_ref ref;
10953 rtx x = XVECEXP (concatn, 0, i);
10955 ref = mem_loc_descriptor (x, mode, VAR_INIT_STATUS_INITIALIZED);
10959 add_loc_descr (&cc_loc_result, ref);
10960 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
10963 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10964 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10966 return cc_loc_result;
10969 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
10972 static dw_loc_descr_ref
10973 tls_mem_loc_descriptor (rtx mem)
10976 dw_loc_descr_ref loc_result;
10978 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
10981 base = get_base_address (MEM_EXPR (mem));
10983 || TREE_CODE (base) != VAR_DECL
10984 || !DECL_THREAD_LOCAL_P (base))
10987 loc_result = loc_descriptor_from_tree_1 (MEM_EXPR (mem), 2);
10988 if (loc_result == NULL)
10991 if (INTVAL (MEM_OFFSET (mem)))
10992 loc_descr_plus_const (&loc_result, INTVAL (MEM_OFFSET (mem)));
10997 /* The following routine converts the RTL for a variable or parameter
10998 (resident in memory) into an equivalent Dwarf representation of a
10999 mechanism for getting the address of that same variable onto the top of a
11000 hypothetical "address evaluation" stack.
11002 When creating memory location descriptors, we are effectively transforming
11003 the RTL for a memory-resident object into its Dwarf postfix expression
11004 equivalent. This routine recursively descends an RTL tree, turning
11005 it into Dwarf postfix code as it goes.
11007 MODE is the mode of the memory reference, needed to handle some
11008 autoincrement addressing modes.
11010 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
11011 location list for RTL.
11013 Return 0 if we can't represent the location. */
11015 static dw_loc_descr_ref
11016 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
11017 enum var_init_status initialized)
11019 dw_loc_descr_ref mem_loc_result = NULL;
11020 enum dwarf_location_atom op;
11021 dw_loc_descr_ref op0, op1;
11023 /* Note that for a dynamically sized array, the location we will generate a
11024 description of here will be the lowest numbered location which is
11025 actually within the array. That's *not* necessarily the same as the
11026 zeroth element of the array. */
11028 rtl = targetm.delegitimize_address (rtl);
11030 switch (GET_CODE (rtl))
11035 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
11036 just fall into the SUBREG code. */
11038 /* ... fall through ... */
11041 /* The case of a subreg may arise when we have a local (register)
11042 variable or a formal (register) parameter which doesn't quite fill
11043 up an entire register. For now, just assume that it is
11044 legitimate to make the Dwarf info refer to the whole register which
11045 contains the given subreg. */
11046 rtl = XEXP (rtl, 0);
11047 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
11050 /* ... fall through ... */
11053 /* Whenever a register number forms a part of the description of the
11054 method for calculating the (dynamic) address of a memory resident
11055 object, DWARF rules require the register number be referred to as
11056 a "base register". This distinction is not based in any way upon
11057 what category of register the hardware believes the given register
11058 belongs to. This is strictly DWARF terminology we're dealing with
11059 here. Note that in cases where the location of a memory-resident
11060 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
11061 OP_CONST (0)) the actual DWARF location descriptor that we generate
11062 may just be OP_BASEREG (basereg). This may look deceptively like
11063 the object in question was allocated to a register (rather than in
11064 memory) so DWARF consumers need to be aware of the subtle
11065 distinction between OP_REG and OP_BASEREG. */
11066 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
11067 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
11068 else if (stack_realign_drap
11070 && crtl->args.internal_arg_pointer == rtl
11071 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
11073 /* If RTL is internal_arg_pointer, which has been optimized
11074 out, use DRAP instead. */
11075 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
11076 VAR_INIT_STATUS_INITIALIZED);
11082 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11083 VAR_INIT_STATUS_INITIALIZED);
11088 int shift = DWARF2_ADDR_SIZE
11089 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
11090 shift *= BITS_PER_UNIT;
11091 if (GET_CODE (rtl) == SIGN_EXTEND)
11095 mem_loc_result = op0;
11096 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
11097 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
11098 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
11099 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11104 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
11105 VAR_INIT_STATUS_INITIALIZED);
11106 if (mem_loc_result == NULL)
11107 mem_loc_result = tls_mem_loc_descriptor (rtl);
11108 if (mem_loc_result != 0)
11109 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
11113 rtl = XEXP (rtl, 1);
11115 /* ... fall through ... */
11118 /* Some ports can transform a symbol ref into a label ref, because
11119 the symbol ref is too far away and has to be dumped into a constant
11123 /* Alternatively, the symbol in the constant pool might be referenced
11124 by a different symbol. */
11125 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
11128 rtx tmp = get_pool_constant_mark (rtl, &marked);
11130 if (GET_CODE (tmp) == SYMBOL_REF)
11133 if (CONSTANT_POOL_ADDRESS_P (tmp))
11134 get_pool_constant_mark (tmp, &marked);
11139 /* If all references to this pool constant were optimized away,
11140 it was not output and thus we can't represent it.
11141 FIXME: might try to use DW_OP_const_value here, though
11142 DW_OP_piece complicates it. */
11147 if (GET_CODE (rtl) == SYMBOL_REF
11148 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11150 dw_loc_descr_ref temp;
11152 /* If this is not defined, we have no way to emit the data. */
11153 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
11156 temp = new_loc_descr (DW_OP_addr, 0, 0);
11157 temp->dw_loc_oprnd1.val_class = dw_val_class_addr;
11158 temp->dw_loc_oprnd1.v.val_addr = rtl;
11159 temp->dtprel = true;
11161 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
11162 add_loc_descr (&mem_loc_result, temp);
11168 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
11169 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
11170 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
11171 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11175 /* Extract the PLUS expression nested inside and fall into
11176 PLUS code below. */
11177 rtl = XEXP (rtl, 1);
11182 /* Turn these into a PLUS expression and fall into the PLUS code
11184 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
11185 GEN_INT (GET_CODE (rtl) == PRE_INC
11186 ? GET_MODE_UNIT_SIZE (mode)
11187 : -GET_MODE_UNIT_SIZE (mode)));
11189 /* ... fall through ... */
11193 if (is_based_loc (rtl))
11194 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
11195 INTVAL (XEXP (rtl, 1)),
11196 VAR_INIT_STATUS_INITIALIZED);
11199 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
11200 VAR_INIT_STATUS_INITIALIZED);
11201 if (mem_loc_result == 0)
11204 if (CONST_INT_P (XEXP (rtl, 1)))
11205 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
11208 dw_loc_descr_ref mem_loc_result2
11209 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11210 VAR_INIT_STATUS_INITIALIZED);
11211 if (mem_loc_result2 == 0)
11213 add_loc_descr (&mem_loc_result, mem_loc_result2);
11214 add_loc_descr (&mem_loc_result,
11215 new_loc_descr (DW_OP_plus, 0, 0));
11220 /* If a pseudo-reg is optimized away, it is possible for it to
11221 be replaced with a MEM containing a multiply or shift. */
11263 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11264 VAR_INIT_STATUS_INITIALIZED);
11265 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11266 VAR_INIT_STATUS_INITIALIZED);
11268 if (op0 == 0 || op1 == 0)
11271 mem_loc_result = op0;
11272 add_loc_descr (&mem_loc_result, op1);
11273 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11289 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11290 VAR_INIT_STATUS_INITIALIZED);
11295 mem_loc_result = op0;
11296 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11300 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
11304 mem_loc_result = concatn_mem_loc_descriptor (rtl, mode,
11305 VAR_INIT_STATUS_INITIALIZED);
11333 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
11334 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
11335 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
11338 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11339 VAR_INIT_STATUS_INITIALIZED);
11340 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11341 VAR_INIT_STATUS_INITIALIZED);
11343 if (op0 == 0 || op1 == 0)
11346 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11348 int shift = DWARF2_ADDR_SIZE
11349 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
11350 shift *= BITS_PER_UNIT;
11351 add_loc_descr (&op0, int_loc_descriptor (shift));
11352 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11353 if (CONST_INT_P (XEXP (rtl, 1)))
11354 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
11357 add_loc_descr (&op1, int_loc_descriptor (shift));
11358 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11363 mem_loc_result = op0;
11364 add_loc_descr (&mem_loc_result, op1);
11365 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11366 if (STORE_FLAG_VALUE != 1)
11368 add_loc_descr (&mem_loc_result,
11369 int_loc_descriptor (STORE_FLAG_VALUE));
11370 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
11391 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
11392 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
11393 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
11396 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11397 VAR_INIT_STATUS_INITIALIZED);
11398 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11399 VAR_INIT_STATUS_INITIALIZED);
11401 if (op0 == 0 || op1 == 0)
11404 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11406 HOST_WIDE_INT mask = GET_MODE_MASK (GET_MODE (XEXP (rtl, 0)));
11407 add_loc_descr (&op0, int_loc_descriptor (mask));
11408 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11409 if (CONST_INT_P (XEXP (rtl, 1)))
11410 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
11413 add_loc_descr (&op1, int_loc_descriptor (mask));
11414 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
11419 HOST_WIDE_INT bias = 1;
11420 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
11421 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11422 if (CONST_INT_P (XEXP (rtl, 1)))
11423 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
11424 + INTVAL (XEXP (rtl, 1)));
11426 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11434 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
11435 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
11436 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
11439 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11440 VAR_INIT_STATUS_INITIALIZED);
11441 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
11442 VAR_INIT_STATUS_INITIALIZED);
11444 if (op0 == 0 || op1 == 0)
11447 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
11448 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
11449 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
11450 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
11452 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11454 HOST_WIDE_INT mask = GET_MODE_MASK (GET_MODE (XEXP (rtl, 0)));
11455 add_loc_descr (&op0, int_loc_descriptor (mask));
11456 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
11457 add_loc_descr (&op1, int_loc_descriptor (mask));
11458 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
11462 HOST_WIDE_INT bias = 1;
11463 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
11464 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11465 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
11468 else if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
11470 int shift = DWARF2_ADDR_SIZE
11471 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
11472 shift *= BITS_PER_UNIT;
11473 add_loc_descr (&op0, int_loc_descriptor (shift));
11474 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
11475 add_loc_descr (&op1, int_loc_descriptor (shift));
11476 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
11479 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
11483 mem_loc_result = op0;
11484 add_loc_descr (&mem_loc_result, op1);
11485 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11487 dw_loc_descr_ref bra_node, drop_node;
11489 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
11490 add_loc_descr (&mem_loc_result, bra_node);
11491 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
11492 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
11493 add_loc_descr (&mem_loc_result, drop_node);
11494 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
11495 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
11501 if (CONST_INT_P (XEXP (rtl, 1))
11502 && CONST_INT_P (XEXP (rtl, 2))
11503 && ((unsigned) INTVAL (XEXP (rtl, 1))
11504 + (unsigned) INTVAL (XEXP (rtl, 2))
11505 <= GET_MODE_BITSIZE (GET_MODE (rtl)))
11506 && GET_MODE_BITSIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
11507 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
11510 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
11511 VAR_INIT_STATUS_INITIALIZED);
11514 if (GET_CODE (rtl) == SIGN_EXTRACT)
11518 mem_loc_result = op0;
11519 size = INTVAL (XEXP (rtl, 1));
11520 shift = INTVAL (XEXP (rtl, 2));
11521 if (BITS_BIG_ENDIAN)
11522 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
11524 add_loc_descr (&mem_loc_result,
11525 int_loc_descriptor (DWARF2_ADDR_SIZE - shift - size));
11526 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
11527 add_loc_descr (&mem_loc_result,
11528 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
11529 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
11538 /* In theory, we could implement the above. */
11539 /* DWARF cannot represent the unsigned compare operations
11555 case FLOAT_TRUNCATE:
11557 case UNSIGNED_FLOAT:
11560 case FRACT_CONVERT:
11561 case UNSIGNED_FRACT_CONVERT:
11563 case UNSIGNED_SAT_FRACT:
11573 /* If delegitimize_address couldn't do anything with the UNSPEC, we
11574 can't express it in the debug info. This can happen e.g. with some
11579 rtl = get_debug_string_label (XSTR (rtl, 0));
11583 #ifdef ENABLE_CHECKING
11584 print_rtl (stderr, rtl);
11585 gcc_unreachable ();
11591 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
11592 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11594 return mem_loc_result;
11597 /* Return a descriptor that describes the concatenation of two locations.
11598 This is typically a complex variable. */
11600 static dw_loc_descr_ref
11601 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
11603 dw_loc_descr_ref cc_loc_result = NULL;
11604 dw_loc_descr_ref x0_ref
11605 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11606 dw_loc_descr_ref x1_ref
11607 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11609 if (x0_ref == 0 || x1_ref == 0)
11612 cc_loc_result = x0_ref;
11613 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
11615 add_loc_descr (&cc_loc_result, x1_ref);
11616 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
11618 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
11619 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11621 return cc_loc_result;
11624 /* Return a descriptor that describes the concatenation of N
11627 static dw_loc_descr_ref
11628 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
11631 dw_loc_descr_ref cc_loc_result = NULL;
11632 unsigned int n = XVECLEN (concatn, 0);
11634 for (i = 0; i < n; ++i)
11636 dw_loc_descr_ref ref;
11637 rtx x = XVECEXP (concatn, 0, i);
11639 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
11643 add_loc_descr (&cc_loc_result, ref);
11644 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
11647 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
11648 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
11650 return cc_loc_result;
11653 /* Output a proper Dwarf location descriptor for a variable or parameter
11654 which is either allocated in a register or in a memory location. For a
11655 register, we just generate an OP_REG and the register number. For a
11656 memory location we provide a Dwarf postfix expression describing how to
11657 generate the (dynamic) address of the object onto the address stack.
11659 MODE is mode of the decl if this loc_descriptor is going to be used in
11660 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
11661 allowed, VOIDmode otherwise.
11663 If we don't know how to describe it, return 0. */
11665 static dw_loc_descr_ref
11666 loc_descriptor (rtx rtl, enum machine_mode mode,
11667 enum var_init_status initialized)
11669 dw_loc_descr_ref loc_result = NULL;
11671 switch (GET_CODE (rtl))
11674 /* The case of a subreg may arise when we have a local (register)
11675 variable or a formal (register) parameter which doesn't quite fill
11676 up an entire register. For now, just assume that it is
11677 legitimate to make the Dwarf info refer to the whole register which
11678 contains the given subreg. */
11679 loc_result = loc_descriptor (SUBREG_REG (rtl), mode, initialized);
11683 loc_result = reg_loc_descriptor (rtl, initialized);
11688 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
11692 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
11694 if (loc_result == NULL)
11695 loc_result = tls_mem_loc_descriptor (rtl);
11699 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
11704 loc_result = concatn_loc_descriptor (rtl, initialized);
11709 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
11711 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), mode,
11716 rtl = XEXP (rtl, 1);
11721 rtvec par_elems = XVEC (rtl, 0);
11722 int num_elem = GET_NUM_ELEM (par_elems);
11723 enum machine_mode mode;
11726 /* Create the first one, so we have something to add to. */
11727 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
11728 VOIDmode, initialized);
11729 if (loc_result == NULL)
11731 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
11732 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
11733 for (i = 1; i < num_elem; i++)
11735 dw_loc_descr_ref temp;
11737 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
11738 VOIDmode, initialized);
11741 add_loc_descr (&loc_result, temp);
11742 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
11743 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
11749 if (mode != VOIDmode && mode != BLKmode && dwarf_version >= 4)
11751 HOST_WIDE_INT i = INTVAL (rtl);
11757 else if (i <= 0xff)
11759 else if (i <= 0xffff)
11761 else if (HOST_BITS_PER_WIDE_INT == 32
11762 || i <= 0xffffffff)
11765 litsize = 1 + size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
11771 else if (i >= -0x8000)
11773 else if (HOST_BITS_PER_WIDE_INT == 32
11774 || i >= -0x80000000)
11777 litsize = 1 + size_of_sleb128 (i);
11779 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
11780 is more compact. For DW_OP_stack_value we need:
11781 litsize + 1 (DW_OP_stack_value) + 1 (DW_OP_bit_size)
11783 and for DW_OP_implicit_value:
11784 1 (DW_OP_implicit_value) + 1 (length) + mode_size. */
11785 if (DWARF2_ADDR_SIZE >= GET_MODE_SIZE (mode)
11786 && litsize + 1 + 1 + 1 < 1 + 1 + GET_MODE_SIZE (mode))
11788 loc_result = int_loc_descriptor (i);
11789 add_loc_descr (&loc_result,
11790 new_loc_descr (DW_OP_stack_value, 0, 0));
11791 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
11795 loc_result = new_loc_descr (DW_OP_implicit_value,
11796 GET_MODE_SIZE (mode), 0);
11797 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
11798 loc_result->dw_loc_oprnd2.v.val_int = i;
11803 if (mode != VOIDmode && dwarf_version >= 4)
11805 /* Note that a CONST_DOUBLE rtx could represent either an integer
11806 or a floating-point constant. A CONST_DOUBLE is used whenever
11807 the constant requires more than one word in order to be
11808 adequately represented. We output CONST_DOUBLEs as blocks. */
11809 if (GET_MODE (rtl) != VOIDmode)
11810 mode = GET_MODE (rtl);
11812 loc_result = new_loc_descr (DW_OP_implicit_value,
11813 GET_MODE_SIZE (mode), 0);
11814 if (SCALAR_FLOAT_MODE_P (mode))
11816 unsigned int length = GET_MODE_SIZE (mode);
11817 unsigned char *array = GGC_NEWVEC (unsigned char, length);
11819 insert_float (rtl, array);
11820 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
11821 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
11822 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
11823 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
11827 loc_result->dw_loc_oprnd2.val_class = dw_val_class_long_long;
11828 loc_result->dw_loc_oprnd2.v.val_long_long = rtl;
11834 if (mode != VOIDmode && dwarf_version >= 4)
11836 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
11837 unsigned int length = CONST_VECTOR_NUNITS (rtl);
11838 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
11842 mode = GET_MODE (rtl);
11843 switch (GET_MODE_CLASS (mode))
11845 case MODE_VECTOR_INT:
11846 for (i = 0, p = array; i < length; i++, p += elt_size)
11848 rtx elt = CONST_VECTOR_ELT (rtl, i);
11849 HOST_WIDE_INT lo, hi;
11851 switch (GET_CODE (elt))
11859 lo = CONST_DOUBLE_LOW (elt);
11860 hi = CONST_DOUBLE_HIGH (elt);
11864 gcc_unreachable ();
11867 if (elt_size <= sizeof (HOST_WIDE_INT))
11868 insert_int (lo, elt_size, p);
11871 unsigned char *p0 = p;
11872 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
11874 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
11875 if (WORDS_BIG_ENDIAN)
11880 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
11881 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
11886 case MODE_VECTOR_FLOAT:
11887 for (i = 0, p = array; i < length; i++, p += elt_size)
11889 rtx elt = CONST_VECTOR_ELT (rtl, i);
11890 insert_float (elt, p);
11895 gcc_unreachable ();
11898 loc_result = new_loc_descr (DW_OP_implicit_value,
11899 length * elt_size, 0);
11900 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
11901 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
11902 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
11903 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
11908 if (mode == VOIDmode
11909 || GET_CODE (XEXP (rtl, 0)) == CONST_INT
11910 || GET_CODE (XEXP (rtl, 0)) == CONST_DOUBLE
11911 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
11913 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
11918 if (GET_CODE (rtl) == SYMBOL_REF
11919 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
11922 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
11923 && dwarf_version >= 4)
11925 loc_result = new_loc_descr (DW_OP_implicit_value,
11926 DWARF2_ADDR_SIZE, 0);
11927 loc_result->dw_loc_oprnd2.val_class = dw_val_class_addr;
11928 loc_result->dw_loc_oprnd2.v.val_addr = rtl;
11929 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11934 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
11935 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
11936 && dwarf_version >= 4)
11938 /* Value expression. */
11939 loc_result = mem_loc_descriptor (rtl, VOIDmode, initialized);
11942 add_loc_descr (&loc_result,
11943 new_loc_descr (DW_OP_stack_value, 0, 0));
11944 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
11953 /* Similar, but generate the descriptor from trees instead of rtl. This comes
11954 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
11955 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
11956 top-level invocation, and we require the address of LOC; is 0 if we require
11957 the value of LOC. */
11959 static dw_loc_descr_ref
11960 loc_descriptor_from_tree_1 (tree loc, int want_address)
11962 dw_loc_descr_ref ret, ret1;
11963 int have_address = 0;
11964 enum dwarf_location_atom op;
11966 /* ??? Most of the time we do not take proper care for sign/zero
11967 extending the values properly. Hopefully this won't be a real
11970 switch (TREE_CODE (loc))
11975 case PLACEHOLDER_EXPR:
11976 /* This case involves extracting fields from an object to determine the
11977 position of other fields. We don't try to encode this here. The
11978 only user of this is Ada, which encodes the needed information using
11979 the names of types. */
11985 case PREINCREMENT_EXPR:
11986 case PREDECREMENT_EXPR:
11987 case POSTINCREMENT_EXPR:
11988 case POSTDECREMENT_EXPR:
11989 /* There are no opcodes for these operations. */
11993 /* If we already want an address, there's nothing we can do. */
11997 /* Otherwise, process the argument and look for the address. */
11998 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
12001 if (DECL_THREAD_LOCAL_P (loc))
12004 enum dwarf_location_atom first_op;
12005 enum dwarf_location_atom second_op;
12006 bool dtprel = false;
12008 if (targetm.have_tls)
12010 /* If this is not defined, we have no way to emit the
12012 if (!targetm.asm_out.output_dwarf_dtprel)
12015 /* The way DW_OP_GNU_push_tls_address is specified, we
12016 can only look up addresses of objects in the current
12018 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
12020 first_op = DW_OP_addr;
12022 second_op = DW_OP_GNU_push_tls_address;
12026 if (!targetm.emutls.debug_form_tls_address)
12028 loc = emutls_decl (loc);
12029 first_op = DW_OP_addr;
12030 second_op = DW_OP_form_tls_address;
12033 rtl = rtl_for_decl_location (loc);
12034 if (rtl == NULL_RTX)
12039 rtl = XEXP (rtl, 0);
12040 if (! CONSTANT_P (rtl))
12043 ret = new_loc_descr (first_op, 0, 0);
12044 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
12045 ret->dw_loc_oprnd1.v.val_addr = rtl;
12046 ret->dtprel = dtprel;
12048 ret1 = new_loc_descr (second_op, 0, 0);
12049 add_loc_descr (&ret, ret1);
12057 if (DECL_HAS_VALUE_EXPR_P (loc))
12058 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
12063 case FUNCTION_DECL:
12065 rtx rtl = rtl_for_decl_location (loc);
12067 if (rtl == NULL_RTX)
12069 else if (CONST_INT_P (rtl))
12071 HOST_WIDE_INT val = INTVAL (rtl);
12072 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
12073 val &= GET_MODE_MASK (DECL_MODE (loc));
12074 ret = int_loc_descriptor (val);
12076 else if (GET_CODE (rtl) == CONST_STRING)
12078 else if (CONSTANT_P (rtl))
12080 ret = new_loc_descr (DW_OP_addr, 0, 0);
12081 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
12082 ret->dw_loc_oprnd1.v.val_addr = rtl;
12086 enum machine_mode mode;
12088 /* Certain constructs can only be represented at top-level. */
12089 if (want_address == 2)
12090 return loc_descriptor (rtl, VOIDmode,
12091 VAR_INIT_STATUS_INITIALIZED);
12093 mode = GET_MODE (rtl);
12096 rtl = XEXP (rtl, 0);
12099 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
12105 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
12109 case COMPOUND_EXPR:
12110 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
12113 case VIEW_CONVERT_EXPR:
12116 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
12118 case COMPONENT_REF:
12119 case BIT_FIELD_REF:
12121 case ARRAY_RANGE_REF:
12124 HOST_WIDE_INT bitsize, bitpos, bytepos;
12125 enum machine_mode mode;
12127 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
12129 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
12130 &unsignedp, &volatilep, false);
12135 ret = loc_descriptor_from_tree_1 (obj, 1);
12137 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
12140 if (offset != NULL_TREE)
12142 /* Variable offset. */
12143 ret1 = loc_descriptor_from_tree_1 (offset, 0);
12146 add_loc_descr (&ret, ret1);
12147 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
12150 bytepos = bitpos / BITS_PER_UNIT;
12151 loc_descr_plus_const (&ret, bytepos);
12158 if (host_integerp (loc, 0))
12159 ret = int_loc_descriptor (tree_low_cst (loc, 0));
12166 /* Get an RTL for this, if something has been emitted. */
12167 rtx rtl = lookup_constant_def (loc);
12168 enum machine_mode mode;
12170 if (!rtl || !MEM_P (rtl))
12172 mode = GET_MODE (rtl);
12173 rtl = XEXP (rtl, 0);
12174 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
12179 case TRUTH_AND_EXPR:
12180 case TRUTH_ANDIF_EXPR:
12185 case TRUTH_XOR_EXPR:
12190 case TRUTH_OR_EXPR:
12191 case TRUTH_ORIF_EXPR:
12196 case FLOOR_DIV_EXPR:
12197 case CEIL_DIV_EXPR:
12198 case ROUND_DIV_EXPR:
12199 case TRUNC_DIV_EXPR:
12207 case FLOOR_MOD_EXPR:
12208 case CEIL_MOD_EXPR:
12209 case ROUND_MOD_EXPR:
12210 case TRUNC_MOD_EXPR:
12223 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
12226 case POINTER_PLUS_EXPR:
12228 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
12229 && host_integerp (TREE_OPERAND (loc, 1), 0))
12231 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
12235 loc_descr_plus_const (&ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
12243 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12250 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12257 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12264 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
12279 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
12280 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
12281 if (ret == 0 || ret1 == 0)
12284 add_loc_descr (&ret, ret1);
12285 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
12288 case TRUTH_NOT_EXPR:
12302 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
12306 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
12312 const enum tree_code code =
12313 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
12315 loc = build3 (COND_EXPR, TREE_TYPE (loc),
12316 build2 (code, integer_type_node,
12317 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
12318 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
12321 /* ... fall through ... */
12325 dw_loc_descr_ref lhs
12326 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
12327 dw_loc_descr_ref rhs
12328 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
12329 dw_loc_descr_ref bra_node, jump_node, tmp;
12331 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
12332 if (ret == 0 || lhs == 0 || rhs == 0)
12335 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
12336 add_loc_descr (&ret, bra_node);
12338 add_loc_descr (&ret, rhs);
12339 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
12340 add_loc_descr (&ret, jump_node);
12342 add_loc_descr (&ret, lhs);
12343 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12344 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
12346 /* ??? Need a node to point the skip at. Use a nop. */
12347 tmp = new_loc_descr (DW_OP_nop, 0, 0);
12348 add_loc_descr (&ret, tmp);
12349 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
12350 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
12354 case FIX_TRUNC_EXPR:
12358 /* Leave front-end specific codes as simply unknown. This comes
12359 up, for instance, with the C STMT_EXPR. */
12360 if ((unsigned int) TREE_CODE (loc)
12361 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
12364 #ifdef ENABLE_CHECKING
12365 /* Otherwise this is a generic code; we should just lists all of
12366 these explicitly. We forgot one. */
12367 gcc_unreachable ();
12369 /* In a release build, we want to degrade gracefully: better to
12370 generate incomplete debugging information than to crash. */
12375 /* Show if we can't fill the request for an address. */
12376 if (want_address && !have_address)
12379 /* If we've got an address and don't want one, dereference. */
12380 if (!want_address && have_address && ret)
12382 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
12384 if (size > DWARF2_ADDR_SIZE || size == -1)
12386 else if (size == DWARF2_ADDR_SIZE)
12389 op = DW_OP_deref_size;
12391 add_loc_descr (&ret, new_loc_descr (op, size, 0));
12397 static inline dw_loc_descr_ref
12398 loc_descriptor_from_tree (tree loc)
12400 return loc_descriptor_from_tree_1 (loc, 2);
12403 /* Given a value, round it up to the lowest multiple of `boundary'
12404 which is not less than the value itself. */
12406 static inline HOST_WIDE_INT
12407 ceiling (HOST_WIDE_INT value, unsigned int boundary)
12409 return (((value + boundary - 1) / boundary) * boundary);
12412 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
12413 pointer to the declared type for the relevant field variable, or return
12414 `integer_type_node' if the given node turns out to be an
12415 ERROR_MARK node. */
12418 field_type (const_tree decl)
12422 if (TREE_CODE (decl) == ERROR_MARK)
12423 return integer_type_node;
12425 type = DECL_BIT_FIELD_TYPE (decl);
12426 if (type == NULL_TREE)
12427 type = TREE_TYPE (decl);
12432 /* Given a pointer to a tree node, return the alignment in bits for
12433 it, or else return BITS_PER_WORD if the node actually turns out to
12434 be an ERROR_MARK node. */
12436 static inline unsigned
12437 simple_type_align_in_bits (const_tree type)
12439 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
12442 static inline unsigned
12443 simple_decl_align_in_bits (const_tree decl)
12445 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
12448 /* Return the result of rounding T up to ALIGN. */
12450 static inline HOST_WIDE_INT
12451 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
12453 /* We must be careful if T is negative because HOST_WIDE_INT can be
12454 either "above" or "below" unsigned int as per the C promotion
12455 rules, depending on the host, thus making the signedness of the
12456 direct multiplication and division unpredictable. */
12457 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
12463 return (HOST_WIDE_INT) u;
12466 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
12467 lowest addressed byte of the "containing object" for the given FIELD_DECL,
12468 or return 0 if we are unable to determine what that offset is, either
12469 because the argument turns out to be a pointer to an ERROR_MARK node, or
12470 because the offset is actually variable. (We can't handle the latter case
12473 static HOST_WIDE_INT
12474 field_byte_offset (const_tree decl)
12476 HOST_WIDE_INT object_offset_in_bits;
12477 HOST_WIDE_INT bitpos_int;
12479 if (TREE_CODE (decl) == ERROR_MARK)
12482 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
12484 /* We cannot yet cope with fields whose positions are variable, so
12485 for now, when we see such things, we simply return 0. Someday, we may
12486 be able to handle such cases, but it will be damn difficult. */
12487 if (! host_integerp (bit_position (decl), 0))
12490 bitpos_int = int_bit_position (decl);
12492 #ifdef PCC_BITFIELD_TYPE_MATTERS
12493 if (PCC_BITFIELD_TYPE_MATTERS)
12496 tree field_size_tree;
12497 HOST_WIDE_INT deepest_bitpos;
12498 unsigned HOST_WIDE_INT field_size_in_bits;
12499 unsigned int type_align_in_bits;
12500 unsigned int decl_align_in_bits;
12501 unsigned HOST_WIDE_INT type_size_in_bits;
12503 type = field_type (decl);
12504 type_size_in_bits = simple_type_size_in_bits (type);
12505 type_align_in_bits = simple_type_align_in_bits (type);
12507 field_size_tree = DECL_SIZE (decl);
12509 /* The size could be unspecified if there was an error, or for
12510 a flexible array member. */
12511 if (!field_size_tree)
12512 field_size_tree = bitsize_zero_node;
12514 /* If the size of the field is not constant, use the type size. */
12515 if (host_integerp (field_size_tree, 1))
12516 field_size_in_bits = tree_low_cst (field_size_tree, 1);
12518 field_size_in_bits = type_size_in_bits;
12520 decl_align_in_bits = simple_decl_align_in_bits (decl);
12522 /* The GCC front-end doesn't make any attempt to keep track of the
12523 starting bit offset (relative to the start of the containing
12524 structure type) of the hypothetical "containing object" for a
12525 bit-field. Thus, when computing the byte offset value for the
12526 start of the "containing object" of a bit-field, we must deduce
12527 this information on our own. This can be rather tricky to do in
12528 some cases. For example, handling the following structure type
12529 definition when compiling for an i386/i486 target (which only
12530 aligns long long's to 32-bit boundaries) can be very tricky:
12532 struct S { int field1; long long field2:31; };
12534 Fortunately, there is a simple rule-of-thumb which can be used
12535 in such cases. When compiling for an i386/i486, GCC will
12536 allocate 8 bytes for the structure shown above. It decides to
12537 do this based upon one simple rule for bit-field allocation.
12538 GCC allocates each "containing object" for each bit-field at
12539 the first (i.e. lowest addressed) legitimate alignment boundary
12540 (based upon the required minimum alignment for the declared
12541 type of the field) which it can possibly use, subject to the
12542 condition that there is still enough available space remaining
12543 in the containing object (when allocated at the selected point)
12544 to fully accommodate all of the bits of the bit-field itself.
12546 This simple rule makes it obvious why GCC allocates 8 bytes for
12547 each object of the structure type shown above. When looking
12548 for a place to allocate the "containing object" for `field2',
12549 the compiler simply tries to allocate a 64-bit "containing
12550 object" at each successive 32-bit boundary (starting at zero)
12551 until it finds a place to allocate that 64- bit field such that
12552 at least 31 contiguous (and previously unallocated) bits remain
12553 within that selected 64 bit field. (As it turns out, for the
12554 example above, the compiler finds it is OK to allocate the
12555 "containing object" 64-bit field at bit-offset zero within the
12558 Here we attempt to work backwards from the limited set of facts
12559 we're given, and we try to deduce from those facts, where GCC
12560 must have believed that the containing object started (within
12561 the structure type). The value we deduce is then used (by the
12562 callers of this routine) to generate DW_AT_location and
12563 DW_AT_bit_offset attributes for fields (both bit-fields and, in
12564 the case of DW_AT_location, regular fields as well). */
12566 /* Figure out the bit-distance from the start of the structure to
12567 the "deepest" bit of the bit-field. */
12568 deepest_bitpos = bitpos_int + field_size_in_bits;
12570 /* This is the tricky part. Use some fancy footwork to deduce
12571 where the lowest addressed bit of the containing object must
12573 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
12575 /* Round up to type_align by default. This works best for
12577 object_offset_in_bits
12578 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
12580 if (object_offset_in_bits > bitpos_int)
12582 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
12584 /* Round up to decl_align instead. */
12585 object_offset_in_bits
12586 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
12591 object_offset_in_bits = bitpos_int;
12593 return object_offset_in_bits / BITS_PER_UNIT;
12596 /* The following routines define various Dwarf attributes and any data
12597 associated with them. */
12599 /* Add a location description attribute value to a DIE.
12601 This emits location attributes suitable for whole variables and
12602 whole parameters. Note that the location attributes for struct fields are
12603 generated by the routine `data_member_location_attribute' below. */
12606 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
12607 dw_loc_descr_ref descr)
12610 add_AT_loc (die, attr_kind, descr);
12613 /* Attach the specialized form of location attribute used for data members of
12614 struct and union types. In the special case of a FIELD_DECL node which
12615 represents a bit-field, the "offset" part of this special location
12616 descriptor must indicate the distance in bytes from the lowest-addressed
12617 byte of the containing struct or union type to the lowest-addressed byte of
12618 the "containing object" for the bit-field. (See the `field_byte_offset'
12621 For any given bit-field, the "containing object" is a hypothetical object
12622 (of some integral or enum type) within which the given bit-field lives. The
12623 type of this hypothetical "containing object" is always the same as the
12624 declared type of the individual bit-field itself (for GCC anyway... the
12625 DWARF spec doesn't actually mandate this). Note that it is the size (in
12626 bytes) of the hypothetical "containing object" which will be given in the
12627 DW_AT_byte_size attribute for this bit-field. (See the
12628 `byte_size_attribute' function below.) It is also used when calculating the
12629 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
12630 function below.) */
12633 add_data_member_location_attribute (dw_die_ref die, tree decl)
12635 HOST_WIDE_INT offset;
12636 dw_loc_descr_ref loc_descr = 0;
12638 if (TREE_CODE (decl) == TREE_BINFO)
12640 /* We're working on the TAG_inheritance for a base class. */
12641 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
12643 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
12644 aren't at a fixed offset from all (sub)objects of the same
12645 type. We need to extract the appropriate offset from our
12646 vtable. The following dwarf expression means
12648 BaseAddr = ObAddr + *((*ObAddr) - Offset)
12650 This is specific to the V3 ABI, of course. */
12652 dw_loc_descr_ref tmp;
12654 /* Make a copy of the object address. */
12655 tmp = new_loc_descr (DW_OP_dup, 0, 0);
12656 add_loc_descr (&loc_descr, tmp);
12658 /* Extract the vtable address. */
12659 tmp = new_loc_descr (DW_OP_deref, 0, 0);
12660 add_loc_descr (&loc_descr, tmp);
12662 /* Calculate the address of the offset. */
12663 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
12664 gcc_assert (offset < 0);
12666 tmp = int_loc_descriptor (-offset);
12667 add_loc_descr (&loc_descr, tmp);
12668 tmp = new_loc_descr (DW_OP_minus, 0, 0);
12669 add_loc_descr (&loc_descr, tmp);
12671 /* Extract the offset. */
12672 tmp = new_loc_descr (DW_OP_deref, 0, 0);
12673 add_loc_descr (&loc_descr, tmp);
12675 /* Add it to the object address. */
12676 tmp = new_loc_descr (DW_OP_plus, 0, 0);
12677 add_loc_descr (&loc_descr, tmp);
12680 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
12683 offset = field_byte_offset (decl);
12687 if (dwarf_version > 2)
12689 /* Don't need to output a location expression, just the constant. */
12690 add_AT_int (die, DW_AT_data_member_location, offset);
12695 enum dwarf_location_atom op;
12697 /* The DWARF2 standard says that we should assume that the structure
12698 address is already on the stack, so we can specify a structure
12699 field address by using DW_OP_plus_uconst. */
12701 #ifdef MIPS_DEBUGGING_INFO
12702 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
12703 operator correctly. It works only if we leave the offset on the
12707 op = DW_OP_plus_uconst;
12710 loc_descr = new_loc_descr (op, offset, 0);
12714 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
12717 /* Writes integer values to dw_vec_const array. */
12720 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
12724 *dest++ = val & 0xff;
12730 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
12732 static HOST_WIDE_INT
12733 extract_int (const unsigned char *src, unsigned int size)
12735 HOST_WIDE_INT val = 0;
12741 val |= *--src & 0xff;
12747 /* Writes floating point values to dw_vec_const array. */
12750 insert_float (const_rtx rtl, unsigned char *array)
12752 REAL_VALUE_TYPE rv;
12756 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
12757 real_to_target (val, &rv, GET_MODE (rtl));
12759 /* real_to_target puts 32-bit pieces in each long. Pack them. */
12760 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
12762 insert_int (val[i], 4, array);
12767 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
12768 does not have a "location" either in memory or in a register. These
12769 things can arise in GNU C when a constant is passed as an actual parameter
12770 to an inlined function. They can also arise in C++ where declared
12771 constants do not necessarily get memory "homes". */
12774 add_const_value_attribute (dw_die_ref die, rtx rtl)
12776 switch (GET_CODE (rtl))
12780 HOST_WIDE_INT val = INTVAL (rtl);
12783 add_AT_int (die, DW_AT_const_value, val);
12785 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
12790 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
12791 floating-point constant. A CONST_DOUBLE is used whenever the
12792 constant requires more than one word in order to be adequately
12793 represented. We output CONST_DOUBLEs as blocks. */
12795 enum machine_mode mode = GET_MODE (rtl);
12797 if (SCALAR_FLOAT_MODE_P (mode))
12799 unsigned int length = GET_MODE_SIZE (mode);
12800 unsigned char *array = GGC_NEWVEC (unsigned char, length);
12802 insert_float (rtl, array);
12803 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
12806 add_AT_long_long (die, DW_AT_const_value, rtl);
12812 enum machine_mode mode = GET_MODE (rtl);
12813 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
12814 unsigned int length = CONST_VECTOR_NUNITS (rtl);
12815 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
12819 switch (GET_MODE_CLASS (mode))
12821 case MODE_VECTOR_INT:
12822 for (i = 0, p = array; i < length; i++, p += elt_size)
12824 rtx elt = CONST_VECTOR_ELT (rtl, i);
12825 HOST_WIDE_INT lo, hi;
12827 switch (GET_CODE (elt))
12835 lo = CONST_DOUBLE_LOW (elt);
12836 hi = CONST_DOUBLE_HIGH (elt);
12840 gcc_unreachable ();
12843 if (elt_size <= sizeof (HOST_WIDE_INT))
12844 insert_int (lo, elt_size, p);
12847 unsigned char *p0 = p;
12848 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
12850 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
12851 if (WORDS_BIG_ENDIAN)
12856 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
12857 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
12862 case MODE_VECTOR_FLOAT:
12863 for (i = 0, p = array; i < length; i++, p += elt_size)
12865 rtx elt = CONST_VECTOR_ELT (rtl, i);
12866 insert_float (elt, p);
12871 gcc_unreachable ();
12874 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
12879 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
12883 if (CONSTANT_P (XEXP (rtl, 0)))
12885 add_const_value_attribute (die, XEXP (rtl, 0));
12890 if (GET_CODE (rtl) == SYMBOL_REF
12891 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
12894 add_AT_addr (die, DW_AT_const_value, rtl);
12895 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
12899 /* In cases where an inlined instance of an inline function is passed
12900 the address of an `auto' variable (which is local to the caller) we
12901 can get a situation where the DECL_RTL of the artificial local
12902 variable (for the inlining) which acts as a stand-in for the
12903 corresponding formal parameter (of the inline function) will look
12904 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
12905 exactly a compile-time constant expression, but it isn't the address
12906 of the (artificial) local variable either. Rather, it represents the
12907 *value* which the artificial local variable always has during its
12908 lifetime. We currently have no way to represent such quasi-constant
12909 values in Dwarf, so for now we just punt and generate nothing. */
12913 /* No other kinds of rtx should be possible here. */
12914 gcc_unreachable ();
12919 /* Determine whether the evaluation of EXPR references any variables
12920 or functions which aren't otherwise used (and therefore may not be
12923 reference_to_unused (tree * tp, int * walk_subtrees,
12924 void * data ATTRIBUTE_UNUSED)
12926 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
12927 *walk_subtrees = 0;
12929 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
12930 && ! TREE_ASM_WRITTEN (*tp))
12932 /* ??? The C++ FE emits debug information for using decls, so
12933 putting gcc_unreachable here falls over. See PR31899. For now
12934 be conservative. */
12935 else if (!cgraph_global_info_ready
12936 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
12938 else if (TREE_CODE (*tp) == VAR_DECL)
12940 struct varpool_node *node = varpool_node (*tp);
12944 else if (TREE_CODE (*tp) == FUNCTION_DECL
12945 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
12947 /* The call graph machinery must have finished analyzing,
12948 optimizing and gimplifying the CU by now.
12949 So if *TP has no call graph node associated
12950 to it, it means *TP will not be emitted. */
12951 if (!cgraph_get_node (*tp))
12954 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
12960 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
12961 for use in a later add_const_value_attribute call. */
12964 rtl_for_decl_init (tree init, tree type)
12966 rtx rtl = NULL_RTX;
12968 /* If a variable is initialized with a string constant without embedded
12969 zeros, build CONST_STRING. */
12970 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
12972 tree enttype = TREE_TYPE (type);
12973 tree domain = TYPE_DOMAIN (type);
12974 enum machine_mode mode = TYPE_MODE (enttype);
12976 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
12978 && integer_zerop (TYPE_MIN_VALUE (domain))
12979 && compare_tree_int (TYPE_MAX_VALUE (domain),
12980 TREE_STRING_LENGTH (init) - 1) == 0
12981 && ((size_t) TREE_STRING_LENGTH (init)
12982 == strlen (TREE_STRING_POINTER (init)) + 1))
12983 rtl = gen_rtx_CONST_STRING (VOIDmode,
12984 ggc_strdup (TREE_STRING_POINTER (init)));
12986 /* Other aggregates, and complex values, could be represented using
12988 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
12990 /* Vectors only work if their mode is supported by the target.
12991 FIXME: generic vectors ought to work too. */
12992 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
12994 /* If the initializer is something that we know will expand into an
12995 immediate RTL constant, expand it now. We must be careful not to
12996 reference variables which won't be output. */
12997 else if (initializer_constant_valid_p (init, type)
12998 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
13000 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
13002 if (TREE_CODE (type) == VECTOR_TYPE)
13003 switch (TREE_CODE (init))
13008 if (TREE_CONSTANT (init))
13010 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
13011 bool constant_p = true;
13013 unsigned HOST_WIDE_INT ix;
13015 /* Even when ctor is constant, it might contain non-*_CST
13016 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
13017 belong into VECTOR_CST nodes. */
13018 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
13019 if (!CONSTANT_CLASS_P (value))
13021 constant_p = false;
13027 init = build_vector_from_ctor (type, elts);
13037 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
13039 /* If expand_expr returns a MEM, it wasn't immediate. */
13040 gcc_assert (!rtl || !MEM_P (rtl));
13046 /* Generate RTL for the variable DECL to represent its location. */
13049 rtl_for_decl_location (tree decl)
13053 /* Here we have to decide where we are going to say the parameter "lives"
13054 (as far as the debugger is concerned). We only have a couple of
13055 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
13057 DECL_RTL normally indicates where the parameter lives during most of the
13058 activation of the function. If optimization is enabled however, this
13059 could be either NULL or else a pseudo-reg. Both of those cases indicate
13060 that the parameter doesn't really live anywhere (as far as the code
13061 generation parts of GCC are concerned) during most of the function's
13062 activation. That will happen (for example) if the parameter is never
13063 referenced within the function.
13065 We could just generate a location descriptor here for all non-NULL
13066 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
13067 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
13068 where DECL_RTL is NULL or is a pseudo-reg.
13070 Note however that we can only get away with using DECL_INCOMING_RTL as
13071 a backup substitute for DECL_RTL in certain limited cases. In cases
13072 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
13073 we can be sure that the parameter was passed using the same type as it is
13074 declared to have within the function, and that its DECL_INCOMING_RTL
13075 points us to a place where a value of that type is passed.
13077 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
13078 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
13079 because in these cases DECL_INCOMING_RTL points us to a value of some
13080 type which is *different* from the type of the parameter itself. Thus,
13081 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
13082 such cases, the debugger would end up (for example) trying to fetch a
13083 `float' from a place which actually contains the first part of a
13084 `double'. That would lead to really incorrect and confusing
13085 output at debug-time.
13087 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
13088 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
13089 are a couple of exceptions however. On little-endian machines we can
13090 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
13091 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
13092 an integral type that is smaller than TREE_TYPE (decl). These cases arise
13093 when (on a little-endian machine) a non-prototyped function has a
13094 parameter declared to be of type `short' or `char'. In such cases,
13095 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
13096 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
13097 passed `int' value. If the debugger then uses that address to fetch
13098 a `short' or a `char' (on a little-endian machine) the result will be
13099 the correct data, so we allow for such exceptional cases below.
13101 Note that our goal here is to describe the place where the given formal
13102 parameter lives during most of the function's activation (i.e. between the
13103 end of the prologue and the start of the epilogue). We'll do that as best
13104 as we can. Note however that if the given formal parameter is modified
13105 sometime during the execution of the function, then a stack backtrace (at
13106 debug-time) will show the function as having been called with the *new*
13107 value rather than the value which was originally passed in. This happens
13108 rarely enough that it is not a major problem, but it *is* a problem, and
13109 I'd like to fix it.
13111 A future version of dwarf2out.c may generate two additional attributes for
13112 any given DW_TAG_formal_parameter DIE which will describe the "passed
13113 type" and the "passed location" for the given formal parameter in addition
13114 to the attributes we now generate to indicate the "declared type" and the
13115 "active location" for each parameter. This additional set of attributes
13116 could be used by debuggers for stack backtraces. Separately, note that
13117 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
13118 This happens (for example) for inlined-instances of inline function formal
13119 parameters which are never referenced. This really shouldn't be
13120 happening. All PARM_DECL nodes should get valid non-NULL
13121 DECL_INCOMING_RTL values. FIXME. */
13123 /* Use DECL_RTL as the "location" unless we find something better. */
13124 rtl = DECL_RTL_IF_SET (decl);
13126 /* When generating abstract instances, ignore everything except
13127 constants, symbols living in memory, and symbols living in
13128 fixed registers. */
13129 if (! reload_completed)
13132 && (CONSTANT_P (rtl)
13134 && CONSTANT_P (XEXP (rtl, 0)))
13136 && TREE_CODE (decl) == VAR_DECL
13137 && TREE_STATIC (decl))))
13139 rtl = targetm.delegitimize_address (rtl);
13144 else if (TREE_CODE (decl) == PARM_DECL)
13146 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
13148 tree declared_type = TREE_TYPE (decl);
13149 tree passed_type = DECL_ARG_TYPE (decl);
13150 enum machine_mode dmode = TYPE_MODE (declared_type);
13151 enum machine_mode pmode = TYPE_MODE (passed_type);
13153 /* This decl represents a formal parameter which was optimized out.
13154 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
13155 all cases where (rtl == NULL_RTX) just below. */
13156 if (dmode == pmode)
13157 rtl = DECL_INCOMING_RTL (decl);
13158 else if (SCALAR_INT_MODE_P (dmode)
13159 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
13160 && DECL_INCOMING_RTL (decl))
13162 rtx inc = DECL_INCOMING_RTL (decl);
13165 else if (MEM_P (inc))
13167 if (BYTES_BIG_ENDIAN)
13168 rtl = adjust_address_nv (inc, dmode,
13169 GET_MODE_SIZE (pmode)
13170 - GET_MODE_SIZE (dmode));
13177 /* If the parm was passed in registers, but lives on the stack, then
13178 make a big endian correction if the mode of the type of the
13179 parameter is not the same as the mode of the rtl. */
13180 /* ??? This is the same series of checks that are made in dbxout.c before
13181 we reach the big endian correction code there. It isn't clear if all
13182 of these checks are necessary here, but keeping them all is the safe
13184 else if (MEM_P (rtl)
13185 && XEXP (rtl, 0) != const0_rtx
13186 && ! CONSTANT_P (XEXP (rtl, 0))
13187 /* Not passed in memory. */
13188 && !MEM_P (DECL_INCOMING_RTL (decl))
13189 /* Not passed by invisible reference. */
13190 && (!REG_P (XEXP (rtl, 0))
13191 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
13192 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
13193 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
13194 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
13197 /* Big endian correction check. */
13198 && BYTES_BIG_ENDIAN
13199 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
13200 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
13203 int offset = (UNITS_PER_WORD
13204 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
13206 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
13207 plus_constant (XEXP (rtl, 0), offset));
13210 else if (TREE_CODE (decl) == VAR_DECL
13213 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
13214 && BYTES_BIG_ENDIAN)
13216 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
13217 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
13219 /* If a variable is declared "register" yet is smaller than
13220 a register, then if we store the variable to memory, it
13221 looks like we're storing a register-sized value, when in
13222 fact we are not. We need to adjust the offset of the
13223 storage location to reflect the actual value's bytes,
13224 else gdb will not be able to display it. */
13226 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
13227 plus_constant (XEXP (rtl, 0), rsize-dsize));
13230 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
13231 and will have been substituted directly into all expressions that use it.
13232 C does not have such a concept, but C++ and other languages do. */
13233 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
13234 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
13237 rtl = targetm.delegitimize_address (rtl);
13239 /* If we don't look past the constant pool, we risk emitting a
13240 reference to a constant pool entry that isn't referenced from
13241 code, and thus is not emitted. */
13243 rtl = avoid_constant_pool_reference (rtl);
13248 /* We need to figure out what section we should use as the base for the
13249 address ranges where a given location is valid.
13250 1. If this particular DECL has a section associated with it, use that.
13251 2. If this function has a section associated with it, use that.
13252 3. Otherwise, use the text section.
13253 XXX: If you split a variable across multiple sections, we won't notice. */
13255 static const char *
13256 secname_for_decl (const_tree decl)
13258 const char *secname;
13260 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
13262 tree sectree = DECL_SECTION_NAME (decl);
13263 secname = TREE_STRING_POINTER (sectree);
13265 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
13267 tree sectree = DECL_SECTION_NAME (current_function_decl);
13268 secname = TREE_STRING_POINTER (sectree);
13270 else if (cfun && in_cold_section_p)
13271 secname = crtl->subsections.cold_section_label;
13273 secname = text_section_label;
13278 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
13279 returned. If so, the decl for the COMMON block is returned, and the
13280 value is the offset into the common block for the symbol. */
13283 fortran_common (tree decl, HOST_WIDE_INT *value)
13285 tree val_expr, cvar;
13286 enum machine_mode mode;
13287 HOST_WIDE_INT bitsize, bitpos;
13289 int volatilep = 0, unsignedp = 0;
13291 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
13292 it does not have a value (the offset into the common area), or if it
13293 is thread local (as opposed to global) then it isn't common, and shouldn't
13294 be handled as such. */
13295 if (TREE_CODE (decl) != VAR_DECL
13296 || !TREE_PUBLIC (decl)
13297 || !TREE_STATIC (decl)
13298 || !DECL_HAS_VALUE_EXPR_P (decl)
13302 val_expr = DECL_VALUE_EXPR (decl);
13303 if (TREE_CODE (val_expr) != COMPONENT_REF)
13306 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
13307 &mode, &unsignedp, &volatilep, true);
13309 if (cvar == NULL_TREE
13310 || TREE_CODE (cvar) != VAR_DECL
13311 || DECL_ARTIFICIAL (cvar)
13312 || !TREE_PUBLIC (cvar))
13316 if (offset != NULL)
13318 if (!host_integerp (offset, 0))
13320 *value = tree_low_cst (offset, 0);
13323 *value += bitpos / BITS_PER_UNIT;
13328 /* Dereference a location expression LOC if DECL is passed by invisible
13331 static dw_loc_descr_ref
13332 loc_by_reference (dw_loc_descr_ref loc, tree decl)
13334 HOST_WIDE_INT size;
13335 enum dwarf_location_atom op;
13340 if ((TREE_CODE (decl) != PARM_DECL
13341 && TREE_CODE (decl) != RESULT_DECL
13342 && TREE_CODE (decl) != VAR_DECL)
13343 || !DECL_BY_REFERENCE (decl))
13346 /* If loc is DW_OP_reg{0...31,x}, don't add DW_OP_deref, instead
13347 change it into corresponding DW_OP_breg{0...31,x} 0. Then the
13348 location expression is considered to be address of a memory location,
13349 rather than the register itself. */
13350 if (((loc->dw_loc_opc >= DW_OP_reg0 && loc->dw_loc_opc <= DW_OP_reg31)
13351 || loc->dw_loc_opc == DW_OP_regx)
13352 && (loc->dw_loc_next == NULL
13353 || (loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_uninit
13354 && loc->dw_loc_next->dw_loc_next == NULL)))
13356 if (loc->dw_loc_opc == DW_OP_regx)
13358 loc->dw_loc_opc = DW_OP_bregx;
13359 loc->dw_loc_oprnd2.v.val_int = 0;
13364 = (enum dwarf_location_atom)
13365 (loc->dw_loc_opc + (DW_OP_breg0 - DW_OP_reg0));
13366 loc->dw_loc_oprnd1.v.val_int = 0;
13371 size = int_size_in_bytes (TREE_TYPE (decl));
13372 if (size > DWARF2_ADDR_SIZE || size == -1)
13374 else if (size == DWARF2_ADDR_SIZE)
13377 op = DW_OP_deref_size;
13378 add_loc_descr (&loc, new_loc_descr (op, size, 0));
13382 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
13383 data attribute for a variable or a parameter. We generate the
13384 DW_AT_const_value attribute only in those cases where the given variable
13385 or parameter does not have a true "location" either in memory or in a
13386 register. This can happen (for example) when a constant is passed as an
13387 actual argument in a call to an inline function. (It's possible that
13388 these things can crop up in other ways also.) Note that one type of
13389 constant value which can be passed into an inlined function is a constant
13390 pointer. This can happen for example if an actual argument in an inlined
13391 function call evaluates to a compile-time constant address. */
13394 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
13395 enum dwarf_attribute attr)
13398 dw_loc_descr_ref descr;
13399 var_loc_list *loc_list;
13400 struct var_loc_node *node;
13401 if (TREE_CODE (decl) == ERROR_MARK)
13404 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
13405 || TREE_CODE (decl) == RESULT_DECL);
13407 /* See if we possibly have multiple locations for this variable. */
13408 loc_list = lookup_decl_loc (decl);
13410 /* If it truly has multiple locations, the first and last node will
13412 if (loc_list && loc_list->first != loc_list->last)
13414 const char *endname, *secname;
13415 dw_loc_list_ref list;
13417 enum var_init_status initialized;
13419 /* Now that we know what section we are using for a base,
13420 actually construct the list of locations.
13421 The first location information is what is passed to the
13422 function that creates the location list, and the remaining
13423 locations just get added on to that list.
13424 Note that we only know the start address for a location
13425 (IE location changes), so to build the range, we use
13426 the range [current location start, next location start].
13427 This means we have to special case the last node, and generate
13428 a range of [last location start, end of function label]. */
13430 node = loc_list->first;
13431 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
13432 secname = secname_for_decl (decl);
13434 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
13435 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
13437 initialized = VAR_INIT_STATUS_INITIALIZED;
13439 descr = loc_by_reference (loc_descriptor (varloc, DECL_MODE (decl),
13440 initialized), decl);
13441 list = new_loc_list (descr, node->label, node->next->label, secname, 1);
13444 for (; node->next; node = node->next)
13445 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
13447 /* The variable has a location between NODE->LABEL and
13448 NODE->NEXT->LABEL. */
13449 enum var_init_status initialized =
13450 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
13451 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
13452 descr = loc_by_reference (loc_descriptor (varloc, DECL_MODE (decl),
13453 initialized), decl);
13454 add_loc_descr_to_loc_list (&list, descr,
13455 node->label, node->next->label, secname);
13458 /* If the variable has a location at the last label
13459 it keeps its location until the end of function. */
13460 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
13462 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
13463 enum var_init_status initialized =
13464 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
13466 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
13467 if (!current_function_decl)
13468 endname = text_end_label;
13471 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
13472 current_function_funcdef_no);
13473 endname = ggc_strdup (label_id);
13475 descr = loc_by_reference (loc_descriptor (varloc,
13479 add_loc_descr_to_loc_list (&list, descr,
13480 node->label, endname, secname);
13483 /* Finally, add the location list to the DIE, and we are done. */
13484 add_AT_loc_list (die, attr, list);
13488 /* Try to get some constant RTL for this decl, and use that as the value of
13491 rtl = rtl_for_decl_location (decl);
13492 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
13494 add_const_value_attribute (die, rtl);
13498 /* If we have tried to generate the location otherwise, and it
13499 didn't work out (we wouldn't be here if we did), and we have a one entry
13500 location list, try generating a location from that. */
13501 if (loc_list && loc_list->first)
13503 enum var_init_status status;
13504 node = loc_list->first;
13505 status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
13506 rtl = NOTE_VAR_LOCATION (node->var_loc_note);
13507 if (GET_CODE (rtl) == VAR_LOCATION
13508 && GET_CODE (XEXP (rtl, 1)) != PARALLEL)
13509 rtl = XEXP (XEXP (rtl, 1), 0);
13510 if (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
13512 add_const_value_attribute (die, rtl);
13515 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note),
13516 DECL_MODE (decl), status);
13519 descr = loc_by_reference (descr, decl);
13520 add_AT_location_description (die, attr, descr);
13525 /* We couldn't get any rtl, so try directly generating the location
13526 description from the tree. */
13527 descr = loc_descriptor_from_tree (decl);
13530 descr = loc_by_reference (descr, decl);
13531 add_AT_location_description (die, attr, descr);
13534 /* None of that worked, so it must not really have a location;
13535 try adding a constant value attribute from the DECL_INITIAL. */
13536 tree_add_const_value_attribute_for_decl (die, decl);
13539 /* Add VARIABLE and DIE into deferred locations list. */
13542 defer_location (tree variable, dw_die_ref die)
13544 deferred_locations entry;
13545 entry.variable = variable;
13547 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
13550 /* Helper function for tree_add_const_value_attribute. Natively encode
13551 initializer INIT into an array. Return true if successful. */
13554 native_encode_initializer (tree init, unsigned char *array, int size)
13558 if (init == NULL_TREE)
13562 switch (TREE_CODE (init))
13565 type = TREE_TYPE (init);
13566 if (TREE_CODE (type) == ARRAY_TYPE)
13568 tree enttype = TREE_TYPE (type);
13569 enum machine_mode mode = TYPE_MODE (enttype);
13571 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
13573 if (int_size_in_bytes (type) != size)
13575 if (size > TREE_STRING_LENGTH (init))
13577 memcpy (array, TREE_STRING_POINTER (init),
13578 TREE_STRING_LENGTH (init));
13579 memset (array + TREE_STRING_LENGTH (init),
13580 '\0', size - TREE_STRING_LENGTH (init));
13583 memcpy (array, TREE_STRING_POINTER (init), size);
13588 type = TREE_TYPE (init);
13589 if (int_size_in_bytes (type) != size)
13591 if (TREE_CODE (type) == ARRAY_TYPE)
13593 HOST_WIDE_INT min_index;
13594 unsigned HOST_WIDE_INT cnt;
13595 int curpos = 0, fieldsize;
13596 constructor_elt *ce;
13598 if (TYPE_DOMAIN (type) == NULL_TREE
13599 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
13602 fieldsize = int_size_in_bytes (TREE_TYPE (type));
13603 if (fieldsize <= 0)
13606 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
13607 memset (array, '\0', size);
13609 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
13612 tree val = ce->value;
13613 tree index = ce->index;
13615 if (index && TREE_CODE (index) == RANGE_EXPR)
13616 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
13619 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
13624 if (!native_encode_initializer (val, array + pos, fieldsize))
13627 curpos = pos + fieldsize;
13628 if (index && TREE_CODE (index) == RANGE_EXPR)
13630 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
13631 - tree_low_cst (TREE_OPERAND (index, 0), 0);
13635 memcpy (array + curpos, array + pos, fieldsize);
13636 curpos += fieldsize;
13639 gcc_assert (curpos <= size);
13643 else if (TREE_CODE (type) == RECORD_TYPE
13644 || TREE_CODE (type) == UNION_TYPE)
13646 tree field = NULL_TREE;
13647 unsigned HOST_WIDE_INT cnt;
13648 constructor_elt *ce;
13650 if (int_size_in_bytes (type) != size)
13653 if (TREE_CODE (type) == RECORD_TYPE)
13654 field = TYPE_FIELDS (type);
13657 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
13658 cnt++, field = field ? TREE_CHAIN (field) : 0)
13660 tree val = ce->value;
13661 int pos, fieldsize;
13663 if (ce->index != 0)
13669 if (field == NULL_TREE || DECL_BIT_FIELD (field))
13672 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
13673 && TYPE_DOMAIN (TREE_TYPE (field))
13674 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
13676 else if (DECL_SIZE_UNIT (field) == NULL_TREE
13677 || !host_integerp (DECL_SIZE_UNIT (field), 0))
13679 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
13680 pos = int_byte_position (field);
13681 gcc_assert (pos + fieldsize <= size);
13683 && !native_encode_initializer (val, array + pos, fieldsize))
13689 case VIEW_CONVERT_EXPR:
13690 case NON_LVALUE_EXPR:
13691 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
13693 return native_encode_expr (init, array, size) == size;
13697 /* Attach a DW_AT_const_value attribute to DIE. The value of the
13698 attribute is the const value T. */
13701 tree_add_const_value_attribute (dw_die_ref die, tree t)
13704 tree type = TREE_TYPE (t);
13707 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
13711 gcc_assert (!DECL_P (init));
13713 rtl = rtl_for_decl_init (init, type);
13715 add_const_value_attribute (die, rtl);
13716 /* If the host and target are sane, try harder. */
13717 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
13718 && initializer_constant_valid_p (init, type))
13720 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
13721 if (size > 0 && (int) size == size)
13723 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
13725 if (native_encode_initializer (init, array, size))
13726 add_AT_vec (die, DW_AT_const_value, size, 1, array);
13731 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
13732 attribute is the const value of T, where T is an integral constant
13733 variable with static storage duration
13734 (so it can't be a PARM_DECL or a RESULT_DECL). */
13737 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
13741 || (TREE_CODE (decl) != VAR_DECL
13742 && TREE_CODE (decl) != CONST_DECL))
13745 if (TREE_READONLY (decl)
13746 && ! TREE_THIS_VOLATILE (decl)
13747 && DECL_INITIAL (decl))
13752 tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
13755 /* Convert the CFI instructions for the current function into a
13756 location list. This is used for DW_AT_frame_base when we targeting
13757 a dwarf2 consumer that does not support the dwarf3
13758 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
13761 static dw_loc_list_ref
13762 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
13765 dw_loc_list_ref list, *list_tail;
13767 dw_cfa_location last_cfa, next_cfa;
13768 const char *start_label, *last_label, *section;
13769 dw_cfa_location remember;
13771 fde = current_fde ();
13772 gcc_assert (fde != NULL);
13774 section = secname_for_decl (current_function_decl);
13778 memset (&next_cfa, 0, sizeof (next_cfa));
13779 next_cfa.reg = INVALID_REGNUM;
13780 remember = next_cfa;
13782 start_label = fde->dw_fde_begin;
13784 /* ??? Bald assumption that the CIE opcode list does not contain
13785 advance opcodes. */
13786 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
13787 lookup_cfa_1 (cfi, &next_cfa, &remember);
13789 last_cfa = next_cfa;
13790 last_label = start_label;
13792 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
13793 switch (cfi->dw_cfi_opc)
13795 case DW_CFA_set_loc:
13796 case DW_CFA_advance_loc1:
13797 case DW_CFA_advance_loc2:
13798 case DW_CFA_advance_loc4:
13799 if (!cfa_equal_p (&last_cfa, &next_cfa))
13801 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
13802 start_label, last_label, section,
13805 list_tail = &(*list_tail)->dw_loc_next;
13806 last_cfa = next_cfa;
13807 start_label = last_label;
13809 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
13812 case DW_CFA_advance_loc:
13813 /* The encoding is complex enough that we should never emit this. */
13814 gcc_unreachable ();
13817 lookup_cfa_1 (cfi, &next_cfa, &remember);
13821 if (!cfa_equal_p (&last_cfa, &next_cfa))
13823 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
13824 start_label, last_label, section,
13826 list_tail = &(*list_tail)->dw_loc_next;
13827 start_label = last_label;
13829 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
13830 start_label, fde->dw_fde_end, section,
13836 /* Compute a displacement from the "steady-state frame pointer" to the
13837 frame base (often the same as the CFA), and store it in
13838 frame_pointer_fb_offset. OFFSET is added to the displacement
13839 before the latter is negated. */
13842 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
13846 #ifdef FRAME_POINTER_CFA_OFFSET
13847 reg = frame_pointer_rtx;
13848 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
13850 reg = arg_pointer_rtx;
13851 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
13854 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
13855 if (GET_CODE (elim) == PLUS)
13857 offset += INTVAL (XEXP (elim, 1));
13858 elim = XEXP (elim, 0);
13861 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
13862 && (elim == hard_frame_pointer_rtx
13863 || elim == stack_pointer_rtx))
13864 || elim == (frame_pointer_needed
13865 ? hard_frame_pointer_rtx
13866 : stack_pointer_rtx));
13868 frame_pointer_fb_offset = -offset;
13871 /* Generate a DW_AT_name attribute given some string value to be included as
13872 the value of the attribute. */
13875 add_name_attribute (dw_die_ref die, const char *name_string)
13877 if (name_string != NULL && *name_string != 0)
13879 if (demangle_name_func)
13880 name_string = (*demangle_name_func) (name_string);
13882 add_AT_string (die, DW_AT_name, name_string);
13886 /* Generate a DW_AT_comp_dir attribute for DIE. */
13889 add_comp_dir_attribute (dw_die_ref die)
13891 const char *wd = get_src_pwd ();
13897 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
13901 wdlen = strlen (wd);
13902 wd1 = GGC_NEWVEC (char, wdlen + 2);
13904 wd1 [wdlen] = DIR_SEPARATOR;
13905 wd1 [wdlen + 1] = 0;
13909 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
13912 /* Given a tree node describing an array bound (either lower or upper) output
13913 a representation for that bound. */
13916 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
13918 switch (TREE_CODE (bound))
13923 /* All fixed-bounds are represented by INTEGER_CST nodes. */
13925 if (! host_integerp (bound, 0)
13926 || (bound_attr == DW_AT_lower_bound
13927 && (((is_c_family () || is_java ()) && integer_zerop (bound))
13928 || (is_fortran () && integer_onep (bound)))))
13929 /* Use the default. */
13932 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
13936 case VIEW_CONVERT_EXPR:
13937 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
13947 dw_die_ref decl_die = lookup_decl_die (bound);
13948 dw_loc_descr_ref loc;
13950 /* ??? Can this happen, or should the variable have been bound
13951 first? Probably it can, since I imagine that we try to create
13952 the types of parameters in the order in which they exist in
13953 the list, and won't have created a forward reference to a
13954 later parameter. */
13955 if (decl_die != NULL)
13956 add_AT_die_ref (subrange_die, bound_attr, decl_die);
13959 loc = loc_descriptor_from_tree_1 (bound, 0);
13960 add_AT_location_description (subrange_die, bound_attr, loc);
13967 /* Otherwise try to create a stack operation procedure to
13968 evaluate the value of the array bound. */
13970 dw_die_ref ctx, decl_die;
13971 dw_loc_descr_ref loc;
13973 loc = loc_descriptor_from_tree (bound);
13977 if (current_function_decl == 0)
13978 ctx = comp_unit_die;
13980 ctx = lookup_decl_die (current_function_decl);
13982 decl_die = new_die (DW_TAG_variable, ctx, bound);
13983 add_AT_flag (decl_die, DW_AT_artificial, 1);
13984 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
13985 add_AT_loc (decl_die, DW_AT_location, loc);
13987 add_AT_die_ref (subrange_die, bound_attr, decl_die);
13993 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
13994 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
13995 Note that the block of subscript information for an array type also
13996 includes information about the element type of the given array type. */
13999 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
14001 unsigned dimension_number;
14003 dw_die_ref subrange_die;
14005 for (dimension_number = 0;
14006 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
14007 type = TREE_TYPE (type), dimension_number++)
14009 tree domain = TYPE_DOMAIN (type);
14011 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
14014 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
14015 and (in GNU C only) variable bounds. Handle all three forms
14017 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
14020 /* We have an array type with specified bounds. */
14021 lower = TYPE_MIN_VALUE (domain);
14022 upper = TYPE_MAX_VALUE (domain);
14024 /* Define the index type. */
14025 if (TREE_TYPE (domain))
14027 /* ??? This is probably an Ada unnamed subrange type. Ignore the
14028 TREE_TYPE field. We can't emit debug info for this
14029 because it is an unnamed integral type. */
14030 if (TREE_CODE (domain) == INTEGER_TYPE
14031 && TYPE_NAME (domain) == NULL_TREE
14032 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
14033 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
14036 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
14040 /* ??? If upper is NULL, the array has unspecified length,
14041 but it does have a lower bound. This happens with Fortran
14043 Since the debugger is definitely going to need to know N
14044 to produce useful results, go ahead and output the lower
14045 bound solo, and hope the debugger can cope. */
14047 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
14049 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
14052 /* Otherwise we have an array type with an unspecified length. The
14053 DWARF-2 spec does not say how to handle this; let's just leave out the
14059 add_byte_size_attribute (dw_die_ref die, tree tree_node)
14063 switch (TREE_CODE (tree_node))
14068 case ENUMERAL_TYPE:
14071 case QUAL_UNION_TYPE:
14072 size = int_size_in_bytes (tree_node);
14075 /* For a data member of a struct or union, the DW_AT_byte_size is
14076 generally given as the number of bytes normally allocated for an
14077 object of the *declared* type of the member itself. This is true
14078 even for bit-fields. */
14079 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
14082 gcc_unreachable ();
14085 /* Note that `size' might be -1 when we get to this point. If it is, that
14086 indicates that the byte size of the entity in question is variable. We
14087 have no good way of expressing this fact in Dwarf at the present time,
14088 so just let the -1 pass on through. */
14089 add_AT_unsigned (die, DW_AT_byte_size, size);
14092 /* For a FIELD_DECL node which represents a bit-field, output an attribute
14093 which specifies the distance in bits from the highest order bit of the
14094 "containing object" for the bit-field to the highest order bit of the
14097 For any given bit-field, the "containing object" is a hypothetical object
14098 (of some integral or enum type) within which the given bit-field lives. The
14099 type of this hypothetical "containing object" is always the same as the
14100 declared type of the individual bit-field itself. The determination of the
14101 exact location of the "containing object" for a bit-field is rather
14102 complicated. It's handled by the `field_byte_offset' function (above).
14104 Note that it is the size (in bytes) of the hypothetical "containing object"
14105 which will be given in the DW_AT_byte_size attribute for this bit-field.
14106 (See `byte_size_attribute' above). */
14109 add_bit_offset_attribute (dw_die_ref die, tree decl)
14111 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
14112 tree type = DECL_BIT_FIELD_TYPE (decl);
14113 HOST_WIDE_INT bitpos_int;
14114 HOST_WIDE_INT highest_order_object_bit_offset;
14115 HOST_WIDE_INT highest_order_field_bit_offset;
14116 HOST_WIDE_INT unsigned bit_offset;
14118 /* Must be a field and a bit field. */
14119 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
14121 /* We can't yet handle bit-fields whose offsets are variable, so if we
14122 encounter such things, just return without generating any attribute
14123 whatsoever. Likewise for variable or too large size. */
14124 if (! host_integerp (bit_position (decl), 0)
14125 || ! host_integerp (DECL_SIZE (decl), 1))
14128 bitpos_int = int_bit_position (decl);
14130 /* Note that the bit offset is always the distance (in bits) from the
14131 highest-order bit of the "containing object" to the highest-order bit of
14132 the bit-field itself. Since the "high-order end" of any object or field
14133 is different on big-endian and little-endian machines, the computation
14134 below must take account of these differences. */
14135 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
14136 highest_order_field_bit_offset = bitpos_int;
14138 if (! BYTES_BIG_ENDIAN)
14140 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
14141 highest_order_object_bit_offset += simple_type_size_in_bits (type);
14145 = (! BYTES_BIG_ENDIAN
14146 ? highest_order_object_bit_offset - highest_order_field_bit_offset
14147 : highest_order_field_bit_offset - highest_order_object_bit_offset);
14149 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
14152 /* For a FIELD_DECL node which represents a bit field, output an attribute
14153 which specifies the length in bits of the given field. */
14156 add_bit_size_attribute (dw_die_ref die, tree decl)
14158 /* Must be a field and a bit field. */
14159 gcc_assert (TREE_CODE (decl) == FIELD_DECL
14160 && DECL_BIT_FIELD_TYPE (decl));
14162 if (host_integerp (DECL_SIZE (decl), 1))
14163 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
14166 /* If the compiled language is ANSI C, then add a 'prototyped'
14167 attribute, if arg types are given for the parameters of a function. */
14170 add_prototyped_attribute (dw_die_ref die, tree func_type)
14172 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
14173 && TYPE_ARG_TYPES (func_type) != NULL)
14174 add_AT_flag (die, DW_AT_prototyped, 1);
14177 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
14178 by looking in either the type declaration or object declaration
14181 static inline dw_die_ref
14182 add_abstract_origin_attribute (dw_die_ref die, tree origin)
14184 dw_die_ref origin_die = NULL;
14186 if (TREE_CODE (origin) != FUNCTION_DECL)
14188 /* We may have gotten separated from the block for the inlined
14189 function, if we're in an exception handler or some such; make
14190 sure that the abstract function has been written out.
14192 Doing this for nested functions is wrong, however; functions are
14193 distinct units, and our context might not even be inline. */
14197 fn = TYPE_STUB_DECL (fn);
14199 fn = decl_function_context (fn);
14201 dwarf2out_abstract_function (fn);
14204 if (DECL_P (origin))
14205 origin_die = lookup_decl_die (origin);
14206 else if (TYPE_P (origin))
14207 origin_die = lookup_type_die (origin);
14209 /* XXX: Functions that are never lowered don't always have correct block
14210 trees (in the case of java, they simply have no block tree, in some other
14211 languages). For these functions, there is nothing we can really do to
14212 output correct debug info for inlined functions in all cases. Rather
14213 than die, we'll just produce deficient debug info now, in that we will
14214 have variables without a proper abstract origin. In the future, when all
14215 functions are lowered, we should re-add a gcc_assert (origin_die)
14219 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
14223 /* We do not currently support the pure_virtual attribute. */
14226 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
14228 if (DECL_VINDEX (func_decl))
14230 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
14232 if (host_integerp (DECL_VINDEX (func_decl), 0))
14233 add_AT_loc (die, DW_AT_vtable_elem_location,
14234 new_loc_descr (DW_OP_constu,
14235 tree_low_cst (DECL_VINDEX (func_decl), 0),
14238 /* GNU extension: Record what type this method came from originally. */
14239 if (debug_info_level > DINFO_LEVEL_TERSE)
14240 add_AT_die_ref (die, DW_AT_containing_type,
14241 lookup_type_die (DECL_CONTEXT (func_decl)));
14245 /* Add source coordinate attributes for the given decl. */
14248 add_src_coords_attributes (dw_die_ref die, tree decl)
14250 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
14252 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
14253 add_AT_unsigned (die, DW_AT_decl_line, s.line);
14256 /* Add a DW_AT_name attribute and source coordinate attribute for the
14257 given decl, but only if it actually has a name. */
14260 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
14264 decl_name = DECL_NAME (decl);
14265 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
14267 add_name_attribute (die, dwarf2_name (decl, 0));
14268 if (! DECL_ARTIFICIAL (decl))
14269 add_src_coords_attributes (die, decl);
14271 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
14272 && TREE_PUBLIC (decl)
14273 && !DECL_ABSTRACT (decl)
14274 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
14277 /* Defer until we have an assembler name set. */
14278 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
14280 limbo_die_node *asm_name;
14282 asm_name = GGC_CNEW (limbo_die_node);
14283 asm_name->die = die;
14284 asm_name->created_for = decl;
14285 asm_name->next = deferred_asm_name;
14286 deferred_asm_name = asm_name;
14288 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
14289 add_AT_string (die, DW_AT_MIPS_linkage_name,
14290 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
14294 #ifdef VMS_DEBUGGING_INFO
14295 /* Get the function's name, as described by its RTL. This may be different
14296 from the DECL_NAME name used in the source file. */
14297 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
14299 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
14300 XEXP (DECL_RTL (decl), 0));
14301 VEC_safe_push (rtx, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
14306 /* Push a new declaration scope. */
14309 push_decl_scope (tree scope)
14311 VEC_safe_push (tree, gc, decl_scope_table, scope);
14314 /* Pop a declaration scope. */
14317 pop_decl_scope (void)
14319 VEC_pop (tree, decl_scope_table);
14322 /* Return the DIE for the scope that immediately contains this type.
14323 Non-named types get global scope. Named types nested in other
14324 types get their containing scope if it's open, or global scope
14325 otherwise. All other types (i.e. function-local named types) get
14326 the current active scope. */
14329 scope_die_for (tree t, dw_die_ref context_die)
14331 dw_die_ref scope_die = NULL;
14332 tree containing_scope;
14335 /* Non-types always go in the current scope. */
14336 gcc_assert (TYPE_P (t));
14338 containing_scope = TYPE_CONTEXT (t);
14340 /* Use the containing namespace if it was passed in (for a declaration). */
14341 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
14343 if (context_die == lookup_decl_die (containing_scope))
14346 containing_scope = NULL_TREE;
14349 /* Ignore function type "scopes" from the C frontend. They mean that
14350 a tagged type is local to a parmlist of a function declarator, but
14351 that isn't useful to DWARF. */
14352 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
14353 containing_scope = NULL_TREE;
14355 if (containing_scope == NULL_TREE)
14356 scope_die = comp_unit_die;
14357 else if (TYPE_P (containing_scope))
14359 /* For types, we can just look up the appropriate DIE. But
14360 first we check to see if we're in the middle of emitting it
14361 so we know where the new DIE should go. */
14362 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
14363 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
14368 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
14369 || TREE_ASM_WRITTEN (containing_scope));
14371 /* If none of the current dies are suitable, we get file scope. */
14372 scope_die = comp_unit_die;
14375 scope_die = lookup_type_die (containing_scope);
14378 scope_die = context_die;
14383 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
14386 local_scope_p (dw_die_ref context_die)
14388 for (; context_die; context_die = context_die->die_parent)
14389 if (context_die->die_tag == DW_TAG_inlined_subroutine
14390 || context_die->die_tag == DW_TAG_subprogram)
14396 /* Returns nonzero if CONTEXT_DIE is a class. */
14399 class_scope_p (dw_die_ref context_die)
14401 return (context_die
14402 && (context_die->die_tag == DW_TAG_structure_type
14403 || context_die->die_tag == DW_TAG_class_type
14404 || context_die->die_tag == DW_TAG_interface_type
14405 || context_die->die_tag == DW_TAG_union_type));
14408 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
14409 whether or not to treat a DIE in this context as a declaration. */
14412 class_or_namespace_scope_p (dw_die_ref context_die)
14414 return (class_scope_p (context_die)
14415 || (context_die && context_die->die_tag == DW_TAG_namespace));
14418 /* Many forms of DIEs require a "type description" attribute. This
14419 routine locates the proper "type descriptor" die for the type given
14420 by 'type', and adds a DW_AT_type attribute below the given die. */
14423 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
14424 int decl_volatile, dw_die_ref context_die)
14426 enum tree_code code = TREE_CODE (type);
14427 dw_die_ref type_die = NULL;
14429 /* ??? If this type is an unnamed subrange type of an integral, floating-point
14430 or fixed-point type, use the inner type. This is because we have no
14431 support for unnamed types in base_type_die. This can happen if this is
14432 an Ada subrange type. Correct solution is emit a subrange type die. */
14433 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
14434 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
14435 type = TREE_TYPE (type), code = TREE_CODE (type);
14437 if (code == ERROR_MARK
14438 /* Handle a special case. For functions whose return type is void, we
14439 generate *no* type attribute. (Note that no object may have type
14440 `void', so this only applies to function return types). */
14441 || code == VOID_TYPE)
14444 type_die = modified_type_die (type,
14445 decl_const || TYPE_READONLY (type),
14446 decl_volatile || TYPE_VOLATILE (type),
14449 if (type_die != NULL)
14450 add_AT_die_ref (object_die, DW_AT_type, type_die);
14453 /* Given an object die, add the calling convention attribute for the
14454 function call type. */
14456 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
14458 enum dwarf_calling_convention value = DW_CC_normal;
14460 value = ((enum dwarf_calling_convention)
14461 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
14463 /* DWARF doesn't provide a way to identify a program's source-level
14464 entry point. DW_AT_calling_convention attributes are only meant
14465 to describe functions' calling conventions. However, lacking a
14466 better way to signal the Fortran main program, we use this for the
14467 time being, following existing custom. */
14469 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
14470 value = DW_CC_program;
14472 /* Only add the attribute if the backend requests it, and
14473 is not DW_CC_normal. */
14474 if (value && (value != DW_CC_normal))
14475 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
14478 /* Given a tree pointer to a struct, class, union, or enum type node, return
14479 a pointer to the (string) tag name for the given type, or zero if the type
14480 was declared without a tag. */
14482 static const char *
14483 type_tag (const_tree type)
14485 const char *name = 0;
14487 if (TYPE_NAME (type) != 0)
14491 /* Find the IDENTIFIER_NODE for the type name. */
14492 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
14493 t = TYPE_NAME (type);
14495 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
14496 a TYPE_DECL node, regardless of whether or not a `typedef' was
14498 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
14499 && ! DECL_IGNORED_P (TYPE_NAME (type)))
14501 /* We want to be extra verbose. Don't call dwarf_name if
14502 DECL_NAME isn't set. The default hook for decl_printable_name
14503 doesn't like that, and in this context it's correct to return
14504 0, instead of "<anonymous>" or the like. */
14505 if (DECL_NAME (TYPE_NAME (type)))
14506 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
14509 /* Now get the name as a string, or invent one. */
14510 if (!name && t != 0)
14511 name = IDENTIFIER_POINTER (t);
14514 return (name == 0 || *name == '\0') ? 0 : name;
14517 /* Return the type associated with a data member, make a special check
14518 for bit field types. */
14521 member_declared_type (const_tree member)
14523 return (DECL_BIT_FIELD_TYPE (member)
14524 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
14527 /* Get the decl's label, as described by its RTL. This may be different
14528 from the DECL_NAME name used in the source file. */
14531 static const char *
14532 decl_start_label (tree decl)
14535 const char *fnname;
14537 x = DECL_RTL (decl);
14538 gcc_assert (MEM_P (x));
14541 gcc_assert (GET_CODE (x) == SYMBOL_REF);
14543 fnname = XSTR (x, 0);
14548 /* These routines generate the internal representation of the DIE's for
14549 the compilation unit. Debugging information is collected by walking
14550 the declaration trees passed in from dwarf2out_decl(). */
14553 gen_array_type_die (tree type, dw_die_ref context_die)
14555 dw_die_ref scope_die = scope_die_for (type, context_die);
14556 dw_die_ref array_die;
14558 /* GNU compilers represent multidimensional array types as sequences of one
14559 dimensional array types whose element types are themselves array types.
14560 We sometimes squish that down to a single array_type DIE with multiple
14561 subscripts in the Dwarf debugging info. The draft Dwarf specification
14562 say that we are allowed to do this kind of compression in C, because
14563 there is no difference between an array of arrays and a multidimensional
14564 array. We don't do this for Ada to remain as close as possible to the
14565 actual representation, which is especially important against the language
14566 flexibilty wrt arrays of variable size. */
14568 bool collapse_nested_arrays = !is_ada ();
14571 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
14572 DW_TAG_string_type doesn't have DW_AT_type attribute). */
14573 if (TYPE_STRING_FLAG (type)
14574 && TREE_CODE (type) == ARRAY_TYPE
14576 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
14578 HOST_WIDE_INT size;
14580 array_die = new_die (DW_TAG_string_type, scope_die, type);
14581 add_name_attribute (array_die, type_tag (type));
14582 equate_type_number_to_die (type, array_die);
14583 size = int_size_in_bytes (type);
14585 add_AT_unsigned (array_die, DW_AT_byte_size, size);
14586 else if (TYPE_DOMAIN (type) != NULL_TREE
14587 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
14588 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
14590 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
14591 dw_loc_descr_ref loc = loc_descriptor_from_tree (szdecl);
14593 size = int_size_in_bytes (TREE_TYPE (szdecl));
14594 if (loc && size > 0)
14596 add_AT_loc (array_die, DW_AT_string_length, loc);
14597 if (size != DWARF2_ADDR_SIZE)
14598 add_AT_unsigned (array_die, DW_AT_byte_size, size);
14604 /* ??? The SGI dwarf reader fails for array of array of enum types
14605 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
14606 array type comes before the outer array type. We thus call gen_type_die
14607 before we new_die and must prevent nested array types collapsing for this
14610 #ifdef MIPS_DEBUGGING_INFO
14611 gen_type_die (TREE_TYPE (type), context_die);
14612 collapse_nested_arrays = false;
14615 array_die = new_die (DW_TAG_array_type, scope_die, type);
14616 add_name_attribute (array_die, type_tag (type));
14617 equate_type_number_to_die (type, array_die);
14619 if (TREE_CODE (type) == VECTOR_TYPE)
14621 /* The frontend feeds us a representation for the vector as a struct
14622 containing an array. Pull out the array type. */
14623 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
14624 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
14627 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
14629 && TREE_CODE (type) == ARRAY_TYPE
14630 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
14631 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
14632 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
14635 /* We default the array ordering. SDB will probably do
14636 the right things even if DW_AT_ordering is not present. It's not even
14637 an issue until we start to get into multidimensional arrays anyway. If
14638 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
14639 then we'll have to put the DW_AT_ordering attribute back in. (But if
14640 and when we find out that we need to put these in, we will only do so
14641 for multidimensional arrays. */
14642 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
14645 #ifdef MIPS_DEBUGGING_INFO
14646 /* The SGI compilers handle arrays of unknown bound by setting
14647 AT_declaration and not emitting any subrange DIEs. */
14648 if (! TYPE_DOMAIN (type))
14649 add_AT_flag (array_die, DW_AT_declaration, 1);
14652 add_subscript_info (array_die, type, collapse_nested_arrays);
14654 /* Add representation of the type of the elements of this array type and
14655 emit the corresponding DIE if we haven't done it already. */
14656 element_type = TREE_TYPE (type);
14657 if (collapse_nested_arrays)
14658 while (TREE_CODE (element_type) == ARRAY_TYPE)
14660 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
14662 element_type = TREE_TYPE (element_type);
14665 #ifndef MIPS_DEBUGGING_INFO
14666 gen_type_die (element_type, context_die);
14669 add_type_attribute (array_die, element_type, 0, 0, context_die);
14671 if (get_AT (array_die, DW_AT_name))
14672 add_pubtype (type, array_die);
14675 static dw_loc_descr_ref
14676 descr_info_loc (tree val, tree base_decl)
14678 HOST_WIDE_INT size;
14679 dw_loc_descr_ref loc, loc2;
14680 enum dwarf_location_atom op;
14682 if (val == base_decl)
14683 return new_loc_descr (DW_OP_push_object_address, 0, 0);
14685 switch (TREE_CODE (val))
14688 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
14690 return loc_descriptor_from_tree_1 (val, 0);
14692 if (host_integerp (val, 0))
14693 return int_loc_descriptor (tree_low_cst (val, 0));
14696 size = int_size_in_bytes (TREE_TYPE (val));
14699 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
14702 if (size == DWARF2_ADDR_SIZE)
14703 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
14705 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
14707 case POINTER_PLUS_EXPR:
14709 if (host_integerp (TREE_OPERAND (val, 1), 1)
14710 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
14713 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
14716 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
14722 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
14725 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
14728 add_loc_descr (&loc, loc2);
14729 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
14751 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
14752 tree val, tree base_decl)
14754 dw_loc_descr_ref loc;
14756 if (host_integerp (val, 0))
14758 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
14762 loc = descr_info_loc (val, base_decl);
14766 add_AT_loc (die, attr, loc);
14769 /* This routine generates DIE for array with hidden descriptor, details
14770 are filled into *info by a langhook. */
14773 gen_descr_array_type_die (tree type, struct array_descr_info *info,
14774 dw_die_ref context_die)
14776 dw_die_ref scope_die = scope_die_for (type, context_die);
14777 dw_die_ref array_die;
14780 array_die = new_die (DW_TAG_array_type, scope_die, type);
14781 add_name_attribute (array_die, type_tag (type));
14782 equate_type_number_to_die (type, array_die);
14784 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
14786 && info->ndimensions >= 2)
14787 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
14789 if (info->data_location)
14790 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
14792 if (info->associated)
14793 add_descr_info_field (array_die, DW_AT_associated, info->associated,
14795 if (info->allocated)
14796 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
14799 for (dim = 0; dim < info->ndimensions; dim++)
14801 dw_die_ref subrange_die
14802 = new_die (DW_TAG_subrange_type, array_die, NULL);
14804 if (info->dimen[dim].lower_bound)
14806 /* If it is the default value, omit it. */
14807 if ((is_c_family () || is_java ())
14808 && integer_zerop (info->dimen[dim].lower_bound))
14810 else if (is_fortran ()
14811 && integer_onep (info->dimen[dim].lower_bound))
14814 add_descr_info_field (subrange_die, DW_AT_lower_bound,
14815 info->dimen[dim].lower_bound,
14818 if (info->dimen[dim].upper_bound)
14819 add_descr_info_field (subrange_die, DW_AT_upper_bound,
14820 info->dimen[dim].upper_bound,
14822 if (info->dimen[dim].stride)
14823 add_descr_info_field (subrange_die, DW_AT_byte_stride,
14824 info->dimen[dim].stride,
14828 gen_type_die (info->element_type, context_die);
14829 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
14831 if (get_AT (array_die, DW_AT_name))
14832 add_pubtype (type, array_die);
14837 gen_entry_point_die (tree decl, dw_die_ref context_die)
14839 tree origin = decl_ultimate_origin (decl);
14840 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
14842 if (origin != NULL)
14843 add_abstract_origin_attribute (decl_die, origin);
14846 add_name_and_src_coords_attributes (decl_die, decl);
14847 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
14848 0, 0, context_die);
14851 if (DECL_ABSTRACT (decl))
14852 equate_decl_number_to_die (decl, decl_die);
14854 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
14858 /* Walk through the list of incomplete types again, trying once more to
14859 emit full debugging info for them. */
14862 retry_incomplete_types (void)
14866 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
14867 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
14870 /* Determine what tag to use for a record type. */
14872 static enum dwarf_tag
14873 record_type_tag (tree type)
14875 if (! lang_hooks.types.classify_record)
14876 return DW_TAG_structure_type;
14878 switch (lang_hooks.types.classify_record (type))
14880 case RECORD_IS_STRUCT:
14881 return DW_TAG_structure_type;
14883 case RECORD_IS_CLASS:
14884 return DW_TAG_class_type;
14886 case RECORD_IS_INTERFACE:
14887 return DW_TAG_interface_type;
14890 gcc_unreachable ();
14894 /* Generate a DIE to represent an enumeration type. Note that these DIEs
14895 include all of the information about the enumeration values also. Each
14896 enumerated type name/value is listed as a child of the enumerated type
14900 gen_enumeration_type_die (tree type, dw_die_ref context_die)
14902 dw_die_ref type_die = lookup_type_die (type);
14904 if (type_die == NULL)
14906 type_die = new_die (DW_TAG_enumeration_type,
14907 scope_die_for (type, context_die), type);
14908 equate_type_number_to_die (type, type_die);
14909 add_name_attribute (type_die, type_tag (type));
14911 else if (! TYPE_SIZE (type))
14914 remove_AT (type_die, DW_AT_declaration);
14916 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
14917 given enum type is incomplete, do not generate the DW_AT_byte_size
14918 attribute or the DW_AT_element_list attribute. */
14919 if (TYPE_SIZE (type))
14923 TREE_ASM_WRITTEN (type) = 1;
14924 add_byte_size_attribute (type_die, type);
14925 if (TYPE_STUB_DECL (type) != NULL_TREE)
14926 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
14928 /* If the first reference to this type was as the return type of an
14929 inline function, then it may not have a parent. Fix this now. */
14930 if (type_die->die_parent == NULL)
14931 add_child_die (scope_die_for (type, context_die), type_die);
14933 for (link = TYPE_VALUES (type);
14934 link != NULL; link = TREE_CHAIN (link))
14936 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
14937 tree value = TREE_VALUE (link);
14939 add_name_attribute (enum_die,
14940 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
14942 if (TREE_CODE (value) == CONST_DECL)
14943 value = DECL_INITIAL (value);
14945 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
14946 /* DWARF2 does not provide a way of indicating whether or
14947 not enumeration constants are signed or unsigned. GDB
14948 always assumes the values are signed, so we output all
14949 values as if they were signed. That means that
14950 enumeration constants with very large unsigned values
14951 will appear to have negative values in the debugger. */
14952 add_AT_int (enum_die, DW_AT_const_value,
14953 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
14957 add_AT_flag (type_die, DW_AT_declaration, 1);
14959 if (get_AT (type_die, DW_AT_name))
14960 add_pubtype (type, type_die);
14965 /* Generate a DIE to represent either a real live formal parameter decl or to
14966 represent just the type of some formal parameter position in some function
14969 Note that this routine is a bit unusual because its argument may be a
14970 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
14971 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
14972 node. If it's the former then this function is being called to output a
14973 DIE to represent a formal parameter object (or some inlining thereof). If
14974 it's the latter, then this function is only being called to output a
14975 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
14976 argument type of some subprogram type. */
14979 gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
14981 tree node_or_origin = node ? node : origin;
14982 dw_die_ref parm_die
14983 = new_die (DW_TAG_formal_parameter, context_die, node);
14985 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
14987 case tcc_declaration:
14989 origin = decl_ultimate_origin (node);
14990 if (origin != NULL)
14991 add_abstract_origin_attribute (parm_die, origin);
14994 tree type = TREE_TYPE (node);
14995 add_name_and_src_coords_attributes (parm_die, node);
14996 if (DECL_BY_REFERENCE (node))
14997 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
15000 add_type_attribute (parm_die, type,
15001 TREE_READONLY (node),
15002 TREE_THIS_VOLATILE (node),
15004 if (DECL_ARTIFICIAL (node))
15005 add_AT_flag (parm_die, DW_AT_artificial, 1);
15008 if (node && node != origin)
15009 equate_decl_number_to_die (node, parm_die);
15010 if (! DECL_ABSTRACT (node_or_origin))
15011 add_location_or_const_value_attribute (parm_die, node_or_origin,
15017 /* We were called with some kind of a ..._TYPE node. */
15018 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
15022 gcc_unreachable ();
15028 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
15029 at the end of an (ANSI prototyped) formal parameters list. */
15032 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
15034 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
15037 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
15038 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
15039 parameters as specified in some function type specification (except for
15040 those which appear as part of a function *definition*). */
15043 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
15046 tree formal_type = NULL;
15047 tree first_parm_type;
15050 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
15052 arg = DECL_ARGUMENTS (function_or_method_type);
15053 function_or_method_type = TREE_TYPE (function_or_method_type);
15058 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
15060 /* Make our first pass over the list of formal parameter types and output a
15061 DW_TAG_formal_parameter DIE for each one. */
15062 for (link = first_parm_type; link; )
15064 dw_die_ref parm_die;
15066 formal_type = TREE_VALUE (link);
15067 if (formal_type == void_type_node)
15070 /* Output a (nameless) DIE to represent the formal parameter itself. */
15071 parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
15072 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
15073 && link == first_parm_type)
15074 || (arg && DECL_ARTIFICIAL (arg)))
15075 add_AT_flag (parm_die, DW_AT_artificial, 1);
15077 link = TREE_CHAIN (link);
15079 arg = TREE_CHAIN (arg);
15082 /* If this function type has an ellipsis, add a
15083 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
15084 if (formal_type != void_type_node)
15085 gen_unspecified_parameters_die (function_or_method_type, context_die);
15087 /* Make our second (and final) pass over the list of formal parameter types
15088 and output DIEs to represent those types (as necessary). */
15089 for (link = TYPE_ARG_TYPES (function_or_method_type);
15090 link && TREE_VALUE (link);
15091 link = TREE_CHAIN (link))
15092 gen_type_die (TREE_VALUE (link), context_die);
15095 /* We want to generate the DIE for TYPE so that we can generate the
15096 die for MEMBER, which has been defined; we will need to refer back
15097 to the member declaration nested within TYPE. If we're trying to
15098 generate minimal debug info for TYPE, processing TYPE won't do the
15099 trick; we need to attach the member declaration by hand. */
15102 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
15104 gen_type_die (type, context_die);
15106 /* If we're trying to avoid duplicate debug info, we may not have
15107 emitted the member decl for this function. Emit it now. */
15108 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
15109 && ! lookup_decl_die (member))
15111 dw_die_ref type_die;
15112 gcc_assert (!decl_ultimate_origin (member));
15114 push_decl_scope (type);
15115 type_die = lookup_type_die (type);
15116 if (TREE_CODE (member) == FUNCTION_DECL)
15117 gen_subprogram_die (member, type_die);
15118 else if (TREE_CODE (member) == FIELD_DECL)
15120 /* Ignore the nameless fields that are used to skip bits but handle
15121 C++ anonymous unions and structs. */
15122 if (DECL_NAME (member) != NULL_TREE
15123 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
15124 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
15126 gen_type_die (member_declared_type (member), type_die);
15127 gen_field_die (member, type_die);
15131 gen_variable_die (member, NULL_TREE, type_die);
15137 /* Generate the DWARF2 info for the "abstract" instance of a function which we
15138 may later generate inlined and/or out-of-line instances of. */
15141 dwarf2out_abstract_function (tree decl)
15143 dw_die_ref old_die;
15146 int was_abstract = DECL_ABSTRACT (decl);
15148 /* Make sure we have the actual abstract inline, not a clone. */
15149 decl = DECL_ORIGIN (decl);
15150 htab_empty (decl_loc_table);
15152 old_die = lookup_decl_die (decl);
15153 if (old_die && get_AT (old_die, DW_AT_inline))
15154 /* We've already generated the abstract instance. */
15157 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
15158 we don't get confused by DECL_ABSTRACT. */
15159 if (debug_info_level > DINFO_LEVEL_TERSE)
15161 context = decl_class_context (decl);
15163 gen_type_die_for_member
15164 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
15167 /* Pretend we've just finished compiling this function. */
15168 save_fn = current_function_decl;
15169 current_function_decl = decl;
15170 push_cfun (DECL_STRUCT_FUNCTION (decl));
15172 set_decl_abstract_flags (decl, 1);
15173 dwarf2out_decl (decl);
15174 if (! was_abstract)
15175 set_decl_abstract_flags (decl, 0);
15177 current_function_decl = save_fn;
15181 /* Helper function of premark_used_types() which gets called through
15182 htab_traverse_resize().
15184 Marks the DIE of a given type in *SLOT as perennial, so it never gets
15185 marked as unused by prune_unused_types. */
15187 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
15192 type = (tree) *slot;
15193 die = lookup_type_die (type);
15195 die->die_perennial_p = 1;
15199 /* Mark all members of used_types_hash as perennial. */
15201 premark_used_types (void)
15203 if (cfun && cfun->used_types_hash)
15204 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
15207 /* Generate a DIE to represent a declared function (either file-scope or
15211 gen_subprogram_die (tree decl, dw_die_ref context_die)
15213 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
15214 tree origin = decl_ultimate_origin (decl);
15215 dw_die_ref subr_die;
15218 dw_die_ref old_die = lookup_decl_die (decl);
15219 int declaration = (current_function_decl != decl
15220 || class_or_namespace_scope_p (context_die));
15222 premark_used_types ();
15224 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
15225 started to generate the abstract instance of an inline, decided to output
15226 its containing class, and proceeded to emit the declaration of the inline
15227 from the member list for the class. If so, DECLARATION takes priority;
15228 we'll get back to the abstract instance when done with the class. */
15230 /* The class-scope declaration DIE must be the primary DIE. */
15231 if (origin && declaration && class_or_namespace_scope_p (context_die))
15234 gcc_assert (!old_die);
15237 /* Now that the C++ front end lazily declares artificial member fns, we
15238 might need to retrofit the declaration into its class. */
15239 if (!declaration && !origin && !old_die
15240 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
15241 && !class_or_namespace_scope_p (context_die)
15242 && debug_info_level > DINFO_LEVEL_TERSE)
15243 old_die = force_decl_die (decl);
15245 if (origin != NULL)
15247 gcc_assert (!declaration || local_scope_p (context_die));
15249 /* Fixup die_parent for the abstract instance of a nested
15250 inline function. */
15251 if (old_die && old_die->die_parent == NULL)
15252 add_child_die (context_die, old_die);
15254 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
15255 add_abstract_origin_attribute (subr_die, origin);
15259 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
15260 struct dwarf_file_data * file_index = lookup_filename (s.file);
15262 if (!get_AT_flag (old_die, DW_AT_declaration)
15263 /* We can have a normal definition following an inline one in the
15264 case of redefinition of GNU C extern inlines.
15265 It seems reasonable to use AT_specification in this case. */
15266 && !get_AT (old_die, DW_AT_inline))
15268 /* Detect and ignore this case, where we are trying to output
15269 something we have already output. */
15273 /* If the definition comes from the same place as the declaration,
15274 maybe use the old DIE. We always want the DIE for this function
15275 that has the *_pc attributes to be under comp_unit_die so the
15276 debugger can find it. We also need to do this for abstract
15277 instances of inlines, since the spec requires the out-of-line copy
15278 to have the same parent. For local class methods, this doesn't
15279 apply; we just use the old DIE. */
15280 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
15281 && (DECL_ARTIFICIAL (decl)
15282 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
15283 && (get_AT_unsigned (old_die, DW_AT_decl_line)
15284 == (unsigned) s.line))))
15286 subr_die = old_die;
15288 /* Clear out the declaration attribute and the formal parameters.
15289 Do not remove all children, because it is possible that this
15290 declaration die was forced using force_decl_die(). In such
15291 cases die that forced declaration die (e.g. TAG_imported_module)
15292 is one of the children that we do not want to remove. */
15293 remove_AT (subr_die, DW_AT_declaration);
15294 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
15298 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
15299 add_AT_specification (subr_die, old_die);
15300 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
15301 add_AT_file (subr_die, DW_AT_decl_file, file_index);
15302 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
15303 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
15308 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
15310 if (TREE_PUBLIC (decl))
15311 add_AT_flag (subr_die, DW_AT_external, 1);
15313 add_name_and_src_coords_attributes (subr_die, decl);
15314 if (debug_info_level > DINFO_LEVEL_TERSE)
15316 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
15317 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
15318 0, 0, context_die);
15321 add_pure_or_virtual_attribute (subr_die, decl);
15322 if (DECL_ARTIFICIAL (decl))
15323 add_AT_flag (subr_die, DW_AT_artificial, 1);
15325 if (TREE_PROTECTED (decl))
15326 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
15327 else if (TREE_PRIVATE (decl))
15328 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
15333 if (!old_die || !get_AT (old_die, DW_AT_inline))
15335 add_AT_flag (subr_die, DW_AT_declaration, 1);
15337 /* If this is an explicit function declaration then generate
15338 a DW_AT_explicit attribute. */
15339 if (lang_hooks.decls.function_decl_explicit_p (decl))
15340 add_AT_flag (subr_die, DW_AT_explicit, 1);
15342 /* The first time we see a member function, it is in the context of
15343 the class to which it belongs. We make sure of this by emitting
15344 the class first. The next time is the definition, which is
15345 handled above. The two may come from the same source text.
15347 Note that force_decl_die() forces function declaration die. It is
15348 later reused to represent definition. */
15349 equate_decl_number_to_die (decl, subr_die);
15352 else if (DECL_ABSTRACT (decl))
15354 if (DECL_DECLARED_INLINE_P (decl))
15356 if (cgraph_function_possibly_inlined_p (decl))
15357 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
15359 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
15363 if (cgraph_function_possibly_inlined_p (decl))
15364 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
15366 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
15369 if (DECL_DECLARED_INLINE_P (decl)
15370 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
15371 add_AT_flag (subr_die, DW_AT_artificial, 1);
15373 equate_decl_number_to_die (decl, subr_die);
15375 else if (!DECL_EXTERNAL (decl))
15377 HOST_WIDE_INT cfa_fb_offset;
15379 if (!old_die || !get_AT (old_die, DW_AT_inline))
15380 equate_decl_number_to_die (decl, subr_die);
15382 if (!flag_reorder_blocks_and_partition)
15384 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
15385 current_function_funcdef_no);
15386 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
15387 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
15388 current_function_funcdef_no);
15389 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
15391 add_pubname (decl, subr_die);
15392 add_arange (decl, subr_die);
15395 { /* Do nothing for now; maybe need to duplicate die, one for
15396 hot section and one for cold section, then use the hot/cold
15397 section begin/end labels to generate the aranges... */
15399 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
15400 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
15401 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
15402 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
15404 add_pubname (decl, subr_die);
15405 add_arange (decl, subr_die);
15406 add_arange (decl, subr_die);
15410 #ifdef MIPS_DEBUGGING_INFO
15411 /* Add a reference to the FDE for this routine. */
15412 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
15415 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
15417 /* We define the "frame base" as the function's CFA. This is more
15418 convenient for several reasons: (1) It's stable across the prologue
15419 and epilogue, which makes it better than just a frame pointer,
15420 (2) With dwarf3, there exists a one-byte encoding that allows us
15421 to reference the .debug_frame data by proxy, but failing that,
15422 (3) We can at least reuse the code inspection and interpretation
15423 code that determines the CFA position at various points in the
15425 if (dwarf_version >= 3)
15427 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
15428 add_AT_loc (subr_die, DW_AT_frame_base, op);
15432 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
15433 if (list->dw_loc_next)
15434 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
15436 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
15439 /* Compute a displacement from the "steady-state frame pointer" to
15440 the CFA. The former is what all stack slots and argument slots
15441 will reference in the rtl; the later is what we've told the
15442 debugger about. We'll need to adjust all frame_base references
15443 by this displacement. */
15444 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
15446 if (cfun->static_chain_decl)
15447 add_AT_location_description (subr_die, DW_AT_static_link,
15448 loc_descriptor_from_tree (cfun->static_chain_decl));
15451 /* Generate child dies for template paramaters. */
15452 if (debug_info_level > DINFO_LEVEL_TERSE)
15453 gen_generic_params_dies (decl);
15455 /* Now output descriptions of the arguments for this function. This gets
15456 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
15457 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
15458 `...' at the end of the formal parameter list. In order to find out if
15459 there was a trailing ellipsis or not, we must instead look at the type
15460 associated with the FUNCTION_DECL. This will be a node of type
15461 FUNCTION_TYPE. If the chain of type nodes hanging off of this
15462 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
15463 an ellipsis at the end. */
15465 /* In the case where we are describing a mere function declaration, all we
15466 need to do here (and all we *can* do here) is to describe the *types* of
15467 its formal parameters. */
15468 if (debug_info_level <= DINFO_LEVEL_TERSE)
15470 else if (declaration)
15471 gen_formal_types_die (decl, subr_die);
15474 /* Generate DIEs to represent all known formal parameters. */
15475 tree arg_decls = DECL_ARGUMENTS (decl);
15478 /* When generating DIEs, generate the unspecified_parameters DIE
15479 instead if we come across the arg "__builtin_va_alist" */
15480 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
15481 if (TREE_CODE (parm) == PARM_DECL)
15483 if (DECL_NAME (parm)
15484 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
15485 "__builtin_va_alist"))
15486 gen_unspecified_parameters_die (parm, subr_die);
15488 gen_decl_die (parm, NULL, subr_die);
15491 /* Decide whether we need an unspecified_parameters DIE at the end.
15492 There are 2 more cases to do this for: 1) the ansi ... declaration -
15493 this is detectable when the end of the arg list is not a
15494 void_type_node 2) an unprototyped function declaration (not a
15495 definition). This just means that we have no info about the
15496 parameters at all. */
15497 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
15498 if (fn_arg_types != NULL)
15500 /* This is the prototyped case, check for.... */
15501 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
15502 gen_unspecified_parameters_die (decl, subr_die);
15504 else if (DECL_INITIAL (decl) == NULL_TREE)
15505 gen_unspecified_parameters_die (decl, subr_die);
15508 /* Output Dwarf info for all of the stuff within the body of the function
15509 (if it has one - it may be just a declaration). */
15510 outer_scope = DECL_INITIAL (decl);
15512 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
15513 a function. This BLOCK actually represents the outermost binding contour
15514 for the function, i.e. the contour in which the function's formal
15515 parameters and labels get declared. Curiously, it appears that the front
15516 end doesn't actually put the PARM_DECL nodes for the current function onto
15517 the BLOCK_VARS list for this outer scope, but are strung off of the
15518 DECL_ARGUMENTS list for the function instead.
15520 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
15521 the LABEL_DECL nodes for the function however, and we output DWARF info
15522 for those in decls_for_scope. Just within the `outer_scope' there will be
15523 a BLOCK node representing the function's outermost pair of curly braces,
15524 and any blocks used for the base and member initializers of a C++
15525 constructor function. */
15526 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
15528 /* Emit a DW_TAG_variable DIE for a named return value. */
15529 if (DECL_NAME (DECL_RESULT (decl)))
15530 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
15532 current_function_has_inlines = 0;
15533 decls_for_scope (outer_scope, subr_die, 0);
15535 #if 0 && defined (MIPS_DEBUGGING_INFO)
15536 if (current_function_has_inlines)
15538 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
15539 if (! comp_unit_has_inlines)
15541 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
15542 comp_unit_has_inlines = 1;
15547 /* Add the calling convention attribute if requested. */
15548 add_calling_convention_attribute (subr_die, decl);
15552 /* Returns a hash value for X (which really is a die_struct). */
15555 common_block_die_table_hash (const void *x)
15557 const_dw_die_ref d = (const_dw_die_ref) x;
15558 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
15561 /* Return nonzero if decl_id and die_parent of die_struct X is the same
15562 as decl_id and die_parent of die_struct Y. */
15565 common_block_die_table_eq (const void *x, const void *y)
15567 const_dw_die_ref d = (const_dw_die_ref) x;
15568 const_dw_die_ref e = (const_dw_die_ref) y;
15569 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
15572 /* Generate a DIE to represent a declared data object.
15573 Either DECL or ORIGIN must be non-null. */
15576 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
15580 tree decl_or_origin = decl ? decl : origin;
15581 dw_die_ref var_die;
15582 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
15583 dw_die_ref origin_die;
15584 int declaration = (DECL_EXTERNAL (decl_or_origin)
15585 /* If DECL is COMDAT and has not actually been
15586 emitted, we cannot take its address; there
15587 might end up being no definition anywhere in
15588 the program. For example, consider the C++
15592 struct S { static const int i = 7; };
15597 int f() { return S<int>::i; }
15599 Here, S<int>::i is not DECL_EXTERNAL, but no
15600 definition is required, so the compiler will
15601 not emit a definition. */
15602 || (TREE_CODE (decl_or_origin) == VAR_DECL
15603 && DECL_COMDAT (decl_or_origin)
15604 && !TREE_ASM_WRITTEN (decl_or_origin))
15605 || class_or_namespace_scope_p (context_die));
15608 origin = decl_ultimate_origin (decl);
15610 com_decl = fortran_common (decl_or_origin, &off);
15612 /* Symbol in common gets emitted as a child of the common block, in the form
15613 of a data member. */
15617 dw_die_ref com_die;
15618 dw_loc_descr_ref loc;
15619 die_node com_die_arg;
15621 var_die = lookup_decl_die (decl_or_origin);
15624 if (get_AT (var_die, DW_AT_location) == NULL)
15626 loc = loc_descriptor_from_tree (com_decl);
15631 /* Optimize the common case. */
15632 if (loc->dw_loc_opc == DW_OP_addr
15633 && loc->dw_loc_next == NULL
15634 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr)
15636 loc->dw_loc_oprnd1.v.val_addr
15637 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
15639 loc_descr_plus_const (&loc, off);
15641 add_AT_loc (var_die, DW_AT_location, loc);
15642 remove_AT (var_die, DW_AT_declaration);
15648 if (common_block_die_table == NULL)
15649 common_block_die_table
15650 = htab_create_ggc (10, common_block_die_table_hash,
15651 common_block_die_table_eq, NULL);
15653 field = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
15654 com_die_arg.decl_id = DECL_UID (com_decl);
15655 com_die_arg.die_parent = context_die;
15656 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
15657 loc = loc_descriptor_from_tree (com_decl);
15658 if (com_die == NULL)
15661 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
15664 com_die = new_die (DW_TAG_common_block, context_die, decl);
15665 add_name_and_src_coords_attributes (com_die, com_decl);
15668 add_AT_loc (com_die, DW_AT_location, loc);
15669 /* Avoid sharing the same loc descriptor between
15670 DW_TAG_common_block and DW_TAG_variable. */
15671 loc = loc_descriptor_from_tree (com_decl);
15673 else if (DECL_EXTERNAL (decl))
15674 add_AT_flag (com_die, DW_AT_declaration, 1);
15675 add_pubname_string (cnam, com_die); /* ??? needed? */
15676 com_die->decl_id = DECL_UID (com_decl);
15677 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
15678 *slot = (void *) com_die;
15680 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
15682 add_AT_loc (com_die, DW_AT_location, loc);
15683 loc = loc_descriptor_from_tree (com_decl);
15684 remove_AT (com_die, DW_AT_declaration);
15686 var_die = new_die (DW_TAG_variable, com_die, decl);
15687 add_name_and_src_coords_attributes (var_die, decl);
15688 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
15689 TREE_THIS_VOLATILE (decl), context_die);
15690 add_AT_flag (var_die, DW_AT_external, 1);
15695 /* Optimize the common case. */
15696 if (loc->dw_loc_opc == DW_OP_addr
15697 && loc->dw_loc_next == NULL
15698 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
15699 loc->dw_loc_oprnd1.v.val_addr
15700 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
15702 loc_descr_plus_const (&loc, off);
15704 add_AT_loc (var_die, DW_AT_location, loc);
15706 else if (DECL_EXTERNAL (decl))
15707 add_AT_flag (var_die, DW_AT_declaration, 1);
15708 equate_decl_number_to_die (decl, var_die);
15712 /* If the compiler emitted a definition for the DECL declaration
15713 and if we already emitted a DIE for it, don't emit a second
15714 DIE for it again. */
15717 && old_die->die_parent == context_die)
15720 /* For static data members, the declaration in the class is supposed
15721 to have DW_TAG_member tag; the specification should still be
15722 DW_TAG_variable referencing the DW_TAG_member DIE. */
15723 if (declaration && class_scope_p (context_die))
15724 var_die = new_die (DW_TAG_member, context_die, decl);
15726 var_die = new_die (DW_TAG_variable, context_die, decl);
15729 if (origin != NULL)
15730 origin_die = add_abstract_origin_attribute (var_die, origin);
15732 /* Loop unrolling can create multiple blocks that refer to the same
15733 static variable, so we must test for the DW_AT_declaration flag.
15735 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
15736 copy decls and set the DECL_ABSTRACT flag on them instead of
15739 ??? Duplicated blocks have been rewritten to use .debug_ranges.
15741 ??? The declare_in_namespace support causes us to get two DIEs for one
15742 variable, both of which are declarations. We want to avoid considering
15743 one to be a specification, so we must test that this DIE is not a
15745 else if (old_die && TREE_STATIC (decl) && ! declaration
15746 && get_AT_flag (old_die, DW_AT_declaration) == 1)
15748 /* This is a definition of a C++ class level static. */
15749 add_AT_specification (var_die, old_die);
15750 if (DECL_NAME (decl))
15752 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
15753 struct dwarf_file_data * file_index = lookup_filename (s.file);
15755 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
15756 add_AT_file (var_die, DW_AT_decl_file, file_index);
15758 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
15759 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
15764 tree type = TREE_TYPE (decl);
15766 add_name_and_src_coords_attributes (var_die, decl);
15767 if ((TREE_CODE (decl) == PARM_DECL
15768 || TREE_CODE (decl) == RESULT_DECL
15769 || TREE_CODE (decl) == VAR_DECL)
15770 && DECL_BY_REFERENCE (decl))
15771 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
15773 add_type_attribute (var_die, type, TREE_READONLY (decl),
15774 TREE_THIS_VOLATILE (decl), context_die);
15776 if (TREE_PUBLIC (decl))
15777 add_AT_flag (var_die, DW_AT_external, 1);
15779 if (DECL_ARTIFICIAL (decl))
15780 add_AT_flag (var_die, DW_AT_artificial, 1);
15782 if (TREE_PROTECTED (decl))
15783 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
15784 else if (TREE_PRIVATE (decl))
15785 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
15789 add_AT_flag (var_die, DW_AT_declaration, 1);
15791 if (decl && (DECL_ABSTRACT (decl) || declaration))
15792 equate_decl_number_to_die (decl, var_die);
15795 && (! DECL_ABSTRACT (decl_or_origin)
15796 /* Local static vars are shared between all clones/inlines,
15797 so emit DW_AT_location on the abstract DIE if DECL_RTL is
15799 || (TREE_CODE (decl_or_origin) == VAR_DECL
15800 && TREE_STATIC (decl_or_origin)
15801 && DECL_RTL_SET_P (decl_or_origin)))
15802 /* When abstract origin already has DW_AT_location attribute, no need
15803 to add it again. */
15804 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
15806 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
15807 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
15808 defer_location (decl_or_origin, var_die);
15810 add_location_or_const_value_attribute (var_die,
15813 add_pubname (decl_or_origin, var_die);
15816 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
15819 /* Generate a DIE to represent a named constant. */
15822 gen_const_die (tree decl, dw_die_ref context_die)
15824 dw_die_ref const_die;
15825 tree type = TREE_TYPE (decl);
15827 const_die = new_die (DW_TAG_constant, context_die, decl);
15828 add_name_and_src_coords_attributes (const_die, decl);
15829 add_type_attribute (const_die, type, 1, 0, context_die);
15830 if (TREE_PUBLIC (decl))
15831 add_AT_flag (const_die, DW_AT_external, 1);
15832 if (DECL_ARTIFICIAL (decl))
15833 add_AT_flag (const_die, DW_AT_artificial, 1);
15834 tree_add_const_value_attribute_for_decl (const_die, decl);
15837 /* Generate a DIE to represent a label identifier. */
15840 gen_label_die (tree decl, dw_die_ref context_die)
15842 tree origin = decl_ultimate_origin (decl);
15843 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
15845 char label[MAX_ARTIFICIAL_LABEL_BYTES];
15847 if (origin != NULL)
15848 add_abstract_origin_attribute (lbl_die, origin);
15850 add_name_and_src_coords_attributes (lbl_die, decl);
15852 if (DECL_ABSTRACT (decl))
15853 equate_decl_number_to_die (decl, lbl_die);
15856 insn = DECL_RTL_IF_SET (decl);
15858 /* Deleted labels are programmer specified labels which have been
15859 eliminated because of various optimizations. We still emit them
15860 here so that it is possible to put breakpoints on them. */
15864 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
15866 /* When optimization is enabled (via -O) some parts of the compiler
15867 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
15868 represent source-level labels which were explicitly declared by
15869 the user. This really shouldn't be happening though, so catch
15870 it if it ever does happen. */
15871 gcc_assert (!INSN_DELETED_P (insn));
15873 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
15874 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
15879 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
15880 attributes to the DIE for a block STMT, to describe where the inlined
15881 function was called from. This is similar to add_src_coords_attributes. */
15884 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
15886 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
15888 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
15889 add_AT_unsigned (die, DW_AT_call_line, s.line);
15893 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
15894 Add low_pc and high_pc attributes to the DIE for a block STMT. */
15897 add_high_low_attributes (tree stmt, dw_die_ref die)
15899 char label[MAX_ARTIFICIAL_LABEL_BYTES];
15901 if (BLOCK_FRAGMENT_CHAIN (stmt))
15905 if (inlined_function_outer_scope_p (stmt))
15907 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
15908 BLOCK_NUMBER (stmt));
15909 add_AT_lbl_id (die, DW_AT_entry_pc, label);
15912 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
15914 chain = BLOCK_FRAGMENT_CHAIN (stmt);
15917 add_ranges (chain);
15918 chain = BLOCK_FRAGMENT_CHAIN (chain);
15925 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
15926 BLOCK_NUMBER (stmt));
15927 add_AT_lbl_id (die, DW_AT_low_pc, label);
15928 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
15929 BLOCK_NUMBER (stmt));
15930 add_AT_lbl_id (die, DW_AT_high_pc, label);
15934 /* Generate a DIE for a lexical block. */
15937 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
15939 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
15941 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
15942 add_high_low_attributes (stmt, stmt_die);
15944 decls_for_scope (stmt, stmt_die, depth);
15947 /* Generate a DIE for an inlined subprogram. */
15950 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
15954 /* The instance of function that is effectively being inlined shall not
15956 gcc_assert (! BLOCK_ABSTRACT (stmt));
15958 decl = block_ultimate_origin (stmt);
15960 /* Emit info for the abstract instance first, if we haven't yet. We
15961 must emit this even if the block is abstract, otherwise when we
15962 emit the block below (or elsewhere), we may end up trying to emit
15963 a die whose origin die hasn't been emitted, and crashing. */
15964 dwarf2out_abstract_function (decl);
15966 if (! BLOCK_ABSTRACT (stmt))
15968 dw_die_ref subr_die
15969 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
15971 add_abstract_origin_attribute (subr_die, decl);
15972 if (TREE_ASM_WRITTEN (stmt))
15973 add_high_low_attributes (stmt, subr_die);
15974 add_call_src_coords_attributes (stmt, subr_die);
15976 decls_for_scope (stmt, subr_die, depth);
15977 current_function_has_inlines = 1;
15981 /* Generate a DIE for a field in a record, or structure. */
15984 gen_field_die (tree decl, dw_die_ref context_die)
15986 dw_die_ref decl_die;
15988 if (TREE_TYPE (decl) == error_mark_node)
15991 decl_die = new_die (DW_TAG_member, context_die, decl);
15992 add_name_and_src_coords_attributes (decl_die, decl);
15993 add_type_attribute (decl_die, member_declared_type (decl),
15994 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
15997 if (DECL_BIT_FIELD_TYPE (decl))
15999 add_byte_size_attribute (decl_die, decl);
16000 add_bit_size_attribute (decl_die, decl);
16001 add_bit_offset_attribute (decl_die, decl);
16004 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
16005 add_data_member_location_attribute (decl_die, decl);
16007 if (DECL_ARTIFICIAL (decl))
16008 add_AT_flag (decl_die, DW_AT_artificial, 1);
16010 if (TREE_PROTECTED (decl))
16011 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
16012 else if (TREE_PRIVATE (decl))
16013 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
16015 /* Equate decl number to die, so that we can look up this decl later on. */
16016 equate_decl_number_to_die (decl, decl_die);
16020 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
16021 Use modified_type_die instead.
16022 We keep this code here just in case these types of DIEs may be needed to
16023 represent certain things in other languages (e.g. Pascal) someday. */
16026 gen_pointer_type_die (tree type, dw_die_ref context_die)
16029 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
16031 equate_type_number_to_die (type, ptr_die);
16032 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
16033 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
16036 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
16037 Use modified_type_die instead.
16038 We keep this code here just in case these types of DIEs may be needed to
16039 represent certain things in other languages (e.g. Pascal) someday. */
16042 gen_reference_type_die (tree type, dw_die_ref context_die)
16045 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
16047 equate_type_number_to_die (type, ref_die);
16048 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
16049 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
16053 /* Generate a DIE for a pointer to a member type. */
16056 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
16059 = new_die (DW_TAG_ptr_to_member_type,
16060 scope_die_for (type, context_die), type);
16062 equate_type_number_to_die (type, ptr_die);
16063 add_AT_die_ref (ptr_die, DW_AT_containing_type,
16064 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
16065 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
16068 /* Generate the DIE for the compilation unit. */
16071 gen_compile_unit_die (const char *filename)
16074 char producer[250];
16075 const char *language_string = lang_hooks.name;
16078 die = new_die (DW_TAG_compile_unit, NULL, NULL);
16082 add_name_attribute (die, filename);
16083 /* Don't add cwd for <built-in>. */
16084 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
16085 add_comp_dir_attribute (die);
16088 sprintf (producer, "%s %s", language_string, version_string);
16090 #ifdef MIPS_DEBUGGING_INFO
16091 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
16092 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
16093 not appear in the producer string, the debugger reaches the conclusion
16094 that the object file is stripped and has no debugging information.
16095 To get the MIPS/SGI debugger to believe that there is debugging
16096 information in the object file, we add a -g to the producer string. */
16097 if (debug_info_level > DINFO_LEVEL_TERSE)
16098 strcat (producer, " -g");
16101 add_AT_string (die, DW_AT_producer, producer);
16103 if (strcmp (language_string, "GNU C++") == 0)
16104 language = DW_LANG_C_plus_plus;
16105 else if (strcmp (language_string, "GNU Ada") == 0)
16106 language = DW_LANG_Ada95;
16107 else if (strcmp (language_string, "GNU F77") == 0)
16108 language = DW_LANG_Fortran77;
16109 else if (strcmp (language_string, "GNU Fortran") == 0)
16110 language = DW_LANG_Fortran95;
16111 else if (strcmp (language_string, "GNU Pascal") == 0)
16112 language = DW_LANG_Pascal83;
16113 else if (strcmp (language_string, "GNU Java") == 0)
16114 language = DW_LANG_Java;
16115 else if (strcmp (language_string, "GNU Objective-C") == 0)
16116 language = DW_LANG_ObjC;
16117 else if (strcmp (language_string, "GNU Objective-C++") == 0)
16118 language = DW_LANG_ObjC_plus_plus;
16120 language = DW_LANG_C89;
16122 add_AT_unsigned (die, DW_AT_language, language);
16126 /* Generate the DIE for a base class. */
16129 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
16131 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
16133 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
16134 add_data_member_location_attribute (die, binfo);
16136 if (BINFO_VIRTUAL_P (binfo))
16137 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
16139 if (access == access_public_node)
16140 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
16141 else if (access == access_protected_node)
16142 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
16145 /* Generate a DIE for a class member. */
16148 gen_member_die (tree type, dw_die_ref context_die)
16151 tree binfo = TYPE_BINFO (type);
16154 /* If this is not an incomplete type, output descriptions of each of its
16155 members. Note that as we output the DIEs necessary to represent the
16156 members of this record or union type, we will also be trying to output
16157 DIEs to represent the *types* of those members. However the `type'
16158 function (above) will specifically avoid generating type DIEs for member
16159 types *within* the list of member DIEs for this (containing) type except
16160 for those types (of members) which are explicitly marked as also being
16161 members of this (containing) type themselves. The g++ front- end can
16162 force any given type to be treated as a member of some other (containing)
16163 type by setting the TYPE_CONTEXT of the given (member) type to point to
16164 the TREE node representing the appropriate (containing) type. */
16166 /* First output info about the base classes. */
16169 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
16173 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
16174 gen_inheritance_die (base,
16175 (accesses ? VEC_index (tree, accesses, i)
16176 : access_public_node), context_die);
16179 /* Now output info about the data members and type members. */
16180 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
16182 /* If we thought we were generating minimal debug info for TYPE
16183 and then changed our minds, some of the member declarations
16184 may have already been defined. Don't define them again, but
16185 do put them in the right order. */
16187 child = lookup_decl_die (member);
16189 splice_child_die (context_die, child);
16191 gen_decl_die (member, NULL, context_die);
16194 /* Now output info about the function members (if any). */
16195 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
16197 /* Don't include clones in the member list. */
16198 if (DECL_ABSTRACT_ORIGIN (member))
16201 child = lookup_decl_die (member);
16203 splice_child_die (context_die, child);
16205 gen_decl_die (member, NULL, context_die);
16209 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
16210 is set, we pretend that the type was never defined, so we only get the
16211 member DIEs needed by later specification DIEs. */
16214 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
16215 enum debug_info_usage usage)
16217 dw_die_ref type_die = lookup_type_die (type);
16218 dw_die_ref scope_die = 0;
16220 int complete = (TYPE_SIZE (type)
16221 && (! TYPE_STUB_DECL (type)
16222 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
16223 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
16224 complete = complete && should_emit_struct_debug (type, usage);
16226 if (type_die && ! complete)
16229 if (TYPE_CONTEXT (type) != NULL_TREE
16230 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
16231 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
16234 scope_die = scope_die_for (type, context_die);
16236 if (! type_die || (nested && scope_die == comp_unit_die))
16237 /* First occurrence of type or toplevel definition of nested class. */
16239 dw_die_ref old_die = type_die;
16241 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
16242 ? record_type_tag (type) : DW_TAG_union_type,
16244 equate_type_number_to_die (type, type_die);
16246 add_AT_specification (type_die, old_die);
16248 add_name_attribute (type_die, type_tag (type));
16251 remove_AT (type_die, DW_AT_declaration);
16253 /* Generate child dies for template paramaters. */
16254 if (debug_info_level > DINFO_LEVEL_TERSE
16255 && COMPLETE_TYPE_P (type))
16256 gen_generic_params_dies (type);
16258 /* If this type has been completed, then give it a byte_size attribute and
16259 then give a list of members. */
16260 if (complete && !ns_decl)
16262 /* Prevent infinite recursion in cases where the type of some member of
16263 this type is expressed in terms of this type itself. */
16264 TREE_ASM_WRITTEN (type) = 1;
16265 add_byte_size_attribute (type_die, type);
16266 if (TYPE_STUB_DECL (type) != NULL_TREE)
16267 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
16269 /* If the first reference to this type was as the return type of an
16270 inline function, then it may not have a parent. Fix this now. */
16271 if (type_die->die_parent == NULL)
16272 add_child_die (scope_die, type_die);
16274 push_decl_scope (type);
16275 gen_member_die (type, type_die);
16278 /* GNU extension: Record what type our vtable lives in. */
16279 if (TYPE_VFIELD (type))
16281 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
16283 gen_type_die (vtype, context_die);
16284 add_AT_die_ref (type_die, DW_AT_containing_type,
16285 lookup_type_die (vtype));
16290 add_AT_flag (type_die, DW_AT_declaration, 1);
16292 /* We don't need to do this for function-local types. */
16293 if (TYPE_STUB_DECL (type)
16294 && ! decl_function_context (TYPE_STUB_DECL (type)))
16295 VEC_safe_push (tree, gc, incomplete_types, type);
16298 if (get_AT (type_die, DW_AT_name))
16299 add_pubtype (type, type_die);
16302 /* Generate a DIE for a subroutine _type_. */
16305 gen_subroutine_type_die (tree type, dw_die_ref context_die)
16307 tree return_type = TREE_TYPE (type);
16308 dw_die_ref subr_die
16309 = new_die (DW_TAG_subroutine_type,
16310 scope_die_for (type, context_die), type);
16312 equate_type_number_to_die (type, subr_die);
16313 add_prototyped_attribute (subr_die, type);
16314 add_type_attribute (subr_die, return_type, 0, 0, context_die);
16315 gen_formal_types_die (type, subr_die);
16317 if (get_AT (subr_die, DW_AT_name))
16318 add_pubtype (type, subr_die);
16321 /* Generate a DIE for a type definition. */
16324 gen_typedef_die (tree decl, dw_die_ref context_die)
16326 dw_die_ref type_die;
16329 if (TREE_ASM_WRITTEN (decl))
16332 TREE_ASM_WRITTEN (decl) = 1;
16333 type_die = new_die (DW_TAG_typedef, context_die, decl);
16334 origin = decl_ultimate_origin (decl);
16335 if (origin != NULL)
16336 add_abstract_origin_attribute (type_die, origin);
16341 add_name_and_src_coords_attributes (type_die, decl);
16342 if (DECL_ORIGINAL_TYPE (decl))
16344 type = DECL_ORIGINAL_TYPE (decl);
16346 gcc_assert (type != TREE_TYPE (decl));
16347 equate_type_number_to_die (TREE_TYPE (decl), type_die);
16350 type = TREE_TYPE (decl);
16352 add_type_attribute (type_die, type, TREE_READONLY (decl),
16353 TREE_THIS_VOLATILE (decl), context_die);
16356 if (DECL_ABSTRACT (decl))
16357 equate_decl_number_to_die (decl, type_die);
16359 if (get_AT (type_die, DW_AT_name))
16360 add_pubtype (decl, type_die);
16363 /* Generate a type description DIE. */
16366 gen_type_die_with_usage (tree type, dw_die_ref context_die,
16367 enum debug_info_usage usage)
16370 struct array_descr_info info;
16372 if (type == NULL_TREE || type == error_mark_node)
16375 /* If TYPE is a typedef type variant, let's generate debug info
16376 for the parent typedef which TYPE is a type of. */
16377 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
16378 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
16380 if (TREE_ASM_WRITTEN (type))
16383 /* Prevent broken recursion; we can't hand off to the same type. */
16384 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
16386 /* Use the DIE of the containing namespace as the parent DIE of
16387 the type description DIE we want to generate. */
16388 if (DECL_CONTEXT (TYPE_NAME (type))
16389 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
16390 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
16392 TREE_ASM_WRITTEN (type) = 1;
16393 gen_decl_die (TYPE_NAME (type), NULL, context_die);
16397 /* If this is an array type with hidden descriptor, handle it first. */
16398 if (!TREE_ASM_WRITTEN (type)
16399 && lang_hooks.types.get_array_descr_info
16400 && lang_hooks.types.get_array_descr_info (type, &info))
16402 gen_descr_array_type_die (type, &info, context_die);
16403 TREE_ASM_WRITTEN (type) = 1;
16407 /* We are going to output a DIE to represent the unqualified version
16408 of this type (i.e. without any const or volatile qualifiers) so
16409 get the main variant (i.e. the unqualified version) of this type
16410 now. (Vectors are special because the debugging info is in the
16411 cloned type itself). */
16412 if (TREE_CODE (type) != VECTOR_TYPE)
16413 type = type_main_variant (type);
16415 if (TREE_ASM_WRITTEN (type))
16418 switch (TREE_CODE (type))
16424 case REFERENCE_TYPE:
16425 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
16426 ensures that the gen_type_die recursion will terminate even if the
16427 type is recursive. Recursive types are possible in Ada. */
16428 /* ??? We could perhaps do this for all types before the switch
16430 TREE_ASM_WRITTEN (type) = 1;
16432 /* For these types, all that is required is that we output a DIE (or a
16433 set of DIEs) to represent the "basis" type. */
16434 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16435 DINFO_USAGE_IND_USE);
16439 /* This code is used for C++ pointer-to-data-member types.
16440 Output a description of the relevant class type. */
16441 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
16442 DINFO_USAGE_IND_USE);
16444 /* Output a description of the type of the object pointed to. */
16445 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16446 DINFO_USAGE_IND_USE);
16448 /* Now output a DIE to represent this pointer-to-data-member type
16450 gen_ptr_to_mbr_type_die (type, context_die);
16453 case FUNCTION_TYPE:
16454 /* Force out return type (in case it wasn't forced out already). */
16455 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16456 DINFO_USAGE_DIR_USE);
16457 gen_subroutine_type_die (type, context_die);
16461 /* Force out return type (in case it wasn't forced out already). */
16462 gen_type_die_with_usage (TREE_TYPE (type), context_die,
16463 DINFO_USAGE_DIR_USE);
16464 gen_subroutine_type_die (type, context_die);
16468 gen_array_type_die (type, context_die);
16472 gen_array_type_die (type, context_die);
16475 case ENUMERAL_TYPE:
16478 case QUAL_UNION_TYPE:
16479 /* If this is a nested type whose containing class hasn't been written
16480 out yet, writing it out will cover this one, too. This does not apply
16481 to instantiations of member class templates; they need to be added to
16482 the containing class as they are generated. FIXME: This hurts the
16483 idea of combining type decls from multiple TUs, since we can't predict
16484 what set of template instantiations we'll get. */
16485 if (TYPE_CONTEXT (type)
16486 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
16487 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
16489 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
16491 if (TREE_ASM_WRITTEN (type))
16494 /* If that failed, attach ourselves to the stub. */
16495 push_decl_scope (TYPE_CONTEXT (type));
16496 context_die = lookup_type_die (TYPE_CONTEXT (type));
16499 else if (TYPE_CONTEXT (type) != NULL_TREE
16500 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
16502 /* If this type is local to a function that hasn't been written
16503 out yet, use a NULL context for now; it will be fixed up in
16504 decls_for_scope. */
16505 context_die = lookup_decl_die (TYPE_CONTEXT (type));
16510 context_die = declare_in_namespace (type, context_die);
16514 if (TREE_CODE (type) == ENUMERAL_TYPE)
16516 /* This might have been written out by the call to
16517 declare_in_namespace. */
16518 if (!TREE_ASM_WRITTEN (type))
16519 gen_enumeration_type_die (type, context_die);
16522 gen_struct_or_union_type_die (type, context_die, usage);
16527 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
16528 it up if it is ever completed. gen_*_type_die will set it for us
16529 when appropriate. */
16535 case FIXED_POINT_TYPE:
16538 /* No DIEs needed for fundamental types. */
16542 /* No Dwarf representation currently defined. */
16546 gcc_unreachable ();
16549 TREE_ASM_WRITTEN (type) = 1;
16553 gen_type_die (tree type, dw_die_ref context_die)
16555 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
16558 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
16559 things which are local to the given block. */
16562 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
16564 int must_output_die = 0;
16567 /* Ignore blocks that are NULL. */
16568 if (stmt == NULL_TREE)
16571 inlined_func = inlined_function_outer_scope_p (stmt);
16573 /* If the block is one fragment of a non-contiguous block, do not
16574 process the variables, since they will have been done by the
16575 origin block. Do process subblocks. */
16576 if (BLOCK_FRAGMENT_ORIGIN (stmt))
16580 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
16581 gen_block_die (sub, context_die, depth + 1);
16586 /* Determine if we need to output any Dwarf DIEs at all to represent this
16589 /* The outer scopes for inlinings *must* always be represented. We
16590 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
16591 must_output_die = 1;
16594 /* Determine if this block directly contains any "significant"
16595 local declarations which we will need to output DIEs for. */
16596 if (debug_info_level > DINFO_LEVEL_TERSE)
16597 /* We are not in terse mode so *any* local declaration counts
16598 as being a "significant" one. */
16599 must_output_die = ((BLOCK_VARS (stmt) != NULL
16600 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
16601 && (TREE_USED (stmt)
16602 || TREE_ASM_WRITTEN (stmt)
16603 || BLOCK_ABSTRACT (stmt)));
16604 else if ((TREE_USED (stmt)
16605 || TREE_ASM_WRITTEN (stmt)
16606 || BLOCK_ABSTRACT (stmt))
16607 && !dwarf2out_ignore_block (stmt))
16608 must_output_die = 1;
16611 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
16612 DIE for any block which contains no significant local declarations at
16613 all. Rather, in such cases we just call `decls_for_scope' so that any
16614 needed Dwarf info for any sub-blocks will get properly generated. Note
16615 that in terse mode, our definition of what constitutes a "significant"
16616 local declaration gets restricted to include only inlined function
16617 instances and local (nested) function definitions. */
16618 if (must_output_die)
16622 /* If STMT block is abstract, that means we have been called
16623 indirectly from dwarf2out_abstract_function.
16624 That function rightfully marks the descendent blocks (of
16625 the abstract function it is dealing with) as being abstract,
16626 precisely to prevent us from emitting any
16627 DW_TAG_inlined_subroutine DIE as a descendent
16628 of an abstract function instance. So in that case, we should
16629 not call gen_inlined_subroutine_die.
16631 Later though, when cgraph asks dwarf2out to emit info
16632 for the concrete instance of the function decl into which
16633 the concrete instance of STMT got inlined, the later will lead
16634 to the generation of a DW_TAG_inlined_subroutine DIE. */
16635 if (! BLOCK_ABSTRACT (stmt))
16636 gen_inlined_subroutine_die (stmt, context_die, depth);
16639 gen_lexical_block_die (stmt, context_die, depth);
16642 decls_for_scope (stmt, context_die, depth);
16645 /* Process variable DECL (or variable with origin ORIGIN) within
16646 block STMT and add it to CONTEXT_DIE. */
16648 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
16651 tree decl_or_origin = decl ? decl : origin;
16652 tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
16654 if (ultimate_origin)
16655 origin = ultimate_origin;
16657 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
16658 die = lookup_decl_die (decl_or_origin);
16659 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
16660 && TYPE_DECL_IS_STUB (decl_or_origin))
16661 die = lookup_type_die (TREE_TYPE (decl_or_origin));
16665 if (die != NULL && die->die_parent == NULL)
16666 add_child_die (context_die, die);
16667 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
16668 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
16669 stmt, context_die);
16671 gen_decl_die (decl, origin, context_die);
16674 /* Generate all of the decls declared within a given scope and (recursively)
16675 all of its sub-blocks. */
16678 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
16684 /* Ignore NULL blocks. */
16685 if (stmt == NULL_TREE)
16688 /* Output the DIEs to represent all of the data objects and typedefs
16689 declared directly within this block but not within any nested
16690 sub-blocks. Also, nested function and tag DIEs have been
16691 generated with a parent of NULL; fix that up now. */
16692 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
16693 process_scope_var (stmt, decl, NULL_TREE, context_die);
16694 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
16695 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
16698 /* If we're at -g1, we're not interested in subblocks. */
16699 if (debug_info_level <= DINFO_LEVEL_TERSE)
16702 /* Output the DIEs to represent all sub-blocks (and the items declared
16703 therein) of this block. */
16704 for (subblocks = BLOCK_SUBBLOCKS (stmt);
16706 subblocks = BLOCK_CHAIN (subblocks))
16707 gen_block_die (subblocks, context_die, depth + 1);
16710 /* Is this a typedef we can avoid emitting? */
16713 is_redundant_typedef (const_tree decl)
16715 if (TYPE_DECL_IS_STUB (decl))
16718 if (DECL_ARTIFICIAL (decl)
16719 && DECL_CONTEXT (decl)
16720 && is_tagged_type (DECL_CONTEXT (decl))
16721 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
16722 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
16723 /* Also ignore the artificial member typedef for the class name. */
16729 /* Returns the DIE for a context. */
16731 static inline dw_die_ref
16732 get_context_die (tree context)
16736 /* Find die that represents this context. */
16737 if (TYPE_P (context))
16738 return force_type_die (context);
16740 return force_decl_die (context);
16742 return comp_unit_die;
16745 /* Returns the DIE for decl. A DIE will always be returned. */
16748 force_decl_die (tree decl)
16750 dw_die_ref decl_die;
16751 unsigned saved_external_flag;
16752 tree save_fn = NULL_TREE;
16753 decl_die = lookup_decl_die (decl);
16756 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
16758 decl_die = lookup_decl_die (decl);
16762 switch (TREE_CODE (decl))
16764 case FUNCTION_DECL:
16765 /* Clear current_function_decl, so that gen_subprogram_die thinks
16766 that this is a declaration. At this point, we just want to force
16767 declaration die. */
16768 save_fn = current_function_decl;
16769 current_function_decl = NULL_TREE;
16770 gen_subprogram_die (decl, context_die);
16771 current_function_decl = save_fn;
16775 /* Set external flag to force declaration die. Restore it after
16776 gen_decl_die() call. */
16777 saved_external_flag = DECL_EXTERNAL (decl);
16778 DECL_EXTERNAL (decl) = 1;
16779 gen_decl_die (decl, NULL, context_die);
16780 DECL_EXTERNAL (decl) = saved_external_flag;
16783 case NAMESPACE_DECL:
16784 dwarf2out_decl (decl);
16788 gcc_unreachable ();
16791 /* We should be able to find the DIE now. */
16793 decl_die = lookup_decl_die (decl);
16794 gcc_assert (decl_die);
16800 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
16801 always returned. */
16804 force_type_die (tree type)
16806 dw_die_ref type_die;
16808 type_die = lookup_type_die (type);
16811 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
16813 type_die = modified_type_die (type, TYPE_READONLY (type),
16814 TYPE_VOLATILE (type), context_die);
16815 gcc_assert (type_die);
16820 /* Force out any required namespaces to be able to output DECL,
16821 and return the new context_die for it, if it's changed. */
16824 setup_namespace_context (tree thing, dw_die_ref context_die)
16826 tree context = (DECL_P (thing)
16827 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
16828 if (context && TREE_CODE (context) == NAMESPACE_DECL)
16829 /* Force out the namespace. */
16830 context_die = force_decl_die (context);
16832 return context_die;
16835 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
16836 type) within its namespace, if appropriate.
16838 For compatibility with older debuggers, namespace DIEs only contain
16839 declarations; all definitions are emitted at CU scope. */
16842 declare_in_namespace (tree thing, dw_die_ref context_die)
16844 dw_die_ref ns_context;
16846 if (debug_info_level <= DINFO_LEVEL_TERSE)
16847 return context_die;
16849 /* If this decl is from an inlined function, then don't try to emit it in its
16850 namespace, as we will get confused. It would have already been emitted
16851 when the abstract instance of the inline function was emitted anyways. */
16852 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
16853 return context_die;
16855 ns_context = setup_namespace_context (thing, context_die);
16857 if (ns_context != context_die)
16861 if (DECL_P (thing))
16862 gen_decl_die (thing, NULL, ns_context);
16864 gen_type_die (thing, ns_context);
16866 return context_die;
16869 /* Generate a DIE for a namespace or namespace alias. */
16872 gen_namespace_die (tree decl, dw_die_ref context_die)
16874 dw_die_ref namespace_die;
16876 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
16877 they are an alias of. */
16878 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
16880 /* Output a real namespace or module. */
16881 context_die = setup_namespace_context (decl, comp_unit_die);
16882 namespace_die = new_die (is_fortran ()
16883 ? DW_TAG_module : DW_TAG_namespace,
16884 context_die, decl);
16885 /* For Fortran modules defined in different CU don't add src coords. */
16886 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
16887 add_name_attribute (namespace_die, dwarf2_name (decl, 0));
16889 add_name_and_src_coords_attributes (namespace_die, decl);
16890 if (DECL_EXTERNAL (decl))
16891 add_AT_flag (namespace_die, DW_AT_declaration, 1);
16892 equate_decl_number_to_die (decl, namespace_die);
16896 /* Output a namespace alias. */
16898 /* Force out the namespace we are an alias of, if necessary. */
16899 dw_die_ref origin_die
16900 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
16902 if (DECL_CONTEXT (decl) == NULL_TREE
16903 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
16904 context_die = setup_namespace_context (decl, comp_unit_die);
16905 /* Now create the namespace alias DIE. */
16906 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
16907 add_name_and_src_coords_attributes (namespace_die, decl);
16908 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
16909 equate_decl_number_to_die (decl, namespace_die);
16913 /* Generate Dwarf debug information for a decl described by DECL. */
16916 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
16918 tree decl_or_origin = decl ? decl : origin;
16919 tree class_origin = NULL;
16921 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
16924 switch (TREE_CODE (decl_or_origin))
16930 if (!is_fortran ())
16932 /* The individual enumerators of an enum type get output when we output
16933 the Dwarf representation of the relevant enum type itself. */
16937 /* Emit its type. */
16938 gen_type_die (TREE_TYPE (decl), context_die);
16940 /* And its containing namespace. */
16941 context_die = declare_in_namespace (decl, context_die);
16943 gen_const_die (decl, context_die);
16946 case FUNCTION_DECL:
16947 /* Don't output any DIEs to represent mere function declarations,
16948 unless they are class members or explicit block externs. */
16949 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
16950 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
16951 && (current_function_decl == NULL_TREE
16952 || DECL_ARTIFICIAL (decl_or_origin)))
16957 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
16958 on local redeclarations of global functions. That seems broken. */
16959 if (current_function_decl != decl)
16960 /* This is only a declaration. */;
16963 /* If we're emitting a clone, emit info for the abstract instance. */
16964 if (origin || DECL_ORIGIN (decl) != decl)
16965 dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
16967 /* If we're emitting an out-of-line copy of an inline function,
16968 emit info for the abstract instance and set up to refer to it. */
16969 else if (cgraph_function_possibly_inlined_p (decl)
16970 && ! DECL_ABSTRACT (decl)
16971 && ! class_or_namespace_scope_p (context_die)
16972 /* dwarf2out_abstract_function won't emit a die if this is just
16973 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
16974 that case, because that works only if we have a die. */
16975 && DECL_INITIAL (decl) != NULL_TREE)
16977 dwarf2out_abstract_function (decl);
16978 set_decl_origin_self (decl);
16981 /* Otherwise we're emitting the primary DIE for this decl. */
16982 else if (debug_info_level > DINFO_LEVEL_TERSE)
16984 /* Before we describe the FUNCTION_DECL itself, make sure that we
16985 have described its return type. */
16986 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
16988 /* And its virtual context. */
16989 if (DECL_VINDEX (decl) != NULL_TREE)
16990 gen_type_die (DECL_CONTEXT (decl), context_die);
16992 /* And its containing type. */
16994 origin = decl_class_context (decl);
16995 if (origin != NULL_TREE)
16996 gen_type_die_for_member (origin, decl, context_die);
16998 /* And its containing namespace. */
16999 context_die = declare_in_namespace (decl, context_die);
17002 /* Now output a DIE to represent the function itself. */
17004 gen_subprogram_die (decl, context_die);
17008 /* If we are in terse mode, don't generate any DIEs to represent any
17009 actual typedefs. */
17010 if (debug_info_level <= DINFO_LEVEL_TERSE)
17013 /* In the special case of a TYPE_DECL node representing the declaration
17014 of some type tag, if the given TYPE_DECL is marked as having been
17015 instantiated from some other (original) TYPE_DECL node (e.g. one which
17016 was generated within the original definition of an inline function) we
17017 used to generate a special (abbreviated) DW_TAG_structure_type,
17018 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
17019 should be actually referencing those DIEs, as variable DIEs with that
17020 type would be emitted already in the abstract origin, so it was always
17021 removed during unused type prunning. Don't add anything in this
17023 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
17026 if (is_redundant_typedef (decl))
17027 gen_type_die (TREE_TYPE (decl), context_die);
17029 /* Output a DIE to represent the typedef itself. */
17030 gen_typedef_die (decl, context_die);
17034 if (debug_info_level >= DINFO_LEVEL_NORMAL)
17035 gen_label_die (decl, context_die);
17040 /* If we are in terse mode, don't generate any DIEs to represent any
17041 variable declarations or definitions. */
17042 if (debug_info_level <= DINFO_LEVEL_TERSE)
17045 /* Output any DIEs that are needed to specify the type of this data
17047 if ((TREE_CODE (decl_or_origin) == RESULT_DECL
17048 || TREE_CODE (decl_or_origin) == VAR_DECL)
17049 && DECL_BY_REFERENCE (decl_or_origin))
17050 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
17052 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
17054 /* And its containing type. */
17055 class_origin = decl_class_context (decl_or_origin);
17056 if (class_origin != NULL_TREE)
17057 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
17059 /* And its containing namespace. */
17060 context_die = declare_in_namespace (decl_or_origin, context_die);
17062 /* Now output the DIE to represent the data object itself. This gets
17063 complicated because of the possibility that the VAR_DECL really
17064 represents an inlined instance of a formal parameter for an inline
17067 origin = decl_ultimate_origin (decl);
17068 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
17069 gen_formal_parameter_die (decl, origin, context_die);
17071 gen_variable_die (decl, origin, context_die);
17075 /* Ignore the nameless fields that are used to skip bits but handle C++
17076 anonymous unions and structs. */
17077 if (DECL_NAME (decl) != NULL_TREE
17078 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
17079 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
17081 gen_type_die (member_declared_type (decl), context_die);
17082 gen_field_die (decl, context_die);
17087 if (DECL_BY_REFERENCE (decl_or_origin))
17088 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
17090 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
17091 gen_formal_parameter_die (decl, origin, context_die);
17094 case NAMESPACE_DECL:
17095 case IMPORTED_DECL:
17096 gen_namespace_die (decl, context_die);
17100 /* Probably some frontend-internal decl. Assume we don't care. */
17101 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
17106 /* Output debug information for global decl DECL. Called from toplev.c after
17107 compilation proper has finished. */
17110 dwarf2out_global_decl (tree decl)
17112 /* Output DWARF2 information for file-scope tentative data object
17113 declarations, file-scope (extern) function declarations (which
17114 had no corresponding body) and file-scope tagged type declarations
17115 and definitions which have not yet been forced out. */
17116 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
17117 dwarf2out_decl (decl);
17120 /* Output debug information for type decl DECL. Called from toplev.c
17121 and from language front ends (to record built-in types). */
17123 dwarf2out_type_decl (tree decl, int local)
17126 dwarf2out_decl (decl);
17129 /* Output debug information for imported module or decl DECL.
17130 NAME is non-NULL name in the lexical block if the decl has been renamed.
17131 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
17132 that DECL belongs to.
17133 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
17135 dwarf2out_imported_module_or_decl_1 (tree decl,
17137 tree lexical_block,
17138 dw_die_ref lexical_block_die)
17140 expanded_location xloc;
17141 dw_die_ref imported_die = NULL;
17142 dw_die_ref at_import_die;
17144 if (TREE_CODE (decl) == IMPORTED_DECL)
17146 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
17147 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
17151 xloc = expand_location (input_location);
17153 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
17155 if (is_base_type (TREE_TYPE (decl)))
17156 at_import_die = base_type_die (TREE_TYPE (decl));
17158 at_import_die = force_type_die (TREE_TYPE (decl));
17159 /* For namespace N { typedef void T; } using N::T; base_type_die
17160 returns NULL, but DW_TAG_imported_declaration requires
17161 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
17162 if (!at_import_die)
17164 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
17165 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
17166 at_import_die = lookup_type_die (TREE_TYPE (decl));
17167 gcc_assert (at_import_die);
17172 at_import_die = lookup_decl_die (decl);
17173 if (!at_import_die)
17175 /* If we're trying to avoid duplicate debug info, we may not have
17176 emitted the member decl for this field. Emit it now. */
17177 if (TREE_CODE (decl) == FIELD_DECL)
17179 tree type = DECL_CONTEXT (decl);
17181 if (TYPE_CONTEXT (type)
17182 && TYPE_P (TYPE_CONTEXT (type))
17183 && !should_emit_struct_debug (TYPE_CONTEXT (type),
17184 DINFO_USAGE_DIR_USE))
17186 gen_type_die_for_member (type, decl,
17187 get_context_die (TYPE_CONTEXT (type)));
17189 at_import_die = force_decl_die (decl);
17193 if (TREE_CODE (decl) == NAMESPACE_DECL)
17194 imported_die = new_die (DW_TAG_imported_module,
17198 imported_die = new_die (DW_TAG_imported_declaration,
17202 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
17203 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
17205 add_AT_string (imported_die, DW_AT_name,
17206 IDENTIFIER_POINTER (name));
17207 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
17210 /* Output debug information for imported module or decl DECL.
17211 NAME is non-NULL name in context if the decl has been renamed.
17212 CHILD is true if decl is one of the renamed decls as part of
17213 importing whole module. */
17216 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
17219 /* dw_die_ref at_import_die; */
17220 dw_die_ref scope_die;
17222 if (debug_info_level <= DINFO_LEVEL_TERSE)
17227 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
17228 We need decl DIE for reference and scope die. First, get DIE for the decl
17231 /* Get the scope die for decl context. Use comp_unit_die for global module
17232 or decl. If die is not found for non globals, force new die. */
17234 && TYPE_P (context)
17235 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
17237 scope_die = get_context_die (context);
17241 gcc_assert (scope_die->die_child);
17242 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
17243 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
17244 scope_die = scope_die->die_child;
17247 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
17248 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
17252 /* Write the debugging output for DECL. */
17255 dwarf2out_decl (tree decl)
17257 dw_die_ref context_die = comp_unit_die;
17259 switch (TREE_CODE (decl))
17264 case FUNCTION_DECL:
17265 /* What we would really like to do here is to filter out all mere
17266 file-scope declarations of file-scope functions which are never
17267 referenced later within this translation unit (and keep all of ones
17268 that *are* referenced later on) but we aren't clairvoyant, so we have
17269 no idea which functions will be referenced in the future (i.e. later
17270 on within the current translation unit). So here we just ignore all
17271 file-scope function declarations which are not also definitions. If
17272 and when the debugger needs to know something about these functions,
17273 it will have to hunt around and find the DWARF information associated
17274 with the definition of the function.
17276 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
17277 nodes represent definitions and which ones represent mere
17278 declarations. We have to check DECL_INITIAL instead. That's because
17279 the C front-end supports some weird semantics for "extern inline"
17280 function definitions. These can get inlined within the current
17281 translation unit (and thus, we need to generate Dwarf info for their
17282 abstract instances so that the Dwarf info for the concrete inlined
17283 instances can have something to refer to) but the compiler never
17284 generates any out-of-lines instances of such things (despite the fact
17285 that they *are* definitions).
17287 The important point is that the C front-end marks these "extern
17288 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
17289 them anyway. Note that the C++ front-end also plays some similar games
17290 for inline function definitions appearing within include files which
17291 also contain `#pragma interface' pragmas. */
17292 if (DECL_INITIAL (decl) == NULL_TREE)
17295 /* If we're a nested function, initially use a parent of NULL; if we're
17296 a plain function, this will be fixed up in decls_for_scope. If
17297 we're a method, it will be ignored, since we already have a DIE. */
17298 if (decl_function_context (decl)
17299 /* But if we're in terse mode, we don't care about scope. */
17300 && debug_info_level > DINFO_LEVEL_TERSE)
17301 context_die = NULL;
17305 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
17306 declaration and if the declaration was never even referenced from
17307 within this entire compilation unit. We suppress these DIEs in
17308 order to save space in the .debug section (by eliminating entries
17309 which are probably useless). Note that we must not suppress
17310 block-local extern declarations (whether used or not) because that
17311 would screw-up the debugger's name lookup mechanism and cause it to
17312 miss things which really ought to be in scope at a given point. */
17313 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
17316 /* For local statics lookup proper context die. */
17317 if (TREE_STATIC (decl) && decl_function_context (decl))
17318 context_die = lookup_decl_die (DECL_CONTEXT (decl));
17320 /* If we are in terse mode, don't generate any DIEs to represent any
17321 variable declarations or definitions. */
17322 if (debug_info_level <= DINFO_LEVEL_TERSE)
17327 if (debug_info_level <= DINFO_LEVEL_TERSE)
17329 if (!is_fortran ())
17331 if (TREE_STATIC (decl) && decl_function_context (decl))
17332 context_die = lookup_decl_die (DECL_CONTEXT (decl));
17335 case NAMESPACE_DECL:
17336 case IMPORTED_DECL:
17337 if (debug_info_level <= DINFO_LEVEL_TERSE)
17339 if (lookup_decl_die (decl) != NULL)
17344 /* Don't emit stubs for types unless they are needed by other DIEs. */
17345 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
17348 /* Don't bother trying to generate any DIEs to represent any of the
17349 normal built-in types for the language we are compiling. */
17350 if (DECL_IS_BUILTIN (decl))
17352 /* OK, we need to generate one for `bool' so GDB knows what type
17353 comparisons have. */
17355 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
17356 && ! DECL_IGNORED_P (decl))
17357 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
17362 /* If we are in terse mode, don't generate any DIEs for types. */
17363 if (debug_info_level <= DINFO_LEVEL_TERSE)
17366 /* If we're a function-scope tag, initially use a parent of NULL;
17367 this will be fixed up in decls_for_scope. */
17368 if (decl_function_context (decl))
17369 context_die = NULL;
17377 gen_decl_die (decl, NULL, context_die);
17380 /* Output a marker (i.e. a label) for the beginning of the generated code for
17381 a lexical block. */
17384 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
17385 unsigned int blocknum)
17387 switch_to_section (current_function_section ());
17388 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
17391 /* Output a marker (i.e. a label) for the end of the generated code for a
17395 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
17397 switch_to_section (current_function_section ());
17398 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
17401 /* Returns nonzero if it is appropriate not to emit any debugging
17402 information for BLOCK, because it doesn't contain any instructions.
17404 Don't allow this for blocks with nested functions or local classes
17405 as we would end up with orphans, and in the presence of scheduling
17406 we may end up calling them anyway. */
17409 dwarf2out_ignore_block (const_tree block)
17414 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
17415 if (TREE_CODE (decl) == FUNCTION_DECL
17416 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
17418 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
17420 decl = BLOCK_NONLOCALIZED_VAR (block, i);
17421 if (TREE_CODE (decl) == FUNCTION_DECL
17422 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
17429 /* Hash table routines for file_hash. */
17432 file_table_eq (const void *p1_p, const void *p2_p)
17434 const struct dwarf_file_data *const p1 =
17435 (const struct dwarf_file_data *) p1_p;
17436 const char *const p2 = (const char *) p2_p;
17437 return strcmp (p1->filename, p2) == 0;
17441 file_table_hash (const void *p_p)
17443 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
17444 return htab_hash_string (p->filename);
17447 /* Lookup FILE_NAME (in the list of filenames that we know about here in
17448 dwarf2out.c) and return its "index". The index of each (known) filename is
17449 just a unique number which is associated with only that one filename. We
17450 need such numbers for the sake of generating labels (in the .debug_sfnames
17451 section) and references to those files numbers (in the .debug_srcinfo
17452 and.debug_macinfo sections). If the filename given as an argument is not
17453 found in our current list, add it to the list and assign it the next
17454 available unique index number. In order to speed up searches, we remember
17455 the index of the filename was looked up last. This handles the majority of
17458 static struct dwarf_file_data *
17459 lookup_filename (const char *file_name)
17462 struct dwarf_file_data * created;
17464 /* Check to see if the file name that was searched on the previous
17465 call matches this file name. If so, return the index. */
17466 if (file_table_last_lookup
17467 && (file_name == file_table_last_lookup->filename
17468 || strcmp (file_table_last_lookup->filename, file_name) == 0))
17469 return file_table_last_lookup;
17471 /* Didn't match the previous lookup, search the table. */
17472 slot = htab_find_slot_with_hash (file_table, file_name,
17473 htab_hash_string (file_name), INSERT);
17475 return (struct dwarf_file_data *) *slot;
17477 created = GGC_NEW (struct dwarf_file_data);
17478 created->filename = file_name;
17479 created->emitted_number = 0;
17484 /* If the assembler will construct the file table, then translate the compiler
17485 internal file table number into the assembler file table number, and emit
17486 a .file directive if we haven't already emitted one yet. The file table
17487 numbers are different because we prune debug info for unused variables and
17488 types, which may include filenames. */
17491 maybe_emit_file (struct dwarf_file_data * fd)
17493 if (! fd->emitted_number)
17495 if (last_emitted_file)
17496 fd->emitted_number = last_emitted_file->emitted_number + 1;
17498 fd->emitted_number = 1;
17499 last_emitted_file = fd;
17501 if (DWARF2_ASM_LINE_DEBUG_INFO)
17503 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
17504 output_quoted_string (asm_out_file,
17505 remap_debug_filename (fd->filename));
17506 fputc ('\n', asm_out_file);
17510 return fd->emitted_number;
17513 /* Schedule generation of a DW_AT_const_value attribute to DIE.
17514 That generation should happen after function debug info has been
17515 generated. The value of the attribute is the constant value of ARG. */
17518 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
17520 die_arg_entry entry;
17525 if (!tmpl_value_parm_die_table)
17526 tmpl_value_parm_die_table
17527 = VEC_alloc (die_arg_entry, gc, 32);
17531 VEC_safe_push (die_arg_entry, gc,
17532 tmpl_value_parm_die_table,
17536 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
17537 by append_entry_to_tmpl_value_parm_die_table. This function must
17538 be called after function DIEs have been generated. */
17541 gen_remaining_tmpl_value_param_die_attribute (void)
17543 if (tmpl_value_parm_die_table)
17549 VEC_iterate (die_arg_entry, tmpl_value_parm_die_table, i, e);
17551 tree_add_const_value_attribute (e->die, e->arg);
17556 /* Replace DW_AT_name for the decl with name. */
17559 dwarf2out_set_name (tree decl, tree name)
17564 die = TYPE_SYMTAB_DIE (decl);
17568 attr = get_AT (die, DW_AT_name);
17571 struct indirect_string_node *node;
17573 node = find_AT_string (dwarf2_name (name, 0));
17574 /* replace the string. */
17575 attr->dw_attr_val.v.val_str = node;
17579 add_name_attribute (die, dwarf2_name (name, 0));
17582 /* Called by the final INSN scan whenever we see a var location. We
17583 use it to drop labels in the right places, and throw the location in
17584 our lookup table. */
17587 dwarf2out_var_location (rtx loc_note)
17589 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
17590 struct var_loc_node *newloc;
17592 static const char *last_label;
17593 static const char *last_postcall_label;
17594 static bool last_in_cold_section_p;
17597 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
17600 next_real = next_real_insn (loc_note);
17601 /* If there are no instructions which would be affected by this note,
17602 don't do anything. */
17603 if (next_real == NULL_RTX)
17606 newloc = GGC_CNEW (struct var_loc_node);
17607 /* If there were no real insns between note we processed last time
17608 and this note, use the label we emitted last time. */
17609 if (last_var_location_insn == NULL_RTX
17610 || last_var_location_insn != next_real
17611 || last_in_cold_section_p != in_cold_section_p)
17613 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
17614 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
17616 last_label = ggc_strdup (loclabel);
17617 if (!NOTE_DURING_CALL_P (loc_note))
17618 last_postcall_label = NULL;
17620 newloc->var_loc_note = loc_note;
17621 newloc->next = NULL;
17623 if (!NOTE_DURING_CALL_P (loc_note))
17624 newloc->label = last_label;
17627 if (!last_postcall_label)
17629 sprintf (loclabel, "%s-1", last_label);
17630 last_postcall_label = ggc_strdup (loclabel);
17632 newloc->label = last_postcall_label;
17635 if (cfun && in_cold_section_p)
17636 newloc->section_label = crtl->subsections.cold_section_label;
17638 newloc->section_label = text_section_label;
17640 last_var_location_insn = next_real;
17641 last_in_cold_section_p = in_cold_section_p;
17642 decl = NOTE_VAR_LOCATION_DECL (loc_note);
17643 add_var_loc_to_decl (decl, newloc);
17646 /* We need to reset the locations at the beginning of each
17647 function. We can't do this in the end_function hook, because the
17648 declarations that use the locations won't have been output when
17649 that hook is called. Also compute have_multiple_function_sections here. */
17652 dwarf2out_begin_function (tree fun)
17654 htab_empty (decl_loc_table);
17656 if (function_section (fun) != text_section)
17657 have_multiple_function_sections = true;
17659 dwarf2out_note_section_used ();
17662 /* Output a label to mark the beginning of a source code line entry
17663 and record information relating to this source line, in
17664 'line_info_table' for later output of the .debug_line section. */
17667 dwarf2out_source_line (unsigned int line, const char *filename,
17668 int discriminator, bool is_stmt)
17670 static bool last_is_stmt = true;
17672 if (debug_info_level >= DINFO_LEVEL_NORMAL
17675 int file_num = maybe_emit_file (lookup_filename (filename));
17677 switch_to_section (current_function_section ());
17679 /* If requested, emit something human-readable. */
17680 if (flag_debug_asm)
17681 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
17684 if (DWARF2_ASM_LINE_DEBUG_INFO)
17686 /* Emit the .loc directive understood by GNU as. */
17687 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
17688 if (is_stmt != last_is_stmt)
17690 fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
17691 last_is_stmt = is_stmt;
17693 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
17694 fprintf (asm_out_file, " discriminator %d", discriminator);
17695 fputc ('\n', asm_out_file);
17697 /* Indicate that line number info exists. */
17698 line_info_table_in_use++;
17700 else if (function_section (current_function_decl) != text_section)
17702 dw_separate_line_info_ref line_info;
17703 targetm.asm_out.internal_label (asm_out_file,
17704 SEPARATE_LINE_CODE_LABEL,
17705 separate_line_info_table_in_use);
17707 /* Expand the line info table if necessary. */
17708 if (separate_line_info_table_in_use
17709 == separate_line_info_table_allocated)
17711 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
17712 separate_line_info_table
17713 = GGC_RESIZEVEC (dw_separate_line_info_entry,
17714 separate_line_info_table,
17715 separate_line_info_table_allocated);
17716 memset (separate_line_info_table
17717 + separate_line_info_table_in_use,
17719 (LINE_INFO_TABLE_INCREMENT
17720 * sizeof (dw_separate_line_info_entry)));
17723 /* Add the new entry at the end of the line_info_table. */
17725 = &separate_line_info_table[separate_line_info_table_in_use++];
17726 line_info->dw_file_num = file_num;
17727 line_info->dw_line_num = line;
17728 line_info->function = current_function_funcdef_no;
17732 dw_line_info_ref line_info;
17734 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
17735 line_info_table_in_use);
17737 /* Expand the line info table if necessary. */
17738 if (line_info_table_in_use == line_info_table_allocated)
17740 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
17742 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
17743 line_info_table_allocated);
17744 memset (line_info_table + line_info_table_in_use, 0,
17745 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
17748 /* Add the new entry at the end of the line_info_table. */
17749 line_info = &line_info_table[line_info_table_in_use++];
17750 line_info->dw_file_num = file_num;
17751 line_info->dw_line_num = line;
17756 /* Record the beginning of a new source file. */
17759 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
17761 if (flag_eliminate_dwarf2_dups)
17763 /* Record the beginning of the file for break_out_includes. */
17764 dw_die_ref bincl_die;
17766 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
17767 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
17770 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
17772 int file_num = maybe_emit_file (lookup_filename (filename));
17774 switch_to_section (debug_macinfo_section);
17775 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
17776 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
17779 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
17783 /* Record the end of a source file. */
17786 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
17788 if (flag_eliminate_dwarf2_dups)
17789 /* Record the end of the file for break_out_includes. */
17790 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
17792 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
17794 switch_to_section (debug_macinfo_section);
17795 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
17799 /* Called from debug_define in toplev.c. The `buffer' parameter contains
17800 the tail part of the directive line, i.e. the part which is past the
17801 initial whitespace, #, whitespace, directive-name, whitespace part. */
17804 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
17805 const char *buffer ATTRIBUTE_UNUSED)
17807 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
17809 switch_to_section (debug_macinfo_section);
17810 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
17811 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
17812 dw2_asm_output_nstring (buffer, -1, "The macro");
17816 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
17817 the tail part of the directive line, i.e. the part which is past the
17818 initial whitespace, #, whitespace, directive-name, whitespace part. */
17821 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
17822 const char *buffer ATTRIBUTE_UNUSED)
17824 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
17826 switch_to_section (debug_macinfo_section);
17827 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
17828 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
17829 dw2_asm_output_nstring (buffer, -1, "The macro");
17833 /* Set up for Dwarf output at the start of compilation. */
17836 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
17838 /* Allocate the file_table. */
17839 file_table = htab_create_ggc (50, file_table_hash,
17840 file_table_eq, NULL);
17842 /* Allocate the decl_die_table. */
17843 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
17844 decl_die_table_eq, NULL);
17846 /* Allocate the decl_loc_table. */
17847 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
17848 decl_loc_table_eq, NULL);
17850 /* Allocate the initial hunk of the decl_scope_table. */
17851 decl_scope_table = VEC_alloc (tree, gc, 256);
17853 /* Allocate the initial hunk of the abbrev_die_table. */
17854 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
17855 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
17856 /* Zero-th entry is allocated, but unused. */
17857 abbrev_die_table_in_use = 1;
17859 /* Allocate the initial hunk of the line_info_table. */
17860 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
17861 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
17863 /* Zero-th entry is allocated, but unused. */
17864 line_info_table_in_use = 1;
17866 /* Allocate the pubtypes and pubnames vectors. */
17867 pubname_table = VEC_alloc (pubname_entry, gc, 32);
17868 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
17870 /* Generate the initial DIE for the .debug section. Note that the (string)
17871 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
17872 will (typically) be a relative pathname and that this pathname should be
17873 taken as being relative to the directory from which the compiler was
17874 invoked when the given (base) source file was compiled. We will fill
17875 in this value in dwarf2out_finish. */
17876 comp_unit_die = gen_compile_unit_die (NULL);
17878 incomplete_types = VEC_alloc (tree, gc, 64);
17880 used_rtx_array = VEC_alloc (rtx, gc, 32);
17882 debug_info_section = get_section (DEBUG_INFO_SECTION,
17883 SECTION_DEBUG, NULL);
17884 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
17885 SECTION_DEBUG, NULL);
17886 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
17887 SECTION_DEBUG, NULL);
17888 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
17889 SECTION_DEBUG, NULL);
17890 debug_line_section = get_section (DEBUG_LINE_SECTION,
17891 SECTION_DEBUG, NULL);
17892 debug_loc_section = get_section (DEBUG_LOC_SECTION,
17893 SECTION_DEBUG, NULL);
17894 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
17895 SECTION_DEBUG, NULL);
17896 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
17897 SECTION_DEBUG, NULL);
17898 debug_str_section = get_section (DEBUG_STR_SECTION,
17899 DEBUG_STR_SECTION_FLAGS, NULL);
17900 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
17901 SECTION_DEBUG, NULL);
17902 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
17903 SECTION_DEBUG, NULL);
17905 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
17906 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
17907 DEBUG_ABBREV_SECTION_LABEL, 0);
17908 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
17909 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
17910 COLD_TEXT_SECTION_LABEL, 0);
17911 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
17913 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
17914 DEBUG_INFO_SECTION_LABEL, 0);
17915 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
17916 DEBUG_LINE_SECTION_LABEL, 0);
17917 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
17918 DEBUG_RANGES_SECTION_LABEL, 0);
17919 switch_to_section (debug_abbrev_section);
17920 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
17921 switch_to_section (debug_info_section);
17922 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
17923 switch_to_section (debug_line_section);
17924 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
17926 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
17928 switch_to_section (debug_macinfo_section);
17929 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
17930 DEBUG_MACINFO_SECTION_LABEL, 0);
17931 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
17934 switch_to_section (text_section);
17935 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
17936 if (flag_reorder_blocks_and_partition)
17938 cold_text_section = unlikely_text_section ();
17939 switch_to_section (cold_text_section);
17940 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
17944 /* A helper function for dwarf2out_finish called through
17945 htab_traverse. Emit one queued .debug_str string. */
17948 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
17950 struct indirect_string_node *node = (struct indirect_string_node *) *h;
17952 if (node->label && node->refcount)
17954 switch_to_section (debug_str_section);
17955 ASM_OUTPUT_LABEL (asm_out_file, node->label);
17956 assemble_string (node->str, strlen (node->str) + 1);
17962 #if ENABLE_ASSERT_CHECKING
17963 /* Verify that all marks are clear. */
17966 verify_marks_clear (dw_die_ref die)
17970 gcc_assert (! die->die_mark);
17971 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
17973 #endif /* ENABLE_ASSERT_CHECKING */
17975 /* Clear the marks for a die and its children.
17976 Be cool if the mark isn't set. */
17979 prune_unmark_dies (dw_die_ref die)
17985 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
17988 /* Given DIE that we're marking as used, find any other dies
17989 it references as attributes and mark them as used. */
17992 prune_unused_types_walk_attribs (dw_die_ref die)
17997 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
17999 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
18001 /* A reference to another DIE.
18002 Make sure that it will get emitted. */
18003 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
18005 /* Set the string's refcount to 0 so that prune_unused_types_mark
18006 accounts properly for it. */
18007 if (AT_class (a) == dw_val_class_str)
18008 a->dw_attr_val.v.val_str->refcount = 0;
18013 /* Mark DIE as being used. If DOKIDS is true, then walk down
18014 to DIE's children. */
18017 prune_unused_types_mark (dw_die_ref die, int dokids)
18021 if (die->die_mark == 0)
18023 /* We haven't done this node yet. Mark it as used. */
18026 /* We also have to mark its parents as used.
18027 (But we don't want to mark our parents' kids due to this.) */
18028 if (die->die_parent)
18029 prune_unused_types_mark (die->die_parent, 0);
18031 /* Mark any referenced nodes. */
18032 prune_unused_types_walk_attribs (die);
18034 /* If this node is a specification,
18035 also mark the definition, if it exists. */
18036 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
18037 prune_unused_types_mark (die->die_definition, 1);
18040 if (dokids && die->die_mark != 2)
18042 /* We need to walk the children, but haven't done so yet.
18043 Remember that we've walked the kids. */
18046 /* If this is an array type, we need to make sure our
18047 kids get marked, even if they're types. */
18048 if (die->die_tag == DW_TAG_array_type)
18049 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
18051 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
18055 /* For local classes, look if any static member functions were emitted
18056 and if so, mark them. */
18059 prune_unused_types_walk_local_classes (dw_die_ref die)
18063 if (die->die_mark == 2)
18066 switch (die->die_tag)
18068 case DW_TAG_structure_type:
18069 case DW_TAG_union_type:
18070 case DW_TAG_class_type:
18073 case DW_TAG_subprogram:
18074 if (!get_AT_flag (die, DW_AT_declaration)
18075 || die->die_definition != NULL)
18076 prune_unused_types_mark (die, 1);
18083 /* Mark children. */
18084 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
18087 /* Walk the tree DIE and mark types that we actually use. */
18090 prune_unused_types_walk (dw_die_ref die)
18094 /* Don't do anything if this node is already marked and
18095 children have been marked as well. */
18096 if (die->die_mark == 2)
18099 switch (die->die_tag)
18101 case DW_TAG_structure_type:
18102 case DW_TAG_union_type:
18103 case DW_TAG_class_type:
18104 if (die->die_perennial_p)
18107 for (c = die->die_parent; c; c = c->die_parent)
18108 if (c->die_tag == DW_TAG_subprogram)
18111 /* Finding used static member functions inside of classes
18112 is needed just for local classes, because for other classes
18113 static member function DIEs with DW_AT_specification
18114 are emitted outside of the DW_TAG_*_type. If we ever change
18115 it, we'd need to call this even for non-local classes. */
18117 prune_unused_types_walk_local_classes (die);
18119 /* It's a type node --- don't mark it. */
18122 case DW_TAG_const_type:
18123 case DW_TAG_packed_type:
18124 case DW_TAG_pointer_type:
18125 case DW_TAG_reference_type:
18126 case DW_TAG_volatile_type:
18127 case DW_TAG_typedef:
18128 case DW_TAG_array_type:
18129 case DW_TAG_interface_type:
18130 case DW_TAG_friend:
18131 case DW_TAG_variant_part:
18132 case DW_TAG_enumeration_type:
18133 case DW_TAG_subroutine_type:
18134 case DW_TAG_string_type:
18135 case DW_TAG_set_type:
18136 case DW_TAG_subrange_type:
18137 case DW_TAG_ptr_to_member_type:
18138 case DW_TAG_file_type:
18139 if (die->die_perennial_p)
18142 /* It's a type node --- don't mark it. */
18146 /* Mark everything else. */
18150 if (die->die_mark == 0)
18154 /* Now, mark any dies referenced from here. */
18155 prune_unused_types_walk_attribs (die);
18160 /* Mark children. */
18161 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
18164 /* Increment the string counts on strings referred to from DIE's
18168 prune_unused_types_update_strings (dw_die_ref die)
18173 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
18174 if (AT_class (a) == dw_val_class_str)
18176 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
18178 /* Avoid unnecessarily putting strings that are used less than
18179 twice in the hash table. */
18181 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
18184 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
18185 htab_hash_string (s->str),
18187 gcc_assert (*slot == NULL);
18193 /* Remove from the tree DIE any dies that aren't marked. */
18196 prune_unused_types_prune (dw_die_ref die)
18200 gcc_assert (die->die_mark);
18201 prune_unused_types_update_strings (die);
18203 if (! die->die_child)
18206 c = die->die_child;
18208 dw_die_ref prev = c;
18209 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
18210 if (c == die->die_child)
18212 /* No marked children between 'prev' and the end of the list. */
18214 /* No marked children at all. */
18215 die->die_child = NULL;
18218 prev->die_sib = c->die_sib;
18219 die->die_child = prev;
18224 if (c != prev->die_sib)
18226 prune_unused_types_prune (c);
18227 } while (c != die->die_child);
18230 /* A helper function for dwarf2out_finish called through
18231 htab_traverse. Clear .debug_str strings that we haven't already
18232 decided to emit. */
18235 prune_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
18237 struct indirect_string_node *node = (struct indirect_string_node *) *h;
18239 if (!node->label || !node->refcount)
18240 htab_clear_slot (debug_str_hash, h);
18245 /* Remove dies representing declarations that we never use. */
18248 prune_unused_types (void)
18251 limbo_die_node *node;
18254 #if ENABLE_ASSERT_CHECKING
18255 /* All the marks should already be clear. */
18256 verify_marks_clear (comp_unit_die);
18257 for (node = limbo_die_list; node; node = node->next)
18258 verify_marks_clear (node->die);
18259 #endif /* ENABLE_ASSERT_CHECKING */
18261 /* Set the mark on nodes that are actually used. */
18262 prune_unused_types_walk (comp_unit_die);
18263 for (node = limbo_die_list; node; node = node->next)
18264 prune_unused_types_walk (node->die);
18266 /* Also set the mark on nodes referenced from the
18267 pubname_table or arange_table. */
18268 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
18269 prune_unused_types_mark (pub->die, 1);
18270 for (i = 0; i < arange_table_in_use; i++)
18271 prune_unused_types_mark (arange_table[i], 1);
18273 /* Get rid of nodes that aren't marked; and update the string counts. */
18274 if (debug_str_hash && debug_str_hash_forced)
18275 htab_traverse (debug_str_hash, prune_indirect_string, NULL);
18276 else if (debug_str_hash)
18277 htab_empty (debug_str_hash);
18278 prune_unused_types_prune (comp_unit_die);
18279 for (node = limbo_die_list; node; node = node->next)
18280 prune_unused_types_prune (node->die);
18282 /* Leave the marks clear. */
18283 prune_unmark_dies (comp_unit_die);
18284 for (node = limbo_die_list; node; node = node->next)
18285 prune_unmark_dies (node->die);
18288 /* Set the parameter to true if there are any relative pathnames in
18291 file_table_relative_p (void ** slot, void *param)
18293 bool *p = (bool *) param;
18294 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
18295 if (!IS_ABSOLUTE_PATH (d->filename))
18303 /* Move a DW_AT_MIPS_linkage_name attribute just added to dw_die_ref
18304 to the location it would have been added, should we know its
18305 DECL_ASSEMBLER_NAME when we added other attributes. This will
18306 probably improve compactness of debug info, removing equivalent
18307 abbrevs, and hide any differences caused by deferring the
18308 computation of the assembler name, triggered by e.g. PCH. */
18311 move_linkage_attr (dw_die_ref die)
18313 unsigned ix = VEC_length (dw_attr_node, die->die_attr);
18314 dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1);
18316 gcc_assert (linkage.dw_attr == DW_AT_MIPS_linkage_name);
18320 dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1);
18322 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
18326 if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
18328 VEC_pop (dw_attr_node, die->die_attr);
18329 VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
18333 /* Output stuff that dwarf requires at the end of every file,
18334 and generate the DWARF-2 debugging info. */
18337 dwarf2out_finish (const char *filename)
18339 limbo_die_node *node, *next_node;
18340 dw_die_ref die = 0;
18343 gen_remaining_tmpl_value_param_die_attribute ();
18345 /* Add the name for the main input file now. We delayed this from
18346 dwarf2out_init to avoid complications with PCH. */
18347 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
18348 if (!IS_ABSOLUTE_PATH (filename))
18349 add_comp_dir_attribute (comp_unit_die);
18350 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
18353 htab_traverse (file_table, file_table_relative_p, &p);
18355 add_comp_dir_attribute (comp_unit_die);
18358 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
18360 add_location_or_const_value_attribute (
18361 VEC_index (deferred_locations, deferred_locations_list, i)->die,
18362 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
18366 /* Traverse the limbo die list, and add parent/child links. The only
18367 dies without parents that should be here are concrete instances of
18368 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
18369 For concrete instances, we can get the parent die from the abstract
18371 for (node = limbo_die_list; node; node = next_node)
18373 next_node = node->next;
18376 if (die->die_parent == NULL)
18378 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
18381 add_child_die (origin->die_parent, die);
18382 else if (die == comp_unit_die)
18384 else if (errorcount > 0 || sorrycount > 0)
18385 /* It's OK to be confused by errors in the input. */
18386 add_child_die (comp_unit_die, die);
18389 /* In certain situations, the lexical block containing a
18390 nested function can be optimized away, which results
18391 in the nested function die being orphaned. Likewise
18392 with the return type of that nested function. Force
18393 this to be a child of the containing function.
18395 It may happen that even the containing function got fully
18396 inlined and optimized out. In that case we are lost and
18397 assign the empty child. This should not be big issue as
18398 the function is likely unreachable too. */
18399 tree context = NULL_TREE;
18401 gcc_assert (node->created_for);
18403 if (DECL_P (node->created_for))
18404 context = DECL_CONTEXT (node->created_for);
18405 else if (TYPE_P (node->created_for))
18406 context = TYPE_CONTEXT (node->created_for);
18408 gcc_assert (context
18409 && (TREE_CODE (context) == FUNCTION_DECL
18410 || TREE_CODE (context) == NAMESPACE_DECL));
18412 origin = lookup_decl_die (context);
18414 add_child_die (origin, die);
18416 add_child_die (comp_unit_die, die);
18421 limbo_die_list = NULL;
18423 for (node = deferred_asm_name; node; node = node->next)
18425 tree decl = node->created_for;
18426 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
18428 add_AT_string (node->die, DW_AT_MIPS_linkage_name,
18429 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
18430 move_linkage_attr (node->die);
18434 deferred_asm_name = NULL;
18436 /* Walk through the list of incomplete types again, trying once more to
18437 emit full debugging info for them. */
18438 retry_incomplete_types ();
18440 if (flag_eliminate_unused_debug_types)
18441 prune_unused_types ();
18443 /* Generate separate CUs for each of the include files we've seen.
18444 They will go into limbo_die_list. */
18445 if (flag_eliminate_dwarf2_dups)
18446 break_out_includes (comp_unit_die);
18448 /* Traverse the DIE's and add add sibling attributes to those DIE's
18449 that have children. */
18450 add_sibling_attributes (comp_unit_die);
18451 for (node = limbo_die_list; node; node = node->next)
18452 add_sibling_attributes (node->die);
18454 /* Output a terminator label for the .text section. */
18455 switch_to_section (text_section);
18456 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
18457 if (flag_reorder_blocks_and_partition)
18459 switch_to_section (unlikely_text_section ());
18460 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
18463 /* We can only use the low/high_pc attributes if all of the code was
18465 if (!have_multiple_function_sections)
18467 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
18468 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
18473 unsigned fde_idx = 0;
18475 /* We need to give .debug_loc and .debug_ranges an appropriate
18476 "base address". Use zero so that these addresses become
18477 absolute. Historically, we've emitted the unexpected
18478 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
18479 Emit both to give time for other tools to adapt. */
18480 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
18481 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
18483 add_AT_range_list (comp_unit_die, DW_AT_ranges,
18484 add_ranges_by_labels (text_section_label,
18486 if (flag_reorder_blocks_and_partition)
18487 add_ranges_by_labels (cold_text_section_label,
18490 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
18492 dw_fde_ref fde = &fde_table[fde_idx];
18494 if (fde->dw_fde_switched_sections)
18496 if (!fde->in_std_section)
18497 add_ranges_by_labels (fde->dw_fde_hot_section_label,
18498 fde->dw_fde_hot_section_end_label);
18499 if (!fde->cold_in_std_section)
18500 add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
18501 fde->dw_fde_unlikely_section_end_label);
18503 else if (!fde->in_std_section)
18504 add_ranges_by_labels (fde->dw_fde_begin,
18511 /* Output location list section if necessary. */
18512 if (have_location_lists)
18514 /* Output the location lists info. */
18515 switch_to_section (debug_loc_section);
18516 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
18517 DEBUG_LOC_SECTION_LABEL, 0);
18518 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
18519 output_location_lists (die);
18522 if (debug_info_level >= DINFO_LEVEL_NORMAL)
18523 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
18524 debug_line_section_label);
18526 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18527 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
18529 /* Output all of the compilation units. We put the main one last so that
18530 the offsets are available to output_pubnames. */
18531 for (node = limbo_die_list; node; node = node->next)
18532 output_comp_unit (node->die, 0);
18534 /* Output the main compilation unit if non-empty or if .debug_macinfo
18535 has been emitted. */
18536 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
18538 /* Output the abbreviation table. */
18539 switch_to_section (debug_abbrev_section);
18540 output_abbrev_section ();
18542 /* Output public names table if necessary. */
18543 if (!VEC_empty (pubname_entry, pubname_table))
18545 switch_to_section (debug_pubnames_section);
18546 output_pubnames (pubname_table);
18549 /* Output public types table if necessary. */
18550 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
18551 It shouldn't hurt to emit it always, since pure DWARF2 consumers
18552 simply won't look for the section. */
18553 if (!VEC_empty (pubname_entry, pubtype_table))
18555 switch_to_section (debug_pubtypes_section);
18556 output_pubnames (pubtype_table);
18559 /* Output the address range information. We only put functions in the arange
18560 table, so don't write it out if we don't have any. */
18561 if (fde_table_in_use)
18563 switch_to_section (debug_aranges_section);
18567 /* Output ranges section if necessary. */
18568 if (ranges_table_in_use)
18570 switch_to_section (debug_ranges_section);
18571 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
18575 /* Output the source line correspondence table. We must do this
18576 even if there is no line information. Otherwise, on an empty
18577 translation unit, we will generate a present, but empty,
18578 .debug_info section. IRIX 6.5 `nm' will then complain when
18579 examining the file. This is done late so that any filenames
18580 used by the debug_info section are marked as 'used'. */
18581 if (! DWARF2_ASM_LINE_DEBUG_INFO)
18583 switch_to_section (debug_line_section);
18584 output_line_info ();
18587 /* Have to end the macro section. */
18588 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
18590 switch_to_section (debug_macinfo_section);
18591 dw2_asm_output_data (1, 0, "End compilation unit");
18594 /* If we emitted any DW_FORM_strp form attribute, output the string
18596 if (debug_str_hash)
18597 htab_traverse (debug_str_hash, output_indirect_string, NULL);
18601 /* This should never be used, but its address is needed for comparisons. */
18602 const struct gcc_debug_hooks dwarf2_debug_hooks =
18608 0, /* start_source_file */
18609 0, /* end_source_file */
18610 0, /* begin_block */
18612 0, /* ignore_block */
18613 0, /* source_line */
18614 0, /* begin_prologue */
18615 0, /* end_prologue */
18616 0, /* end_epilogue */
18617 0, /* begin_function */
18618 0, /* end_function */
18619 0, /* function_decl */
18620 0, /* global_decl */
18622 0, /* imported_module_or_decl */
18623 0, /* deferred_inline_function */
18624 0, /* outlining_inline_function */
18626 0, /* handle_pch */
18627 0, /* var_location */
18628 0, /* switch_text_section */
18630 0 /* start_end_main_source_file */
18633 #endif /* DWARF2_DEBUGGING_INFO */
18635 #include "gt-dwarf2out.h"