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);
97 #ifndef DWARF2_FRAME_INFO
98 # ifdef DWARF2_DEBUGGING_INFO
99 # define DWARF2_FRAME_INFO \
100 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
102 # define DWARF2_FRAME_INFO 0
106 /* Map register numbers held in the call frame info that gcc has
107 collected using DWARF_FRAME_REGNUM to those that should be output in
108 .debug_frame and .eh_frame. */
109 #ifndef DWARF2_FRAME_REG_OUT
110 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
113 /* Save the result of dwarf2out_do_frame across PCH. */
114 static GTY(()) bool saved_do_cfi_asm = 0;
116 /* Decide whether we want to emit frame unwind information for the current
120 dwarf2out_do_frame (void)
122 /* We want to emit correct CFA location expressions or lists, so we
123 have to return true if we're going to output debug info, even if
124 we're not going to output frame or unwind info. */
125 return (write_symbols == DWARF2_DEBUG
126 || write_symbols == VMS_AND_DWARF2_DEBUG
127 || DWARF2_FRAME_INFO || saved_do_cfi_asm
128 #ifdef DWARF2_UNWIND_INFO
129 || (DWARF2_UNWIND_INFO
130 && (flag_unwind_tables
131 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
136 /* Decide whether to emit frame unwind via assembler directives. */
139 dwarf2out_do_cfi_asm (void)
143 #ifdef MIPS_DEBUGGING_INFO
146 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
148 if (saved_do_cfi_asm || !eh_personality_libfunc)
150 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
153 /* Make sure the personality encoding is one the assembler can support.
154 In particular, aligned addresses can't be handled. */
155 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
156 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
158 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
159 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
162 saved_do_cfi_asm = true;
166 /* The size of the target's pointer type. */
168 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
171 /* Array of RTXes referenced by the debugging information, which therefore
172 must be kept around forever. */
173 static GTY(()) VEC(rtx,gc) *used_rtx_array;
175 /* A pointer to the base of a list of incomplete types which might be
176 completed at some later time. incomplete_types_list needs to be a
177 VEC(tree,gc) because we want to tell the garbage collector about
179 static GTY(()) VEC(tree,gc) *incomplete_types;
181 /* A pointer to the base of a table of references to declaration
182 scopes. This table is a display which tracks the nesting
183 of declaration scopes at the current scope and containing
184 scopes. This table is used to find the proper place to
185 define type declaration DIE's. */
186 static GTY(()) VEC(tree,gc) *decl_scope_table;
188 /* Pointers to various DWARF2 sections. */
189 static GTY(()) section *debug_info_section;
190 static GTY(()) section *debug_abbrev_section;
191 static GTY(()) section *debug_aranges_section;
192 static GTY(()) section *debug_macinfo_section;
193 static GTY(()) section *debug_line_section;
194 static GTY(()) section *debug_loc_section;
195 static GTY(()) section *debug_pubnames_section;
196 static GTY(()) section *debug_pubtypes_section;
197 static GTY(()) section *debug_str_section;
198 static GTY(()) section *debug_ranges_section;
199 static GTY(()) section *debug_frame_section;
201 /* How to start an assembler comment. */
202 #ifndef ASM_COMMENT_START
203 #define ASM_COMMENT_START ";#"
206 typedef struct dw_cfi_struct *dw_cfi_ref;
207 typedef struct dw_fde_struct *dw_fde_ref;
208 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
210 /* Call frames are described using a sequence of Call Frame
211 Information instructions. The register number, offset
212 and address fields are provided as possible operands;
213 their use is selected by the opcode field. */
215 enum dw_cfi_oprnd_type {
217 dw_cfi_oprnd_reg_num,
223 typedef union GTY(()) dw_cfi_oprnd_struct {
224 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
225 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
226 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
227 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
231 typedef struct GTY(()) dw_cfi_struct {
232 dw_cfi_ref dw_cfi_next;
233 enum dwarf_call_frame_info dw_cfi_opc;
234 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
236 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
241 /* This is how we define the location of the CFA. We use to handle it
242 as REG + OFFSET all the time, but now it can be more complex.
243 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
244 Instead of passing around REG and OFFSET, we pass a copy
245 of this structure. */
246 typedef struct GTY(()) cfa_loc {
247 HOST_WIDE_INT offset;
248 HOST_WIDE_INT base_offset;
250 BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
251 BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
254 /* All call frame descriptions (FDE's) in the GCC generated DWARF
255 refer to a single Common Information Entry (CIE), defined at
256 the beginning of the .debug_frame section. This use of a single
257 CIE obviates the need to keep track of multiple CIE's
258 in the DWARF generation routines below. */
260 typedef struct GTY(()) dw_fde_struct {
262 const char *dw_fde_begin;
263 const char *dw_fde_current_label;
264 const char *dw_fde_end;
265 const char *dw_fde_hot_section_label;
266 const char *dw_fde_hot_section_end_label;
267 const char *dw_fde_unlikely_section_label;
268 const char *dw_fde_unlikely_section_end_label;
269 bool dw_fde_switched_sections;
270 dw_cfi_ref dw_fde_cfi;
271 unsigned funcdef_number;
272 HOST_WIDE_INT stack_realignment;
273 /* Dynamic realign argument pointer register. */
274 unsigned int drap_reg;
275 /* Virtual dynamic realign argument pointer register. */
276 unsigned int vdrap_reg;
277 unsigned all_throwers_are_sibcalls : 1;
278 unsigned nothrow : 1;
279 unsigned uses_eh_lsda : 1;
280 /* Whether we did stack realign in this call frame. */
281 unsigned stack_realign : 1;
282 /* Whether dynamic realign argument pointer register has been saved. */
283 unsigned drap_reg_saved: 1;
287 /* Maximum size (in bytes) of an artificially generated label. */
288 #define MAX_ARTIFICIAL_LABEL_BYTES 30
290 /* The size of addresses as they appear in the Dwarf 2 data.
291 Some architectures use word addresses to refer to code locations,
292 but Dwarf 2 info always uses byte addresses. On such machines,
293 Dwarf 2 addresses need to be larger than the architecture's
295 #ifndef DWARF2_ADDR_SIZE
296 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
299 /* The size in bytes of a DWARF field indicating an offset or length
300 relative to a debug info section, specified to be 4 bytes in the
301 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
304 #ifndef DWARF_OFFSET_SIZE
305 #define DWARF_OFFSET_SIZE 4
308 /* According to the (draft) DWARF 3 specification, the initial length
309 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
310 bytes are 0xffffffff, followed by the length stored in the next 8
313 However, the SGI/MIPS ABI uses an initial length which is equal to
314 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
316 #ifndef DWARF_INITIAL_LENGTH_SIZE
317 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
320 #define DWARF_VERSION 2
322 /* Round SIZE up to the nearest BOUNDARY. */
323 #define DWARF_ROUND(SIZE,BOUNDARY) \
324 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
326 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
327 #ifndef DWARF_CIE_DATA_ALIGNMENT
328 #ifdef STACK_GROWS_DOWNWARD
329 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
331 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
335 /* CIE identifier. */
336 #if HOST_BITS_PER_WIDE_INT >= 64
337 #define DWARF_CIE_ID \
338 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
340 #define DWARF_CIE_ID DW_CIE_ID
343 /* A pointer to the base of a table that contains frame description
344 information for each routine. */
345 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
347 /* Number of elements currently allocated for fde_table. */
348 static GTY(()) unsigned fde_table_allocated;
350 /* Number of elements in fde_table currently in use. */
351 static GTY(()) unsigned fde_table_in_use;
353 /* Size (in elements) of increments by which we may expand the
355 #define FDE_TABLE_INCREMENT 256
357 /* Get the current fde_table entry we should use. */
359 static inline dw_fde_ref
362 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
365 /* A list of call frame insns for the CIE. */
366 static GTY(()) dw_cfi_ref cie_cfi_head;
368 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
369 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
370 attribute that accelerates the lookup of the FDE associated
371 with the subprogram. This variable holds the table index of the FDE
372 associated with the current function (body) definition. */
373 static unsigned current_funcdef_fde;
376 struct GTY(()) indirect_string_node {
378 unsigned int refcount;
379 enum dwarf_form form;
383 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
385 static GTY(()) int dw2_string_counter;
386 static GTY(()) unsigned long dwarf2out_cfi_label_num;
388 /* True if the compilation unit places functions in more than one section. */
389 static GTY(()) bool have_multiple_function_sections = false;
391 /* Whether the default text and cold text sections have been used at all. */
393 static GTY(()) bool text_section_used = false;
394 static GTY(()) bool cold_text_section_used = false;
396 /* The default cold text section. */
397 static GTY(()) section *cold_text_section;
399 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
401 /* Forward declarations for functions defined in this file. */
403 static char *stripattributes (const char *);
404 static const char *dwarf_cfi_name (unsigned);
405 static dw_cfi_ref new_cfi (void);
406 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
407 static void add_fde_cfi (const char *, dw_cfi_ref);
408 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
409 static void lookup_cfa (dw_cfa_location *);
410 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
411 #ifdef DWARF2_UNWIND_INFO
412 static void initial_return_save (rtx);
414 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
416 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
417 static void output_cfi_directive (dw_cfi_ref);
418 static void output_call_frame_info (int);
419 static void dwarf2out_note_section_used (void);
420 static void dwarf2out_stack_adjust (rtx, bool);
421 static void dwarf2out_args_size_adjust (HOST_WIDE_INT, const char *);
422 static void flush_queued_reg_saves (void);
423 static bool clobbers_queued_reg_save (const_rtx);
424 static void dwarf2out_frame_debug_expr (rtx, const char *);
426 /* Support for complex CFA locations. */
427 static void output_cfa_loc (dw_cfi_ref);
428 static void output_cfa_loc_raw (dw_cfi_ref);
429 static void get_cfa_from_loc_descr (dw_cfa_location *,
430 struct dw_loc_descr_struct *);
431 static struct dw_loc_descr_struct *build_cfa_loc
432 (dw_cfa_location *, HOST_WIDE_INT);
433 static struct dw_loc_descr_struct *build_cfa_aligned_loc
434 (HOST_WIDE_INT, HOST_WIDE_INT);
435 static void def_cfa_1 (const char *, dw_cfa_location *);
437 /* How to start an assembler comment. */
438 #ifndef ASM_COMMENT_START
439 #define ASM_COMMENT_START ";#"
442 /* Data and reference forms for relocatable data. */
443 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
444 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
446 #ifndef DEBUG_FRAME_SECTION
447 #define DEBUG_FRAME_SECTION ".debug_frame"
450 #ifndef FUNC_BEGIN_LABEL
451 #define FUNC_BEGIN_LABEL "LFB"
454 #ifndef FUNC_END_LABEL
455 #define FUNC_END_LABEL "LFE"
458 #ifndef FRAME_BEGIN_LABEL
459 #define FRAME_BEGIN_LABEL "Lframe"
461 #define CIE_AFTER_SIZE_LABEL "LSCIE"
462 #define CIE_END_LABEL "LECIE"
463 #define FDE_LABEL "LSFDE"
464 #define FDE_AFTER_SIZE_LABEL "LASFDE"
465 #define FDE_END_LABEL "LEFDE"
466 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
467 #define LINE_NUMBER_END_LABEL "LELT"
468 #define LN_PROLOG_AS_LABEL "LASLTP"
469 #define LN_PROLOG_END_LABEL "LELTP"
470 #define DIE_LABEL_PREFIX "DW"
472 /* The DWARF 2 CFA column which tracks the return address. Normally this
473 is the column for PC, or the first column after all of the hard
475 #ifndef DWARF_FRAME_RETURN_COLUMN
477 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
479 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
483 /* The mapping from gcc register number to DWARF 2 CFA column number. By
484 default, we just provide columns for all registers. */
485 #ifndef DWARF_FRAME_REGNUM
486 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
489 /* Hook used by __throw. */
492 expand_builtin_dwarf_sp_column (void)
494 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
495 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
498 /* Return a pointer to a copy of the section string name S with all
499 attributes stripped off, and an asterisk prepended (for assemble_name). */
502 stripattributes (const char *s)
504 char *stripped = XNEWVEC (char, strlen (s) + 2);
509 while (*s && *s != ',')
516 /* MEM is a memory reference for the register size table, each element of
517 which has mode MODE. Initialize column C as a return address column. */
520 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
522 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
523 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
524 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
527 /* Generate code to initialize the register size table. */
530 expand_builtin_init_dwarf_reg_sizes (tree address)
533 enum machine_mode mode = TYPE_MODE (char_type_node);
534 rtx addr = expand_normal (address);
535 rtx mem = gen_rtx_MEM (BLKmode, addr);
536 bool wrote_return_column = false;
538 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
540 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
542 if (rnum < DWARF_FRAME_REGISTERS)
544 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
545 enum machine_mode save_mode = reg_raw_mode[i];
548 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
549 save_mode = choose_hard_reg_mode (i, 1, true);
550 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
552 if (save_mode == VOIDmode)
554 wrote_return_column = true;
556 size = GET_MODE_SIZE (save_mode);
560 emit_move_insn (adjust_address (mem, mode, offset),
561 gen_int_mode (size, mode));
565 if (!wrote_return_column)
566 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
568 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
569 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
572 targetm.init_dwarf_reg_sizes_extra (address);
575 /* Convert a DWARF call frame info. operation to its string name */
578 dwarf_cfi_name (unsigned int cfi_opc)
582 case DW_CFA_advance_loc:
583 return "DW_CFA_advance_loc";
585 return "DW_CFA_offset";
587 return "DW_CFA_restore";
591 return "DW_CFA_set_loc";
592 case DW_CFA_advance_loc1:
593 return "DW_CFA_advance_loc1";
594 case DW_CFA_advance_loc2:
595 return "DW_CFA_advance_loc2";
596 case DW_CFA_advance_loc4:
597 return "DW_CFA_advance_loc4";
598 case DW_CFA_offset_extended:
599 return "DW_CFA_offset_extended";
600 case DW_CFA_restore_extended:
601 return "DW_CFA_restore_extended";
602 case DW_CFA_undefined:
603 return "DW_CFA_undefined";
604 case DW_CFA_same_value:
605 return "DW_CFA_same_value";
606 case DW_CFA_register:
607 return "DW_CFA_register";
608 case DW_CFA_remember_state:
609 return "DW_CFA_remember_state";
610 case DW_CFA_restore_state:
611 return "DW_CFA_restore_state";
613 return "DW_CFA_def_cfa";
614 case DW_CFA_def_cfa_register:
615 return "DW_CFA_def_cfa_register";
616 case DW_CFA_def_cfa_offset:
617 return "DW_CFA_def_cfa_offset";
620 case DW_CFA_def_cfa_expression:
621 return "DW_CFA_def_cfa_expression";
622 case DW_CFA_expression:
623 return "DW_CFA_expression";
624 case DW_CFA_offset_extended_sf:
625 return "DW_CFA_offset_extended_sf";
626 case DW_CFA_def_cfa_sf:
627 return "DW_CFA_def_cfa_sf";
628 case DW_CFA_def_cfa_offset_sf:
629 return "DW_CFA_def_cfa_offset_sf";
631 /* SGI/MIPS specific */
632 case DW_CFA_MIPS_advance_loc8:
633 return "DW_CFA_MIPS_advance_loc8";
636 case DW_CFA_GNU_window_save:
637 return "DW_CFA_GNU_window_save";
638 case DW_CFA_GNU_args_size:
639 return "DW_CFA_GNU_args_size";
640 case DW_CFA_GNU_negative_offset_extended:
641 return "DW_CFA_GNU_negative_offset_extended";
644 return "DW_CFA_<unknown>";
648 /* Return a pointer to a newly allocated Call Frame Instruction. */
650 static inline dw_cfi_ref
653 dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
655 cfi->dw_cfi_next = NULL;
656 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
657 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
662 /* Add a Call Frame Instruction to list of instructions. */
665 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
668 dw_fde_ref fde = current_fde ();
670 /* When DRAP is used, CFA is defined with an expression. Redefine
671 CFA may lead to a different CFA value. */
672 /* ??? Of course, this heuristic fails when we're annotating epilogues,
673 because of course we'll always want to redefine the CFA back to the
674 stack pointer on the way out. Where should we move this check? */
675 if (0 && fde && fde->drap_reg != INVALID_REGNUM)
676 switch (cfi->dw_cfi_opc)
678 case DW_CFA_def_cfa_register:
679 case DW_CFA_def_cfa_offset:
680 case DW_CFA_def_cfa_offset_sf:
682 case DW_CFA_def_cfa_sf:
689 /* Find the end of the chain. */
690 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
696 /* Generate a new label for the CFI info to refer to. FORCE is true
697 if a label needs to be output even when using .cfi_* directives. */
700 dwarf2out_cfi_label (bool force)
702 static char label[20];
704 if (!force && dwarf2out_do_cfi_asm ())
706 /* In this case, we will be emitting the asm directive instead of
707 the label, so just return a placeholder to keep the rest of the
709 strcpy (label, "<do not output>");
713 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
714 ASM_OUTPUT_LABEL (asm_out_file, label);
720 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
721 or to the CIE if LABEL is NULL. */
724 add_fde_cfi (const char *label, dw_cfi_ref cfi)
726 dw_cfi_ref *list_head = &cie_cfi_head;
728 if (dwarf2out_do_cfi_asm ())
732 dw_fde_ref fde = current_fde ();
734 gcc_assert (fde != NULL);
736 /* We still have to add the cfi to the list so that
737 lookup_cfa works later on. When -g2 and above we
738 even need to force emitting of CFI labels and
739 add to list a DW_CFA_set_loc for convert_cfa_to_fb_loc_list
741 switch (cfi->dw_cfi_opc)
743 case DW_CFA_def_cfa_offset:
744 case DW_CFA_def_cfa_offset_sf:
745 case DW_CFA_def_cfa_register:
747 case DW_CFA_def_cfa_sf:
748 case DW_CFA_def_cfa_expression:
749 case DW_CFA_restore_state:
750 if (write_symbols != DWARF2_DEBUG
751 && write_symbols != VMS_AND_DWARF2_DEBUG)
753 if (debug_info_level <= DINFO_LEVEL_TERSE)
756 if (*label == 0 || strcmp (label, "<do not output>") == 0)
757 label = dwarf2out_cfi_label (true);
759 if (fde->dw_fde_current_label == NULL
760 || strcmp (label, fde->dw_fde_current_label) != 0)
764 label = xstrdup (label);
766 /* Set the location counter to the new label. */
768 /* It doesn't metter whether DW_CFA_set_loc
769 or DW_CFA_advance_loc4 is added here, those aren't
770 emitted into assembly, only looked up by
771 convert_cfa_to_fb_loc_list. */
772 xcfi->dw_cfi_opc = DW_CFA_set_loc;
773 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
774 add_cfi (&fde->dw_fde_cfi, xcfi);
775 fde->dw_fde_current_label = label;
782 output_cfi_directive (cfi);
784 list_head = &fde->dw_fde_cfi;
786 /* ??? If this is a CFI for the CIE, we don't emit. This
787 assumes that the standard CIE contents that the assembler
788 uses matches the standard CIE contents that the compiler
789 uses. This is probably a bad assumption. I'm not quite
790 sure how to address this for now. */
794 dw_fde_ref fde = current_fde ();
796 gcc_assert (fde != NULL);
799 label = dwarf2out_cfi_label (false);
801 if (fde->dw_fde_current_label == NULL
802 || strcmp (label, fde->dw_fde_current_label) != 0)
806 label = xstrdup (label);
808 /* Set the location counter to the new label. */
810 /* If we have a current label, advance from there, otherwise
811 set the location directly using set_loc. */
812 xcfi->dw_cfi_opc = fde->dw_fde_current_label
813 ? DW_CFA_advance_loc4
815 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
816 add_cfi (&fde->dw_fde_cfi, xcfi);
818 fde->dw_fde_current_label = label;
821 list_head = &fde->dw_fde_cfi;
824 add_cfi (list_head, cfi);
827 /* Subroutine of lookup_cfa. */
830 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
832 switch (cfi->dw_cfi_opc)
834 case DW_CFA_def_cfa_offset:
835 case DW_CFA_def_cfa_offset_sf:
836 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
838 case DW_CFA_def_cfa_register:
839 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
842 case DW_CFA_def_cfa_sf:
843 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
844 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
846 case DW_CFA_def_cfa_expression:
847 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
850 case DW_CFA_remember_state:
851 gcc_assert (!remember->in_use);
853 remember->in_use = 1;
855 case DW_CFA_restore_state:
856 gcc_assert (remember->in_use);
858 remember->in_use = 0;
866 /* Find the previous value for the CFA. */
869 lookup_cfa (dw_cfa_location *loc)
873 dw_cfa_location remember;
875 memset (loc, 0, sizeof (*loc));
876 loc->reg = INVALID_REGNUM;
879 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
880 lookup_cfa_1 (cfi, loc, &remember);
882 fde = current_fde ();
884 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
885 lookup_cfa_1 (cfi, loc, &remember);
888 /* The current rule for calculating the DWARF2 canonical frame address. */
889 static dw_cfa_location cfa;
891 /* The register used for saving registers to the stack, and its offset
893 static dw_cfa_location cfa_store;
895 /* The current save location around an epilogue. */
896 static dw_cfa_location cfa_remember;
898 /* The running total of the size of arguments pushed onto the stack. */
899 static HOST_WIDE_INT args_size;
901 /* The last args_size we actually output. */
902 static HOST_WIDE_INT old_args_size;
904 /* Entry point to update the canonical frame address (CFA).
905 LABEL is passed to add_fde_cfi. The value of CFA is now to be
906 calculated from REG+OFFSET. */
909 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
916 def_cfa_1 (label, &loc);
919 /* Determine if two dw_cfa_location structures define the same data. */
922 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
924 return (loc1->reg == loc2->reg
925 && loc1->offset == loc2->offset
926 && loc1->indirect == loc2->indirect
927 && (loc1->indirect == 0
928 || loc1->base_offset == loc2->base_offset));
931 /* This routine does the actual work. The CFA is now calculated from
932 the dw_cfa_location structure. */
935 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
938 dw_cfa_location old_cfa, loc;
943 if (cfa_store.reg == loc.reg && loc.indirect == 0)
944 cfa_store.offset = loc.offset;
946 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
947 lookup_cfa (&old_cfa);
949 /* If nothing changed, no need to issue any call frame instructions. */
950 if (cfa_equal_p (&loc, &old_cfa))
955 if (loc.reg == old_cfa.reg && !loc.indirect)
957 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
958 the CFA register did not change but the offset did. The data
959 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
960 in the assembler via the .cfi_def_cfa_offset directive. */
962 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
964 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
965 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
968 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
969 else if (loc.offset == old_cfa.offset
970 && old_cfa.reg != INVALID_REGNUM
973 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
974 indicating the CFA register has changed to <register> but the
975 offset has not changed. */
976 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
977 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
981 else if (loc.indirect == 0)
983 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
984 indicating the CFA register has changed to <register> with
985 the specified offset. The data factoring for DW_CFA_def_cfa_sf
986 happens in output_cfi, or in the assembler via the .cfi_def_cfa
989 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
991 cfi->dw_cfi_opc = DW_CFA_def_cfa;
992 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
993 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
997 /* Construct a DW_CFA_def_cfa_expression instruction to
998 calculate the CFA using a full location expression since no
999 register-offset pair is available. */
1000 struct dw_loc_descr_struct *loc_list;
1002 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1003 loc_list = build_cfa_loc (&loc, 0);
1004 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1007 add_fde_cfi (label, cfi);
1010 /* Add the CFI for saving a register. REG is the CFA column number.
1011 LABEL is passed to add_fde_cfi.
1012 If SREG is -1, the register is saved at OFFSET from the CFA;
1013 otherwise it is saved in SREG. */
1016 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1018 dw_cfi_ref cfi = new_cfi ();
1019 dw_fde_ref fde = current_fde ();
1021 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1023 /* When stack is aligned, store REG using DW_CFA_expression with
1026 && fde->stack_realign
1027 && sreg == INVALID_REGNUM)
1029 cfi->dw_cfi_opc = DW_CFA_expression;
1030 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = reg;
1031 cfi->dw_cfi_oprnd1.dw_cfi_loc
1032 = build_cfa_aligned_loc (offset, fde->stack_realignment);
1034 else if (sreg == INVALID_REGNUM)
1037 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1038 else if (reg & ~0x3f)
1039 cfi->dw_cfi_opc = DW_CFA_offset_extended;
1041 cfi->dw_cfi_opc = DW_CFA_offset;
1042 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1044 else if (sreg == reg)
1045 cfi->dw_cfi_opc = DW_CFA_same_value;
1048 cfi->dw_cfi_opc = DW_CFA_register;
1049 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1052 add_fde_cfi (label, cfi);
1055 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1056 This CFI tells the unwinder that it needs to restore the window registers
1057 from the previous frame's window save area.
1059 ??? Perhaps we should note in the CIE where windows are saved (instead of
1060 assuming 0(cfa)) and what registers are in the window. */
1063 dwarf2out_window_save (const char *label)
1065 dw_cfi_ref cfi = new_cfi ();
1067 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1068 add_fde_cfi (label, cfi);
1071 /* Add a CFI to update the running total of the size of arguments
1072 pushed onto the stack. */
1075 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1079 if (size == old_args_size)
1082 old_args_size = size;
1085 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1086 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1087 add_fde_cfi (label, cfi);
1090 /* Entry point for saving a register to the stack. REG is the GCC register
1091 number. LABEL and OFFSET are passed to reg_save. */
1094 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1096 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1099 /* Entry point for saving the return address in the stack.
1100 LABEL and OFFSET are passed to reg_save. */
1103 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1105 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1108 /* Entry point for saving the return address in a register.
1109 LABEL and SREG are passed to reg_save. */
1112 dwarf2out_return_reg (const char *label, unsigned int sreg)
1114 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1117 #ifdef DWARF2_UNWIND_INFO
1118 /* Record the initial position of the return address. RTL is
1119 INCOMING_RETURN_ADDR_RTX. */
1122 initial_return_save (rtx rtl)
1124 unsigned int reg = INVALID_REGNUM;
1125 HOST_WIDE_INT offset = 0;
1127 switch (GET_CODE (rtl))
1130 /* RA is in a register. */
1131 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1135 /* RA is on the stack. */
1136 rtl = XEXP (rtl, 0);
1137 switch (GET_CODE (rtl))
1140 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1145 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1146 offset = INTVAL (XEXP (rtl, 1));
1150 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1151 offset = -INTVAL (XEXP (rtl, 1));
1161 /* The return address is at some offset from any value we can
1162 actually load. For instance, on the SPARC it is in %i7+8. Just
1163 ignore the offset for now; it doesn't matter for unwinding frames. */
1164 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1165 initial_return_save (XEXP (rtl, 0));
1172 if (reg != DWARF_FRAME_RETURN_COLUMN)
1173 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1177 /* Given a SET, calculate the amount of stack adjustment it
1180 static HOST_WIDE_INT
1181 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1182 HOST_WIDE_INT cur_offset)
1184 const_rtx src = SET_SRC (pattern);
1185 const_rtx dest = SET_DEST (pattern);
1186 HOST_WIDE_INT offset = 0;
1189 if (dest == stack_pointer_rtx)
1191 code = GET_CODE (src);
1193 /* Assume (set (reg sp) (reg whatever)) sets args_size
1195 if (code == REG && src != stack_pointer_rtx)
1197 offset = -cur_args_size;
1198 #ifndef STACK_GROWS_DOWNWARD
1201 return offset - cur_offset;
1204 if (! (code == PLUS || code == MINUS)
1205 || XEXP (src, 0) != stack_pointer_rtx
1206 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1209 /* (set (reg sp) (plus (reg sp) (const_int))) */
1210 offset = INTVAL (XEXP (src, 1));
1216 if (MEM_P (src) && !MEM_P (dest))
1220 /* (set (mem (pre_dec (reg sp))) (foo)) */
1221 src = XEXP (dest, 0);
1222 code = GET_CODE (src);
1228 if (XEXP (src, 0) == stack_pointer_rtx)
1230 rtx val = XEXP (XEXP (src, 1), 1);
1231 /* We handle only adjustments by constant amount. */
1232 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1233 && GET_CODE (val) == CONST_INT);
1234 offset = -INTVAL (val);
1241 if (XEXP (src, 0) == stack_pointer_rtx)
1243 offset = GET_MODE_SIZE (GET_MODE (dest));
1250 if (XEXP (src, 0) == stack_pointer_rtx)
1252 offset = -GET_MODE_SIZE (GET_MODE (dest));
1267 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1268 indexed by INSN_UID. */
1270 static HOST_WIDE_INT *barrier_args_size;
1272 /* Helper function for compute_barrier_args_size. Handle one insn. */
1274 static HOST_WIDE_INT
1275 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1276 VEC (rtx, heap) **next)
1278 HOST_WIDE_INT offset = 0;
1281 if (! RTX_FRAME_RELATED_P (insn))
1283 if (prologue_epilogue_contains (insn))
1285 else if (GET_CODE (PATTERN (insn)) == SET)
1286 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1287 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1288 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1290 /* There may be stack adjustments inside compound insns. Search
1292 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1293 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1294 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1295 cur_args_size, offset);
1300 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1304 expr = XEXP (expr, 0);
1305 if (GET_CODE (expr) == PARALLEL
1306 || GET_CODE (expr) == SEQUENCE)
1307 for (i = 1; i < XVECLEN (expr, 0); i++)
1309 rtx elem = XVECEXP (expr, 0, i);
1311 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1312 offset += stack_adjust_offset (elem, cur_args_size, offset);
1317 #ifndef STACK_GROWS_DOWNWARD
1321 cur_args_size += offset;
1322 if (cur_args_size < 0)
1327 rtx dest = JUMP_LABEL (insn);
1331 if (barrier_args_size [INSN_UID (dest)] < 0)
1333 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1334 VEC_safe_push (rtx, heap, *next, dest);
1339 return cur_args_size;
1342 /* Walk the whole function and compute args_size on BARRIERs. */
1345 compute_barrier_args_size (void)
1347 int max_uid = get_max_uid (), i;
1349 VEC (rtx, heap) *worklist, *next, *tmp;
1351 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1352 for (i = 0; i < max_uid; i++)
1353 barrier_args_size[i] = -1;
1355 worklist = VEC_alloc (rtx, heap, 20);
1356 next = VEC_alloc (rtx, heap, 20);
1357 insn = get_insns ();
1358 barrier_args_size[INSN_UID (insn)] = 0;
1359 VEC_quick_push (rtx, worklist, insn);
1362 while (!VEC_empty (rtx, worklist))
1364 rtx prev, body, first_insn;
1365 HOST_WIDE_INT cur_args_size;
1367 first_insn = insn = VEC_pop (rtx, worklist);
1368 cur_args_size = barrier_args_size[INSN_UID (insn)];
1369 prev = prev_nonnote_insn (insn);
1370 if (prev && BARRIER_P (prev))
1371 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1373 for (; insn; insn = NEXT_INSN (insn))
1375 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1377 if (BARRIER_P (insn))
1382 if (insn == first_insn)
1384 else if (barrier_args_size[INSN_UID (insn)] < 0)
1386 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1391 /* The insns starting with this label have been
1392 already scanned or are in the worklist. */
1397 body = PATTERN (insn);
1398 if (GET_CODE (body) == SEQUENCE)
1400 HOST_WIDE_INT dest_args_size = cur_args_size;
1401 for (i = 1; i < XVECLEN (body, 0); i++)
1402 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1403 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1405 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1406 dest_args_size, &next);
1409 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1410 cur_args_size, &next);
1412 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1413 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1414 dest_args_size, &next);
1417 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1418 cur_args_size, &next);
1422 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1426 if (VEC_empty (rtx, next))
1429 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1433 VEC_truncate (rtx, next, 0);
1436 VEC_free (rtx, heap, worklist);
1437 VEC_free (rtx, heap, next);
1441 /* Check INSN to see if it looks like a push or a stack adjustment, and
1442 make a note of it if it does. EH uses this information to find out how
1443 much extra space it needs to pop off the stack. */
1446 dwarf2out_stack_adjust (rtx insn, bool after_p)
1448 HOST_WIDE_INT offset;
1452 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1453 with this function. Proper support would require all frame-related
1454 insns to be marked, and to be able to handle saving state around
1455 epilogues textually in the middle of the function. */
1456 if (prologue_epilogue_contains (insn))
1459 /* If INSN is an instruction from target of an annulled branch, the
1460 effects are for the target only and so current argument size
1461 shouldn't change at all. */
1463 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1464 && INSN_FROM_TARGET_P (insn))
1467 /* If only calls can throw, and we have a frame pointer,
1468 save up adjustments until we see the CALL_INSN. */
1469 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1471 if (CALL_P (insn) && !after_p)
1473 /* Extract the size of the args from the CALL rtx itself. */
1474 insn = PATTERN (insn);
1475 if (GET_CODE (insn) == PARALLEL)
1476 insn = XVECEXP (insn, 0, 0);
1477 if (GET_CODE (insn) == SET)
1478 insn = SET_SRC (insn);
1479 gcc_assert (GET_CODE (insn) == CALL);
1480 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1485 if (CALL_P (insn) && !after_p)
1487 if (!flag_asynchronous_unwind_tables)
1488 dwarf2out_args_size ("", args_size);
1491 else if (BARRIER_P (insn))
1493 /* Don't call compute_barrier_args_size () if the only
1494 BARRIER is at the end of function. */
1495 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1496 compute_barrier_args_size ();
1497 if (barrier_args_size == NULL)
1501 offset = barrier_args_size[INSN_UID (insn)];
1506 offset -= args_size;
1507 #ifndef STACK_GROWS_DOWNWARD
1511 else if (GET_CODE (PATTERN (insn)) == SET)
1512 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1513 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1514 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1516 /* There may be stack adjustments inside compound insns. Search
1518 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1519 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1520 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1529 label = dwarf2out_cfi_label (false);
1530 dwarf2out_args_size_adjust (offset, label);
1533 /* Adjust args_size based on stack adjustment OFFSET. */
1536 dwarf2out_args_size_adjust (HOST_WIDE_INT offset, const char *label)
1538 if (cfa.reg == STACK_POINTER_REGNUM)
1539 cfa.offset += offset;
1541 if (cfa_store.reg == STACK_POINTER_REGNUM)
1542 cfa_store.offset += offset;
1544 #ifndef STACK_GROWS_DOWNWARD
1548 args_size += offset;
1552 def_cfa_1 (label, &cfa);
1553 if (flag_asynchronous_unwind_tables)
1554 dwarf2out_args_size (label, args_size);
1559 /* We delay emitting a register save until either (a) we reach the end
1560 of the prologue or (b) the register is clobbered. This clusters
1561 register saves so that there are fewer pc advances. */
1563 struct GTY(()) queued_reg_save {
1564 struct queued_reg_save *next;
1566 HOST_WIDE_INT cfa_offset;
1570 static GTY(()) struct queued_reg_save *queued_reg_saves;
1572 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1573 struct GTY(()) reg_saved_in_data {
1578 /* A list of registers saved in other registers.
1579 The list intentionally has a small maximum capacity of 4; if your
1580 port needs more than that, you might consider implementing a
1581 more efficient data structure. */
1582 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1583 static GTY(()) size_t num_regs_saved_in_regs;
1585 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1586 static const char *last_reg_save_label;
1588 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1589 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1592 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1594 struct queued_reg_save *q;
1596 /* Duplicates waste space, but it's also necessary to remove them
1597 for correctness, since the queue gets output in reverse
1599 for (q = queued_reg_saves; q != NULL; q = q->next)
1600 if (REGNO (q->reg) == REGNO (reg))
1605 q = GGC_NEW (struct queued_reg_save);
1606 q->next = queued_reg_saves;
1607 queued_reg_saves = q;
1611 q->cfa_offset = offset;
1612 q->saved_reg = sreg;
1614 last_reg_save_label = label;
1617 /* Output all the entries in QUEUED_REG_SAVES. */
1620 flush_queued_reg_saves (void)
1622 struct queued_reg_save *q;
1624 for (q = queued_reg_saves; q; q = q->next)
1627 unsigned int reg, sreg;
1629 for (i = 0; i < num_regs_saved_in_regs; i++)
1630 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1632 if (q->saved_reg && i == num_regs_saved_in_regs)
1634 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1635 num_regs_saved_in_regs++;
1637 if (i != num_regs_saved_in_regs)
1639 regs_saved_in_regs[i].orig_reg = q->reg;
1640 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1643 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1645 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1647 sreg = INVALID_REGNUM;
1648 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1651 queued_reg_saves = NULL;
1652 last_reg_save_label = NULL;
1655 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1656 location for? Or, does it clobber a register which we've previously
1657 said that some other register is saved in, and for which we now
1658 have a new location for? */
1661 clobbers_queued_reg_save (const_rtx insn)
1663 struct queued_reg_save *q;
1665 for (q = queued_reg_saves; q; q = q->next)
1668 if (modified_in_p (q->reg, insn))
1670 for (i = 0; i < num_regs_saved_in_regs; i++)
1671 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1672 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1679 /* Entry point for saving the first register into the second. */
1682 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1685 unsigned int regno, sregno;
1687 for (i = 0; i < num_regs_saved_in_regs; i++)
1688 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1690 if (i == num_regs_saved_in_regs)
1692 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1693 num_regs_saved_in_regs++;
1695 regs_saved_in_regs[i].orig_reg = reg;
1696 regs_saved_in_regs[i].saved_in_reg = sreg;
1698 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1699 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1700 reg_save (label, regno, sregno, 0);
1703 /* What register, if any, is currently saved in REG? */
1706 reg_saved_in (rtx reg)
1708 unsigned int regn = REGNO (reg);
1710 struct queued_reg_save *q;
1712 for (q = queued_reg_saves; q; q = q->next)
1713 if (q->saved_reg && regn == REGNO (q->saved_reg))
1716 for (i = 0; i < num_regs_saved_in_regs; i++)
1717 if (regs_saved_in_regs[i].saved_in_reg
1718 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1719 return regs_saved_in_regs[i].orig_reg;
1725 /* A temporary register holding an integral value used in adjusting SP
1726 or setting up the store_reg. The "offset" field holds the integer
1727 value, not an offset. */
1728 static dw_cfa_location cfa_temp;
1730 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1733 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1735 memset (&cfa, 0, sizeof (cfa));
1737 switch (GET_CODE (pat))
1740 cfa.reg = REGNO (XEXP (pat, 0));
1741 cfa.offset = INTVAL (XEXP (pat, 1));
1745 cfa.reg = REGNO (pat);
1749 /* Recurse and define an expression. */
1753 def_cfa_1 (label, &cfa);
1756 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1759 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1763 gcc_assert (GET_CODE (pat) == SET);
1764 dest = XEXP (pat, 0);
1765 src = XEXP (pat, 1);
1767 switch (GET_CODE (src))
1770 gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1771 cfa.offset -= INTVAL (XEXP (src, 1));
1781 cfa.reg = REGNO (dest);
1782 gcc_assert (cfa.indirect == 0);
1784 def_cfa_1 (label, &cfa);
1787 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1790 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1792 HOST_WIDE_INT offset;
1793 rtx src, addr, span;
1795 src = XEXP (set, 1);
1796 addr = XEXP (set, 0);
1797 gcc_assert (MEM_P (addr));
1798 addr = XEXP (addr, 0);
1800 /* As documented, only consider extremely simple addresses. */
1801 switch (GET_CODE (addr))
1804 gcc_assert (REGNO (addr) == cfa.reg);
1805 offset = -cfa.offset;
1808 gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1809 offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1815 span = targetm.dwarf_register_span (src);
1817 /* ??? We'd like to use queue_reg_save, but we need to come up with
1818 a different flushing heuristic for epilogues. */
1820 reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1823 /* We have a PARALLEL describing where the contents of SRC live.
1824 Queue register saves for each piece of the PARALLEL. */
1827 HOST_WIDE_INT span_offset = offset;
1829 gcc_assert (GET_CODE (span) == PARALLEL);
1831 limit = XVECLEN (span, 0);
1832 for (par_index = 0; par_index < limit; par_index++)
1834 rtx elem = XVECEXP (span, 0, par_index);
1836 reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1837 INVALID_REGNUM, span_offset);
1838 span_offset += GET_MODE_SIZE (GET_MODE (elem));
1843 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
1846 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1849 unsigned sregno, dregno;
1851 src = XEXP (set, 1);
1852 dest = XEXP (set, 0);
1855 sregno = DWARF_FRAME_RETURN_COLUMN;
1857 sregno = DWARF_FRAME_REGNUM (REGNO (src));
1859 dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1861 /* ??? We'd like to use queue_reg_save, but we need to come up with
1862 a different flushing heuristic for epilogues. */
1863 reg_save (label, sregno, dregno, 0);
1866 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
1869 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
1871 dw_cfi_ref cfi = new_cfi ();
1872 unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
1874 cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
1875 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
1877 add_fde_cfi (label, cfi);
1880 /* Record call frame debugging information for an expression EXPR,
1881 which either sets SP or FP (adjusting how we calculate the frame
1882 address) or saves a register to the stack or another register.
1883 LABEL indicates the address of EXPR.
1885 This function encodes a state machine mapping rtxes to actions on
1886 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1887 users need not read the source code.
1889 The High-Level Picture
1891 Changes in the register we use to calculate the CFA: Currently we
1892 assume that if you copy the CFA register into another register, we
1893 should take the other one as the new CFA register; this seems to
1894 work pretty well. If it's wrong for some target, it's simple
1895 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1897 Changes in the register we use for saving registers to the stack:
1898 This is usually SP, but not always. Again, we deduce that if you
1899 copy SP into another register (and SP is not the CFA register),
1900 then the new register is the one we will be using for register
1901 saves. This also seems to work.
1903 Register saves: There's not much guesswork about this one; if
1904 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1905 register save, and the register used to calculate the destination
1906 had better be the one we think we're using for this purpose.
1907 It's also assumed that a copy from a call-saved register to another
1908 register is saving that register if RTX_FRAME_RELATED_P is set on
1909 that instruction. If the copy is from a call-saved register to
1910 the *same* register, that means that the register is now the same
1911 value as in the caller.
1913 Except: If the register being saved is the CFA register, and the
1914 offset is nonzero, we are saving the CFA, so we assume we have to
1915 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1916 the intent is to save the value of SP from the previous frame.
1918 In addition, if a register has previously been saved to a different
1921 Invariants / Summaries of Rules
1923 cfa current rule for calculating the CFA. It usually
1924 consists of a register and an offset.
1925 cfa_store register used by prologue code to save things to the stack
1926 cfa_store.offset is the offset from the value of
1927 cfa_store.reg to the actual CFA
1928 cfa_temp register holding an integral value. cfa_temp.offset
1929 stores the value, which will be used to adjust the
1930 stack pointer. cfa_temp is also used like cfa_store,
1931 to track stores to the stack via fp or a temp reg.
1933 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1934 with cfa.reg as the first operand changes the cfa.reg and its
1935 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1938 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1939 expression yielding a constant. This sets cfa_temp.reg
1940 and cfa_temp.offset.
1942 Rule 5: Create a new register cfa_store used to save items to the
1945 Rules 10-14: Save a register to the stack. Define offset as the
1946 difference of the original location and cfa_store's
1947 location (or cfa_temp's location if cfa_temp is used).
1949 Rules 16-20: If AND operation happens on sp in prologue, we assume
1950 stack is realigned. We will use a group of DW_OP_XXX
1951 expressions to represent the location of the stored
1952 register instead of CFA+offset.
1956 "{a,b}" indicates a choice of a xor b.
1957 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1960 (set <reg1> <reg2>:cfa.reg)
1961 effects: cfa.reg = <reg1>
1962 cfa.offset unchanged
1963 cfa_temp.reg = <reg1>
1964 cfa_temp.offset = cfa.offset
1967 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1968 {<const_int>,<reg>:cfa_temp.reg}))
1969 effects: cfa.reg = sp if fp used
1970 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1971 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1972 if cfa_store.reg==sp
1975 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1976 effects: cfa.reg = fp
1977 cfa_offset += +/- <const_int>
1980 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1981 constraints: <reg1> != fp
1983 effects: cfa.reg = <reg1>
1984 cfa_temp.reg = <reg1>
1985 cfa_temp.offset = cfa.offset
1988 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1989 constraints: <reg1> != fp
1991 effects: cfa_store.reg = <reg1>
1992 cfa_store.offset = cfa.offset - cfa_temp.offset
1995 (set <reg> <const_int>)
1996 effects: cfa_temp.reg = <reg>
1997 cfa_temp.offset = <const_int>
2000 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2001 effects: cfa_temp.reg = <reg1>
2002 cfa_temp.offset |= <const_int>
2005 (set <reg> (high <exp>))
2009 (set <reg> (lo_sum <exp> <const_int>))
2010 effects: cfa_temp.reg = <reg>
2011 cfa_temp.offset = <const_int>
2014 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2015 effects: cfa_store.offset -= <const_int>
2016 cfa.offset = cfa_store.offset if cfa.reg == sp
2018 cfa.base_offset = -cfa_store.offset
2021 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2022 effects: cfa_store.offset += -/+ mode_size(mem)
2023 cfa.offset = cfa_store.offset if cfa.reg == sp
2025 cfa.base_offset = -cfa_store.offset
2028 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2031 effects: cfa.reg = <reg1>
2032 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2035 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2036 effects: cfa.reg = <reg1>
2037 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2040 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2041 effects: cfa.reg = <reg1>
2042 cfa.base_offset = -cfa_temp.offset
2043 cfa_temp.offset -= mode_size(mem)
2046 (set <reg> {unspec, unspec_volatile})
2047 effects: target-dependent
2050 (set sp (and: sp <const_int>))
2051 constraints: cfa_store.reg == sp
2052 effects: current_fde.stack_realign = 1
2053 cfa_store.offset = 0
2054 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2057 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2058 effects: cfa_store.offset += -/+ mode_size(mem)
2061 (set (mem ({pre_inc, pre_dec} sp)) fp)
2062 constraints: fde->stack_realign == 1
2063 effects: cfa_store.offset = 0
2064 cfa.reg != HARD_FRAME_POINTER_REGNUM
2067 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2068 constraints: fde->stack_realign == 1
2070 && cfa.indirect == 0
2071 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2072 effects: Use DW_CFA_def_cfa_expression to define cfa
2073 cfa.reg == fde->drap_reg
2076 (set reg fde->drap_reg)
2077 constraints: fde->vdrap_reg == INVALID_REGNUM
2078 effects: fde->vdrap_reg = reg.
2079 (set mem fde->drap_reg)
2080 constraints: fde->drap_reg_saved == 1
2084 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2086 rtx src, dest, span;
2087 HOST_WIDE_INT offset;
2090 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2091 the PARALLEL independently. The first element is always processed if
2092 it is a SET. This is for backward compatibility. Other elements
2093 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2094 flag is set in them. */
2095 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2098 int limit = XVECLEN (expr, 0);
2101 /* PARALLELs have strict read-modify-write semantics, so we
2102 ought to evaluate every rvalue before changing any lvalue.
2103 It's cumbersome to do that in general, but there's an
2104 easy approximation that is enough for all current users:
2105 handle register saves before register assignments. */
2106 if (GET_CODE (expr) == PARALLEL)
2107 for (par_index = 0; par_index < limit; par_index++)
2109 elem = XVECEXP (expr, 0, par_index);
2110 if (GET_CODE (elem) == SET
2111 && MEM_P (SET_DEST (elem))
2112 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2113 dwarf2out_frame_debug_expr (elem, label);
2116 for (par_index = 0; par_index < limit; par_index++)
2118 elem = XVECEXP (expr, 0, par_index);
2119 if (GET_CODE (elem) == SET
2120 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2121 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2122 dwarf2out_frame_debug_expr (elem, label);
2123 else if (GET_CODE (elem) == SET
2125 && !RTX_FRAME_RELATED_P (elem))
2127 /* Stack adjustment combining might combine some post-prologue
2128 stack adjustment into a prologue stack adjustment. */
2129 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2132 dwarf2out_args_size_adjust (offset, label);
2138 gcc_assert (GET_CODE (expr) == SET);
2140 src = SET_SRC (expr);
2141 dest = SET_DEST (expr);
2145 rtx rsi = reg_saved_in (src);
2150 fde = current_fde ();
2152 if (GET_CODE (src) == REG
2154 && fde->drap_reg == REGNO (src)
2155 && (fde->drap_reg_saved
2156 || GET_CODE (dest) == REG))
2159 /* If we are saving dynamic realign argument pointer to a
2160 register, the destination is virtual dynamic realign
2161 argument pointer. It may be used to access argument. */
2162 if (GET_CODE (dest) == REG)
2164 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2165 fde->vdrap_reg = REGNO (dest);
2170 switch (GET_CODE (dest))
2173 switch (GET_CODE (src))
2175 /* Setting FP from SP. */
2177 if (cfa.reg == (unsigned) REGNO (src))
2180 /* Update the CFA rule wrt SP or FP. Make sure src is
2181 relative to the current CFA register.
2183 We used to require that dest be either SP or FP, but the
2184 ARM copies SP to a temporary register, and from there to
2185 FP. So we just rely on the backends to only set
2186 RTX_FRAME_RELATED_P on appropriate insns. */
2187 cfa.reg = REGNO (dest);
2188 cfa_temp.reg = cfa.reg;
2189 cfa_temp.offset = cfa.offset;
2193 /* Saving a register in a register. */
2194 gcc_assert (!fixed_regs [REGNO (dest)]
2195 /* For the SPARC and its register window. */
2196 || (DWARF_FRAME_REGNUM (REGNO (src))
2197 == DWARF_FRAME_RETURN_COLUMN));
2199 /* After stack is aligned, we can only save SP in FP
2200 if drap register is used. In this case, we have
2201 to restore stack pointer with the CFA value and we
2202 don't generate this DWARF information. */
2204 && fde->stack_realign
2205 && REGNO (src) == STACK_POINTER_REGNUM)
2206 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2207 && fde->drap_reg != INVALID_REGNUM
2208 && cfa.reg != REGNO (src));
2210 queue_reg_save (label, src, dest, 0);
2217 if (dest == stack_pointer_rtx)
2221 switch (GET_CODE (XEXP (src, 1)))
2224 offset = INTVAL (XEXP (src, 1));
2227 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2229 offset = cfa_temp.offset;
2235 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2237 /* Restoring SP from FP in the epilogue. */
2238 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2239 cfa.reg = STACK_POINTER_REGNUM;
2241 else if (GET_CODE (src) == LO_SUM)
2242 /* Assume we've set the source reg of the LO_SUM from sp. */
2245 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2247 if (GET_CODE (src) != MINUS)
2249 if (cfa.reg == STACK_POINTER_REGNUM)
2250 cfa.offset += offset;
2251 if (cfa_store.reg == STACK_POINTER_REGNUM)
2252 cfa_store.offset += offset;
2254 else if (dest == hard_frame_pointer_rtx)
2257 /* Either setting the FP from an offset of the SP,
2258 or adjusting the FP */
2259 gcc_assert (frame_pointer_needed);
2261 gcc_assert (REG_P (XEXP (src, 0))
2262 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2263 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2264 offset = INTVAL (XEXP (src, 1));
2265 if (GET_CODE (src) != MINUS)
2267 cfa.offset += offset;
2268 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2272 gcc_assert (GET_CODE (src) != MINUS);
2275 if (REG_P (XEXP (src, 0))
2276 && REGNO (XEXP (src, 0)) == cfa.reg
2277 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2279 /* Setting a temporary CFA register that will be copied
2280 into the FP later on. */
2281 offset = - INTVAL (XEXP (src, 1));
2282 cfa.offset += offset;
2283 cfa.reg = REGNO (dest);
2284 /* Or used to save regs to the stack. */
2285 cfa_temp.reg = cfa.reg;
2286 cfa_temp.offset = cfa.offset;
2290 else if (REG_P (XEXP (src, 0))
2291 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2292 && XEXP (src, 1) == stack_pointer_rtx)
2294 /* Setting a scratch register that we will use instead
2295 of SP for saving registers to the stack. */
2296 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2297 cfa_store.reg = REGNO (dest);
2298 cfa_store.offset = cfa.offset - cfa_temp.offset;
2302 else if (GET_CODE (src) == LO_SUM
2303 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2305 cfa_temp.reg = REGNO (dest);
2306 cfa_temp.offset = INTVAL (XEXP (src, 1));
2315 cfa_temp.reg = REGNO (dest);
2316 cfa_temp.offset = INTVAL (src);
2321 gcc_assert (REG_P (XEXP (src, 0))
2322 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2323 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2325 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2326 cfa_temp.reg = REGNO (dest);
2327 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2330 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2331 which will fill in all of the bits. */
2338 case UNSPEC_VOLATILE:
2339 gcc_assert (targetm.dwarf_handle_frame_unspec);
2340 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2345 /* If this AND operation happens on stack pointer in prologue,
2346 we assume the stack is realigned and we extract the
2348 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2350 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2351 fde->stack_realign = 1;
2352 fde->stack_realignment = INTVAL (XEXP (src, 1));
2353 cfa_store.offset = 0;
2355 if (cfa.reg != STACK_POINTER_REGNUM
2356 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2357 fde->drap_reg = cfa.reg;
2365 def_cfa_1 (label, &cfa);
2370 /* Saving a register to the stack. Make sure dest is relative to the
2372 switch (GET_CODE (XEXP (dest, 0)))
2377 /* We can't handle variable size modifications. */
2378 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2380 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2382 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2383 && cfa_store.reg == STACK_POINTER_REGNUM);
2385 cfa_store.offset += offset;
2386 if (cfa.reg == STACK_POINTER_REGNUM)
2387 cfa.offset = cfa_store.offset;
2389 offset = -cfa_store.offset;
2395 offset = GET_MODE_SIZE (GET_MODE (dest));
2396 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2399 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2400 == STACK_POINTER_REGNUM)
2401 && cfa_store.reg == STACK_POINTER_REGNUM);
2403 cfa_store.offset += offset;
2405 /* Rule 18: If stack is aligned, we will use FP as a
2406 reference to represent the address of the stored
2409 && fde->stack_realign
2410 && src == hard_frame_pointer_rtx)
2412 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2413 cfa_store.offset = 0;
2416 if (cfa.reg == STACK_POINTER_REGNUM)
2417 cfa.offset = cfa_store.offset;
2419 offset = -cfa_store.offset;
2423 /* With an offset. */
2430 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
2431 && REG_P (XEXP (XEXP (dest, 0), 0)));
2432 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2433 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2436 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2438 if (cfa_store.reg == (unsigned) regno)
2439 offset -= cfa_store.offset;
2442 gcc_assert (cfa_temp.reg == (unsigned) regno);
2443 offset -= cfa_temp.offset;
2449 /* Without an offset. */
2452 int regno = REGNO (XEXP (dest, 0));
2454 if (cfa_store.reg == (unsigned) regno)
2455 offset = -cfa_store.offset;
2458 gcc_assert (cfa_temp.reg == (unsigned) regno);
2459 offset = -cfa_temp.offset;
2466 gcc_assert (cfa_temp.reg
2467 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2468 offset = -cfa_temp.offset;
2469 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2477 /* If the source operand of this MEM operation is not a
2478 register, basically the source is return address. Here
2479 we only care how much stack grew and we don't save it. */
2483 if (REGNO (src) != STACK_POINTER_REGNUM
2484 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2485 && (unsigned) REGNO (src) == cfa.reg)
2487 /* We're storing the current CFA reg into the stack. */
2489 if (cfa.offset == 0)
2492 /* If stack is aligned, putting CFA reg into stack means
2493 we can no longer use reg + offset to represent CFA.
2494 Here we use DW_CFA_def_cfa_expression instead. The
2495 result of this expression equals to the original CFA
2498 && fde->stack_realign
2499 && cfa.indirect == 0
2500 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2502 dw_cfa_location cfa_exp;
2504 gcc_assert (fde->drap_reg == cfa.reg);
2506 cfa_exp.indirect = 1;
2507 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2508 cfa_exp.base_offset = offset;
2511 fde->drap_reg_saved = 1;
2513 def_cfa_1 (label, &cfa_exp);
2517 /* If the source register is exactly the CFA, assume
2518 we're saving SP like any other register; this happens
2520 def_cfa_1 (label, &cfa);
2521 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2526 /* Otherwise, we'll need to look in the stack to
2527 calculate the CFA. */
2528 rtx x = XEXP (dest, 0);
2532 gcc_assert (REG_P (x));
2534 cfa.reg = REGNO (x);
2535 cfa.base_offset = offset;
2537 def_cfa_1 (label, &cfa);
2542 def_cfa_1 (label, &cfa);
2544 span = targetm.dwarf_register_span (src);
2547 queue_reg_save (label, src, NULL_RTX, offset);
2550 /* We have a PARALLEL describing where the contents of SRC
2551 live. Queue register saves for each piece of the
2555 HOST_WIDE_INT span_offset = offset;
2557 gcc_assert (GET_CODE (span) == PARALLEL);
2559 limit = XVECLEN (span, 0);
2560 for (par_index = 0; par_index < limit; par_index++)
2562 rtx elem = XVECEXP (span, 0, par_index);
2564 queue_reg_save (label, elem, NULL_RTX, span_offset);
2565 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2576 /* Record call frame debugging information for INSN, which either
2577 sets SP or FP (adjusting how we calculate the frame address) or saves a
2578 register to the stack. If INSN is NULL_RTX, initialize our state.
2580 If AFTER_P is false, we're being called before the insn is emitted,
2581 otherwise after. Call instructions get invoked twice. */
2584 dwarf2out_frame_debug (rtx insn, bool after_p)
2588 bool handled_one = false;
2590 if (insn == NULL_RTX)
2594 /* Flush any queued register saves. */
2595 flush_queued_reg_saves ();
2597 /* Set up state for generating call frame debug info. */
2600 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2602 cfa.reg = STACK_POINTER_REGNUM;
2605 cfa_temp.offset = 0;
2607 for (i = 0; i < num_regs_saved_in_regs; i++)
2609 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2610 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2612 num_regs_saved_in_regs = 0;
2614 if (barrier_args_size)
2616 XDELETEVEC (barrier_args_size);
2617 barrier_args_size = NULL;
2622 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2623 flush_queued_reg_saves ();
2625 if (! RTX_FRAME_RELATED_P (insn))
2627 if (!ACCUMULATE_OUTGOING_ARGS)
2628 dwarf2out_stack_adjust (insn, after_p);
2632 label = dwarf2out_cfi_label (false);
2634 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2635 switch (REG_NOTE_KIND (note))
2637 case REG_FRAME_RELATED_EXPR:
2638 insn = XEXP (note, 0);
2641 case REG_CFA_DEF_CFA:
2642 dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2646 case REG_CFA_ADJUST_CFA:
2651 if (GET_CODE (n) == PARALLEL)
2652 n = XVECEXP (n, 0, 0);
2654 dwarf2out_frame_debug_adjust_cfa (n, label);
2658 case REG_CFA_OFFSET:
2661 n = single_set (insn);
2662 dwarf2out_frame_debug_cfa_offset (n, label);
2666 case REG_CFA_REGISTER:
2671 if (GET_CODE (n) == PARALLEL)
2672 n = XVECEXP (n, 0, 0);
2674 dwarf2out_frame_debug_cfa_register (n, label);
2678 case REG_CFA_RESTORE:
2683 if (GET_CODE (n) == PARALLEL)
2684 n = XVECEXP (n, 0, 0);
2687 dwarf2out_frame_debug_cfa_restore (n, label);
2697 insn = PATTERN (insn);
2699 dwarf2out_frame_debug_expr (insn, label);
2702 /* Determine if we need to save and restore CFI information around this
2703 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2704 we do need to save/restore, then emit the save now, and insert a
2705 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2708 dwarf2out_begin_epilogue (rtx insn)
2710 bool saw_frp = false;
2714 /* Scan forward to the return insn, noticing if there are possible
2715 frame related insns. */
2716 for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2721 /* Look for both regular and sibcalls to end the block. */
2722 if (returnjump_p (i))
2724 if (CALL_P (i) && SIBLING_CALL_P (i))
2727 if (RTX_FRAME_RELATED_P (i))
2731 /* If the port doesn't emit epilogue unwind info, we don't need a
2732 save/restore pair. */
2736 /* Otherwise, search forward to see if the return insn was the last
2737 basic block of the function. If so, we don't need save/restore. */
2738 gcc_assert (i != NULL);
2739 i = next_real_insn (i);
2743 /* Insert the restore before that next real insn in the stream, and before
2744 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2745 properly nested. This should be after any label or alignment. This
2746 will be pushed into the CFI stream by the function below. */
2749 rtx p = PREV_INSN (i);
2752 if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2756 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2758 /* Emit the state save. */
2760 cfi->dw_cfi_opc = DW_CFA_remember_state;
2761 add_fde_cfi (dwarf2out_cfi_label (false), cfi);
2763 /* And emulate the state save. */
2764 gcc_assert (!cfa_remember.in_use);
2766 cfa_remember.in_use = 1;
2769 /* A "subroutine" of dwarf2out_begin_epilogue. Emit the restore required. */
2772 dwarf2out_frame_debug_restore_state (void)
2774 dw_cfi_ref cfi = new_cfi ();
2775 const char *label = dwarf2out_cfi_label (false);
2777 cfi->dw_cfi_opc = DW_CFA_restore_state;
2778 add_fde_cfi (label, cfi);
2780 gcc_assert (cfa_remember.in_use);
2782 cfa_remember.in_use = 0;
2787 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2788 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2789 (enum dwarf_call_frame_info cfi);
2791 static enum dw_cfi_oprnd_type
2792 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2797 case DW_CFA_GNU_window_save:
2798 case DW_CFA_remember_state:
2799 case DW_CFA_restore_state:
2800 return dw_cfi_oprnd_unused;
2802 case DW_CFA_set_loc:
2803 case DW_CFA_advance_loc1:
2804 case DW_CFA_advance_loc2:
2805 case DW_CFA_advance_loc4:
2806 case DW_CFA_MIPS_advance_loc8:
2807 return dw_cfi_oprnd_addr;
2810 case DW_CFA_offset_extended:
2811 case DW_CFA_def_cfa:
2812 case DW_CFA_offset_extended_sf:
2813 case DW_CFA_def_cfa_sf:
2814 case DW_CFA_restore:
2815 case DW_CFA_restore_extended:
2816 case DW_CFA_undefined:
2817 case DW_CFA_same_value:
2818 case DW_CFA_def_cfa_register:
2819 case DW_CFA_register:
2820 return dw_cfi_oprnd_reg_num;
2822 case DW_CFA_def_cfa_offset:
2823 case DW_CFA_GNU_args_size:
2824 case DW_CFA_def_cfa_offset_sf:
2825 return dw_cfi_oprnd_offset;
2827 case DW_CFA_def_cfa_expression:
2828 case DW_CFA_expression:
2829 return dw_cfi_oprnd_loc;
2836 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2837 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2838 (enum dwarf_call_frame_info cfi);
2840 static enum dw_cfi_oprnd_type
2841 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2845 case DW_CFA_def_cfa:
2846 case DW_CFA_def_cfa_sf:
2848 case DW_CFA_offset_extended_sf:
2849 case DW_CFA_offset_extended:
2850 return dw_cfi_oprnd_offset;
2852 case DW_CFA_register:
2853 return dw_cfi_oprnd_reg_num;
2856 return dw_cfi_oprnd_unused;
2860 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2862 /* Switch to eh_frame_section. If we don't have an eh_frame_section,
2863 switch to the data section instead, and write out a synthetic label
2867 switch_to_eh_frame_section (void)
2871 #ifdef EH_FRAME_SECTION_NAME
2872 if (eh_frame_section == 0)
2876 if (EH_TABLES_CAN_BE_READ_ONLY)
2882 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2884 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2886 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2888 flags = ((! flag_pic
2889 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2890 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2891 && (per_encoding & 0x70) != DW_EH_PE_absptr
2892 && (per_encoding & 0x70) != DW_EH_PE_aligned
2893 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2894 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2895 ? 0 : SECTION_WRITE);
2898 flags = SECTION_WRITE;
2899 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2903 if (eh_frame_section)
2904 switch_to_section (eh_frame_section);
2907 /* We have no special eh_frame section. Put the information in
2908 the data section and emit special labels to guide collect2. */
2909 switch_to_section (data_section);
2910 label = get_file_function_name ("F");
2911 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2912 targetm.asm_out.globalize_label (asm_out_file,
2913 IDENTIFIER_POINTER (label));
2914 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2918 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
2920 static HOST_WIDE_INT
2921 div_data_align (HOST_WIDE_INT off)
2923 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
2924 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
2928 /* Output a Call Frame Information opcode and its operand(s). */
2931 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2936 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2937 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2938 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2939 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2940 ((unsigned HOST_WIDE_INT)
2941 cfi->dw_cfi_oprnd1.dw_cfi_offset));
2942 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2944 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2945 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2946 "DW_CFA_offset, column 0x%lx", r);
2947 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2948 dw2_asm_output_data_uleb128 (off, NULL);
2950 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2952 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2953 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2954 "DW_CFA_restore, column 0x%lx", r);
2958 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2959 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2961 switch (cfi->dw_cfi_opc)
2963 case DW_CFA_set_loc:
2965 dw2_asm_output_encoded_addr_rtx (
2966 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2967 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2970 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2971 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2972 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2975 case DW_CFA_advance_loc1:
2976 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2977 fde->dw_fde_current_label, NULL);
2978 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2981 case DW_CFA_advance_loc2:
2982 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2983 fde->dw_fde_current_label, NULL);
2984 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2987 case DW_CFA_advance_loc4:
2988 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2989 fde->dw_fde_current_label, NULL);
2990 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2993 case DW_CFA_MIPS_advance_loc8:
2994 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2995 fde->dw_fde_current_label, NULL);
2996 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2999 case DW_CFA_offset_extended:
3000 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3001 dw2_asm_output_data_uleb128 (r, NULL);
3002 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3003 dw2_asm_output_data_uleb128 (off, NULL);
3006 case DW_CFA_def_cfa:
3007 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3008 dw2_asm_output_data_uleb128 (r, NULL);
3009 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3012 case DW_CFA_offset_extended_sf:
3013 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3014 dw2_asm_output_data_uleb128 (r, NULL);
3015 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3016 dw2_asm_output_data_sleb128 (off, NULL);
3019 case DW_CFA_def_cfa_sf:
3020 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3021 dw2_asm_output_data_uleb128 (r, NULL);
3022 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3023 dw2_asm_output_data_sleb128 (off, NULL);
3026 case DW_CFA_restore_extended:
3027 case DW_CFA_undefined:
3028 case DW_CFA_same_value:
3029 case DW_CFA_def_cfa_register:
3030 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3031 dw2_asm_output_data_uleb128 (r, NULL);
3034 case DW_CFA_register:
3035 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3036 dw2_asm_output_data_uleb128 (r, NULL);
3037 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3038 dw2_asm_output_data_uleb128 (r, NULL);
3041 case DW_CFA_def_cfa_offset:
3042 case DW_CFA_GNU_args_size:
3043 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3046 case DW_CFA_def_cfa_offset_sf:
3047 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3048 dw2_asm_output_data_sleb128 (off, NULL);
3051 case DW_CFA_GNU_window_save:
3054 case DW_CFA_def_cfa_expression:
3055 case DW_CFA_expression:
3056 output_cfa_loc (cfi);
3059 case DW_CFA_GNU_negative_offset_extended:
3060 /* Obsoleted by DW_CFA_offset_extended_sf. */
3069 /* Similar, but do it via assembler directives instead. */
3072 output_cfi_directive (dw_cfi_ref cfi)
3074 unsigned long r, r2;
3076 switch (cfi->dw_cfi_opc)
3078 case DW_CFA_advance_loc:
3079 case DW_CFA_advance_loc1:
3080 case DW_CFA_advance_loc2:
3081 case DW_CFA_advance_loc4:
3082 case DW_CFA_MIPS_advance_loc8:
3083 case DW_CFA_set_loc:
3084 /* Should only be created by add_fde_cfi in a code path not
3085 followed when emitting via directives. The assembler is
3086 going to take care of this for us. */
3090 case DW_CFA_offset_extended:
3091 case DW_CFA_offset_extended_sf:
3092 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3093 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3094 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3097 case DW_CFA_restore:
3098 case DW_CFA_restore_extended:
3099 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3100 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3103 case DW_CFA_undefined:
3104 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3105 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3108 case DW_CFA_same_value:
3109 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3110 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3113 case DW_CFA_def_cfa:
3114 case DW_CFA_def_cfa_sf:
3115 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3116 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3117 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3120 case DW_CFA_def_cfa_register:
3121 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3122 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3125 case DW_CFA_register:
3126 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3127 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3128 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3131 case DW_CFA_def_cfa_offset:
3132 case DW_CFA_def_cfa_offset_sf:
3133 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3134 HOST_WIDE_INT_PRINT_DEC"\n",
3135 cfi->dw_cfi_oprnd1.dw_cfi_offset);
3138 case DW_CFA_remember_state:
3139 fprintf (asm_out_file, "\t.cfi_remember_state\n");
3141 case DW_CFA_restore_state:
3142 fprintf (asm_out_file, "\t.cfi_restore_state\n");
3145 case DW_CFA_GNU_args_size:
3146 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size);
3147 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3149 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3150 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3151 fputc ('\n', asm_out_file);
3154 case DW_CFA_GNU_window_save:
3155 fprintf (asm_out_file, "\t.cfi_window_save\n");
3158 case DW_CFA_def_cfa_expression:
3159 case DW_CFA_expression:
3160 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", cfi->dw_cfi_opc);
3161 output_cfa_loc_raw (cfi);
3162 fputc ('\n', asm_out_file);
3170 /* Output the call frame information used to record information
3171 that relates to calculating the frame pointer, and records the
3172 location of saved registers. */
3175 output_call_frame_info (int for_eh)
3180 char l1[20], l2[20], section_start_label[20];
3181 bool any_lsda_needed = false;
3182 char augmentation[6];
3183 int augmentation_size;
3184 int fde_encoding = DW_EH_PE_absptr;
3185 int per_encoding = DW_EH_PE_absptr;
3186 int lsda_encoding = DW_EH_PE_absptr;
3189 /* Don't emit a CIE if there won't be any FDEs. */
3190 if (fde_table_in_use == 0)
3193 /* Nothing to do if the assembler's doing it all. */
3194 if (dwarf2out_do_cfi_asm ())
3197 /* If we make FDEs linkonce, we may have to emit an empty label for
3198 an FDE that wouldn't otherwise be emitted. We want to avoid
3199 having an FDE kept around when the function it refers to is
3200 discarded. Example where this matters: a primary function
3201 template in C++ requires EH information, but an explicit
3202 specialization doesn't. */
3203 if (TARGET_USES_WEAK_UNWIND_INFO
3204 && ! flag_asynchronous_unwind_tables
3207 for (i = 0; i < fde_table_in_use; i++)
3208 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
3209 && !fde_table[i].uses_eh_lsda
3210 && ! DECL_WEAK (fde_table[i].decl))
3211 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
3212 for_eh, /* empty */ 1);
3214 /* If we don't have any functions we'll want to unwind out of, don't
3215 emit any EH unwind information. Note that if exceptions aren't
3216 enabled, we won't have collected nothrow information, and if we
3217 asked for asynchronous tables, we always want this info. */
3220 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
3222 for (i = 0; i < fde_table_in_use; i++)
3223 if (fde_table[i].uses_eh_lsda)
3224 any_eh_needed = any_lsda_needed = true;
3225 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3226 any_eh_needed = true;
3227 else if (! fde_table[i].nothrow
3228 && ! fde_table[i].all_throwers_are_sibcalls)
3229 any_eh_needed = true;
3231 if (! any_eh_needed)
3235 /* We're going to be generating comments, so turn on app. */
3240 switch_to_eh_frame_section ();
3243 if (!debug_frame_section)
3244 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3245 SECTION_DEBUG, NULL);
3246 switch_to_section (debug_frame_section);
3249 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3250 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3252 /* Output the CIE. */
3253 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3254 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3255 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3256 dw2_asm_output_data (4, 0xffffffff,
3257 "Initial length escape value indicating 64-bit DWARF extension");
3258 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3259 "Length of Common Information Entry");
3260 ASM_OUTPUT_LABEL (asm_out_file, l1);
3262 /* Now that the CIE pointer is PC-relative for EH,
3263 use 0 to identify the CIE. */
3264 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3265 (for_eh ? 0 : DWARF_CIE_ID),
3266 "CIE Identifier Tag");
3268 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
3270 augmentation[0] = 0;
3271 augmentation_size = 0;
3277 z Indicates that a uleb128 is present to size the
3278 augmentation section.
3279 L Indicates the encoding (and thus presence) of
3280 an LSDA pointer in the FDE augmentation.
3281 R Indicates a non-default pointer encoding for
3283 P Indicates the presence of an encoding + language
3284 personality routine in the CIE augmentation. */
3286 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3287 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3288 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3290 p = augmentation + 1;
3291 if (eh_personality_libfunc)
3294 augmentation_size += 1 + size_of_encoded_value (per_encoding);
3295 assemble_external_libcall (eh_personality_libfunc);
3297 if (any_lsda_needed)
3300 augmentation_size += 1;
3302 if (fde_encoding != DW_EH_PE_absptr)
3305 augmentation_size += 1;
3307 if (p > augmentation + 1)
3309 augmentation[0] = 'z';
3313 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3314 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
3316 int offset = ( 4 /* Length */
3318 + 1 /* CIE version */
3319 + strlen (augmentation) + 1 /* Augmentation */
3320 + size_of_uleb128 (1) /* Code alignment */
3321 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3323 + 1 /* Augmentation size */
3324 + 1 /* Personality encoding */ );
3325 int pad = -offset & (PTR_SIZE - 1);
3327 augmentation_size += pad;
3329 /* Augmentations should be small, so there's scarce need to
3330 iterate for a solution. Die if we exceed one uleb128 byte. */
3331 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3335 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3336 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3337 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3338 "CIE Data Alignment Factor");
3340 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3341 if (DW_CIE_VERSION == 1)
3342 dw2_asm_output_data (1, return_reg, "CIE RA Column");
3344 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3346 if (augmentation[0])
3348 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3349 if (eh_personality_libfunc)
3351 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3352 eh_data_format_name (per_encoding));
3353 dw2_asm_output_encoded_addr_rtx (per_encoding,
3354 eh_personality_libfunc,
3358 if (any_lsda_needed)
3359 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3360 eh_data_format_name (lsda_encoding));
3362 if (fde_encoding != DW_EH_PE_absptr)
3363 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3364 eh_data_format_name (fde_encoding));
3367 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3368 output_cfi (cfi, NULL, for_eh);
3370 /* Pad the CIE out to an address sized boundary. */
3371 ASM_OUTPUT_ALIGN (asm_out_file,
3372 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3373 ASM_OUTPUT_LABEL (asm_out_file, l2);
3375 /* Loop through all of the FDE's. */
3376 for (i = 0; i < fde_table_in_use; i++)
3378 fde = &fde_table[i];
3380 /* Don't emit EH unwind info for leaf functions that don't need it. */
3381 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3382 && (fde->nothrow || fde->all_throwers_are_sibcalls)
3383 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3384 && !fde->uses_eh_lsda)
3387 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
3388 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
3389 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
3390 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
3391 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3392 dw2_asm_output_data (4, 0xffffffff,
3393 "Initial length escape value indicating 64-bit DWARF extension");
3394 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3396 ASM_OUTPUT_LABEL (asm_out_file, l1);
3399 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3401 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3402 debug_frame_section, "FDE CIE offset");
3406 if (fde->dw_fde_switched_sections)
3408 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
3409 fde->dw_fde_unlikely_section_label);
3410 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
3411 fde->dw_fde_hot_section_label);
3412 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
3413 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
3414 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
3415 "FDE initial location");
3416 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3417 fde->dw_fde_hot_section_end_label,
3418 fde->dw_fde_hot_section_label,
3419 "FDE address range");
3420 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
3421 "FDE initial location");
3422 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3423 fde->dw_fde_unlikely_section_end_label,
3424 fde->dw_fde_unlikely_section_label,
3425 "FDE address range");
3429 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
3430 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3431 dw2_asm_output_encoded_addr_rtx (fde_encoding,
3434 "FDE initial location");
3435 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3436 fde->dw_fde_end, fde->dw_fde_begin,
3437 "FDE address range");
3442 if (fde->dw_fde_switched_sections)
3444 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3445 fde->dw_fde_hot_section_label,
3446 "FDE initial location");
3447 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3448 fde->dw_fde_hot_section_end_label,
3449 fde->dw_fde_hot_section_label,
3450 "FDE address range");
3451 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3452 fde->dw_fde_unlikely_section_label,
3453 "FDE initial location");
3454 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3455 fde->dw_fde_unlikely_section_end_label,
3456 fde->dw_fde_unlikely_section_label,
3457 "FDE address range");
3461 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
3462 "FDE initial location");
3463 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3464 fde->dw_fde_end, fde->dw_fde_begin,
3465 "FDE address range");
3469 if (augmentation[0])
3471 if (any_lsda_needed)
3473 int size = size_of_encoded_value (lsda_encoding);
3475 if (lsda_encoding == DW_EH_PE_aligned)
3477 int offset = ( 4 /* Length */
3478 + 4 /* CIE offset */
3479 + 2 * size_of_encoded_value (fde_encoding)
3480 + 1 /* Augmentation size */ );
3481 int pad = -offset & (PTR_SIZE - 1);
3484 gcc_assert (size_of_uleb128 (size) == 1);
3487 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3489 if (fde->uses_eh_lsda)
3491 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
3492 fde->funcdef_number);
3493 dw2_asm_output_encoded_addr_rtx (
3494 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
3495 false, "Language Specific Data Area");
3499 if (lsda_encoding == DW_EH_PE_aligned)
3500 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3502 (size_of_encoded_value (lsda_encoding), 0,
3503 "Language Specific Data Area (none)");
3507 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3510 /* Loop through the Call Frame Instructions associated with
3512 fde->dw_fde_current_label = fde->dw_fde_begin;
3513 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3514 output_cfi (cfi, fde, for_eh);
3516 /* Pad the FDE out to an address sized boundary. */
3517 ASM_OUTPUT_ALIGN (asm_out_file,
3518 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3519 ASM_OUTPUT_LABEL (asm_out_file, l2);
3522 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3523 dw2_asm_output_data (4, 0, "End of Table");
3524 #ifdef MIPS_DEBUGGING_INFO
3525 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3526 get a value of 0. Putting .align 0 after the label fixes it. */
3527 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3530 /* Turn off app to make assembly quicker. */
3535 /* Output a marker (i.e. a label) for the beginning of a function, before
3539 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3540 const char *file ATTRIBUTE_UNUSED)
3542 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3546 current_function_func_begin_label = NULL;
3548 #ifdef TARGET_UNWIND_INFO
3549 /* ??? current_function_func_begin_label is also used by except.c
3550 for call-site information. We must emit this label if it might
3552 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3553 && ! dwarf2out_do_frame ())
3556 if (! dwarf2out_do_frame ())
3560 switch_to_section (function_section (current_function_decl));
3561 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3562 current_function_funcdef_no);
3563 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3564 current_function_funcdef_no);
3565 dup_label = xstrdup (label);
3566 current_function_func_begin_label = dup_label;
3568 #ifdef TARGET_UNWIND_INFO
3569 /* We can elide the fde allocation if we're not emitting debug info. */
3570 if (! dwarf2out_do_frame ())
3574 /* Expand the fde table if necessary. */
3575 if (fde_table_in_use == fde_table_allocated)
3577 fde_table_allocated += FDE_TABLE_INCREMENT;
3578 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3579 memset (fde_table + fde_table_in_use, 0,
3580 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3583 /* Record the FDE associated with this function. */
3584 current_funcdef_fde = fde_table_in_use;
3586 /* Add the new FDE at the end of the fde_table. */
3587 fde = &fde_table[fde_table_in_use++];
3588 fde->decl = current_function_decl;
3589 fde->dw_fde_begin = dup_label;
3590 fde->dw_fde_current_label = dup_label;
3591 fde->dw_fde_hot_section_label = NULL;
3592 fde->dw_fde_hot_section_end_label = NULL;
3593 fde->dw_fde_unlikely_section_label = NULL;
3594 fde->dw_fde_unlikely_section_end_label = NULL;
3595 fde->dw_fde_switched_sections = false;
3596 fde->dw_fde_end = NULL;
3597 fde->dw_fde_cfi = NULL;
3598 fde->funcdef_number = current_function_funcdef_no;
3599 fde->nothrow = crtl->nothrow;
3600 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3601 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3602 fde->drap_reg = INVALID_REGNUM;
3603 fde->vdrap_reg = INVALID_REGNUM;
3605 args_size = old_args_size = 0;
3607 /* We only want to output line number information for the genuine dwarf2
3608 prologue case, not the eh frame case. */
3609 #ifdef DWARF2_DEBUGGING_INFO
3611 dwarf2out_source_line (line, file, 0);
3614 if (dwarf2out_do_cfi_asm ())
3619 fprintf (asm_out_file, "\t.cfi_startproc\n");
3621 if (eh_personality_libfunc)
3623 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3624 ref = eh_personality_libfunc;
3626 /* ??? The GAS support isn't entirely consistent. We have to
3627 handle indirect support ourselves, but PC-relative is done
3628 in the assembler. Further, the assembler can't handle any
3629 of the weirder relocation types. */
3630 if (enc & DW_EH_PE_indirect)
3631 ref = dw2_force_const_mem (ref, true);
3633 fprintf (asm_out_file, "\t.cfi_personality 0x%x,", enc);
3634 output_addr_const (asm_out_file, ref);
3635 fputc ('\n', asm_out_file);
3638 if (crtl->uses_eh_lsda)
3642 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3643 ASM_GENERATE_INTERNAL_LABEL (lab, "LLSDA",
3644 current_function_funcdef_no);
3645 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3646 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3648 if (enc & DW_EH_PE_indirect)
3649 ref = dw2_force_const_mem (ref, true);
3651 fprintf (asm_out_file, "\t.cfi_lsda 0x%x,", enc);
3652 output_addr_const (asm_out_file, ref);
3653 fputc ('\n', asm_out_file);
3658 /* Output a marker (i.e. a label) for the absolute end of the generated code
3659 for a function definition. This gets called *after* the epilogue code has
3663 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
3664 const char *file ATTRIBUTE_UNUSED)
3667 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3669 if (dwarf2out_do_cfi_asm ())
3670 fprintf (asm_out_file, "\t.cfi_endproc\n");
3672 /* Output a label to mark the endpoint of the code generated for this
3674 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
3675 current_function_funcdef_no);
3676 ASM_OUTPUT_LABEL (asm_out_file, label);
3677 fde = current_fde ();
3678 gcc_assert (fde != NULL);
3679 fde->dw_fde_end = xstrdup (label);
3683 dwarf2out_frame_init (void)
3685 /* Allocate the initial hunk of the fde_table. */
3686 fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
3687 fde_table_allocated = FDE_TABLE_INCREMENT;
3688 fde_table_in_use = 0;
3690 /* Generate the CFA instructions common to all FDE's. Do it now for the
3691 sake of lookup_cfa. */
3693 /* On entry, the Canonical Frame Address is at SP. */
3694 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
3696 #ifdef DWARF2_UNWIND_INFO
3697 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
3698 initial_return_save (INCOMING_RETURN_ADDR_RTX);
3703 dwarf2out_frame_finish (void)
3705 /* Output call frame information. */
3706 if (DWARF2_FRAME_INFO)
3707 output_call_frame_info (0);
3709 #ifndef TARGET_UNWIND_INFO
3710 /* Output another copy for the unwinder. */
3711 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
3712 output_call_frame_info (1);
3716 /* Note that the current function section is being used for code. */
3719 dwarf2out_note_section_used (void)
3721 section *sec = current_function_section ();
3722 if (sec == text_section)
3723 text_section_used = true;
3724 else if (sec == cold_text_section)
3725 cold_text_section_used = true;
3729 dwarf2out_switch_text_section (void)
3731 dw_fde_ref fde = current_fde ();
3733 gcc_assert (cfun && fde);
3735 fde->dw_fde_switched_sections = true;
3736 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
3737 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
3738 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
3739 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
3740 have_multiple_function_sections = true;
3742 /* Reset the current label on switching text sections, so that we
3743 don't attempt to advance_loc4 between labels in different sections. */
3744 fde->dw_fde_current_label = NULL;
3746 /* There is no need to mark used sections when not debugging. */
3747 if (cold_text_section != NULL)
3748 dwarf2out_note_section_used ();
3752 /* And now, the subset of the debugging information support code necessary
3753 for emitting location expressions. */
3755 /* Data about a single source file. */
3756 struct GTY(()) dwarf_file_data {
3757 const char * filename;
3761 /* We need some way to distinguish DW_OP_addr with a direct symbol
3762 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
3763 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
3766 typedef struct dw_val_struct *dw_val_ref;
3767 typedef struct die_struct *dw_die_ref;
3768 typedef const struct die_struct *const_dw_die_ref;
3769 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
3770 typedef struct dw_loc_list_struct *dw_loc_list_ref;
3772 typedef struct GTY(()) deferred_locations_struct
3776 } deferred_locations;
3778 DEF_VEC_O(deferred_locations);
3779 DEF_VEC_ALLOC_O(deferred_locations,gc);
3781 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
3783 /* Each DIE may have a series of attribute/value pairs. Values
3784 can take on several forms. The forms that are used in this
3785 implementation are listed below. */
3790 dw_val_class_offset,
3792 dw_val_class_loc_list,
3793 dw_val_class_range_list,
3795 dw_val_class_unsigned_const,
3796 dw_val_class_long_long,
3799 dw_val_class_die_ref,
3800 dw_val_class_fde_ref,
3801 dw_val_class_lbl_id,
3802 dw_val_class_lineptr,
3804 dw_val_class_macptr,
3808 /* Describe a double word constant value. */
3809 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
3811 typedef struct GTY(()) dw_long_long_struct {
3817 /* Describe a floating point constant value, or a vector constant value. */
3819 typedef struct GTY(()) dw_vec_struct {
3820 unsigned char * GTY((length ("%h.length"))) array;
3826 /* The dw_val_node describes an attribute's value, as it is
3827 represented internally. */
3829 typedef struct GTY(()) dw_val_struct {
3830 enum dw_val_class val_class;
3831 union dw_val_struct_union
3833 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
3834 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
3835 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
3836 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
3837 HOST_WIDE_INT GTY ((default)) val_int;
3838 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
3839 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
3840 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
3841 struct dw_val_die_union
3845 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
3846 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
3847 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
3848 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
3849 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
3850 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
3852 GTY ((desc ("%1.val_class"))) v;
3856 /* Locations in memory are described using a sequence of stack machine
3859 typedef struct GTY(()) dw_loc_descr_struct {
3860 dw_loc_descr_ref dw_loc_next;
3861 enum dwarf_location_atom dw_loc_opc;
3863 dw_val_node dw_loc_oprnd1;
3864 dw_val_node dw_loc_oprnd2;
3868 /* Location lists are ranges + location descriptions for that range,
3869 so you can track variables that are in different places over
3870 their entire life. */
3871 typedef struct GTY(()) dw_loc_list_struct {
3872 dw_loc_list_ref dw_loc_next;
3873 const char *begin; /* Label for begin address of range */
3874 const char *end; /* Label for end address of range */
3875 char *ll_symbol; /* Label for beginning of location list.
3876 Only on head of list */
3877 const char *section; /* Section this loclist is relative to */
3878 dw_loc_descr_ref expr;
3881 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
3883 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
3885 /* Convert a DWARF stack opcode into its string name. */
3888 dwarf_stack_op_name (unsigned int op)
3893 case INTERNAL_DW_OP_tls_addr:
3894 return "DW_OP_addr";
3896 return "DW_OP_deref";
3898 return "DW_OP_const1u";
3900 return "DW_OP_const1s";
3902 return "DW_OP_const2u";
3904 return "DW_OP_const2s";
3906 return "DW_OP_const4u";
3908 return "DW_OP_const4s";
3910 return "DW_OP_const8u";
3912 return "DW_OP_const8s";
3914 return "DW_OP_constu";
3916 return "DW_OP_consts";
3920 return "DW_OP_drop";
3922 return "DW_OP_over";
3924 return "DW_OP_pick";
3926 return "DW_OP_swap";
3930 return "DW_OP_xderef";
3938 return "DW_OP_minus";
3950 return "DW_OP_plus";
3951 case DW_OP_plus_uconst:
3952 return "DW_OP_plus_uconst";
3958 return "DW_OP_shra";
3976 return "DW_OP_skip";
3978 return "DW_OP_lit0";
3980 return "DW_OP_lit1";
3982 return "DW_OP_lit2";
3984 return "DW_OP_lit3";
3986 return "DW_OP_lit4";
3988 return "DW_OP_lit5";
3990 return "DW_OP_lit6";
3992 return "DW_OP_lit7";
3994 return "DW_OP_lit8";
3996 return "DW_OP_lit9";
3998 return "DW_OP_lit10";
4000 return "DW_OP_lit11";
4002 return "DW_OP_lit12";
4004 return "DW_OP_lit13";
4006 return "DW_OP_lit14";
4008 return "DW_OP_lit15";
4010 return "DW_OP_lit16";
4012 return "DW_OP_lit17";
4014 return "DW_OP_lit18";
4016 return "DW_OP_lit19";
4018 return "DW_OP_lit20";
4020 return "DW_OP_lit21";
4022 return "DW_OP_lit22";
4024 return "DW_OP_lit23";
4026 return "DW_OP_lit24";
4028 return "DW_OP_lit25";
4030 return "DW_OP_lit26";
4032 return "DW_OP_lit27";
4034 return "DW_OP_lit28";
4036 return "DW_OP_lit29";
4038 return "DW_OP_lit30";
4040 return "DW_OP_lit31";
4042 return "DW_OP_reg0";
4044 return "DW_OP_reg1";
4046 return "DW_OP_reg2";
4048 return "DW_OP_reg3";
4050 return "DW_OP_reg4";
4052 return "DW_OP_reg5";
4054 return "DW_OP_reg6";
4056 return "DW_OP_reg7";
4058 return "DW_OP_reg8";
4060 return "DW_OP_reg9";
4062 return "DW_OP_reg10";
4064 return "DW_OP_reg11";
4066 return "DW_OP_reg12";
4068 return "DW_OP_reg13";
4070 return "DW_OP_reg14";
4072 return "DW_OP_reg15";
4074 return "DW_OP_reg16";
4076 return "DW_OP_reg17";
4078 return "DW_OP_reg18";
4080 return "DW_OP_reg19";
4082 return "DW_OP_reg20";
4084 return "DW_OP_reg21";
4086 return "DW_OP_reg22";
4088 return "DW_OP_reg23";
4090 return "DW_OP_reg24";
4092 return "DW_OP_reg25";
4094 return "DW_OP_reg26";
4096 return "DW_OP_reg27";
4098 return "DW_OP_reg28";
4100 return "DW_OP_reg29";
4102 return "DW_OP_reg30";
4104 return "DW_OP_reg31";
4106 return "DW_OP_breg0";
4108 return "DW_OP_breg1";
4110 return "DW_OP_breg2";
4112 return "DW_OP_breg3";
4114 return "DW_OP_breg4";
4116 return "DW_OP_breg5";
4118 return "DW_OP_breg6";
4120 return "DW_OP_breg7";
4122 return "DW_OP_breg8";
4124 return "DW_OP_breg9";
4126 return "DW_OP_breg10";
4128 return "DW_OP_breg11";
4130 return "DW_OP_breg12";
4132 return "DW_OP_breg13";
4134 return "DW_OP_breg14";
4136 return "DW_OP_breg15";
4138 return "DW_OP_breg16";
4140 return "DW_OP_breg17";
4142 return "DW_OP_breg18";
4144 return "DW_OP_breg19";
4146 return "DW_OP_breg20";
4148 return "DW_OP_breg21";
4150 return "DW_OP_breg22";
4152 return "DW_OP_breg23";
4154 return "DW_OP_breg24";
4156 return "DW_OP_breg25";
4158 return "DW_OP_breg26";
4160 return "DW_OP_breg27";
4162 return "DW_OP_breg28";
4164 return "DW_OP_breg29";
4166 return "DW_OP_breg30";
4168 return "DW_OP_breg31";
4170 return "DW_OP_regx";
4172 return "DW_OP_fbreg";
4174 return "DW_OP_bregx";
4176 return "DW_OP_piece";
4177 case DW_OP_deref_size:
4178 return "DW_OP_deref_size";
4179 case DW_OP_xderef_size:
4180 return "DW_OP_xderef_size";
4183 case DW_OP_push_object_address:
4184 return "DW_OP_push_object_address";
4186 return "DW_OP_call2";
4188 return "DW_OP_call4";
4189 case DW_OP_call_ref:
4190 return "DW_OP_call_ref";
4191 case DW_OP_GNU_push_tls_address:
4192 return "DW_OP_GNU_push_tls_address";
4193 case DW_OP_GNU_uninit:
4194 return "DW_OP_GNU_uninit";
4196 return "OP_<unknown>";
4200 /* Return a pointer to a newly allocated location description. Location
4201 descriptions are simple expression terms that can be strung
4202 together to form more complicated location (address) descriptions. */
4204 static inline dw_loc_descr_ref
4205 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
4206 unsigned HOST_WIDE_INT oprnd2)
4208 dw_loc_descr_ref descr = GGC_CNEW (dw_loc_descr_node);
4210 descr->dw_loc_opc = op;
4211 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4212 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4213 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4214 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4219 /* Return a pointer to a newly allocated location description for
4222 static inline dw_loc_descr_ref
4223 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
4226 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
4229 return new_loc_descr (DW_OP_bregx, reg, offset);
4232 /* Add a location description term to a location description expression. */
4235 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
4237 dw_loc_descr_ref *d;
4239 /* Find the end of the chain. */
4240 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4246 /* Add a constant OFFSET to a location expression. */
4249 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
4251 dw_loc_descr_ref loc;
4254 gcc_assert (*list_head != NULL);
4259 /* Find the end of the chain. */
4260 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
4264 if (loc->dw_loc_opc == DW_OP_fbreg
4265 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
4266 p = &loc->dw_loc_oprnd1.v.val_int;
4267 else if (loc->dw_loc_opc == DW_OP_bregx)
4268 p = &loc->dw_loc_oprnd2.v.val_int;
4270 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4271 offset. Don't optimize if an signed integer overflow would happen. */
4273 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
4274 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
4277 else if (offset > 0)
4278 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4282 loc->dw_loc_next = int_loc_descriptor (offset);
4283 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_plus, 0, 0));
4287 /* Return the size of a location descriptor. */
4289 static unsigned long
4290 size_of_loc_descr (dw_loc_descr_ref loc)
4292 unsigned long size = 1;
4294 switch (loc->dw_loc_opc)
4297 case INTERNAL_DW_OP_tls_addr:
4298 size += DWARF2_ADDR_SIZE;
4317 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4320 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4325 case DW_OP_plus_uconst:
4326 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4364 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4367 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4370 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4373 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4374 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4377 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4379 case DW_OP_deref_size:
4380 case DW_OP_xderef_size:
4389 case DW_OP_call_ref:
4390 size += DWARF2_ADDR_SIZE;
4399 /* Return the size of a series of location descriptors. */
4401 static unsigned long
4402 size_of_locs (dw_loc_descr_ref loc)
4407 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4408 field, to avoid writing to a PCH file. */
4409 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4411 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4413 size += size_of_loc_descr (l);
4418 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4420 l->dw_loc_addr = size;
4421 size += size_of_loc_descr (l);
4427 /* Output location description stack opcode's operands (if any). */
4430 output_loc_operands (dw_loc_descr_ref loc)
4432 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4433 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4435 switch (loc->dw_loc_opc)
4437 #ifdef DWARF2_DEBUGGING_INFO
4439 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
4443 dw2_asm_output_data (2, val1->v.val_int, NULL);
4447 dw2_asm_output_data (4, val1->v.val_int, NULL);
4451 gcc_assert (HOST_BITS_PER_LONG >= 64);
4452 dw2_asm_output_data (8, val1->v.val_int, NULL);
4459 gcc_assert (val1->val_class == dw_val_class_loc);
4460 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4462 dw2_asm_output_data (2, offset, NULL);
4475 /* We currently don't make any attempt to make sure these are
4476 aligned properly like we do for the main unwind info, so
4477 don't support emitting things larger than a byte if we're
4478 only doing unwinding. */
4483 dw2_asm_output_data (1, val1->v.val_int, NULL);
4486 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4489 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4492 dw2_asm_output_data (1, val1->v.val_int, NULL);
4494 case DW_OP_plus_uconst:
4495 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4529 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4532 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4535 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4538 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4539 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
4542 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4544 case DW_OP_deref_size:
4545 case DW_OP_xderef_size:
4546 dw2_asm_output_data (1, val1->v.val_int, NULL);
4549 case INTERNAL_DW_OP_tls_addr:
4550 if (targetm.asm_out.output_dwarf_dtprel)
4552 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
4555 fputc ('\n', asm_out_file);
4562 /* Other codes have no operands. */
4567 /* Output a sequence of location operations. */
4570 output_loc_sequence (dw_loc_descr_ref loc)
4572 for (; loc != NULL; loc = loc->dw_loc_next)
4574 /* Output the opcode. */
4575 dw2_asm_output_data (1, loc->dw_loc_opc,
4576 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
4578 /* Output the operand(s) (if any). */
4579 output_loc_operands (loc);
4583 /* Output location description stack opcode's operands (if any).
4584 The output is single bytes on a line, suitable for .cfi_escape. */
4587 output_loc_operands_raw (dw_loc_descr_ref loc)
4589 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4590 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4592 switch (loc->dw_loc_opc)
4595 /* We cannot output addresses in .cfi_escape, only bytes. */
4601 case DW_OP_deref_size:
4602 case DW_OP_xderef_size:
4603 fputc (',', asm_out_file);
4604 dw2_asm_output_data_raw (1, val1->v.val_int);
4609 fputc (',', asm_out_file);
4610 dw2_asm_output_data_raw (2, val1->v.val_int);
4615 fputc (',', asm_out_file);
4616 dw2_asm_output_data_raw (4, val1->v.val_int);
4621 gcc_assert (HOST_BITS_PER_LONG >= 64);
4622 fputc (',', asm_out_file);
4623 dw2_asm_output_data_raw (8, val1->v.val_int);
4631 gcc_assert (val1->val_class == dw_val_class_loc);
4632 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4634 fputc (',', asm_out_file);
4635 dw2_asm_output_data_raw (2, offset);
4640 case DW_OP_plus_uconst:
4643 fputc (',', asm_out_file);
4644 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4681 fputc (',', asm_out_file);
4682 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
4686 fputc (',', asm_out_file);
4687 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4688 fputc (',', asm_out_file);
4689 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
4692 case INTERNAL_DW_OP_tls_addr:
4696 /* Other codes have no operands. */
4702 output_loc_sequence_raw (dw_loc_descr_ref loc)
4706 /* Output the opcode. */
4707 fprintf (asm_out_file, "0x%x", loc->dw_loc_opc);
4708 output_loc_operands_raw (loc);
4710 if (!loc->dw_loc_next)
4712 loc = loc->dw_loc_next;
4714 fputc (',', asm_out_file);
4718 /* This routine will generate the correct assembly data for a location
4719 description based on a cfi entry with a complex address. */
4722 output_cfa_loc (dw_cfi_ref cfi)
4724 dw_loc_descr_ref loc;
4727 if (cfi->dw_cfi_opc == DW_CFA_expression)
4728 dw2_asm_output_data (1, cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL);
4730 /* Output the size of the block. */
4731 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4732 size = size_of_locs (loc);
4733 dw2_asm_output_data_uleb128 (size, NULL);
4735 /* Now output the operations themselves. */
4736 output_loc_sequence (loc);
4739 /* Similar, but used for .cfi_escape. */
4742 output_cfa_loc_raw (dw_cfi_ref cfi)
4744 dw_loc_descr_ref loc;
4747 if (cfi->dw_cfi_opc == DW_CFA_expression)
4748 fprintf (asm_out_file, "0x%x,", cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4750 /* Output the size of the block. */
4751 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4752 size = size_of_locs (loc);
4753 dw2_asm_output_data_uleb128_raw (size);
4754 fputc (',', asm_out_file);
4756 /* Now output the operations themselves. */
4757 output_loc_sequence_raw (loc);
4760 /* This function builds a dwarf location descriptor sequence from a
4761 dw_cfa_location, adding the given OFFSET to the result of the
4764 static struct dw_loc_descr_struct *
4765 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
4767 struct dw_loc_descr_struct *head, *tmp;
4769 offset += cfa->offset;
4773 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
4774 head->dw_loc_oprnd1.val_class = dw_val_class_const;
4775 tmp = new_loc_descr (DW_OP_deref, 0, 0);
4776 add_loc_descr (&head, tmp);
4779 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4780 add_loc_descr (&head, tmp);
4784 head = new_reg_loc_descr (cfa->reg, offset);
4789 /* This function builds a dwarf location descriptor sequence for
4790 the address at OFFSET from the CFA when stack is aligned to
4793 static struct dw_loc_descr_struct *
4794 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
4796 struct dw_loc_descr_struct *head;
4797 unsigned int dwarf_fp
4798 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
4800 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
4801 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
4803 head = new_reg_loc_descr (dwarf_fp, 0);
4804 add_loc_descr (&head, int_loc_descriptor (alignment));
4805 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
4806 loc_descr_plus_const (&head, offset);
4809 head = new_reg_loc_descr (dwarf_fp, offset);
4813 /* This function fills in aa dw_cfa_location structure from a dwarf location
4814 descriptor sequence. */
4817 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
4819 struct dw_loc_descr_struct *ptr;
4821 cfa->base_offset = 0;
4825 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
4827 enum dwarf_location_atom op = ptr->dw_loc_opc;
4863 cfa->reg = op - DW_OP_reg0;
4866 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4900 cfa->reg = op - DW_OP_breg0;
4901 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
4904 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4905 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
4910 case DW_OP_plus_uconst:
4911 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
4914 internal_error ("DW_LOC_OP %s not implemented",
4915 dwarf_stack_op_name (ptr->dw_loc_opc));
4919 #endif /* .debug_frame support */
4921 /* And now, the support for symbolic debugging information. */
4922 #ifdef DWARF2_DEBUGGING_INFO
4924 /* .debug_str support. */
4925 static int output_indirect_string (void **, void *);
4927 static void dwarf2out_init (const char *);
4928 static void dwarf2out_finish (const char *);
4929 static void dwarf2out_define (unsigned int, const char *);
4930 static void dwarf2out_undef (unsigned int, const char *);
4931 static void dwarf2out_start_source_file (unsigned, const char *);
4932 static void dwarf2out_end_source_file (unsigned);
4933 static void dwarf2out_begin_block (unsigned, unsigned);
4934 static void dwarf2out_end_block (unsigned, unsigned);
4935 static bool dwarf2out_ignore_block (const_tree);
4936 static void dwarf2out_global_decl (tree);
4937 static void dwarf2out_type_decl (tree, int);
4938 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
4939 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
4941 static void dwarf2out_abstract_function (tree);
4942 static void dwarf2out_var_location (rtx);
4943 static void dwarf2out_begin_function (tree);
4944 static void dwarf2out_set_name (tree, tree);
4946 /* The debug hooks structure. */
4948 const struct gcc_debug_hooks dwarf2_debug_hooks =
4954 dwarf2out_start_source_file,
4955 dwarf2out_end_source_file,
4956 dwarf2out_begin_block,
4957 dwarf2out_end_block,
4958 dwarf2out_ignore_block,
4959 dwarf2out_source_line,
4960 dwarf2out_begin_prologue,
4961 debug_nothing_int_charstar, /* end_prologue */
4962 dwarf2out_end_epilogue,
4963 dwarf2out_begin_function,
4964 debug_nothing_int, /* end_function */
4965 dwarf2out_decl, /* function_decl */
4966 dwarf2out_global_decl,
4967 dwarf2out_type_decl, /* type_decl */
4968 dwarf2out_imported_module_or_decl,
4969 debug_nothing_tree, /* deferred_inline_function */
4970 /* The DWARF 2 backend tries to reduce debugging bloat by not
4971 emitting the abstract description of inline functions until
4972 something tries to reference them. */
4973 dwarf2out_abstract_function, /* outlining_inline_function */
4974 debug_nothing_rtx, /* label */
4975 debug_nothing_int, /* handle_pch */
4976 dwarf2out_var_location,
4977 dwarf2out_switch_text_section,
4979 1 /* start_end_main_source_file */
4983 /* NOTE: In the comments in this file, many references are made to
4984 "Debugging Information Entries". This term is abbreviated as `DIE'
4985 throughout the remainder of this file. */
4987 /* An internal representation of the DWARF output is built, and then
4988 walked to generate the DWARF debugging info. The walk of the internal
4989 representation is done after the entire program has been compiled.
4990 The types below are used to describe the internal representation. */
4992 /* Various DIE's use offsets relative to the beginning of the
4993 .debug_info section to refer to each other. */
4995 typedef long int dw_offset;
4997 /* Define typedefs here to avoid circular dependencies. */
4999 typedef struct dw_attr_struct *dw_attr_ref;
5000 typedef struct dw_line_info_struct *dw_line_info_ref;
5001 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
5002 typedef struct pubname_struct *pubname_ref;
5003 typedef struct dw_ranges_struct *dw_ranges_ref;
5004 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
5006 /* Each entry in the line_info_table maintains the file and
5007 line number associated with the label generated for that
5008 entry. The label gives the PC value associated with
5009 the line number entry. */
5011 typedef struct GTY(()) dw_line_info_struct {
5012 unsigned long dw_file_num;
5013 unsigned long dw_line_num;
5017 /* Line information for functions in separate sections; each one gets its
5019 typedef struct GTY(()) dw_separate_line_info_struct {
5020 unsigned long dw_file_num;
5021 unsigned long dw_line_num;
5022 unsigned long function;
5024 dw_separate_line_info_entry;
5026 /* Each DIE attribute has a field specifying the attribute kind,
5027 a link to the next attribute in the chain, and an attribute value.
5028 Attributes are typically linked below the DIE they modify. */
5030 typedef struct GTY(()) dw_attr_struct {
5031 enum dwarf_attribute dw_attr;
5032 dw_val_node dw_attr_val;
5036 DEF_VEC_O(dw_attr_node);
5037 DEF_VEC_ALLOC_O(dw_attr_node,gc);
5039 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
5040 The children of each node form a circular list linked by
5041 die_sib. die_child points to the node *before* the "first" child node. */
5043 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
5044 enum dwarf_tag die_tag;
5046 VEC(dw_attr_node,gc) * die_attr;
5047 dw_die_ref die_parent;
5048 dw_die_ref die_child;
5050 dw_die_ref die_definition; /* ref from a specification to its definition */
5051 dw_offset die_offset;
5052 unsigned long die_abbrev;
5054 /* Die is used and must not be pruned as unused. */
5055 int die_perennial_p;
5056 unsigned int decl_id;
5060 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
5061 #define FOR_EACH_CHILD(die, c, expr) do { \
5062 c = die->die_child; \
5066 } while (c != die->die_child); \
5069 /* The pubname structure */
5071 typedef struct GTY(()) pubname_struct {
5077 DEF_VEC_O(pubname_entry);
5078 DEF_VEC_ALLOC_O(pubname_entry, gc);
5080 struct GTY(()) dw_ranges_struct {
5081 /* If this is positive, it's a block number, otherwise it's a
5082 bitwise-negated index into dw_ranges_by_label. */
5086 struct GTY(()) dw_ranges_by_label_struct {
5091 /* The limbo die list structure. */
5092 typedef struct GTY(()) limbo_die_struct {
5095 struct limbo_die_struct *next;
5099 /* How to start an assembler comment. */
5100 #ifndef ASM_COMMENT_START
5101 #define ASM_COMMENT_START ";#"
5104 /* Define a macro which returns nonzero for a TYPE_DECL which was
5105 implicitly generated for a tagged type.
5107 Note that unlike the gcc front end (which generates a NULL named
5108 TYPE_DECL node for each complete tagged type, each array type, and
5109 each function type node created) the g++ front end generates a
5110 _named_ TYPE_DECL node for each tagged type node created.
5111 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
5112 generate a DW_TAG_typedef DIE for them. */
5114 #define TYPE_DECL_IS_STUB(decl) \
5115 (DECL_NAME (decl) == NULL_TREE \
5116 || (DECL_ARTIFICIAL (decl) \
5117 && is_tagged_type (TREE_TYPE (decl)) \
5118 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
5119 /* This is necessary for stub decls that \
5120 appear in nested inline functions. */ \
5121 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
5122 && (decl_ultimate_origin (decl) \
5123 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
5125 /* Information concerning the compilation unit's programming
5126 language, and compiler version. */
5128 /* Fixed size portion of the DWARF compilation unit header. */
5129 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
5130 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
5132 /* Fixed size portion of public names info. */
5133 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
5135 /* Fixed size portion of the address range info. */
5136 #define DWARF_ARANGES_HEADER_SIZE \
5137 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5138 DWARF2_ADDR_SIZE * 2) \
5139 - DWARF_INITIAL_LENGTH_SIZE)
5141 /* Size of padding portion in the address range info. It must be
5142 aligned to twice the pointer size. */
5143 #define DWARF_ARANGES_PAD_SIZE \
5144 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5145 DWARF2_ADDR_SIZE * 2) \
5146 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
5148 /* Use assembler line directives if available. */
5149 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
5150 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
5151 #define DWARF2_ASM_LINE_DEBUG_INFO 1
5153 #define DWARF2_ASM_LINE_DEBUG_INFO 0
5157 /* Minimum line offset in a special line info. opcode.
5158 This value was chosen to give a reasonable range of values. */
5159 #define DWARF_LINE_BASE -10
5161 /* First special line opcode - leave room for the standard opcodes. */
5162 #define DWARF_LINE_OPCODE_BASE 10
5164 /* Range of line offsets in a special line info. opcode. */
5165 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
5167 /* Flag that indicates the initial value of the is_stmt_start flag.
5168 In the present implementation, we do not mark any lines as
5169 the beginning of a source statement, because that information
5170 is not made available by the GCC front-end. */
5171 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
5173 #ifdef DWARF2_DEBUGGING_INFO
5174 /* This location is used by calc_die_sizes() to keep track
5175 the offset of each DIE within the .debug_info section. */
5176 static unsigned long next_die_offset;
5179 /* Record the root of the DIE's built for the current compilation unit. */
5180 static GTY(()) dw_die_ref comp_unit_die;
5182 /* A list of DIEs with a NULL parent waiting to be relocated. */
5183 static GTY(()) limbo_die_node *limbo_die_list;
5185 /* Filenames referenced by this compilation unit. */
5186 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
5188 /* A hash table of references to DIE's that describe declarations.
5189 The key is a DECL_UID() which is a unique number identifying each decl. */
5190 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
5192 /* A hash table of references to DIE's that describe COMMON blocks.
5193 The key is DECL_UID() ^ die_parent. */
5194 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
5196 /* Node of the variable location list. */
5197 struct GTY ((chain_next ("%h.next"))) var_loc_node {
5198 rtx GTY (()) var_loc_note;
5199 const char * GTY (()) label;
5200 const char * GTY (()) section_label;
5201 struct var_loc_node * GTY (()) next;
5204 /* Variable location list. */
5205 struct GTY (()) var_loc_list_def {
5206 struct var_loc_node * GTY (()) first;
5208 /* Do not mark the last element of the chained list because
5209 it is marked through the chain. */
5210 struct var_loc_node * GTY ((skip ("%h"))) last;
5212 /* DECL_UID of the variable decl. */
5213 unsigned int decl_id;
5215 typedef struct var_loc_list_def var_loc_list;
5218 /* Table of decl location linked lists. */
5219 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
5221 /* A pointer to the base of a list of references to DIE's that
5222 are uniquely identified by their tag, presence/absence of
5223 children DIE's, and list of attribute/value pairs. */
5224 static GTY((length ("abbrev_die_table_allocated")))
5225 dw_die_ref *abbrev_die_table;
5227 /* Number of elements currently allocated for abbrev_die_table. */
5228 static GTY(()) unsigned abbrev_die_table_allocated;
5230 /* Number of elements in type_die_table currently in use. */
5231 static GTY(()) unsigned abbrev_die_table_in_use;
5233 /* Size (in elements) of increments by which we may expand the
5234 abbrev_die_table. */
5235 #define ABBREV_DIE_TABLE_INCREMENT 256
5237 /* A pointer to the base of a table that contains line information
5238 for each source code line in .text in the compilation unit. */
5239 static GTY((length ("line_info_table_allocated")))
5240 dw_line_info_ref line_info_table;
5242 /* Number of elements currently allocated for line_info_table. */
5243 static GTY(()) unsigned line_info_table_allocated;
5245 /* Number of elements in line_info_table currently in use. */
5246 static GTY(()) unsigned line_info_table_in_use;
5248 /* A pointer to the base of a table that contains line information
5249 for each source code line outside of .text in the compilation unit. */
5250 static GTY ((length ("separate_line_info_table_allocated")))
5251 dw_separate_line_info_ref separate_line_info_table;
5253 /* Number of elements currently allocated for separate_line_info_table. */
5254 static GTY(()) unsigned separate_line_info_table_allocated;
5256 /* Number of elements in separate_line_info_table currently in use. */
5257 static GTY(()) unsigned separate_line_info_table_in_use;
5259 /* Size (in elements) of increments by which we may expand the
5261 #define LINE_INFO_TABLE_INCREMENT 1024
5263 /* A pointer to the base of a table that contains a list of publicly
5264 accessible names. */
5265 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
5267 /* A pointer to the base of a table that contains a list of publicly
5268 accessible types. */
5269 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
5271 /* Array of dies for which we should generate .debug_arange info. */
5272 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
5274 /* Number of elements currently allocated for arange_table. */
5275 static GTY(()) unsigned arange_table_allocated;
5277 /* Number of elements in arange_table currently in use. */
5278 static GTY(()) unsigned arange_table_in_use;
5280 /* Size (in elements) of increments by which we may expand the
5282 #define ARANGE_TABLE_INCREMENT 64
5284 /* Array of dies for which we should generate .debug_ranges info. */
5285 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
5287 /* Number of elements currently allocated for ranges_table. */
5288 static GTY(()) unsigned ranges_table_allocated;
5290 /* Number of elements in ranges_table currently in use. */
5291 static GTY(()) unsigned ranges_table_in_use;
5293 /* Array of pairs of labels referenced in ranges_table. */
5294 static GTY ((length ("ranges_by_label_allocated")))
5295 dw_ranges_by_label_ref ranges_by_label;
5297 /* Number of elements currently allocated for ranges_by_label. */
5298 static GTY(()) unsigned ranges_by_label_allocated;
5300 /* Number of elements in ranges_by_label currently in use. */
5301 static GTY(()) unsigned ranges_by_label_in_use;
5303 /* Size (in elements) of increments by which we may expand the
5305 #define RANGES_TABLE_INCREMENT 64
5307 /* Whether we have location lists that need outputting */
5308 static GTY(()) bool have_location_lists;
5310 /* Unique label counter. */
5311 static GTY(()) unsigned int loclabel_num;
5313 #ifdef DWARF2_DEBUGGING_INFO
5314 /* Record whether the function being analyzed contains inlined functions. */
5315 static int current_function_has_inlines;
5317 #if 0 && defined (MIPS_DEBUGGING_INFO)
5318 static int comp_unit_has_inlines;
5321 /* The last file entry emitted by maybe_emit_file(). */
5322 static GTY(()) struct dwarf_file_data * last_emitted_file;
5324 /* Number of internal labels generated by gen_internal_sym(). */
5325 static GTY(()) int label_num;
5327 /* Cached result of previous call to lookup_filename. */
5328 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
5330 #ifdef DWARF2_DEBUGGING_INFO
5332 /* Offset from the "steady-state frame pointer" to the frame base,
5333 within the current function. */
5334 static HOST_WIDE_INT frame_pointer_fb_offset;
5336 /* Forward declarations for functions defined in this file. */
5338 static int is_pseudo_reg (const_rtx);
5339 static tree type_main_variant (tree);
5340 static int is_tagged_type (const_tree);
5341 static const char *dwarf_tag_name (unsigned);
5342 static const char *dwarf_attr_name (unsigned);
5343 static const char *dwarf_form_name (unsigned);
5344 static tree decl_ultimate_origin (const_tree);
5345 static tree decl_class_context (tree);
5346 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
5347 static inline enum dw_val_class AT_class (dw_attr_ref);
5348 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
5349 static inline unsigned AT_flag (dw_attr_ref);
5350 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
5351 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
5352 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
5353 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
5354 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
5356 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
5357 unsigned int, unsigned char *);
5358 static hashval_t debug_str_do_hash (const void *);
5359 static int debug_str_eq (const void *, const void *);
5360 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
5361 static inline const char *AT_string (dw_attr_ref);
5362 static enum dwarf_form AT_string_form (dw_attr_ref);
5363 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
5364 static void add_AT_specification (dw_die_ref, dw_die_ref);
5365 static inline dw_die_ref AT_ref (dw_attr_ref);
5366 static inline int AT_ref_external (dw_attr_ref);
5367 static inline void set_AT_ref_external (dw_attr_ref, int);
5368 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
5369 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
5370 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
5371 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
5373 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
5374 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
5375 static inline rtx AT_addr (dw_attr_ref);
5376 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
5377 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
5378 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
5379 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
5380 unsigned HOST_WIDE_INT);
5381 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
5383 static inline const char *AT_lbl (dw_attr_ref);
5384 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
5385 static const char *get_AT_low_pc (dw_die_ref);
5386 static const char *get_AT_hi_pc (dw_die_ref);
5387 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
5388 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
5389 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
5390 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
5391 static bool is_c_family (void);
5392 static bool is_cxx (void);
5393 static bool is_java (void);
5394 static bool is_fortran (void);
5395 static bool is_ada (void);
5396 static void remove_AT (dw_die_ref, enum dwarf_attribute);
5397 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
5398 static void add_child_die (dw_die_ref, dw_die_ref);
5399 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
5400 static dw_die_ref lookup_type_die (tree);
5401 static void equate_type_number_to_die (tree, dw_die_ref);
5402 static hashval_t decl_die_table_hash (const void *);
5403 static int decl_die_table_eq (const void *, const void *);
5404 static dw_die_ref lookup_decl_die (tree);
5405 static hashval_t common_block_die_table_hash (const void *);
5406 static int common_block_die_table_eq (const void *, const void *);
5407 static hashval_t decl_loc_table_hash (const void *);
5408 static int decl_loc_table_eq (const void *, const void *);
5409 static var_loc_list *lookup_decl_loc (const_tree);
5410 static void equate_decl_number_to_die (tree, dw_die_ref);
5411 static void add_var_loc_to_decl (tree, struct var_loc_node *);
5412 static void print_spaces (FILE *);
5413 static void print_die (dw_die_ref, FILE *);
5414 static void print_dwarf_line_table (FILE *);
5415 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
5416 static dw_die_ref pop_compile_unit (dw_die_ref);
5417 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
5418 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
5419 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
5420 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
5421 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
5422 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
5423 static int same_die_p (dw_die_ref, dw_die_ref, int *);
5424 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
5425 static void compute_section_prefix (dw_die_ref);
5426 static int is_type_die (dw_die_ref);
5427 static int is_comdat_die (dw_die_ref);
5428 static int is_symbol_die (dw_die_ref);
5429 static void assign_symbol_names (dw_die_ref);
5430 static void break_out_includes (dw_die_ref);
5431 static hashval_t htab_cu_hash (const void *);
5432 static int htab_cu_eq (const void *, const void *);
5433 static void htab_cu_del (void *);
5434 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
5435 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
5436 static void add_sibling_attributes (dw_die_ref);
5437 static void build_abbrev_table (dw_die_ref);
5438 static void output_location_lists (dw_die_ref);
5439 static int constant_size (unsigned HOST_WIDE_INT);
5440 static unsigned long size_of_die (dw_die_ref);
5441 static void calc_die_sizes (dw_die_ref);
5442 static void mark_dies (dw_die_ref);
5443 static void unmark_dies (dw_die_ref);
5444 static void unmark_all_dies (dw_die_ref);
5445 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
5446 static unsigned long size_of_aranges (void);
5447 static enum dwarf_form value_format (dw_attr_ref);
5448 static void output_value_format (dw_attr_ref);
5449 static void output_abbrev_section (void);
5450 static void output_die_symbol (dw_die_ref);
5451 static void output_die (dw_die_ref);
5452 static void output_compilation_unit_header (void);
5453 static void output_comp_unit (dw_die_ref, int);
5454 static const char *dwarf2_name (tree, int);
5455 static void add_pubname (tree, dw_die_ref);
5456 static void add_pubname_string (const char *, dw_die_ref);
5457 static void add_pubtype (tree, dw_die_ref);
5458 static void output_pubnames (VEC (pubname_entry,gc) *);
5459 static void add_arange (tree, dw_die_ref);
5460 static void output_aranges (void);
5461 static unsigned int add_ranges_num (int);
5462 static unsigned int add_ranges (const_tree);
5463 static unsigned int add_ranges_by_labels (const char *, const char *);
5464 static void output_ranges (void);
5465 static void output_line_info (void);
5466 static void output_file_names (void);
5467 static dw_die_ref base_type_die (tree);
5468 static int is_base_type (tree);
5469 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
5470 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
5471 static int type_is_enum (const_tree);
5472 static unsigned int dbx_reg_number (const_rtx);
5473 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
5474 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
5475 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
5476 enum var_init_status);
5477 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
5478 enum var_init_status);
5479 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
5480 enum var_init_status);
5481 static int is_based_loc (const_rtx);
5482 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
5483 enum var_init_status);
5484 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
5485 enum var_init_status);
5486 static dw_loc_descr_ref loc_descriptor (rtx, enum var_init_status);
5487 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
5488 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
5489 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
5490 static tree field_type (const_tree);
5491 static unsigned int simple_type_align_in_bits (const_tree);
5492 static unsigned int simple_decl_align_in_bits (const_tree);
5493 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
5494 static HOST_WIDE_INT field_byte_offset (const_tree);
5495 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
5497 static void add_data_member_location_attribute (dw_die_ref, tree);
5498 static void add_const_value_attribute (dw_die_ref, rtx);
5499 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
5500 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
5501 static void insert_float (const_rtx, unsigned char *);
5502 static rtx rtl_for_decl_location (tree);
5503 static void add_location_or_const_value_attribute (dw_die_ref, tree,
5504 enum dwarf_attribute);
5505 static void tree_add_const_value_attribute (dw_die_ref, tree);
5506 static void add_name_attribute (dw_die_ref, const char *);
5507 static void add_comp_dir_attribute (dw_die_ref);
5508 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
5509 static void add_subscript_info (dw_die_ref, tree, bool);
5510 static void add_byte_size_attribute (dw_die_ref, tree);
5511 static void add_bit_offset_attribute (dw_die_ref, tree);
5512 static void add_bit_size_attribute (dw_die_ref, tree);
5513 static void add_prototyped_attribute (dw_die_ref, tree);
5514 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
5515 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
5516 static void add_src_coords_attributes (dw_die_ref, tree);
5517 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
5518 static void push_decl_scope (tree);
5519 static void pop_decl_scope (void);
5520 static dw_die_ref scope_die_for (tree, dw_die_ref);
5521 static inline int local_scope_p (dw_die_ref);
5522 static inline int class_scope_p (dw_die_ref);
5523 static inline int class_or_namespace_scope_p (dw_die_ref);
5524 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
5525 static void add_calling_convention_attribute (dw_die_ref, tree);
5526 static const char *type_tag (const_tree);
5527 static tree member_declared_type (const_tree);
5529 static const char *decl_start_label (tree);
5531 static void gen_array_type_die (tree, dw_die_ref);
5532 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
5534 static void gen_entry_point_die (tree, dw_die_ref);
5536 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
5537 static dw_die_ref gen_formal_parameter_die (tree, tree, dw_die_ref);
5538 static void gen_unspecified_parameters_die (tree, dw_die_ref);
5539 static void gen_formal_types_die (tree, dw_die_ref);
5540 static void gen_subprogram_die (tree, dw_die_ref);
5541 static void gen_variable_die (tree, tree, dw_die_ref);
5542 static void gen_const_die (tree, dw_die_ref);
5543 static void gen_label_die (tree, dw_die_ref);
5544 static void gen_lexical_block_die (tree, dw_die_ref, int);
5545 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
5546 static void gen_field_die (tree, dw_die_ref);
5547 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
5548 static dw_die_ref gen_compile_unit_die (const char *);
5549 static void gen_inheritance_die (tree, tree, dw_die_ref);
5550 static void gen_member_die (tree, dw_die_ref);
5551 static void gen_struct_or_union_type_die (tree, dw_die_ref,
5552 enum debug_info_usage);
5553 static void gen_subroutine_type_die (tree, dw_die_ref);
5554 static void gen_typedef_die (tree, dw_die_ref);
5555 static void gen_type_die (tree, dw_die_ref);
5556 static void gen_block_die (tree, dw_die_ref, int);
5557 static void decls_for_scope (tree, dw_die_ref, int);
5558 static int is_redundant_typedef (const_tree);
5559 static void gen_namespace_die (tree, dw_die_ref);
5560 static void gen_decl_die (tree, tree, dw_die_ref);
5561 static dw_die_ref force_decl_die (tree);
5562 static dw_die_ref force_type_die (tree);
5563 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
5564 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
5565 static struct dwarf_file_data * lookup_filename (const char *);
5566 static void retry_incomplete_types (void);
5567 static void gen_type_die_for_member (tree, tree, dw_die_ref);
5568 static void splice_child_die (dw_die_ref, dw_die_ref);
5569 static int file_info_cmp (const void *, const void *);
5570 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
5571 const char *, const char *, unsigned);
5572 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
5573 const char *, const char *,
5575 static void output_loc_list (dw_loc_list_ref);
5576 static char *gen_internal_sym (const char *);
5578 static void prune_unmark_dies (dw_die_ref);
5579 static void prune_unused_types_mark (dw_die_ref, int);
5580 static void prune_unused_types_walk (dw_die_ref);
5581 static void prune_unused_types_walk_attribs (dw_die_ref);
5582 static void prune_unused_types_prune (dw_die_ref);
5583 static void prune_unused_types (void);
5584 static int maybe_emit_file (struct dwarf_file_data *fd);
5586 /* Section names used to hold DWARF debugging information. */
5587 #ifndef DEBUG_INFO_SECTION
5588 #define DEBUG_INFO_SECTION ".debug_info"
5590 #ifndef DEBUG_ABBREV_SECTION
5591 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
5593 #ifndef DEBUG_ARANGES_SECTION
5594 #define DEBUG_ARANGES_SECTION ".debug_aranges"
5596 #ifndef DEBUG_MACINFO_SECTION
5597 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
5599 #ifndef DEBUG_LINE_SECTION
5600 #define DEBUG_LINE_SECTION ".debug_line"
5602 #ifndef DEBUG_LOC_SECTION
5603 #define DEBUG_LOC_SECTION ".debug_loc"
5605 #ifndef DEBUG_PUBNAMES_SECTION
5606 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
5608 #ifndef DEBUG_STR_SECTION
5609 #define DEBUG_STR_SECTION ".debug_str"
5611 #ifndef DEBUG_RANGES_SECTION
5612 #define DEBUG_RANGES_SECTION ".debug_ranges"
5615 /* Standard ELF section names for compiled code and data. */
5616 #ifndef TEXT_SECTION_NAME
5617 #define TEXT_SECTION_NAME ".text"
5620 /* Section flags for .debug_str section. */
5621 #define DEBUG_STR_SECTION_FLAGS \
5622 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
5623 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
5626 /* Labels we insert at beginning sections we can reference instead of
5627 the section names themselves. */
5629 #ifndef TEXT_SECTION_LABEL
5630 #define TEXT_SECTION_LABEL "Ltext"
5632 #ifndef COLD_TEXT_SECTION_LABEL
5633 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
5635 #ifndef DEBUG_LINE_SECTION_LABEL
5636 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
5638 #ifndef DEBUG_INFO_SECTION_LABEL
5639 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
5641 #ifndef DEBUG_ABBREV_SECTION_LABEL
5642 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
5644 #ifndef DEBUG_LOC_SECTION_LABEL
5645 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
5647 #ifndef DEBUG_RANGES_SECTION_LABEL
5648 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
5650 #ifndef DEBUG_MACINFO_SECTION_LABEL
5651 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
5654 /* Definitions of defaults for formats and names of various special
5655 (artificial) labels which may be generated within this file (when the -g
5656 options is used and DWARF2_DEBUGGING_INFO is in effect.
5657 If necessary, these may be overridden from within the tm.h file, but
5658 typically, overriding these defaults is unnecessary. */
5660 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5661 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5662 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5663 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5664 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5665 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5666 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5667 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5668 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5669 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
5671 #ifndef TEXT_END_LABEL
5672 #define TEXT_END_LABEL "Letext"
5674 #ifndef COLD_END_LABEL
5675 #define COLD_END_LABEL "Letext_cold"
5677 #ifndef BLOCK_BEGIN_LABEL
5678 #define BLOCK_BEGIN_LABEL "LBB"
5680 #ifndef BLOCK_END_LABEL
5681 #define BLOCK_END_LABEL "LBE"
5683 #ifndef LINE_CODE_LABEL
5684 #define LINE_CODE_LABEL "LM"
5686 #ifndef SEPARATE_LINE_CODE_LABEL
5687 #define SEPARATE_LINE_CODE_LABEL "LSM"
5691 /* We allow a language front-end to designate a function that is to be
5692 called to "demangle" any name before it is put into a DIE. */
5694 static const char *(*demangle_name_func) (const char *);
5697 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
5699 demangle_name_func = func;
5702 /* Test if rtl node points to a pseudo register. */
5705 is_pseudo_reg (const_rtx rtl)
5707 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
5708 || (GET_CODE (rtl) == SUBREG
5709 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
5712 /* Return a reference to a type, with its const and volatile qualifiers
5716 type_main_variant (tree type)
5718 type = TYPE_MAIN_VARIANT (type);
5720 /* ??? There really should be only one main variant among any group of
5721 variants of a given type (and all of the MAIN_VARIANT values for all
5722 members of the group should point to that one type) but sometimes the C
5723 front-end messes this up for array types, so we work around that bug
5725 if (TREE_CODE (type) == ARRAY_TYPE)
5726 while (type != TYPE_MAIN_VARIANT (type))
5727 type = TYPE_MAIN_VARIANT (type);
5732 /* Return nonzero if the given type node represents a tagged type. */
5735 is_tagged_type (const_tree type)
5737 enum tree_code code = TREE_CODE (type);
5739 return (code == RECORD_TYPE || code == UNION_TYPE
5740 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
5743 /* Convert a DIE tag into its string name. */
5746 dwarf_tag_name (unsigned int tag)
5750 case DW_TAG_padding:
5751 return "DW_TAG_padding";
5752 case DW_TAG_array_type:
5753 return "DW_TAG_array_type";
5754 case DW_TAG_class_type:
5755 return "DW_TAG_class_type";
5756 case DW_TAG_entry_point:
5757 return "DW_TAG_entry_point";
5758 case DW_TAG_enumeration_type:
5759 return "DW_TAG_enumeration_type";
5760 case DW_TAG_formal_parameter:
5761 return "DW_TAG_formal_parameter";
5762 case DW_TAG_imported_declaration:
5763 return "DW_TAG_imported_declaration";
5765 return "DW_TAG_label";
5766 case DW_TAG_lexical_block:
5767 return "DW_TAG_lexical_block";
5769 return "DW_TAG_member";
5770 case DW_TAG_pointer_type:
5771 return "DW_TAG_pointer_type";
5772 case DW_TAG_reference_type:
5773 return "DW_TAG_reference_type";
5774 case DW_TAG_compile_unit:
5775 return "DW_TAG_compile_unit";
5776 case DW_TAG_string_type:
5777 return "DW_TAG_string_type";
5778 case DW_TAG_structure_type:
5779 return "DW_TAG_structure_type";
5780 case DW_TAG_subroutine_type:
5781 return "DW_TAG_subroutine_type";
5782 case DW_TAG_typedef:
5783 return "DW_TAG_typedef";
5784 case DW_TAG_union_type:
5785 return "DW_TAG_union_type";
5786 case DW_TAG_unspecified_parameters:
5787 return "DW_TAG_unspecified_parameters";
5788 case DW_TAG_variant:
5789 return "DW_TAG_variant";
5790 case DW_TAG_common_block:
5791 return "DW_TAG_common_block";
5792 case DW_TAG_common_inclusion:
5793 return "DW_TAG_common_inclusion";
5794 case DW_TAG_inheritance:
5795 return "DW_TAG_inheritance";
5796 case DW_TAG_inlined_subroutine:
5797 return "DW_TAG_inlined_subroutine";
5799 return "DW_TAG_module";
5800 case DW_TAG_ptr_to_member_type:
5801 return "DW_TAG_ptr_to_member_type";
5802 case DW_TAG_set_type:
5803 return "DW_TAG_set_type";
5804 case DW_TAG_subrange_type:
5805 return "DW_TAG_subrange_type";
5806 case DW_TAG_with_stmt:
5807 return "DW_TAG_with_stmt";
5808 case DW_TAG_access_declaration:
5809 return "DW_TAG_access_declaration";
5810 case DW_TAG_base_type:
5811 return "DW_TAG_base_type";
5812 case DW_TAG_catch_block:
5813 return "DW_TAG_catch_block";
5814 case DW_TAG_const_type:
5815 return "DW_TAG_const_type";
5816 case DW_TAG_constant:
5817 return "DW_TAG_constant";
5818 case DW_TAG_enumerator:
5819 return "DW_TAG_enumerator";
5820 case DW_TAG_file_type:
5821 return "DW_TAG_file_type";
5823 return "DW_TAG_friend";
5824 case DW_TAG_namelist:
5825 return "DW_TAG_namelist";
5826 case DW_TAG_namelist_item:
5827 return "DW_TAG_namelist_item";
5828 case DW_TAG_packed_type:
5829 return "DW_TAG_packed_type";
5830 case DW_TAG_subprogram:
5831 return "DW_TAG_subprogram";
5832 case DW_TAG_template_type_param:
5833 return "DW_TAG_template_type_param";
5834 case DW_TAG_template_value_param:
5835 return "DW_TAG_template_value_param";
5836 case DW_TAG_thrown_type:
5837 return "DW_TAG_thrown_type";
5838 case DW_TAG_try_block:
5839 return "DW_TAG_try_block";
5840 case DW_TAG_variant_part:
5841 return "DW_TAG_variant_part";
5842 case DW_TAG_variable:
5843 return "DW_TAG_variable";
5844 case DW_TAG_volatile_type:
5845 return "DW_TAG_volatile_type";
5846 case DW_TAG_dwarf_procedure:
5847 return "DW_TAG_dwarf_procedure";
5848 case DW_TAG_restrict_type:
5849 return "DW_TAG_restrict_type";
5850 case DW_TAG_interface_type:
5851 return "DW_TAG_interface_type";
5852 case DW_TAG_namespace:
5853 return "DW_TAG_namespace";
5854 case DW_TAG_imported_module:
5855 return "DW_TAG_imported_module";
5856 case DW_TAG_unspecified_type:
5857 return "DW_TAG_unspecified_type";
5858 case DW_TAG_partial_unit:
5859 return "DW_TAG_partial_unit";
5860 case DW_TAG_imported_unit:
5861 return "DW_TAG_imported_unit";
5862 case DW_TAG_condition:
5863 return "DW_TAG_condition";
5864 case DW_TAG_shared_type:
5865 return "DW_TAG_shared_type";
5866 case DW_TAG_MIPS_loop:
5867 return "DW_TAG_MIPS_loop";
5868 case DW_TAG_format_label:
5869 return "DW_TAG_format_label";
5870 case DW_TAG_function_template:
5871 return "DW_TAG_function_template";
5872 case DW_TAG_class_template:
5873 return "DW_TAG_class_template";
5874 case DW_TAG_GNU_BINCL:
5875 return "DW_TAG_GNU_BINCL";
5876 case DW_TAG_GNU_EINCL:
5877 return "DW_TAG_GNU_EINCL";
5879 return "DW_TAG_<unknown>";
5883 /* Convert a DWARF attribute code into its string name. */
5886 dwarf_attr_name (unsigned int attr)
5891 return "DW_AT_sibling";
5892 case DW_AT_location:
5893 return "DW_AT_location";
5895 return "DW_AT_name";
5896 case DW_AT_ordering:
5897 return "DW_AT_ordering";
5898 case DW_AT_subscr_data:
5899 return "DW_AT_subscr_data";
5900 case DW_AT_byte_size:
5901 return "DW_AT_byte_size";
5902 case DW_AT_bit_offset:
5903 return "DW_AT_bit_offset";
5904 case DW_AT_bit_size:
5905 return "DW_AT_bit_size";
5906 case DW_AT_element_list:
5907 return "DW_AT_element_list";
5908 case DW_AT_stmt_list:
5909 return "DW_AT_stmt_list";
5911 return "DW_AT_low_pc";
5913 return "DW_AT_high_pc";
5914 case DW_AT_language:
5915 return "DW_AT_language";
5917 return "DW_AT_member";
5919 return "DW_AT_discr";
5920 case DW_AT_discr_value:
5921 return "DW_AT_discr_value";
5922 case DW_AT_visibility:
5923 return "DW_AT_visibility";
5925 return "DW_AT_import";
5926 case DW_AT_string_length:
5927 return "DW_AT_string_length";
5928 case DW_AT_common_reference:
5929 return "DW_AT_common_reference";
5930 case DW_AT_comp_dir:
5931 return "DW_AT_comp_dir";
5932 case DW_AT_const_value:
5933 return "DW_AT_const_value";
5934 case DW_AT_containing_type:
5935 return "DW_AT_containing_type";
5936 case DW_AT_default_value:
5937 return "DW_AT_default_value";
5939 return "DW_AT_inline";
5940 case DW_AT_is_optional:
5941 return "DW_AT_is_optional";
5942 case DW_AT_lower_bound:
5943 return "DW_AT_lower_bound";
5944 case DW_AT_producer:
5945 return "DW_AT_producer";
5946 case DW_AT_prototyped:
5947 return "DW_AT_prototyped";
5948 case DW_AT_return_addr:
5949 return "DW_AT_return_addr";
5950 case DW_AT_start_scope:
5951 return "DW_AT_start_scope";
5952 case DW_AT_bit_stride:
5953 return "DW_AT_bit_stride";
5954 case DW_AT_upper_bound:
5955 return "DW_AT_upper_bound";
5956 case DW_AT_abstract_origin:
5957 return "DW_AT_abstract_origin";
5958 case DW_AT_accessibility:
5959 return "DW_AT_accessibility";
5960 case DW_AT_address_class:
5961 return "DW_AT_address_class";
5962 case DW_AT_artificial:
5963 return "DW_AT_artificial";
5964 case DW_AT_base_types:
5965 return "DW_AT_base_types";
5966 case DW_AT_calling_convention:
5967 return "DW_AT_calling_convention";
5969 return "DW_AT_count";
5970 case DW_AT_data_member_location:
5971 return "DW_AT_data_member_location";
5972 case DW_AT_decl_column:
5973 return "DW_AT_decl_column";
5974 case DW_AT_decl_file:
5975 return "DW_AT_decl_file";
5976 case DW_AT_decl_line:
5977 return "DW_AT_decl_line";
5978 case DW_AT_declaration:
5979 return "DW_AT_declaration";
5980 case DW_AT_discr_list:
5981 return "DW_AT_discr_list";
5982 case DW_AT_encoding:
5983 return "DW_AT_encoding";
5984 case DW_AT_external:
5985 return "DW_AT_external";
5986 case DW_AT_explicit:
5987 return "DW_AT_explicit";
5988 case DW_AT_frame_base:
5989 return "DW_AT_frame_base";
5991 return "DW_AT_friend";
5992 case DW_AT_identifier_case:
5993 return "DW_AT_identifier_case";
5994 case DW_AT_macro_info:
5995 return "DW_AT_macro_info";
5996 case DW_AT_namelist_items:
5997 return "DW_AT_namelist_items";
5998 case DW_AT_priority:
5999 return "DW_AT_priority";
6001 return "DW_AT_segment";
6002 case DW_AT_specification:
6003 return "DW_AT_specification";
6004 case DW_AT_static_link:
6005 return "DW_AT_static_link";
6007 return "DW_AT_type";
6008 case DW_AT_use_location:
6009 return "DW_AT_use_location";
6010 case DW_AT_variable_parameter:
6011 return "DW_AT_variable_parameter";
6012 case DW_AT_virtuality:
6013 return "DW_AT_virtuality";
6014 case DW_AT_vtable_elem_location:
6015 return "DW_AT_vtable_elem_location";
6017 case DW_AT_allocated:
6018 return "DW_AT_allocated";
6019 case DW_AT_associated:
6020 return "DW_AT_associated";
6021 case DW_AT_data_location:
6022 return "DW_AT_data_location";
6023 case DW_AT_byte_stride:
6024 return "DW_AT_byte_stride";
6025 case DW_AT_entry_pc:
6026 return "DW_AT_entry_pc";
6027 case DW_AT_use_UTF8:
6028 return "DW_AT_use_UTF8";
6029 case DW_AT_extension:
6030 return "DW_AT_extension";
6032 return "DW_AT_ranges";
6033 case DW_AT_trampoline:
6034 return "DW_AT_trampoline";
6035 case DW_AT_call_column:
6036 return "DW_AT_call_column";
6037 case DW_AT_call_file:
6038 return "DW_AT_call_file";
6039 case DW_AT_call_line:
6040 return "DW_AT_call_line";
6042 case DW_AT_MIPS_fde:
6043 return "DW_AT_MIPS_fde";
6044 case DW_AT_MIPS_loop_begin:
6045 return "DW_AT_MIPS_loop_begin";
6046 case DW_AT_MIPS_tail_loop_begin:
6047 return "DW_AT_MIPS_tail_loop_begin";
6048 case DW_AT_MIPS_epilog_begin:
6049 return "DW_AT_MIPS_epilog_begin";
6050 case DW_AT_MIPS_loop_unroll_factor:
6051 return "DW_AT_MIPS_loop_unroll_factor";
6052 case DW_AT_MIPS_software_pipeline_depth:
6053 return "DW_AT_MIPS_software_pipeline_depth";
6054 case DW_AT_MIPS_linkage_name:
6055 return "DW_AT_MIPS_linkage_name";
6056 case DW_AT_MIPS_stride:
6057 return "DW_AT_MIPS_stride";
6058 case DW_AT_MIPS_abstract_name:
6059 return "DW_AT_MIPS_abstract_name";
6060 case DW_AT_MIPS_clone_origin:
6061 return "DW_AT_MIPS_clone_origin";
6062 case DW_AT_MIPS_has_inlines:
6063 return "DW_AT_MIPS_has_inlines";
6065 case DW_AT_sf_names:
6066 return "DW_AT_sf_names";
6067 case DW_AT_src_info:
6068 return "DW_AT_src_info";
6069 case DW_AT_mac_info:
6070 return "DW_AT_mac_info";
6071 case DW_AT_src_coords:
6072 return "DW_AT_src_coords";
6073 case DW_AT_body_begin:
6074 return "DW_AT_body_begin";
6075 case DW_AT_body_end:
6076 return "DW_AT_body_end";
6077 case DW_AT_GNU_vector:
6078 return "DW_AT_GNU_vector";
6080 case DW_AT_VMS_rtnbeg_pd_address:
6081 return "DW_AT_VMS_rtnbeg_pd_address";
6084 return "DW_AT_<unknown>";
6088 /* Convert a DWARF value form code into its string name. */
6091 dwarf_form_name (unsigned int form)
6096 return "DW_FORM_addr";
6097 case DW_FORM_block2:
6098 return "DW_FORM_block2";
6099 case DW_FORM_block4:
6100 return "DW_FORM_block4";
6102 return "DW_FORM_data2";
6104 return "DW_FORM_data4";
6106 return "DW_FORM_data8";
6107 case DW_FORM_string:
6108 return "DW_FORM_string";
6110 return "DW_FORM_block";
6111 case DW_FORM_block1:
6112 return "DW_FORM_block1";
6114 return "DW_FORM_data1";
6116 return "DW_FORM_flag";
6118 return "DW_FORM_sdata";
6120 return "DW_FORM_strp";
6122 return "DW_FORM_udata";
6123 case DW_FORM_ref_addr:
6124 return "DW_FORM_ref_addr";
6126 return "DW_FORM_ref1";
6128 return "DW_FORM_ref2";
6130 return "DW_FORM_ref4";
6132 return "DW_FORM_ref8";
6133 case DW_FORM_ref_udata:
6134 return "DW_FORM_ref_udata";
6135 case DW_FORM_indirect:
6136 return "DW_FORM_indirect";
6138 return "DW_FORM_<unknown>";
6142 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
6143 instance of an inlined instance of a decl which is local to an inline
6144 function, so we have to trace all of the way back through the origin chain
6145 to find out what sort of node actually served as the original seed for the
6149 decl_ultimate_origin (const_tree decl)
6151 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
6154 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
6155 nodes in the function to point to themselves; ignore that if
6156 we're trying to output the abstract instance of this function. */
6157 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
6160 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
6161 most distant ancestor, this should never happen. */
6162 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
6164 return DECL_ABSTRACT_ORIGIN (decl);
6167 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
6168 of a virtual function may refer to a base class, so we check the 'this'
6172 decl_class_context (tree decl)
6174 tree context = NULL_TREE;
6176 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
6177 context = DECL_CONTEXT (decl);
6179 context = TYPE_MAIN_VARIANT
6180 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
6182 if (context && !TYPE_P (context))
6183 context = NULL_TREE;
6188 /* Add an attribute/value pair to a DIE. */
6191 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
6193 /* Maybe this should be an assert? */
6197 if (die->die_attr == NULL)
6198 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
6199 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
6202 static inline enum dw_val_class
6203 AT_class (dw_attr_ref a)
6205 return a->dw_attr_val.val_class;
6208 /* Add a flag value attribute to a DIE. */
6211 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
6215 attr.dw_attr = attr_kind;
6216 attr.dw_attr_val.val_class = dw_val_class_flag;
6217 attr.dw_attr_val.v.val_flag = flag;
6218 add_dwarf_attr (die, &attr);
6221 static inline unsigned
6222 AT_flag (dw_attr_ref a)
6224 gcc_assert (a && AT_class (a) == dw_val_class_flag);
6225 return a->dw_attr_val.v.val_flag;
6228 /* Add a signed integer attribute value to a DIE. */
6231 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
6235 attr.dw_attr = attr_kind;
6236 attr.dw_attr_val.val_class = dw_val_class_const;
6237 attr.dw_attr_val.v.val_int = int_val;
6238 add_dwarf_attr (die, &attr);
6241 static inline HOST_WIDE_INT
6242 AT_int (dw_attr_ref a)
6244 gcc_assert (a && AT_class (a) == dw_val_class_const);
6245 return a->dw_attr_val.v.val_int;
6248 /* Add an unsigned integer attribute value to a DIE. */
6251 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
6252 unsigned HOST_WIDE_INT unsigned_val)
6256 attr.dw_attr = attr_kind;
6257 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
6258 attr.dw_attr_val.v.val_unsigned = unsigned_val;
6259 add_dwarf_attr (die, &attr);
6262 static inline unsigned HOST_WIDE_INT
6263 AT_unsigned (dw_attr_ref a)
6265 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
6266 return a->dw_attr_val.v.val_unsigned;
6269 /* Add an unsigned double integer attribute value to a DIE. */
6272 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
6273 long unsigned int val_hi, long unsigned int val_low)
6277 attr.dw_attr = attr_kind;
6278 attr.dw_attr_val.val_class = dw_val_class_long_long;
6279 attr.dw_attr_val.v.val_long_long.hi = val_hi;
6280 attr.dw_attr_val.v.val_long_long.low = val_low;
6281 add_dwarf_attr (die, &attr);
6284 /* Add a floating point attribute value to a DIE and return it. */
6287 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
6288 unsigned int length, unsigned int elt_size, unsigned char *array)
6292 attr.dw_attr = attr_kind;
6293 attr.dw_attr_val.val_class = dw_val_class_vec;
6294 attr.dw_attr_val.v.val_vec.length = length;
6295 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
6296 attr.dw_attr_val.v.val_vec.array = array;
6297 add_dwarf_attr (die, &attr);
6300 /* Hash and equality functions for debug_str_hash. */
6303 debug_str_do_hash (const void *x)
6305 return htab_hash_string (((const struct indirect_string_node *)x)->str);
6309 debug_str_eq (const void *x1, const void *x2)
6311 return strcmp ((((const struct indirect_string_node *)x1)->str),
6312 (const char *)x2) == 0;
6315 static struct indirect_string_node *
6316 find_AT_string (const char *str)
6318 struct indirect_string_node *node;
6321 if (! debug_str_hash)
6322 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
6323 debug_str_eq, NULL);
6325 slot = htab_find_slot_with_hash (debug_str_hash, str,
6326 htab_hash_string (str), INSERT);
6329 node = (struct indirect_string_node *)
6330 ggc_alloc_cleared (sizeof (struct indirect_string_node));
6331 node->str = ggc_strdup (str);
6335 node = (struct indirect_string_node *) *slot;
6341 /* Add a string attribute value to a DIE. */
6344 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
6347 struct indirect_string_node *node;
6349 node = find_AT_string (str);
6351 attr.dw_attr = attr_kind;
6352 attr.dw_attr_val.val_class = dw_val_class_str;
6353 attr.dw_attr_val.v.val_str = node;
6354 add_dwarf_attr (die, &attr);
6357 static inline const char *
6358 AT_string (dw_attr_ref a)
6360 gcc_assert (a && AT_class (a) == dw_val_class_str);
6361 return a->dw_attr_val.v.val_str->str;
6364 /* Find out whether a string should be output inline in DIE
6365 or out-of-line in .debug_str section. */
6367 static enum dwarf_form
6368 AT_string_form (dw_attr_ref a)
6370 struct indirect_string_node *node;
6374 gcc_assert (a && AT_class (a) == dw_val_class_str);
6376 node = a->dw_attr_val.v.val_str;
6380 len = strlen (node->str) + 1;
6382 /* If the string is shorter or equal to the size of the reference, it is
6383 always better to put it inline. */
6384 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
6385 return node->form = DW_FORM_string;
6387 /* If we cannot expect the linker to merge strings in .debug_str
6388 section, only put it into .debug_str if it is worth even in this
6390 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
6391 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
6392 return node->form = DW_FORM_string;
6394 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
6395 ++dw2_string_counter;
6396 node->label = xstrdup (label);
6398 return node->form = DW_FORM_strp;
6401 /* Add a DIE reference attribute value to a DIE. */
6404 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
6408 attr.dw_attr = attr_kind;
6409 attr.dw_attr_val.val_class = dw_val_class_die_ref;
6410 attr.dw_attr_val.v.val_die_ref.die = targ_die;
6411 attr.dw_attr_val.v.val_die_ref.external = 0;
6412 add_dwarf_attr (die, &attr);
6415 /* Add an AT_specification attribute to a DIE, and also make the back
6416 pointer from the specification to the definition. */
6419 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
6421 add_AT_die_ref (die, DW_AT_specification, targ_die);
6422 gcc_assert (!targ_die->die_definition);
6423 targ_die->die_definition = die;
6426 static inline dw_die_ref
6427 AT_ref (dw_attr_ref a)
6429 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6430 return a->dw_attr_val.v.val_die_ref.die;
6434 AT_ref_external (dw_attr_ref a)
6436 if (a && AT_class (a) == dw_val_class_die_ref)
6437 return a->dw_attr_val.v.val_die_ref.external;
6443 set_AT_ref_external (dw_attr_ref a, int i)
6445 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6446 a->dw_attr_val.v.val_die_ref.external = i;
6449 /* Add an FDE reference attribute value to a DIE. */
6452 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
6456 attr.dw_attr = attr_kind;
6457 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
6458 attr.dw_attr_val.v.val_fde_index = targ_fde;
6459 add_dwarf_attr (die, &attr);
6462 /* Add a location description attribute value to a DIE. */
6465 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
6469 attr.dw_attr = attr_kind;
6470 attr.dw_attr_val.val_class = dw_val_class_loc;
6471 attr.dw_attr_val.v.val_loc = loc;
6472 add_dwarf_attr (die, &attr);
6475 static inline dw_loc_descr_ref
6476 AT_loc (dw_attr_ref a)
6478 gcc_assert (a && AT_class (a) == dw_val_class_loc);
6479 return a->dw_attr_val.v.val_loc;
6483 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
6487 attr.dw_attr = attr_kind;
6488 attr.dw_attr_val.val_class = dw_val_class_loc_list;
6489 attr.dw_attr_val.v.val_loc_list = loc_list;
6490 add_dwarf_attr (die, &attr);
6491 have_location_lists = true;
6494 static inline dw_loc_list_ref
6495 AT_loc_list (dw_attr_ref a)
6497 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
6498 return a->dw_attr_val.v.val_loc_list;
6501 /* Add an address constant attribute value to a DIE. */
6504 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
6508 attr.dw_attr = attr_kind;
6509 attr.dw_attr_val.val_class = dw_val_class_addr;
6510 attr.dw_attr_val.v.val_addr = addr;
6511 add_dwarf_attr (die, &attr);
6514 /* Get the RTX from to an address DIE attribute. */
6517 AT_addr (dw_attr_ref a)
6519 gcc_assert (a && AT_class (a) == dw_val_class_addr);
6520 return a->dw_attr_val.v.val_addr;
6523 /* Add a file attribute value to a DIE. */
6526 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
6527 struct dwarf_file_data *fd)
6531 attr.dw_attr = attr_kind;
6532 attr.dw_attr_val.val_class = dw_val_class_file;
6533 attr.dw_attr_val.v.val_file = fd;
6534 add_dwarf_attr (die, &attr);
6537 /* Get the dwarf_file_data from a file DIE attribute. */
6539 static inline struct dwarf_file_data *
6540 AT_file (dw_attr_ref a)
6542 gcc_assert (a && AT_class (a) == dw_val_class_file);
6543 return a->dw_attr_val.v.val_file;
6546 /* Add a label identifier attribute value to a DIE. */
6549 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
6553 attr.dw_attr = attr_kind;
6554 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
6555 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
6556 add_dwarf_attr (die, &attr);
6559 /* Add a section offset attribute value to a DIE, an offset into the
6560 debug_line section. */
6563 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6568 attr.dw_attr = attr_kind;
6569 attr.dw_attr_val.val_class = dw_val_class_lineptr;
6570 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6571 add_dwarf_attr (die, &attr);
6574 /* Add a section offset attribute value to a DIE, an offset into the
6575 debug_macinfo section. */
6578 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6583 attr.dw_attr = attr_kind;
6584 attr.dw_attr_val.val_class = dw_val_class_macptr;
6585 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6586 add_dwarf_attr (die, &attr);
6589 /* Add an offset attribute value to a DIE. */
6592 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
6593 unsigned HOST_WIDE_INT offset)
6597 attr.dw_attr = attr_kind;
6598 attr.dw_attr_val.val_class = dw_val_class_offset;
6599 attr.dw_attr_val.v.val_offset = offset;
6600 add_dwarf_attr (die, &attr);
6603 /* Add an range_list attribute value to a DIE. */
6606 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
6607 long unsigned int offset)
6611 attr.dw_attr = attr_kind;
6612 attr.dw_attr_val.val_class = dw_val_class_range_list;
6613 attr.dw_attr_val.v.val_offset = offset;
6614 add_dwarf_attr (die, &attr);
6617 static inline const char *
6618 AT_lbl (dw_attr_ref a)
6620 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
6621 || AT_class (a) == dw_val_class_lineptr
6622 || AT_class (a) == dw_val_class_macptr));
6623 return a->dw_attr_val.v.val_lbl_id;
6626 /* Get the attribute of type attr_kind. */
6629 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6633 dw_die_ref spec = NULL;
6638 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6639 if (a->dw_attr == attr_kind)
6641 else if (a->dw_attr == DW_AT_specification
6642 || a->dw_attr == DW_AT_abstract_origin)
6646 return get_AT (spec, attr_kind);
6651 /* Return the "low pc" attribute value, typically associated with a subprogram
6652 DIE. Return null if the "low pc" attribute is either not present, or if it
6653 cannot be represented as an assembler label identifier. */
6655 static inline const char *
6656 get_AT_low_pc (dw_die_ref die)
6658 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
6660 return a ? AT_lbl (a) : NULL;
6663 /* Return the "high pc" attribute value, typically associated with a subprogram
6664 DIE. Return null if the "high pc" attribute is either not present, or if it
6665 cannot be represented as an assembler label identifier. */
6667 static inline const char *
6668 get_AT_hi_pc (dw_die_ref die)
6670 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
6672 return a ? AT_lbl (a) : NULL;
6675 /* Return the value of the string attribute designated by ATTR_KIND, or
6676 NULL if it is not present. */
6678 static inline const char *
6679 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
6681 dw_attr_ref a = get_AT (die, attr_kind);
6683 return a ? AT_string (a) : NULL;
6686 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
6687 if it is not present. */
6690 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
6692 dw_attr_ref a = get_AT (die, attr_kind);
6694 return a ? AT_flag (a) : 0;
6697 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
6698 if it is not present. */
6700 static inline unsigned
6701 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
6703 dw_attr_ref a = get_AT (die, attr_kind);
6705 return a ? AT_unsigned (a) : 0;
6708 static inline dw_die_ref
6709 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
6711 dw_attr_ref a = get_AT (die, attr_kind);
6713 return a ? AT_ref (a) : NULL;
6716 static inline struct dwarf_file_data *
6717 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
6719 dw_attr_ref a = get_AT (die, attr_kind);
6721 return a ? AT_file (a) : NULL;
6724 /* Return TRUE if the language is C or C++. */
6729 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6731 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
6732 || lang == DW_LANG_C99
6733 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
6736 /* Return TRUE if the language is C++. */
6741 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6743 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
6746 /* Return TRUE if the language is Fortran. */
6751 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6753 return (lang == DW_LANG_Fortran77
6754 || lang == DW_LANG_Fortran90
6755 || lang == DW_LANG_Fortran95);
6758 /* Return TRUE if the language is Java. */
6763 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6765 return lang == DW_LANG_Java;
6768 /* Return TRUE if the language is Ada. */
6773 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6775 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
6778 /* Remove the specified attribute if present. */
6781 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6789 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6790 if (a->dw_attr == attr_kind)
6792 if (AT_class (a) == dw_val_class_str)
6793 if (a->dw_attr_val.v.val_str->refcount)
6794 a->dw_attr_val.v.val_str->refcount--;
6796 /* VEC_ordered_remove should help reduce the number of abbrevs
6798 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
6803 /* Remove CHILD from its parent. PREV must have the property that
6804 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
6807 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
6809 gcc_assert (child->die_parent == prev->die_parent);
6810 gcc_assert (prev->die_sib == child);
6813 gcc_assert (child->die_parent->die_child == child);
6817 prev->die_sib = child->die_sib;
6818 if (child->die_parent->die_child == child)
6819 child->die_parent->die_child = prev;
6822 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
6826 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
6832 dw_die_ref prev = c;
6834 while (c->die_tag == tag)
6836 remove_child_with_prev (c, prev);
6837 /* Might have removed every child. */
6838 if (c == c->die_sib)
6842 } while (c != die->die_child);
6845 /* Add a CHILD_DIE as the last child of DIE. */
6848 add_child_die (dw_die_ref die, dw_die_ref child_die)
6850 /* FIXME this should probably be an assert. */
6851 if (! die || ! child_die)
6853 gcc_assert (die != child_die);
6855 child_die->die_parent = die;
6858 child_die->die_sib = die->die_child->die_sib;
6859 die->die_child->die_sib = child_die;
6862 child_die->die_sib = child_die;
6863 die->die_child = child_die;
6866 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
6867 is the specification, to the end of PARENT's list of children.
6868 This is done by removing and re-adding it. */
6871 splice_child_die (dw_die_ref parent, dw_die_ref child)
6875 /* We want the declaration DIE from inside the class, not the
6876 specification DIE at toplevel. */
6877 if (child->die_parent != parent)
6879 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
6885 gcc_assert (child->die_parent == parent
6886 || (child->die_parent
6887 == get_AT_ref (parent, DW_AT_specification)));
6889 for (p = child->die_parent->die_child; ; p = p->die_sib)
6890 if (p->die_sib == child)
6892 remove_child_with_prev (child, p);
6896 add_child_die (parent, child);
6899 /* Return a pointer to a newly created DIE node. */
6901 static inline dw_die_ref
6902 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
6904 dw_die_ref die = GGC_CNEW (die_node);
6906 die->die_tag = tag_value;
6908 if (parent_die != NULL)
6909 add_child_die (parent_die, die);
6912 limbo_die_node *limbo_node;
6914 limbo_node = GGC_CNEW (limbo_die_node);
6915 limbo_node->die = die;
6916 limbo_node->created_for = t;
6917 limbo_node->next = limbo_die_list;
6918 limbo_die_list = limbo_node;
6924 /* Return the DIE associated with the given type specifier. */
6926 static inline dw_die_ref
6927 lookup_type_die (tree type)
6929 return TYPE_SYMTAB_DIE (type);
6932 /* Equate a DIE to a given type specifier. */
6935 equate_type_number_to_die (tree type, dw_die_ref type_die)
6937 TYPE_SYMTAB_DIE (type) = type_die;
6940 /* Returns a hash value for X (which really is a die_struct). */
6943 decl_die_table_hash (const void *x)
6945 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
6948 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
6951 decl_die_table_eq (const void *x, const void *y)
6953 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
6956 /* Return the DIE associated with a given declaration. */
6958 static inline dw_die_ref
6959 lookup_decl_die (tree decl)
6961 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
6964 /* Returns a hash value for X (which really is a var_loc_list). */
6967 decl_loc_table_hash (const void *x)
6969 return (hashval_t) ((const var_loc_list *) x)->decl_id;
6972 /* Return nonzero if decl_id of var_loc_list X is the same as
6976 decl_loc_table_eq (const void *x, const void *y)
6978 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
6981 /* Return the var_loc list associated with a given declaration. */
6983 static inline var_loc_list *
6984 lookup_decl_loc (const_tree decl)
6986 return (var_loc_list *)
6987 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
6990 /* Equate a DIE to a particular declaration. */
6993 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
6995 unsigned int decl_id = DECL_UID (decl);
6998 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
7000 decl_die->decl_id = decl_id;
7003 /* Add a variable location node to the linked list for DECL. */
7006 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
7008 unsigned int decl_id = DECL_UID (decl);
7012 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
7015 temp = GGC_CNEW (var_loc_list);
7016 temp->decl_id = decl_id;
7020 temp = (var_loc_list *) *slot;
7024 /* If the current location is the same as the end of the list,
7025 and either both or neither of the locations is uninitialized,
7026 we have nothing to do. */
7027 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
7028 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
7029 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7030 != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
7031 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
7032 == VAR_INIT_STATUS_UNINITIALIZED)
7033 || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
7034 == VAR_INIT_STATUS_UNINITIALIZED))))
7036 /* Add LOC to the end of list and update LAST. */
7037 temp->last->next = loc;
7041 /* Do not add empty location to the beginning of the list. */
7042 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
7049 /* Keep track of the number of spaces used to indent the
7050 output of the debugging routines that print the structure of
7051 the DIE internal representation. */
7052 static int print_indent;
7054 /* Indent the line the number of spaces given by print_indent. */
7057 print_spaces (FILE *outfile)
7059 fprintf (outfile, "%*s", print_indent, "");
7062 /* Print the information associated with a given DIE, and its children.
7063 This routine is a debugging aid only. */
7066 print_die (dw_die_ref die, FILE *outfile)
7072 print_spaces (outfile);
7073 fprintf (outfile, "DIE %4ld: %s\n",
7074 die->die_offset, dwarf_tag_name (die->die_tag));
7075 print_spaces (outfile);
7076 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
7077 fprintf (outfile, " offset: %ld\n", die->die_offset);
7079 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7081 print_spaces (outfile);
7082 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
7084 switch (AT_class (a))
7086 case dw_val_class_addr:
7087 fprintf (outfile, "address");
7089 case dw_val_class_offset:
7090 fprintf (outfile, "offset");
7092 case dw_val_class_loc:
7093 fprintf (outfile, "location descriptor");
7095 case dw_val_class_loc_list:
7096 fprintf (outfile, "location list -> label:%s",
7097 AT_loc_list (a)->ll_symbol);
7099 case dw_val_class_range_list:
7100 fprintf (outfile, "range list");
7102 case dw_val_class_const:
7103 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
7105 case dw_val_class_unsigned_const:
7106 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
7108 case dw_val_class_long_long:
7109 fprintf (outfile, "constant (%lu,%lu)",
7110 a->dw_attr_val.v.val_long_long.hi,
7111 a->dw_attr_val.v.val_long_long.low);
7113 case dw_val_class_vec:
7114 fprintf (outfile, "floating-point or vector constant");
7116 case dw_val_class_flag:
7117 fprintf (outfile, "%u", AT_flag (a));
7119 case dw_val_class_die_ref:
7120 if (AT_ref (a) != NULL)
7122 if (AT_ref (a)->die_symbol)
7123 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
7125 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
7128 fprintf (outfile, "die -> <null>");
7130 case dw_val_class_lbl_id:
7131 case dw_val_class_lineptr:
7132 case dw_val_class_macptr:
7133 fprintf (outfile, "label: %s", AT_lbl (a));
7135 case dw_val_class_str:
7136 if (AT_string (a) != NULL)
7137 fprintf (outfile, "\"%s\"", AT_string (a));
7139 fprintf (outfile, "<null>");
7141 case dw_val_class_file:
7142 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
7143 AT_file (a)->emitted_number);
7149 fprintf (outfile, "\n");
7152 if (die->die_child != NULL)
7155 FOR_EACH_CHILD (die, c, print_die (c, outfile));
7158 if (print_indent == 0)
7159 fprintf (outfile, "\n");
7162 /* Print the contents of the source code line number correspondence table.
7163 This routine is a debugging aid only. */
7166 print_dwarf_line_table (FILE *outfile)
7169 dw_line_info_ref line_info;
7171 fprintf (outfile, "\n\nDWARF source line information\n");
7172 for (i = 1; i < line_info_table_in_use; i++)
7174 line_info = &line_info_table[i];
7175 fprintf (outfile, "%5d: %4ld %6ld\n", i,
7176 line_info->dw_file_num,
7177 line_info->dw_line_num);
7180 fprintf (outfile, "\n\n");
7183 /* Print the information collected for a given DIE. */
7186 debug_dwarf_die (dw_die_ref die)
7188 print_die (die, stderr);
7191 /* Print all DWARF information collected for the compilation unit.
7192 This routine is a debugging aid only. */
7198 print_die (comp_unit_die, stderr);
7199 if (! DWARF2_ASM_LINE_DEBUG_INFO)
7200 print_dwarf_line_table (stderr);
7203 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
7204 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
7205 DIE that marks the start of the DIEs for this include file. */
7208 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
7210 const char *filename = get_AT_string (bincl_die, DW_AT_name);
7211 dw_die_ref new_unit = gen_compile_unit_die (filename);
7213 new_unit->die_sib = old_unit;
7217 /* Close an include-file CU and reopen the enclosing one. */
7220 pop_compile_unit (dw_die_ref old_unit)
7222 dw_die_ref new_unit = old_unit->die_sib;
7224 old_unit->die_sib = NULL;
7228 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7229 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
7231 /* Calculate the checksum of a location expression. */
7234 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
7236 CHECKSUM (loc->dw_loc_opc);
7237 CHECKSUM (loc->dw_loc_oprnd1);
7238 CHECKSUM (loc->dw_loc_oprnd2);
7241 /* Calculate the checksum of an attribute. */
7244 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
7246 dw_loc_descr_ref loc;
7249 CHECKSUM (at->dw_attr);
7251 /* We don't care that this was compiled with a different compiler
7252 snapshot; if the output is the same, that's what matters. */
7253 if (at->dw_attr == DW_AT_producer)
7256 switch (AT_class (at))
7258 case dw_val_class_const:
7259 CHECKSUM (at->dw_attr_val.v.val_int);
7261 case dw_val_class_unsigned_const:
7262 CHECKSUM (at->dw_attr_val.v.val_unsigned);
7264 case dw_val_class_long_long:
7265 CHECKSUM (at->dw_attr_val.v.val_long_long);
7267 case dw_val_class_vec:
7268 CHECKSUM (at->dw_attr_val.v.val_vec);
7270 case dw_val_class_flag:
7271 CHECKSUM (at->dw_attr_val.v.val_flag);
7273 case dw_val_class_str:
7274 CHECKSUM_STRING (AT_string (at));
7277 case dw_val_class_addr:
7279 gcc_assert (GET_CODE (r) == SYMBOL_REF);
7280 CHECKSUM_STRING (XSTR (r, 0));
7283 case dw_val_class_offset:
7284 CHECKSUM (at->dw_attr_val.v.val_offset);
7287 case dw_val_class_loc:
7288 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
7289 loc_checksum (loc, ctx);
7292 case dw_val_class_die_ref:
7293 die_checksum (AT_ref (at), ctx, mark);
7296 case dw_val_class_fde_ref:
7297 case dw_val_class_lbl_id:
7298 case dw_val_class_lineptr:
7299 case dw_val_class_macptr:
7302 case dw_val_class_file:
7303 CHECKSUM_STRING (AT_file (at)->filename);
7311 /* Calculate the checksum of a DIE. */
7314 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
7320 /* To avoid infinite recursion. */
7323 CHECKSUM (die->die_mark);
7326 die->die_mark = ++(*mark);
7328 CHECKSUM (die->die_tag);
7330 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7331 attr_checksum (a, ctx, mark);
7333 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
7337 #undef CHECKSUM_STRING
7339 /* Do the location expressions look same? */
7341 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
7343 return loc1->dw_loc_opc == loc2->dw_loc_opc
7344 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
7345 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
7348 /* Do the values look the same? */
7350 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
7352 dw_loc_descr_ref loc1, loc2;
7355 if (v1->val_class != v2->val_class)
7358 switch (v1->val_class)
7360 case dw_val_class_const:
7361 return v1->v.val_int == v2->v.val_int;
7362 case dw_val_class_unsigned_const:
7363 return v1->v.val_unsigned == v2->v.val_unsigned;
7364 case dw_val_class_long_long:
7365 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
7366 && v1->v.val_long_long.low == v2->v.val_long_long.low;
7367 case dw_val_class_vec:
7368 if (v1->v.val_vec.length != v2->v.val_vec.length
7369 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
7371 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
7372 v1->v.val_vec.length * v1->v.val_vec.elt_size))
7375 case dw_val_class_flag:
7376 return v1->v.val_flag == v2->v.val_flag;
7377 case dw_val_class_str:
7378 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
7380 case dw_val_class_addr:
7381 r1 = v1->v.val_addr;
7382 r2 = v2->v.val_addr;
7383 if (GET_CODE (r1) != GET_CODE (r2))
7385 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
7386 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
7388 case dw_val_class_offset:
7389 return v1->v.val_offset == v2->v.val_offset;
7391 case dw_val_class_loc:
7392 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
7394 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7395 if (!same_loc_p (loc1, loc2, mark))
7397 return !loc1 && !loc2;
7399 case dw_val_class_die_ref:
7400 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7402 case dw_val_class_fde_ref:
7403 case dw_val_class_lbl_id:
7404 case dw_val_class_lineptr:
7405 case dw_val_class_macptr:
7408 case dw_val_class_file:
7409 return v1->v.val_file == v2->v.val_file;
7416 /* Do the attributes look the same? */
7419 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
7421 if (at1->dw_attr != at2->dw_attr)
7424 /* We don't care that this was compiled with a different compiler
7425 snapshot; if the output is the same, that's what matters. */
7426 if (at1->dw_attr == DW_AT_producer)
7429 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7432 /* Do the dies look the same? */
7435 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7441 /* To avoid infinite recursion. */
7443 return die1->die_mark == die2->die_mark;
7444 die1->die_mark = die2->die_mark = ++(*mark);
7446 if (die1->die_tag != die2->die_tag)
7449 if (VEC_length (dw_attr_node, die1->die_attr)
7450 != VEC_length (dw_attr_node, die2->die_attr))
7453 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
7454 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
7457 c1 = die1->die_child;
7458 c2 = die2->die_child;
7467 if (!same_die_p (c1, c2, mark))
7471 if (c1 == die1->die_child)
7473 if (c2 == die2->die_child)
7483 /* Do the dies look the same? Wrapper around same_die_p. */
7486 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
7489 int ret = same_die_p (die1, die2, &mark);
7491 unmark_all_dies (die1);
7492 unmark_all_dies (die2);
7497 /* The prefix to attach to symbols on DIEs in the current comdat debug
7499 static char *comdat_symbol_id;
7501 /* The index of the current symbol within the current comdat CU. */
7502 static unsigned int comdat_symbol_number;
7504 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7505 children, and set comdat_symbol_id accordingly. */
7508 compute_section_prefix (dw_die_ref unit_die)
7510 const char *die_name = get_AT_string (unit_die, DW_AT_name);
7511 const char *base = die_name ? lbasename (die_name) : "anonymous";
7512 char *name = XALLOCAVEC (char, strlen (base) + 64);
7515 unsigned char checksum[16];
7518 /* Compute the checksum of the DIE, then append part of it as hex digits to
7519 the name filename of the unit. */
7521 md5_init_ctx (&ctx);
7523 die_checksum (unit_die, &ctx, &mark);
7524 unmark_all_dies (unit_die);
7525 md5_finish_ctx (&ctx, checksum);
7527 sprintf (name, "%s.", base);
7528 clean_symbol_name (name);
7530 p = name + strlen (name);
7531 for (i = 0; i < 4; i++)
7533 sprintf (p, "%.2x", checksum[i]);
7537 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
7538 comdat_symbol_number = 0;
7541 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7544 is_type_die (dw_die_ref die)
7546 switch (die->die_tag)
7548 case DW_TAG_array_type:
7549 case DW_TAG_class_type:
7550 case DW_TAG_interface_type:
7551 case DW_TAG_enumeration_type:
7552 case DW_TAG_pointer_type:
7553 case DW_TAG_reference_type:
7554 case DW_TAG_string_type:
7555 case DW_TAG_structure_type:
7556 case DW_TAG_subroutine_type:
7557 case DW_TAG_union_type:
7558 case DW_TAG_ptr_to_member_type:
7559 case DW_TAG_set_type:
7560 case DW_TAG_subrange_type:
7561 case DW_TAG_base_type:
7562 case DW_TAG_const_type:
7563 case DW_TAG_file_type:
7564 case DW_TAG_packed_type:
7565 case DW_TAG_volatile_type:
7566 case DW_TAG_typedef:
7573 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7574 Basically, we want to choose the bits that are likely to be shared between
7575 compilations (types) and leave out the bits that are specific to individual
7576 compilations (functions). */
7579 is_comdat_die (dw_die_ref c)
7581 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7582 we do for stabs. The advantage is a greater likelihood of sharing between
7583 objects that don't include headers in the same order (and therefore would
7584 put the base types in a different comdat). jason 8/28/00 */
7586 if (c->die_tag == DW_TAG_base_type)
7589 if (c->die_tag == DW_TAG_pointer_type
7590 || c->die_tag == DW_TAG_reference_type
7591 || c->die_tag == DW_TAG_const_type
7592 || c->die_tag == DW_TAG_volatile_type)
7594 dw_die_ref t = get_AT_ref (c, DW_AT_type);
7596 return t ? is_comdat_die (t) : 0;
7599 return is_type_die (c);
7602 /* Returns 1 iff C is the sort of DIE that might be referred to from another
7603 compilation unit. */
7606 is_symbol_die (dw_die_ref c)
7608 return (is_type_die (c)
7609 || (get_AT (c, DW_AT_declaration)
7610 && !get_AT (c, DW_AT_specification))
7611 || c->die_tag == DW_TAG_namespace
7612 || c->die_tag == DW_TAG_module);
7616 gen_internal_sym (const char *prefix)
7620 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
7621 return xstrdup (buf);
7624 /* Assign symbols to all worthy DIEs under DIE. */
7627 assign_symbol_names (dw_die_ref die)
7631 if (is_symbol_die (die))
7633 if (comdat_symbol_id)
7635 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
7637 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
7638 comdat_symbol_id, comdat_symbol_number++);
7639 die->die_symbol = xstrdup (p);
7642 die->die_symbol = gen_internal_sym ("LDIE");
7645 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
7648 struct cu_hash_table_entry
7651 unsigned min_comdat_num, max_comdat_num;
7652 struct cu_hash_table_entry *next;
7655 /* Routines to manipulate hash table of CUs. */
7657 htab_cu_hash (const void *of)
7659 const struct cu_hash_table_entry *const entry =
7660 (const struct cu_hash_table_entry *) of;
7662 return htab_hash_string (entry->cu->die_symbol);
7666 htab_cu_eq (const void *of1, const void *of2)
7668 const struct cu_hash_table_entry *const entry1 =
7669 (const struct cu_hash_table_entry *) of1;
7670 const struct die_struct *const entry2 = (const struct die_struct *) of2;
7672 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
7676 htab_cu_del (void *what)
7678 struct cu_hash_table_entry *next,
7679 *entry = (struct cu_hash_table_entry *) what;
7689 /* Check whether we have already seen this CU and set up SYM_NUM
7692 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
7694 struct cu_hash_table_entry dummy;
7695 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
7697 dummy.max_comdat_num = 0;
7699 slot = (struct cu_hash_table_entry **)
7700 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7704 for (; entry; last = entry, entry = entry->next)
7706 if (same_die_p_wrap (cu, entry->cu))
7712 *sym_num = entry->min_comdat_num;
7716 entry = XCNEW (struct cu_hash_table_entry);
7718 entry->min_comdat_num = *sym_num = last->max_comdat_num;
7719 entry->next = *slot;
7725 /* Record SYM_NUM to record of CU in HTABLE. */
7727 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
7729 struct cu_hash_table_entry **slot, *entry;
7731 slot = (struct cu_hash_table_entry **)
7732 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7736 entry->max_comdat_num = sym_num;
7739 /* Traverse the DIE (which is always comp_unit_die), and set up
7740 additional compilation units for each of the include files we see
7741 bracketed by BINCL/EINCL. */
7744 break_out_includes (dw_die_ref die)
7747 dw_die_ref unit = NULL;
7748 limbo_die_node *node, **pnode;
7749 htab_t cu_hash_table;
7753 dw_die_ref prev = c;
7755 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
7756 || (unit && is_comdat_die (c)))
7758 dw_die_ref next = c->die_sib;
7760 /* This DIE is for a secondary CU; remove it from the main one. */
7761 remove_child_with_prev (c, prev);
7763 if (c->die_tag == DW_TAG_GNU_BINCL)
7764 unit = push_new_compile_unit (unit, c);
7765 else if (c->die_tag == DW_TAG_GNU_EINCL)
7766 unit = pop_compile_unit (unit);
7768 add_child_die (unit, c);
7770 if (c == die->die_child)
7773 } while (c != die->die_child);
7776 /* We can only use this in debugging, since the frontend doesn't check
7777 to make sure that we leave every include file we enter. */
7781 assign_symbol_names (die);
7782 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
7783 for (node = limbo_die_list, pnode = &limbo_die_list;
7789 compute_section_prefix (node->die);
7790 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
7791 &comdat_symbol_number);
7792 assign_symbol_names (node->die);
7794 *pnode = node->next;
7797 pnode = &node->next;
7798 record_comdat_symbol_number (node->die, cu_hash_table,
7799 comdat_symbol_number);
7802 htab_delete (cu_hash_table);
7805 /* Traverse the DIE and add a sibling attribute if it may have the
7806 effect of speeding up access to siblings. To save some space,
7807 avoid generating sibling attributes for DIE's without children. */
7810 add_sibling_attributes (dw_die_ref die)
7814 if (! die->die_child)
7817 if (die->die_parent && die != die->die_parent->die_child)
7818 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7820 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7823 /* Output all location lists for the DIE and its children. */
7826 output_location_lists (dw_die_ref die)
7832 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7833 if (AT_class (a) == dw_val_class_loc_list)
7834 output_loc_list (AT_loc_list (a));
7836 FOR_EACH_CHILD (die, c, output_location_lists (c));
7839 /* The format of each DIE (and its attribute value pairs) is encoded in an
7840 abbreviation table. This routine builds the abbreviation table and assigns
7841 a unique abbreviation id for each abbreviation entry. The children of each
7842 die are visited recursively. */
7845 build_abbrev_table (dw_die_ref die)
7847 unsigned long abbrev_id;
7848 unsigned int n_alloc;
7853 /* Scan the DIE references, and mark as external any that refer to
7854 DIEs from other CUs (i.e. those which are not marked). */
7855 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7856 if (AT_class (a) == dw_val_class_die_ref
7857 && AT_ref (a)->die_mark == 0)
7859 gcc_assert (AT_ref (a)->die_symbol);
7861 set_AT_ref_external (a, 1);
7864 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7866 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7867 dw_attr_ref die_a, abbrev_a;
7871 if (abbrev->die_tag != die->die_tag)
7873 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7876 if (VEC_length (dw_attr_node, abbrev->die_attr)
7877 != VEC_length (dw_attr_node, die->die_attr))
7880 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
7882 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
7883 if ((abbrev_a->dw_attr != die_a->dw_attr)
7884 || (value_format (abbrev_a) != value_format (die_a)))
7894 if (abbrev_id >= abbrev_die_table_in_use)
7896 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7898 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7899 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7902 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7903 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7904 abbrev_die_table_allocated = n_alloc;
7907 ++abbrev_die_table_in_use;
7908 abbrev_die_table[abbrev_id] = die;
7911 die->die_abbrev = abbrev_id;
7912 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
7915 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7918 constant_size (unsigned HOST_WIDE_INT value)
7925 log = floor_log2 (value);
7928 log = 1 << (floor_log2 (log) + 1);
7933 /* Return the size of a DIE as it is represented in the
7934 .debug_info section. */
7936 static unsigned long
7937 size_of_die (dw_die_ref die)
7939 unsigned long size = 0;
7943 size += size_of_uleb128 (die->die_abbrev);
7944 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7946 switch (AT_class (a))
7948 case dw_val_class_addr:
7949 size += DWARF2_ADDR_SIZE;
7951 case dw_val_class_offset:
7952 size += DWARF_OFFSET_SIZE;
7954 case dw_val_class_loc:
7956 unsigned long lsize = size_of_locs (AT_loc (a));
7959 size += constant_size (lsize);
7963 case dw_val_class_loc_list:
7964 size += DWARF_OFFSET_SIZE;
7966 case dw_val_class_range_list:
7967 size += DWARF_OFFSET_SIZE;
7969 case dw_val_class_const:
7970 size += size_of_sleb128 (AT_int (a));
7972 case dw_val_class_unsigned_const:
7973 size += constant_size (AT_unsigned (a));
7975 case dw_val_class_long_long:
7976 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
7978 case dw_val_class_vec:
7979 size += constant_size (a->dw_attr_val.v.val_vec.length
7980 * a->dw_attr_val.v.val_vec.elt_size)
7981 + a->dw_attr_val.v.val_vec.length
7982 * a->dw_attr_val.v.val_vec.elt_size; /* block */
7984 case dw_val_class_flag:
7987 case dw_val_class_die_ref:
7988 if (AT_ref_external (a))
7989 size += DWARF2_ADDR_SIZE;
7991 size += DWARF_OFFSET_SIZE;
7993 case dw_val_class_fde_ref:
7994 size += DWARF_OFFSET_SIZE;
7996 case dw_val_class_lbl_id:
7997 size += DWARF2_ADDR_SIZE;
7999 case dw_val_class_lineptr:
8000 case dw_val_class_macptr:
8001 size += DWARF_OFFSET_SIZE;
8003 case dw_val_class_str:
8004 if (AT_string_form (a) == DW_FORM_strp)
8005 size += DWARF_OFFSET_SIZE;
8007 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
8009 case dw_val_class_file:
8010 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
8020 /* Size the debugging information associated with a given DIE. Visits the
8021 DIE's children recursively. Updates the global variable next_die_offset, on
8022 each time through. Uses the current value of next_die_offset to update the
8023 die_offset field in each DIE. */
8026 calc_die_sizes (dw_die_ref die)
8030 die->die_offset = next_die_offset;
8031 next_die_offset += size_of_die (die);
8033 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
8035 if (die->die_child != NULL)
8036 /* Count the null byte used to terminate sibling lists. */
8037 next_die_offset += 1;
8040 /* Set the marks for a die and its children. We do this so
8041 that we know whether or not a reference needs to use FORM_ref_addr; only
8042 DIEs in the same CU will be marked. We used to clear out the offset
8043 and use that as the flag, but ran into ordering problems. */
8046 mark_dies (dw_die_ref die)
8050 gcc_assert (!die->die_mark);
8053 FOR_EACH_CHILD (die, c, mark_dies (c));
8056 /* Clear the marks for a die and its children. */
8059 unmark_dies (dw_die_ref die)
8063 gcc_assert (die->die_mark);
8066 FOR_EACH_CHILD (die, c, unmark_dies (c));
8069 /* Clear the marks for a die, its children and referred dies. */
8072 unmark_all_dies (dw_die_ref die)
8082 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
8084 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8085 if (AT_class (a) == dw_val_class_die_ref)
8086 unmark_all_dies (AT_ref (a));
8089 /* Return the size of the .debug_pubnames or .debug_pubtypes table
8090 generated for the compilation unit. */
8092 static unsigned long
8093 size_of_pubnames (VEC (pubname_entry, gc) * names)
8099 size = DWARF_PUBNAMES_HEADER_SIZE;
8100 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
8101 if (names != pubtype_table
8102 || p->die->die_offset != 0
8103 || !flag_eliminate_unused_debug_types)
8104 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
8106 size += DWARF_OFFSET_SIZE;
8110 /* Return the size of the information in the .debug_aranges section. */
8112 static unsigned long
8113 size_of_aranges (void)
8117 size = DWARF_ARANGES_HEADER_SIZE;
8119 /* Count the address/length pair for this compilation unit. */
8120 if (text_section_used)
8121 size += 2 * DWARF2_ADDR_SIZE;
8122 if (cold_text_section_used)
8123 size += 2 * DWARF2_ADDR_SIZE;
8124 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
8126 /* Count the two zero words used to terminated the address range table. */
8127 size += 2 * DWARF2_ADDR_SIZE;
8131 /* Select the encoding of an attribute value. */
8133 static enum dwarf_form
8134 value_format (dw_attr_ref a)
8136 switch (a->dw_attr_val.val_class)
8138 case dw_val_class_addr:
8139 return DW_FORM_addr;
8140 case dw_val_class_range_list:
8141 case dw_val_class_offset:
8142 case dw_val_class_loc_list:
8143 switch (DWARF_OFFSET_SIZE)
8146 return DW_FORM_data4;
8148 return DW_FORM_data8;
8152 case dw_val_class_loc:
8153 switch (constant_size (size_of_locs (AT_loc (a))))
8156 return DW_FORM_block1;
8158 return DW_FORM_block2;
8162 case dw_val_class_const:
8163 return DW_FORM_sdata;
8164 case dw_val_class_unsigned_const:
8165 switch (constant_size (AT_unsigned (a)))
8168 return DW_FORM_data1;
8170 return DW_FORM_data2;
8172 return DW_FORM_data4;
8174 return DW_FORM_data8;
8178 case dw_val_class_long_long:
8179 return DW_FORM_block1;
8180 case dw_val_class_vec:
8181 switch (constant_size (a->dw_attr_val.v.val_vec.length
8182 * a->dw_attr_val.v.val_vec.elt_size))
8185 return DW_FORM_block1;
8187 return DW_FORM_block2;
8189 return DW_FORM_block4;
8193 case dw_val_class_flag:
8194 return DW_FORM_flag;
8195 case dw_val_class_die_ref:
8196 if (AT_ref_external (a))
8197 return DW_FORM_ref_addr;
8200 case dw_val_class_fde_ref:
8201 return DW_FORM_data;
8202 case dw_val_class_lbl_id:
8203 return DW_FORM_addr;
8204 case dw_val_class_lineptr:
8205 case dw_val_class_macptr:
8206 return DW_FORM_data;
8207 case dw_val_class_str:
8208 return AT_string_form (a);
8209 case dw_val_class_file:
8210 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
8213 return DW_FORM_data1;
8215 return DW_FORM_data2;
8217 return DW_FORM_data4;
8227 /* Output the encoding of an attribute value. */
8230 output_value_format (dw_attr_ref a)
8232 enum dwarf_form form = value_format (a);
8234 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
8237 /* Output the .debug_abbrev section which defines the DIE abbreviation
8241 output_abbrev_section (void)
8243 unsigned long abbrev_id;
8245 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
8247 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
8251 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
8252 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
8253 dwarf_tag_name (abbrev->die_tag));
8255 if (abbrev->die_child != NULL)
8256 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
8258 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
8260 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
8263 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
8264 dwarf_attr_name (a_attr->dw_attr));
8265 output_value_format (a_attr);
8268 dw2_asm_output_data (1, 0, NULL);
8269 dw2_asm_output_data (1, 0, NULL);
8272 /* Terminate the table. */
8273 dw2_asm_output_data (1, 0, NULL);
8276 /* Output a symbol we can use to refer to this DIE from another CU. */
8279 output_die_symbol (dw_die_ref die)
8281 char *sym = die->die_symbol;
8286 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
8287 /* We make these global, not weak; if the target doesn't support
8288 .linkonce, it doesn't support combining the sections, so debugging
8290 targetm.asm_out.globalize_label (asm_out_file, sym);
8292 ASM_OUTPUT_LABEL (asm_out_file, sym);
8295 /* Return a new location list, given the begin and end range, and the
8296 expression. gensym tells us whether to generate a new internal symbol for
8297 this location list node, which is done for the head of the list only. */
8299 static inline dw_loc_list_ref
8300 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
8301 const char *section, unsigned int gensym)
8303 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
8305 retlist->begin = begin;
8307 retlist->expr = expr;
8308 retlist->section = section;
8310 retlist->ll_symbol = gen_internal_sym ("LLST");
8315 /* Add a location description expression to a location list. */
8318 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
8319 const char *begin, const char *end,
8320 const char *section)
8324 /* Find the end of the chain. */
8325 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
8328 /* Add a new location list node to the list. */
8329 *d = new_loc_list (descr, begin, end, section, 0);
8332 /* Output the location list given to us. */
8335 output_loc_list (dw_loc_list_ref list_head)
8337 dw_loc_list_ref curr = list_head;
8339 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
8341 /* Walk the location list, and output each range + expression. */
8342 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
8345 /* Don't output an entry that starts and ends at the same address. */
8346 if (strcmp (curr->begin, curr->end) == 0)
8348 if (!have_multiple_function_sections)
8350 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
8351 "Location list begin address (%s)",
8352 list_head->ll_symbol);
8353 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
8354 "Location list end address (%s)",
8355 list_head->ll_symbol);
8359 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
8360 "Location list begin address (%s)",
8361 list_head->ll_symbol);
8362 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
8363 "Location list end address (%s)",
8364 list_head->ll_symbol);
8366 size = size_of_locs (curr->expr);
8368 /* Output the block length for this list of location operations. */
8369 gcc_assert (size <= 0xffff);
8370 dw2_asm_output_data (2, size, "%s", "Location expression size");
8372 output_loc_sequence (curr->expr);
8375 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8376 "Location list terminator begin (%s)",
8377 list_head->ll_symbol);
8378 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
8379 "Location list terminator end (%s)",
8380 list_head->ll_symbol);
8383 /* Output the DIE and its attributes. Called recursively to generate
8384 the definitions of each child DIE. */
8387 output_die (dw_die_ref die)
8394 /* If someone in another CU might refer to us, set up a symbol for
8395 them to point to. */
8396 if (die->die_symbol)
8397 output_die_symbol (die);
8399 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
8400 (unsigned long)die->die_offset,
8401 dwarf_tag_name (die->die_tag));
8403 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8405 const char *name = dwarf_attr_name (a->dw_attr);
8407 switch (AT_class (a))
8409 case dw_val_class_addr:
8410 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8413 case dw_val_class_offset:
8414 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8418 case dw_val_class_range_list:
8420 char *p = strchr (ranges_section_label, '\0');
8422 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8423 a->dw_attr_val.v.val_offset);
8424 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8425 debug_ranges_section, "%s", name);
8430 case dw_val_class_loc:
8431 size = size_of_locs (AT_loc (a));
8433 /* Output the block length for this list of location operations. */
8434 dw2_asm_output_data (constant_size (size), size, "%s", name);
8436 output_loc_sequence (AT_loc (a));
8439 case dw_val_class_const:
8440 /* ??? It would be slightly more efficient to use a scheme like is
8441 used for unsigned constants below, but gdb 4.x does not sign
8442 extend. Gdb 5.x does sign extend. */
8443 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8446 case dw_val_class_unsigned_const:
8447 dw2_asm_output_data (constant_size (AT_unsigned (a)),
8448 AT_unsigned (a), "%s", name);
8451 case dw_val_class_long_long:
8453 unsigned HOST_WIDE_INT first, second;
8455 dw2_asm_output_data (1,
8456 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8459 if (WORDS_BIG_ENDIAN)
8461 first = a->dw_attr_val.v.val_long_long.hi;
8462 second = a->dw_attr_val.v.val_long_long.low;
8466 first = a->dw_attr_val.v.val_long_long.low;
8467 second = a->dw_attr_val.v.val_long_long.hi;
8470 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8471 first, "long long constant");
8472 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8477 case dw_val_class_vec:
8479 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8480 unsigned int len = a->dw_attr_val.v.val_vec.length;
8484 dw2_asm_output_data (constant_size (len * elt_size),
8485 len * elt_size, "%s", name);
8486 if (elt_size > sizeof (HOST_WIDE_INT))
8491 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8494 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8495 "fp or vector constant word %u", i);
8499 case dw_val_class_flag:
8500 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8503 case dw_val_class_loc_list:
8505 char *sym = AT_loc_list (a)->ll_symbol;
8508 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8513 case dw_val_class_die_ref:
8514 if (AT_ref_external (a))
8516 char *sym = AT_ref (a)->die_symbol;
8519 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
8524 gcc_assert (AT_ref (a)->die_offset);
8525 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8530 case dw_val_class_fde_ref:
8534 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8535 a->dw_attr_val.v.val_fde_index * 2);
8536 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
8541 case dw_val_class_lbl_id:
8542 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8545 case dw_val_class_lineptr:
8546 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8547 debug_line_section, "%s", name);
8550 case dw_val_class_macptr:
8551 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8552 debug_macinfo_section, "%s", name);
8555 case dw_val_class_str:
8556 if (AT_string_form (a) == DW_FORM_strp)
8557 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
8558 a->dw_attr_val.v.val_str->label,
8560 "%s: \"%s\"", name, AT_string (a));
8562 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
8565 case dw_val_class_file:
8567 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
8569 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
8570 a->dw_attr_val.v.val_file->filename);
8579 FOR_EACH_CHILD (die, c, output_die (c));
8581 /* Add null byte to terminate sibling list. */
8582 if (die->die_child != NULL)
8583 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
8584 (unsigned long) die->die_offset);
8587 /* Output the compilation unit that appears at the beginning of the
8588 .debug_info section, and precedes the DIE descriptions. */
8591 output_compilation_unit_header (void)
8593 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8594 dw2_asm_output_data (4, 0xffffffff,
8595 "Initial length escape value indicating 64-bit DWARF extension");
8596 dw2_asm_output_data (DWARF_OFFSET_SIZE,
8597 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
8598 "Length of Compilation Unit Info");
8599 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
8600 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
8601 debug_abbrev_section,
8602 "Offset Into Abbrev. Section");
8603 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
8606 /* Output the compilation unit DIE and its children. */
8609 output_comp_unit (dw_die_ref die, int output_if_empty)
8611 const char *secname;
8614 /* Unless we are outputting main CU, we may throw away empty ones. */
8615 if (!output_if_empty && die->die_child == NULL)
8618 /* Even if there are no children of this DIE, we must output the information
8619 about the compilation unit. Otherwise, on an empty translation unit, we
8620 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8621 will then complain when examining the file. First mark all the DIEs in
8622 this CU so we know which get local refs. */
8625 build_abbrev_table (die);
8627 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8628 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8629 calc_die_sizes (die);
8631 oldsym = die->die_symbol;
8634 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
8636 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
8638 die->die_symbol = NULL;
8639 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
8642 switch_to_section (debug_info_section);
8644 /* Output debugging information. */
8645 output_compilation_unit_header ();
8648 /* Leave the marks on the main CU, so we can check them in
8653 die->die_symbol = oldsym;
8657 /* Return the DWARF2/3 pubname associated with a decl. */
8660 dwarf2_name (tree decl, int scope)
8662 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
8665 /* Add a new entry to .debug_pubnames if appropriate. */
8668 add_pubname_string (const char *str, dw_die_ref die)
8673 e.name = xstrdup (str);
8674 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
8678 add_pubname (tree decl, dw_die_ref die)
8681 if (TREE_PUBLIC (decl))
8682 add_pubname_string (dwarf2_name (decl, 1), die);
8685 /* Add a new entry to .debug_pubtypes if appropriate. */
8688 add_pubtype (tree decl, dw_die_ref die)
8693 if ((TREE_PUBLIC (decl)
8694 || die->die_parent == comp_unit_die)
8695 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
8700 if (TYPE_NAME (decl))
8702 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
8703 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
8704 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
8705 && DECL_NAME (TYPE_NAME (decl)))
8706 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
8708 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
8712 e.name = xstrdup (dwarf2_name (decl, 1));
8714 /* If we don't have a name for the type, there's no point in adding
8716 if (e.name && e.name[0] != '\0')
8717 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
8721 /* Output the public names table used to speed up access to externally
8722 visible names; or the public types table used to find type definitions. */
8725 output_pubnames (VEC (pubname_entry, gc) * names)
8728 unsigned long pubnames_length = size_of_pubnames (names);
8731 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8732 dw2_asm_output_data (4, 0xffffffff,
8733 "Initial length escape value indicating 64-bit DWARF extension");
8734 if (names == pubname_table)
8735 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8736 "Length of Public Names Info");
8738 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8739 "Length of Public Type Names Info");
8740 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8741 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8743 "Offset of Compilation Unit Info");
8744 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
8745 "Compilation Unit Length");
8747 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
8749 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8750 if (names == pubname_table)
8751 gcc_assert (pub->die->die_mark);
8753 if (names != pubtype_table
8754 || pub->die->die_offset != 0
8755 || !flag_eliminate_unused_debug_types)
8757 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
8760 dw2_asm_output_nstring (pub->name, -1, "external name");
8764 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
8767 /* Add a new entry to .debug_aranges if appropriate. */
8770 add_arange (tree decl, dw_die_ref die)
8772 if (! DECL_SECTION_NAME (decl))
8775 if (arange_table_in_use == arange_table_allocated)
8777 arange_table_allocated += ARANGE_TABLE_INCREMENT;
8778 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
8779 arange_table_allocated);
8780 memset (arange_table + arange_table_in_use, 0,
8781 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
8784 arange_table[arange_table_in_use++] = die;
8787 /* Output the information that goes into the .debug_aranges table.
8788 Namely, define the beginning and ending address range of the
8789 text section generated for this compilation unit. */
8792 output_aranges (void)
8795 unsigned long aranges_length = size_of_aranges ();
8797 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8798 dw2_asm_output_data (4, 0xffffffff,
8799 "Initial length escape value indicating 64-bit DWARF extension");
8800 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
8801 "Length of Address Ranges Info");
8802 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8803 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8805 "Offset of Compilation Unit Info");
8806 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
8807 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8809 /* We need to align to twice the pointer size here. */
8810 if (DWARF_ARANGES_PAD_SIZE)
8812 /* Pad using a 2 byte words so that padding is correct for any
8814 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8815 2 * DWARF2_ADDR_SIZE);
8816 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
8817 dw2_asm_output_data (2, 0, NULL);
8820 /* It is necessary not to output these entries if the sections were
8821 not used; if the sections were not used, the length will be 0 and
8822 the address may end up as 0 if the section is discarded by ld
8823 --gc-sections, leaving an invalid (0, 0) entry that can be
8824 confused with the terminator. */
8825 if (text_section_used)
8827 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
8828 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
8829 text_section_label, "Length");
8831 if (cold_text_section_used)
8833 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
8835 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
8836 cold_text_section_label, "Length");
8839 for (i = 0; i < arange_table_in_use; i++)
8841 dw_die_ref die = arange_table[i];
8843 /* We shouldn't see aranges for DIEs outside of the main CU. */
8844 gcc_assert (die->die_mark);
8846 if (die->die_tag == DW_TAG_subprogram)
8848 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
8850 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
8851 get_AT_low_pc (die), "Length");
8855 /* A static variable; extract the symbol from DW_AT_location.
8856 Note that this code isn't currently hit, as we only emit
8857 aranges for functions (jason 9/23/99). */
8858 dw_attr_ref a = get_AT (die, DW_AT_location);
8859 dw_loc_descr_ref loc;
8861 gcc_assert (a && AT_class (a) == dw_val_class_loc);
8864 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
8866 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
8867 loc->dw_loc_oprnd1.v.val_addr, "Address");
8868 dw2_asm_output_data (DWARF2_ADDR_SIZE,
8869 get_AT_unsigned (die, DW_AT_byte_size),
8874 /* Output the terminator words. */
8875 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8876 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8879 /* Add a new entry to .debug_ranges. Return the offset at which it
8883 add_ranges_num (int num)
8885 unsigned int in_use = ranges_table_in_use;
8887 if (in_use == ranges_table_allocated)
8889 ranges_table_allocated += RANGES_TABLE_INCREMENT;
8890 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
8891 ranges_table_allocated);
8892 memset (ranges_table + ranges_table_in_use, 0,
8893 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
8896 ranges_table[in_use].num = num;
8897 ranges_table_in_use = in_use + 1;
8899 return in_use * 2 * DWARF2_ADDR_SIZE;
8902 /* Add a new entry to .debug_ranges corresponding to a block, or a
8903 range terminator if BLOCK is NULL. */
8906 add_ranges (const_tree block)
8908 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
8911 /* Add a new entry to .debug_ranges corresponding to a pair of
8915 add_ranges_by_labels (const char *begin, const char *end)
8917 unsigned int in_use = ranges_by_label_in_use;
8919 if (in_use == ranges_by_label_allocated)
8921 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
8922 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
8924 ranges_by_label_allocated);
8925 memset (ranges_by_label + ranges_by_label_in_use, 0,
8926 RANGES_TABLE_INCREMENT
8927 * sizeof (struct dw_ranges_by_label_struct));
8930 ranges_by_label[in_use].begin = begin;
8931 ranges_by_label[in_use].end = end;
8932 ranges_by_label_in_use = in_use + 1;
8934 return add_ranges_num (-(int)in_use - 1);
8938 output_ranges (void)
8941 static const char *const start_fmt = "Offset 0x%x";
8942 const char *fmt = start_fmt;
8944 for (i = 0; i < ranges_table_in_use; i++)
8946 int block_num = ranges_table[i].num;
8950 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
8951 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
8953 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
8954 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
8956 /* If all code is in the text section, then the compilation
8957 unit base address defaults to DW_AT_low_pc, which is the
8958 base of the text section. */
8959 if (!have_multiple_function_sections)
8961 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
8963 fmt, i * 2 * DWARF2_ADDR_SIZE);
8964 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
8965 text_section_label, NULL);
8968 /* Otherwise, the compilation unit base address is zero,
8969 which allows us to use absolute addresses, and not worry
8970 about whether the target supports cross-section
8974 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
8975 fmt, i * 2 * DWARF2_ADDR_SIZE);
8976 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
8982 /* Negative block_num stands for an index into ranges_by_label. */
8983 else if (block_num < 0)
8985 int lab_idx = - block_num - 1;
8987 if (!have_multiple_function_sections)
8991 /* If we ever use add_ranges_by_labels () for a single
8992 function section, all we have to do is to take out
8994 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8995 ranges_by_label[lab_idx].begin,
8997 fmt, i * 2 * DWARF2_ADDR_SIZE);
8998 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8999 ranges_by_label[lab_idx].end,
9000 text_section_label, NULL);
9005 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9006 ranges_by_label[lab_idx].begin,
9007 fmt, i * 2 * DWARF2_ADDR_SIZE);
9008 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
9009 ranges_by_label[lab_idx].end,
9015 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9016 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
9022 /* Data structure containing information about input files. */
9025 const char *path; /* Complete file name. */
9026 const char *fname; /* File name part. */
9027 int length; /* Length of entire string. */
9028 struct dwarf_file_data * file_idx; /* Index in input file table. */
9029 int dir_idx; /* Index in directory table. */
9032 /* Data structure containing information about directories with source
9036 const char *path; /* Path including directory name. */
9037 int length; /* Path length. */
9038 int prefix; /* Index of directory entry which is a prefix. */
9039 int count; /* Number of files in this directory. */
9040 int dir_idx; /* Index of directory used as base. */
9043 /* Callback function for file_info comparison. We sort by looking at
9044 the directories in the path. */
9047 file_info_cmp (const void *p1, const void *p2)
9049 const struct file_info *const s1 = (const struct file_info *) p1;
9050 const struct file_info *const s2 = (const struct file_info *) p2;
9051 const unsigned char *cp1;
9052 const unsigned char *cp2;
9054 /* Take care of file names without directories. We need to make sure that
9055 we return consistent values to qsort since some will get confused if
9056 we return the same value when identical operands are passed in opposite
9057 orders. So if neither has a directory, return 0 and otherwise return
9058 1 or -1 depending on which one has the directory. */
9059 if ((s1->path == s1->fname || s2->path == s2->fname))
9060 return (s2->path == s2->fname) - (s1->path == s1->fname);
9062 cp1 = (const unsigned char *) s1->path;
9063 cp2 = (const unsigned char *) s2->path;
9069 /* Reached the end of the first path? If so, handle like above. */
9070 if ((cp1 == (const unsigned char *) s1->fname)
9071 || (cp2 == (const unsigned char *) s2->fname))
9072 return ((cp2 == (const unsigned char *) s2->fname)
9073 - (cp1 == (const unsigned char *) s1->fname));
9075 /* Character of current path component the same? */
9076 else if (*cp1 != *cp2)
9081 struct file_name_acquire_data
9083 struct file_info *files;
9088 /* Traversal function for the hash table. */
9091 file_name_acquire (void ** slot, void *data)
9093 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
9094 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
9095 struct file_info *fi;
9098 gcc_assert (fnad->max_files >= d->emitted_number);
9100 if (! d->emitted_number)
9103 gcc_assert (fnad->max_files != fnad->used_files);
9105 fi = fnad->files + fnad->used_files++;
9107 /* Skip all leading "./". */
9109 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
9112 /* Create a new array entry. */
9114 fi->length = strlen (f);
9117 /* Search for the file name part. */
9118 f = strrchr (f, DIR_SEPARATOR);
9119 #if defined (DIR_SEPARATOR_2)
9121 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
9125 if (f == NULL || f < g)
9131 fi->fname = f == NULL ? fi->path : f + 1;
9135 /* Output the directory table and the file name table. We try to minimize
9136 the total amount of memory needed. A heuristic is used to avoid large
9137 slowdowns with many input files. */
9140 output_file_names (void)
9142 struct file_name_acquire_data fnad;
9144 struct file_info *files;
9145 struct dir_info *dirs;
9154 if (!last_emitted_file)
9156 dw2_asm_output_data (1, 0, "End directory table");
9157 dw2_asm_output_data (1, 0, "End file name table");
9161 numfiles = last_emitted_file->emitted_number;
9163 /* Allocate the various arrays we need. */
9164 files = XALLOCAVEC (struct file_info, numfiles);
9165 dirs = XALLOCAVEC (struct dir_info, numfiles);
9168 fnad.used_files = 0;
9169 fnad.max_files = numfiles;
9170 htab_traverse (file_table, file_name_acquire, &fnad);
9171 gcc_assert (fnad.used_files == fnad.max_files);
9173 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
9175 /* Find all the different directories used. */
9176 dirs[0].path = files[0].path;
9177 dirs[0].length = files[0].fname - files[0].path;
9178 dirs[0].prefix = -1;
9180 dirs[0].dir_idx = 0;
9181 files[0].dir_idx = 0;
9184 for (i = 1; i < numfiles; i++)
9185 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
9186 && memcmp (dirs[ndirs - 1].path, files[i].path,
9187 dirs[ndirs - 1].length) == 0)
9189 /* Same directory as last entry. */
9190 files[i].dir_idx = ndirs - 1;
9191 ++dirs[ndirs - 1].count;
9197 /* This is a new directory. */
9198 dirs[ndirs].path = files[i].path;
9199 dirs[ndirs].length = files[i].fname - files[i].path;
9200 dirs[ndirs].count = 1;
9201 dirs[ndirs].dir_idx = ndirs;
9202 files[i].dir_idx = ndirs;
9204 /* Search for a prefix. */
9205 dirs[ndirs].prefix = -1;
9206 for (j = 0; j < ndirs; j++)
9207 if (dirs[j].length < dirs[ndirs].length
9208 && dirs[j].length > 1
9209 && (dirs[ndirs].prefix == -1
9210 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
9211 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
9212 dirs[ndirs].prefix = j;
9217 /* Now to the actual work. We have to find a subset of the directories which
9218 allow expressing the file name using references to the directory table
9219 with the least amount of characters. We do not do an exhaustive search
9220 where we would have to check out every combination of every single
9221 possible prefix. Instead we use a heuristic which provides nearly optimal
9222 results in most cases and never is much off. */
9223 saved = XALLOCAVEC (int, ndirs);
9224 savehere = XALLOCAVEC (int, ndirs);
9226 memset (saved, '\0', ndirs * sizeof (saved[0]));
9227 for (i = 0; i < ndirs; i++)
9232 /* We can always save some space for the current directory. But this
9233 does not mean it will be enough to justify adding the directory. */
9234 savehere[i] = dirs[i].length;
9235 total = (savehere[i] - saved[i]) * dirs[i].count;
9237 for (j = i + 1; j < ndirs; j++)
9240 if (saved[j] < dirs[i].length)
9242 /* Determine whether the dirs[i] path is a prefix of the
9247 while (k != -1 && k != (int) i)
9252 /* Yes it is. We can possibly save some memory by
9253 writing the filenames in dirs[j] relative to
9255 savehere[j] = dirs[i].length;
9256 total += (savehere[j] - saved[j]) * dirs[j].count;
9261 /* Check whether we can save enough to justify adding the dirs[i]
9263 if (total > dirs[i].length + 1)
9265 /* It's worthwhile adding. */
9266 for (j = i; j < ndirs; j++)
9267 if (savehere[j] > 0)
9269 /* Remember how much we saved for this directory so far. */
9270 saved[j] = savehere[j];
9272 /* Remember the prefix directory. */
9273 dirs[j].dir_idx = i;
9278 /* Emit the directory name table. */
9280 idx_offset = dirs[0].length > 0 ? 1 : 0;
9281 for (i = 1 - idx_offset; i < ndirs; i++)
9282 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
9283 "Directory Entry: 0x%x", i + idx_offset);
9285 dw2_asm_output_data (1, 0, "End directory table");
9287 /* We have to emit them in the order of emitted_number since that's
9288 used in the debug info generation. To do this efficiently we
9289 generate a back-mapping of the indices first. */
9290 backmap = XALLOCAVEC (int, numfiles);
9291 for (i = 0; i < numfiles; i++)
9292 backmap[files[i].file_idx->emitted_number - 1] = i;
9294 /* Now write all the file names. */
9295 for (i = 0; i < numfiles; i++)
9297 int file_idx = backmap[i];
9298 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
9300 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
9301 "File Entry: 0x%x", (unsigned) i + 1);
9303 /* Include directory index. */
9304 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
9306 /* Modification time. */
9307 dw2_asm_output_data_uleb128 (0, NULL);
9309 /* File length in bytes. */
9310 dw2_asm_output_data_uleb128 (0, NULL);
9313 dw2_asm_output_data (1, 0, "End file name table");
9317 /* Output the source line number correspondence information. This
9318 information goes into the .debug_line section. */
9321 output_line_info (void)
9323 char l1[20], l2[20], p1[20], p2[20];
9324 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
9325 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
9328 unsigned long lt_index;
9329 unsigned long current_line;
9332 unsigned long current_file;
9333 unsigned long function;
9335 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
9336 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
9337 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
9338 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
9340 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
9341 dw2_asm_output_data (4, 0xffffffff,
9342 "Initial length escape value indicating 64-bit DWARF extension");
9343 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
9344 "Length of Source Line Info");
9345 ASM_OUTPUT_LABEL (asm_out_file, l1);
9347 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
9348 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
9349 ASM_OUTPUT_LABEL (asm_out_file, p1);
9351 /* Define the architecture-dependent minimum instruction length (in
9352 bytes). In this implementation of DWARF, this field is used for
9353 information purposes only. Since GCC generates assembly language,
9354 we have no a priori knowledge of how many instruction bytes are
9355 generated for each source line, and therefore can use only the
9356 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
9357 commands. Accordingly, we fix this as `1', which is "correct
9358 enough" for all architectures, and don't let the target override. */
9359 dw2_asm_output_data (1, 1,
9360 "Minimum Instruction Length");
9362 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
9363 "Default is_stmt_start flag");
9364 dw2_asm_output_data (1, DWARF_LINE_BASE,
9365 "Line Base Value (Special Opcodes)");
9366 dw2_asm_output_data (1, DWARF_LINE_RANGE,
9367 "Line Range Value (Special Opcodes)");
9368 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
9369 "Special Opcode Base");
9371 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
9375 case DW_LNS_advance_pc:
9376 case DW_LNS_advance_line:
9377 case DW_LNS_set_file:
9378 case DW_LNS_set_column:
9379 case DW_LNS_fixed_advance_pc:
9387 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
9391 /* Write out the information about the files we use. */
9392 output_file_names ();
9393 ASM_OUTPUT_LABEL (asm_out_file, p2);
9395 /* We used to set the address register to the first location in the text
9396 section here, but that didn't accomplish anything since we already
9397 have a line note for the opening brace of the first function. */
9399 /* Generate the line number to PC correspondence table, encoded as
9400 a series of state machine operations. */
9404 if (cfun && in_cold_section_p)
9405 strcpy (prev_line_label, crtl->subsections.cold_section_label);
9407 strcpy (prev_line_label, text_section_label);
9408 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
9410 dw_line_info_ref line_info = &line_info_table[lt_index];
9413 /* Disable this optimization for now; GDB wants to see two line notes
9414 at the beginning of a function so it can find the end of the
9417 /* Don't emit anything for redundant notes. Just updating the
9418 address doesn't accomplish anything, because we already assume
9419 that anything after the last address is this line. */
9420 if (line_info->dw_line_num == current_line
9421 && line_info->dw_file_num == current_file)
9425 /* Emit debug info for the address of the current line.
9427 Unfortunately, we have little choice here currently, and must always
9428 use the most general form. GCC does not know the address delta
9429 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9430 attributes which will give an upper bound on the address range. We
9431 could perhaps use length attributes to determine when it is safe to
9432 use DW_LNS_fixed_advance_pc. */
9434 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
9437 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
9438 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9439 "DW_LNS_fixed_advance_pc");
9440 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9444 /* This can handle any delta. This takes
9445 4+DWARF2_ADDR_SIZE bytes. */
9446 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9447 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9448 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9449 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9452 strcpy (prev_line_label, line_label);
9454 /* Emit debug info for the source file of the current line, if
9455 different from the previous line. */
9456 if (line_info->dw_file_num != current_file)
9458 current_file = line_info->dw_file_num;
9459 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9460 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9463 /* Emit debug info for the current line number, choosing the encoding
9464 that uses the least amount of space. */
9465 if (line_info->dw_line_num != current_line)
9467 line_offset = line_info->dw_line_num - current_line;
9468 line_delta = line_offset - DWARF_LINE_BASE;
9469 current_line = line_info->dw_line_num;
9470 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9471 /* This can handle deltas from -10 to 234, using the current
9472 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
9474 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9475 "line %lu", current_line);
9478 /* This can handle any delta. This takes at least 4 bytes,
9479 depending on the value being encoded. */
9480 dw2_asm_output_data (1, DW_LNS_advance_line,
9481 "advance to line %lu", current_line);
9482 dw2_asm_output_data_sleb128 (line_offset, NULL);
9483 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9487 /* We still need to start a new row, so output a copy insn. */
9488 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9491 /* Emit debug info for the address of the end of the function. */
9494 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9495 "DW_LNS_fixed_advance_pc");
9496 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
9500 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9501 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9502 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9503 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
9506 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9507 dw2_asm_output_data_uleb128 (1, NULL);
9508 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9513 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
9515 dw_separate_line_info_ref line_info
9516 = &separate_line_info_table[lt_index];
9519 /* Don't emit anything for redundant notes. */
9520 if (line_info->dw_line_num == current_line
9521 && line_info->dw_file_num == current_file
9522 && line_info->function == function)
9526 /* Emit debug info for the address of the current line. If this is
9527 a new function, or the first line of a function, then we need
9528 to handle it differently. */
9529 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
9531 if (function != line_info->function)
9533 function = line_info->function;
9535 /* Set the address register to the first line in the function. */
9536 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9537 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9538 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9539 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9543 /* ??? See the DW_LNS_advance_pc comment above. */
9546 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9547 "DW_LNS_fixed_advance_pc");
9548 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9552 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9553 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9554 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9555 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9559 strcpy (prev_line_label, line_label);
9561 /* Emit debug info for the source file of the current line, if
9562 different from the previous line. */
9563 if (line_info->dw_file_num != current_file)
9565 current_file = line_info->dw_file_num;
9566 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9567 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9570 /* Emit debug info for the current line number, choosing the encoding
9571 that uses the least amount of space. */
9572 if (line_info->dw_line_num != current_line)
9574 line_offset = line_info->dw_line_num - current_line;
9575 line_delta = line_offset - DWARF_LINE_BASE;
9576 current_line = line_info->dw_line_num;
9577 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9578 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9579 "line %lu", current_line);
9582 dw2_asm_output_data (1, DW_LNS_advance_line,
9583 "advance to line %lu", current_line);
9584 dw2_asm_output_data_sleb128 (line_offset, NULL);
9585 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9589 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9597 /* If we're done with a function, end its sequence. */
9598 if (lt_index == separate_line_info_table_in_use
9599 || separate_line_info_table[lt_index].function != function)
9604 /* Emit debug info for the address of the end of the function. */
9605 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
9608 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9609 "DW_LNS_fixed_advance_pc");
9610 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9614 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9615 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9616 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9617 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9620 /* Output the marker for the end of this sequence. */
9621 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9622 dw2_asm_output_data_uleb128 (1, NULL);
9623 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9627 /* Output the marker for the end of the line number info. */
9628 ASM_OUTPUT_LABEL (asm_out_file, l2);
9631 /* Given a pointer to a tree node for some base type, return a pointer to
9632 a DIE that describes the given type.
9634 This routine must only be called for GCC type nodes that correspond to
9635 Dwarf base (fundamental) types. */
9638 base_type_die (tree type)
9640 dw_die_ref base_type_result;
9641 enum dwarf_type encoding;
9643 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
9646 /* If this is a subtype that should not be emitted as a subrange type,
9647 use the base type. See subrange_type_for_debug_p. */
9648 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
9649 type = TREE_TYPE (type);
9651 switch (TREE_CODE (type))
9654 if (TYPE_STRING_FLAG (type))
9656 if (TYPE_UNSIGNED (type))
9657 encoding = DW_ATE_unsigned_char;
9659 encoding = DW_ATE_signed_char;
9661 else if (TYPE_UNSIGNED (type))
9662 encoding = DW_ATE_unsigned;
9664 encoding = DW_ATE_signed;
9668 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
9669 encoding = DW_ATE_decimal_float;
9671 encoding = DW_ATE_float;
9674 case FIXED_POINT_TYPE:
9675 if (TYPE_UNSIGNED (type))
9676 encoding = DW_ATE_unsigned_fixed;
9678 encoding = DW_ATE_signed_fixed;
9681 /* Dwarf2 doesn't know anything about complex ints, so use
9682 a user defined type for it. */
9684 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
9685 encoding = DW_ATE_complex_float;
9687 encoding = DW_ATE_lo_user;
9691 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9692 encoding = DW_ATE_boolean;
9696 /* No other TREE_CODEs are Dwarf fundamental types. */
9700 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
9702 /* This probably indicates a bug. */
9703 if (! TYPE_NAME (type))
9704 add_name_attribute (base_type_result, "__unknown__");
9706 add_AT_unsigned (base_type_result, DW_AT_byte_size,
9707 int_size_in_bytes (type));
9708 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
9710 return base_type_result;
9713 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9714 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9717 is_base_type (tree type)
9719 switch (TREE_CODE (type))
9725 case FIXED_POINT_TYPE:
9733 case QUAL_UNION_TYPE:
9738 case REFERENCE_TYPE:
9751 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9752 node, return the size in bits for the type if it is a constant, or else
9753 return the alignment for the type if the type's size is not constant, or
9754 else return BITS_PER_WORD if the type actually turns out to be an
9757 static inline unsigned HOST_WIDE_INT
9758 simple_type_size_in_bits (const_tree type)
9760 if (TREE_CODE (type) == ERROR_MARK)
9761 return BITS_PER_WORD;
9762 else if (TYPE_SIZE (type) == NULL_TREE)
9764 else if (host_integerp (TYPE_SIZE (type), 1))
9765 return tree_low_cst (TYPE_SIZE (type), 1);
9767 return TYPE_ALIGN (type);
9770 /* Given a pointer to a tree node for a subrange type, return a pointer
9771 to a DIE that describes the given type. */
9774 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
9776 dw_die_ref subrange_die;
9777 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
9779 if (context_die == NULL)
9780 context_die = comp_unit_die;
9782 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
9784 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
9786 /* The size of the subrange type and its base type do not match,
9787 so we need to generate a size attribute for the subrange type. */
9788 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
9792 add_bound_info (subrange_die, DW_AT_lower_bound, low);
9794 add_bound_info (subrange_die, DW_AT_upper_bound, high);
9796 return subrange_die;
9799 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9800 entry that chains various modifiers in front of the given type. */
9803 modified_type_die (tree type, int is_const_type, int is_volatile_type,
9804 dw_die_ref context_die)
9806 enum tree_code code = TREE_CODE (type);
9807 dw_die_ref mod_type_die;
9808 dw_die_ref sub_die = NULL;
9809 tree item_type = NULL;
9810 tree qualified_type;
9811 tree name, low, high;
9813 if (code == ERROR_MARK)
9816 /* See if we already have the appropriately qualified variant of
9819 = get_qualified_type (type,
9820 ((is_const_type ? TYPE_QUAL_CONST : 0)
9821 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
9823 /* If we do, then we can just use its DIE, if it exists. */
9826 mod_type_die = lookup_type_die (qualified_type);
9828 return mod_type_die;
9831 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
9833 /* Handle C typedef types. */
9834 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
9836 tree dtype = TREE_TYPE (name);
9838 if (qualified_type == dtype)
9840 /* For a named type, use the typedef. */
9841 gen_type_die (qualified_type, context_die);
9842 return lookup_type_die (qualified_type);
9844 else if (is_const_type < TYPE_READONLY (dtype)
9845 || is_volatile_type < TYPE_VOLATILE (dtype)
9846 || (is_const_type <= TYPE_READONLY (dtype)
9847 && is_volatile_type <= TYPE_VOLATILE (dtype)
9848 && DECL_ORIGINAL_TYPE (name) != type))
9849 /* cv-unqualified version of named type. Just use the unnamed
9850 type to which it refers. */
9851 return modified_type_die (DECL_ORIGINAL_TYPE (name),
9852 is_const_type, is_volatile_type,
9854 /* Else cv-qualified version of named type; fall through. */
9859 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
9860 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
9862 else if (is_volatile_type)
9864 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
9865 sub_die = modified_type_die (type, 0, 0, context_die);
9867 else if (code == POINTER_TYPE)
9869 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
9870 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9871 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9872 item_type = TREE_TYPE (type);
9874 else if (code == REFERENCE_TYPE)
9876 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
9877 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9878 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9879 item_type = TREE_TYPE (type);
9881 else if (code == INTEGER_TYPE
9882 && TREE_TYPE (type) != NULL_TREE
9883 && subrange_type_for_debug_p (type, &low, &high))
9885 mod_type_die = subrange_type_die (type, low, high, context_die);
9886 item_type = TREE_TYPE (type);
9888 else if (is_base_type (type))
9889 mod_type_die = base_type_die (type);
9892 gen_type_die (type, context_die);
9894 /* We have to get the type_main_variant here (and pass that to the
9895 `lookup_type_die' routine) because the ..._TYPE node we have
9896 might simply be a *copy* of some original type node (where the
9897 copy was created to help us keep track of typedef names) and
9898 that copy might have a different TYPE_UID from the original
9900 if (TREE_CODE (type) != VECTOR_TYPE)
9901 return lookup_type_die (type_main_variant (type));
9903 /* Vectors have the debugging information in the type,
9904 not the main variant. */
9905 return lookup_type_die (type);
9908 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9909 don't output a DW_TAG_typedef, since there isn't one in the
9910 user's program; just attach a DW_AT_name to the type. */
9912 && (TREE_CODE (name) != TYPE_DECL
9913 || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
9915 if (TREE_CODE (name) == TYPE_DECL)
9916 /* Could just call add_name_and_src_coords_attributes here,
9917 but since this is a builtin type it doesn't have any
9918 useful source coordinates anyway. */
9919 name = DECL_NAME (name);
9920 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
9924 equate_type_number_to_die (qualified_type, mod_type_die);
9927 /* We must do this after the equate_type_number_to_die call, in case
9928 this is a recursive type. This ensures that the modified_type_die
9929 recursion will terminate even if the type is recursive. Recursive
9930 types are possible in Ada. */
9931 sub_die = modified_type_die (item_type,
9932 TYPE_READONLY (item_type),
9933 TYPE_VOLATILE (item_type),
9936 if (sub_die != NULL)
9937 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
9939 return mod_type_die;
9942 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
9943 an enumerated type. */
9946 type_is_enum (const_tree type)
9948 return TREE_CODE (type) == ENUMERAL_TYPE;
9951 /* Return the DBX register number described by a given RTL node. */
9954 dbx_reg_number (const_rtx rtl)
9956 unsigned regno = REGNO (rtl);
9958 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
9960 #ifdef LEAF_REG_REMAP
9961 if (current_function_uses_only_leaf_regs)
9963 int leaf_reg = LEAF_REG_REMAP (regno);
9965 regno = (unsigned) leaf_reg;
9969 return DBX_REGISTER_NUMBER (regno);
9972 /* Optionally add a DW_OP_piece term to a location description expression.
9973 DW_OP_piece is only added if the location description expression already
9974 doesn't end with DW_OP_piece. */
9977 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
9979 dw_loc_descr_ref loc;
9981 if (*list_head != NULL)
9983 /* Find the end of the chain. */
9984 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
9987 if (loc->dw_loc_opc != DW_OP_piece)
9988 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
9992 /* Return a location descriptor that designates a machine register or
9993 zero if there is none. */
9995 static dw_loc_descr_ref
9996 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
10000 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
10003 regs = targetm.dwarf_register_span (rtl);
10005 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
10006 return multiple_reg_loc_descriptor (rtl, regs, initialized);
10008 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
10011 /* Return a location descriptor that designates a machine register for
10012 a given hard register number. */
10014 static dw_loc_descr_ref
10015 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
10017 dw_loc_descr_ref reg_loc_descr;
10021 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
10023 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
10025 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10026 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10028 return reg_loc_descr;
10031 /* Given an RTL of a register, return a location descriptor that
10032 designates a value that spans more than one register. */
10034 static dw_loc_descr_ref
10035 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
10036 enum var_init_status initialized)
10038 int nregs, size, i;
10040 dw_loc_descr_ref loc_result = NULL;
10043 #ifdef LEAF_REG_REMAP
10044 if (current_function_uses_only_leaf_regs)
10046 int leaf_reg = LEAF_REG_REMAP (reg);
10047 if (leaf_reg != -1)
10048 reg = (unsigned) leaf_reg;
10051 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
10052 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
10054 /* Simple, contiguous registers. */
10055 if (regs == NULL_RTX)
10057 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
10062 dw_loc_descr_ref t;
10064 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
10065 VAR_INIT_STATUS_INITIALIZED);
10066 add_loc_descr (&loc_result, t);
10067 add_loc_descr_op_piece (&loc_result, size);
10073 /* Now onto stupid register sets in non contiguous locations. */
10075 gcc_assert (GET_CODE (regs) == PARALLEL);
10077 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10080 for (i = 0; i < XVECLEN (regs, 0); ++i)
10082 dw_loc_descr_ref t;
10084 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
10085 VAR_INIT_STATUS_INITIALIZED);
10086 add_loc_descr (&loc_result, t);
10087 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
10088 add_loc_descr_op_piece (&loc_result, size);
10091 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10092 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10096 #endif /* DWARF2_DEBUGGING_INFO */
10098 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
10100 /* Return a location descriptor that designates a constant. */
10102 static dw_loc_descr_ref
10103 int_loc_descriptor (HOST_WIDE_INT i)
10105 enum dwarf_location_atom op;
10107 /* Pick the smallest representation of a constant, rather than just
10108 defaulting to the LEB encoding. */
10112 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
10113 else if (i <= 0xff)
10114 op = DW_OP_const1u;
10115 else if (i <= 0xffff)
10116 op = DW_OP_const2u;
10117 else if (HOST_BITS_PER_WIDE_INT == 32
10118 || i <= 0xffffffff)
10119 op = DW_OP_const4u;
10126 op = DW_OP_const1s;
10127 else if (i >= -0x8000)
10128 op = DW_OP_const2s;
10129 else if (HOST_BITS_PER_WIDE_INT == 32
10130 || i >= -0x80000000)
10131 op = DW_OP_const4s;
10136 return new_loc_descr (op, i, 0);
10140 #ifdef DWARF2_DEBUGGING_INFO
10142 /* Return a location descriptor that designates a base+offset location. */
10144 static dw_loc_descr_ref
10145 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
10146 enum var_init_status initialized)
10148 unsigned int regno;
10149 dw_loc_descr_ref result;
10150 dw_fde_ref fde = current_fde ();
10152 /* We only use "frame base" when we're sure we're talking about the
10153 post-prologue local stack frame. We do this by *not* running
10154 register elimination until this point, and recognizing the special
10155 argument pointer and soft frame pointer rtx's. */
10156 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
10158 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10162 if (GET_CODE (elim) == PLUS)
10164 offset += INTVAL (XEXP (elim, 1));
10165 elim = XEXP (elim, 0);
10167 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
10168 && (elim == hard_frame_pointer_rtx
10169 || elim == stack_pointer_rtx))
10170 || elim == (frame_pointer_needed
10171 ? hard_frame_pointer_rtx
10172 : stack_pointer_rtx));
10174 /* If drap register is used to align stack, use frame
10175 pointer + offset to access stack variables. If stack
10176 is aligned without drap, use stack pointer + offset to
10177 access stack variables. */
10178 if (crtl->stack_realign_tried
10179 && cfa.reg == HARD_FRAME_POINTER_REGNUM
10180 && reg == frame_pointer_rtx)
10183 = DWARF_FRAME_REGNUM (cfa.indirect
10184 ? HARD_FRAME_POINTER_REGNUM
10185 : STACK_POINTER_REGNUM);
10186 return new_reg_loc_descr (base_reg, offset);
10189 offset += frame_pointer_fb_offset;
10190 return new_loc_descr (DW_OP_fbreg, offset, 0);
10194 && fde->drap_reg != INVALID_REGNUM
10195 && (fde->drap_reg == REGNO (reg)
10196 || fde->vdrap_reg == REGNO (reg)))
10198 /* Use cfa+offset to represent the location of arguments passed
10199 on stack when drap is used to align stack. */
10200 return new_loc_descr (DW_OP_fbreg, offset, 0);
10203 regno = dbx_reg_number (reg);
10205 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
10208 result = new_loc_descr (DW_OP_bregx, regno, offset);
10210 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10211 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10216 /* Return true if this RTL expression describes a base+offset calculation. */
10219 is_based_loc (const_rtx rtl)
10221 return (GET_CODE (rtl) == PLUS
10222 && ((REG_P (XEXP (rtl, 0))
10223 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
10224 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
10227 /* Return a descriptor that describes the concatenation of N locations
10228 used to form the address of a memory location. */
10230 static dw_loc_descr_ref
10231 concatn_mem_loc_descriptor (rtx concatn, enum machine_mode mode,
10232 enum var_init_status initialized)
10235 dw_loc_descr_ref cc_loc_result = NULL;
10236 unsigned int n = XVECLEN (concatn, 0);
10238 for (i = 0; i < n; ++i)
10240 dw_loc_descr_ref ref;
10241 rtx x = XVECEXP (concatn, 0, i);
10243 ref = mem_loc_descriptor (x, mode, VAR_INIT_STATUS_INITIALIZED);
10247 add_loc_descr (&cc_loc_result, ref);
10248 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
10251 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10252 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10254 return cc_loc_result;
10257 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
10260 static dw_loc_descr_ref
10261 tls_mem_loc_descriptor (rtx mem)
10264 dw_loc_descr_ref loc_result;
10266 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
10269 base = get_base_address (MEM_EXPR (mem));
10271 || TREE_CODE (base) != VAR_DECL
10272 || !DECL_THREAD_LOCAL_P (base))
10275 loc_result = loc_descriptor_from_tree_1 (MEM_EXPR (mem), 2);
10276 if (loc_result == NULL)
10279 if (INTVAL (MEM_OFFSET (mem)))
10280 loc_descr_plus_const (&loc_result, INTVAL (MEM_OFFSET (mem)));
10285 /* The following routine converts the RTL for a variable or parameter
10286 (resident in memory) into an equivalent Dwarf representation of a
10287 mechanism for getting the address of that same variable onto the top of a
10288 hypothetical "address evaluation" stack.
10290 When creating memory location descriptors, we are effectively transforming
10291 the RTL for a memory-resident object into its Dwarf postfix expression
10292 equivalent. This routine recursively descends an RTL tree, turning
10293 it into Dwarf postfix code as it goes.
10295 MODE is the mode of the memory reference, needed to handle some
10296 autoincrement addressing modes.
10298 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
10299 location list for RTL.
10301 Return 0 if we can't represent the location. */
10303 static dw_loc_descr_ref
10304 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
10305 enum var_init_status initialized)
10307 dw_loc_descr_ref mem_loc_result = NULL;
10308 enum dwarf_location_atom op;
10310 /* Note that for a dynamically sized array, the location we will generate a
10311 description of here will be the lowest numbered location which is
10312 actually within the array. That's *not* necessarily the same as the
10313 zeroth element of the array. */
10315 rtl = targetm.delegitimize_address (rtl);
10317 switch (GET_CODE (rtl))
10322 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
10323 just fall into the SUBREG code. */
10325 /* ... fall through ... */
10328 /* The case of a subreg may arise when we have a local (register)
10329 variable or a formal (register) parameter which doesn't quite fill
10330 up an entire register. For now, just assume that it is
10331 legitimate to make the Dwarf info refer to the whole register which
10332 contains the given subreg. */
10333 rtl = XEXP (rtl, 0);
10335 /* ... fall through ... */
10338 /* Whenever a register number forms a part of the description of the
10339 method for calculating the (dynamic) address of a memory resident
10340 object, DWARF rules require the register number be referred to as
10341 a "base register". This distinction is not based in any way upon
10342 what category of register the hardware believes the given register
10343 belongs to. This is strictly DWARF terminology we're dealing with
10344 here. Note that in cases where the location of a memory-resident
10345 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
10346 OP_CONST (0)) the actual DWARF location descriptor that we generate
10347 may just be OP_BASEREG (basereg). This may look deceptively like
10348 the object in question was allocated to a register (rather than in
10349 memory) so DWARF consumers need to be aware of the subtle
10350 distinction between OP_REG and OP_BASEREG. */
10351 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
10352 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
10353 else if (stack_realign_drap
10355 && crtl->args.internal_arg_pointer == rtl
10356 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
10358 /* If RTL is internal_arg_pointer, which has been optimized
10359 out, use DRAP instead. */
10360 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
10361 VAR_INIT_STATUS_INITIALIZED);
10366 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10367 VAR_INIT_STATUS_INITIALIZED);
10368 if (mem_loc_result == NULL)
10369 mem_loc_result = tls_mem_loc_descriptor (rtl);
10370 if (mem_loc_result != 0)
10371 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
10375 rtl = XEXP (rtl, 1);
10377 /* ... fall through ... */
10380 /* Some ports can transform a symbol ref into a label ref, because
10381 the symbol ref is too far away and has to be dumped into a constant
10385 /* Alternatively, the symbol in the constant pool might be referenced
10386 by a different symbol. */
10387 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
10390 rtx tmp = get_pool_constant_mark (rtl, &marked);
10392 if (GET_CODE (tmp) == SYMBOL_REF)
10395 if (CONSTANT_POOL_ADDRESS_P (tmp))
10396 get_pool_constant_mark (tmp, &marked);
10401 /* If all references to this pool constant were optimized away,
10402 it was not output and thus we can't represent it.
10403 FIXME: might try to use DW_OP_const_value here, though
10404 DW_OP_piece complicates it. */
10409 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
10410 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
10411 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
10412 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10416 /* Extract the PLUS expression nested inside and fall into
10417 PLUS code below. */
10418 rtl = XEXP (rtl, 1);
10423 /* Turn these into a PLUS expression and fall into the PLUS code
10425 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
10426 GEN_INT (GET_CODE (rtl) == PRE_INC
10427 ? GET_MODE_UNIT_SIZE (mode)
10428 : -GET_MODE_UNIT_SIZE (mode)));
10430 /* ... fall through ... */
10434 if (is_based_loc (rtl))
10435 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
10436 INTVAL (XEXP (rtl, 1)),
10437 VAR_INIT_STATUS_INITIALIZED);
10440 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
10441 VAR_INIT_STATUS_INITIALIZED);
10442 if (mem_loc_result == 0)
10445 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT)
10446 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
10449 dw_loc_descr_ref mem_loc_result2
10450 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10451 VAR_INIT_STATUS_INITIALIZED);
10452 if (mem_loc_result2 == 0)
10454 add_loc_descr (&mem_loc_result, mem_loc_result2);
10455 add_loc_descr (&mem_loc_result,
10456 new_loc_descr (DW_OP_plus, 0, 0));
10461 /* If a pseudo-reg is optimized away, it is possible for it to
10462 be replaced with a MEM containing a multiply or shift. */
10481 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
10482 VAR_INIT_STATUS_INITIALIZED);
10483 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10484 VAR_INIT_STATUS_INITIALIZED);
10486 if (op0 == 0 || op1 == 0)
10489 mem_loc_result = op0;
10490 add_loc_descr (&mem_loc_result, op1);
10491 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
10496 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
10500 mem_loc_result = concatn_mem_loc_descriptor (rtl, mode,
10501 VAR_INIT_STATUS_INITIALIZED);
10505 /* If delegitimize_address couldn't do anything with the UNSPEC, we
10506 can't express it in the debug info. This can happen e.g. with some
10511 gcc_unreachable ();
10514 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10515 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10517 return mem_loc_result;
10520 /* Return a descriptor that describes the concatenation of two locations.
10521 This is typically a complex variable. */
10523 static dw_loc_descr_ref
10524 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
10526 dw_loc_descr_ref cc_loc_result = NULL;
10527 dw_loc_descr_ref x0_ref = loc_descriptor (x0, VAR_INIT_STATUS_INITIALIZED);
10528 dw_loc_descr_ref x1_ref = loc_descriptor (x1, VAR_INIT_STATUS_INITIALIZED);
10530 if (x0_ref == 0 || x1_ref == 0)
10533 cc_loc_result = x0_ref;
10534 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
10536 add_loc_descr (&cc_loc_result, x1_ref);
10537 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
10539 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10540 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10542 return cc_loc_result;
10545 /* Return a descriptor that describes the concatenation of N
10548 static dw_loc_descr_ref
10549 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
10552 dw_loc_descr_ref cc_loc_result = NULL;
10553 unsigned int n = XVECLEN (concatn, 0);
10555 for (i = 0; i < n; ++i)
10557 dw_loc_descr_ref ref;
10558 rtx x = XVECEXP (concatn, 0, i);
10560 ref = loc_descriptor (x, VAR_INIT_STATUS_INITIALIZED);
10564 add_loc_descr (&cc_loc_result, ref);
10565 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
10568 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10569 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10571 return cc_loc_result;
10574 /* Output a proper Dwarf location descriptor for a variable or parameter
10575 which is either allocated in a register or in a memory location. For a
10576 register, we just generate an OP_REG and the register number. For a
10577 memory location we provide a Dwarf postfix expression describing how to
10578 generate the (dynamic) address of the object onto the address stack.
10580 If we don't know how to describe it, return 0. */
10582 static dw_loc_descr_ref
10583 loc_descriptor (rtx rtl, enum var_init_status initialized)
10585 dw_loc_descr_ref loc_result = NULL;
10587 switch (GET_CODE (rtl))
10590 /* The case of a subreg may arise when we have a local (register)
10591 variable or a formal (register) parameter which doesn't quite fill
10592 up an entire register. For now, just assume that it is
10593 legitimate to make the Dwarf info refer to the whole register which
10594 contains the given subreg. */
10595 rtl = SUBREG_REG (rtl);
10597 /* ... fall through ... */
10600 loc_result = reg_loc_descriptor (rtl, initialized);
10604 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10606 if (loc_result == NULL)
10607 loc_result = tls_mem_loc_descriptor (rtl);
10611 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
10616 loc_result = concatn_loc_descriptor (rtl, initialized);
10621 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
10623 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), initialized);
10627 rtl = XEXP (rtl, 1);
10632 rtvec par_elems = XVEC (rtl, 0);
10633 int num_elem = GET_NUM_ELEM (par_elems);
10634 enum machine_mode mode;
10637 /* Create the first one, so we have something to add to. */
10638 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
10640 if (loc_result == NULL)
10642 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
10643 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10644 for (i = 1; i < num_elem; i++)
10646 dw_loc_descr_ref temp;
10648 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
10652 add_loc_descr (&loc_result, temp);
10653 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
10654 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10660 gcc_unreachable ();
10666 /* Similar, but generate the descriptor from trees instead of rtl. This comes
10667 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
10668 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
10669 top-level invocation, and we require the address of LOC; is 0 if we require
10670 the value of LOC. */
10672 static dw_loc_descr_ref
10673 loc_descriptor_from_tree_1 (tree loc, int want_address)
10675 dw_loc_descr_ref ret, ret1;
10676 int have_address = 0;
10677 enum dwarf_location_atom op;
10679 /* ??? Most of the time we do not take proper care for sign/zero
10680 extending the values properly. Hopefully this won't be a real
10683 switch (TREE_CODE (loc))
10688 case PLACEHOLDER_EXPR:
10689 /* This case involves extracting fields from an object to determine the
10690 position of other fields. We don't try to encode this here. The
10691 only user of this is Ada, which encodes the needed information using
10692 the names of types. */
10698 case PREINCREMENT_EXPR:
10699 case PREDECREMENT_EXPR:
10700 case POSTINCREMENT_EXPR:
10701 case POSTDECREMENT_EXPR:
10702 /* There are no opcodes for these operations. */
10706 /* If we already want an address, there's nothing we can do. */
10710 /* Otherwise, process the argument and look for the address. */
10711 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
10714 if (DECL_THREAD_LOCAL_P (loc))
10717 enum dwarf_location_atom first_op;
10718 enum dwarf_location_atom second_op;
10720 if (targetm.have_tls)
10722 /* If this is not defined, we have no way to emit the
10724 if (!targetm.asm_out.output_dwarf_dtprel)
10727 /* The way DW_OP_GNU_push_tls_address is specified, we
10728 can only look up addresses of objects in the current
10730 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
10732 first_op = (enum dwarf_location_atom) INTERNAL_DW_OP_tls_addr;
10733 second_op = DW_OP_GNU_push_tls_address;
10737 if (!targetm.emutls.debug_form_tls_address)
10739 loc = emutls_decl (loc);
10740 first_op = DW_OP_addr;
10741 second_op = DW_OP_form_tls_address;
10744 rtl = rtl_for_decl_location (loc);
10745 if (rtl == NULL_RTX)
10750 rtl = XEXP (rtl, 0);
10751 if (! CONSTANT_P (rtl))
10754 ret = new_loc_descr (first_op, 0, 0);
10755 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10756 ret->dw_loc_oprnd1.v.val_addr = rtl;
10758 ret1 = new_loc_descr (second_op, 0, 0);
10759 add_loc_descr (&ret, ret1);
10767 if (DECL_HAS_VALUE_EXPR_P (loc))
10768 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
10773 case FUNCTION_DECL:
10775 rtx rtl = rtl_for_decl_location (loc);
10777 if (rtl == NULL_RTX)
10779 else if (GET_CODE (rtl) == CONST_INT)
10781 HOST_WIDE_INT val = INTVAL (rtl);
10782 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
10783 val &= GET_MODE_MASK (DECL_MODE (loc));
10784 ret = int_loc_descriptor (val);
10786 else if (GET_CODE (rtl) == CONST_STRING)
10788 else if (CONSTANT_P (rtl))
10790 ret = new_loc_descr (DW_OP_addr, 0, 0);
10791 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10792 ret->dw_loc_oprnd1.v.val_addr = rtl;
10796 enum machine_mode mode;
10798 /* Certain constructs can only be represented at top-level. */
10799 if (want_address == 2)
10800 return loc_descriptor (rtl, VAR_INIT_STATUS_INITIALIZED);
10802 mode = GET_MODE (rtl);
10805 rtl = XEXP (rtl, 0);
10808 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10814 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10818 case COMPOUND_EXPR:
10819 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
10822 case VIEW_CONVERT_EXPR:
10825 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
10827 case COMPONENT_REF:
10828 case BIT_FIELD_REF:
10830 case ARRAY_RANGE_REF:
10833 HOST_WIDE_INT bitsize, bitpos, bytepos;
10834 enum machine_mode mode;
10836 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
10838 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
10839 &unsignedp, &volatilep, false);
10844 ret = loc_descriptor_from_tree_1 (obj, 1);
10846 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
10849 if (offset != NULL_TREE)
10851 /* Variable offset. */
10852 ret1 = loc_descriptor_from_tree_1 (offset, 0);
10855 add_loc_descr (&ret, ret1);
10856 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10859 bytepos = bitpos / BITS_PER_UNIT;
10860 loc_descr_plus_const (&ret, bytepos);
10867 if (host_integerp (loc, 0))
10868 ret = int_loc_descriptor (tree_low_cst (loc, 0));
10875 /* Get an RTL for this, if something has been emitted. */
10876 rtx rtl = lookup_constant_def (loc);
10877 enum machine_mode mode;
10879 if (!rtl || !MEM_P (rtl))
10881 mode = GET_MODE (rtl);
10882 rtl = XEXP (rtl, 0);
10883 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10888 case TRUTH_AND_EXPR:
10889 case TRUTH_ANDIF_EXPR:
10894 case TRUTH_XOR_EXPR:
10899 case TRUTH_OR_EXPR:
10900 case TRUTH_ORIF_EXPR:
10905 case FLOOR_DIV_EXPR:
10906 case CEIL_DIV_EXPR:
10907 case ROUND_DIV_EXPR:
10908 case TRUNC_DIV_EXPR:
10916 case FLOOR_MOD_EXPR:
10917 case CEIL_MOD_EXPR:
10918 case ROUND_MOD_EXPR:
10919 case TRUNC_MOD_EXPR:
10932 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
10935 case POINTER_PLUS_EXPR:
10937 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
10938 && host_integerp (TREE_OPERAND (loc, 1), 0))
10940 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10944 loc_descr_plus_const (&ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
10952 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10959 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10966 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10973 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10988 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10989 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10990 if (ret == 0 || ret1 == 0)
10993 add_loc_descr (&ret, ret1);
10994 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10997 case TRUTH_NOT_EXPR:
11011 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
11015 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
11021 const enum tree_code code =
11022 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
11024 loc = build3 (COND_EXPR, TREE_TYPE (loc),
11025 build2 (code, integer_type_node,
11026 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
11027 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
11030 /* ... fall through ... */
11034 dw_loc_descr_ref lhs
11035 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
11036 dw_loc_descr_ref rhs
11037 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
11038 dw_loc_descr_ref bra_node, jump_node, tmp;
11040 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
11041 if (ret == 0 || lhs == 0 || rhs == 0)
11044 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
11045 add_loc_descr (&ret, bra_node);
11047 add_loc_descr (&ret, rhs);
11048 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
11049 add_loc_descr (&ret, jump_node);
11051 add_loc_descr (&ret, lhs);
11052 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
11053 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
11055 /* ??? Need a node to point the skip at. Use a nop. */
11056 tmp = new_loc_descr (DW_OP_nop, 0, 0);
11057 add_loc_descr (&ret, tmp);
11058 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
11059 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
11063 case FIX_TRUNC_EXPR:
11067 /* Leave front-end specific codes as simply unknown. This comes
11068 up, for instance, with the C STMT_EXPR. */
11069 if ((unsigned int) TREE_CODE (loc)
11070 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
11073 #ifdef ENABLE_CHECKING
11074 /* Otherwise this is a generic code; we should just lists all of
11075 these explicitly. We forgot one. */
11076 gcc_unreachable ();
11078 /* In a release build, we want to degrade gracefully: better to
11079 generate incomplete debugging information than to crash. */
11084 /* Show if we can't fill the request for an address. */
11085 if (want_address && !have_address)
11088 /* If we've got an address and don't want one, dereference. */
11089 if (!want_address && have_address && ret)
11091 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
11093 if (size > DWARF2_ADDR_SIZE || size == -1)
11095 else if (size == DWARF2_ADDR_SIZE)
11098 op = DW_OP_deref_size;
11100 add_loc_descr (&ret, new_loc_descr (op, size, 0));
11106 static inline dw_loc_descr_ref
11107 loc_descriptor_from_tree (tree loc)
11109 return loc_descriptor_from_tree_1 (loc, 2);
11112 /* Given a value, round it up to the lowest multiple of `boundary'
11113 which is not less than the value itself. */
11115 static inline HOST_WIDE_INT
11116 ceiling (HOST_WIDE_INT value, unsigned int boundary)
11118 return (((value + boundary - 1) / boundary) * boundary);
11121 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
11122 pointer to the declared type for the relevant field variable, or return
11123 `integer_type_node' if the given node turns out to be an
11124 ERROR_MARK node. */
11127 field_type (const_tree decl)
11131 if (TREE_CODE (decl) == ERROR_MARK)
11132 return integer_type_node;
11134 type = DECL_BIT_FIELD_TYPE (decl);
11135 if (type == NULL_TREE)
11136 type = TREE_TYPE (decl);
11141 /* Given a pointer to a tree node, return the alignment in bits for
11142 it, or else return BITS_PER_WORD if the node actually turns out to
11143 be an ERROR_MARK node. */
11145 static inline unsigned
11146 simple_type_align_in_bits (const_tree type)
11148 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
11151 static inline unsigned
11152 simple_decl_align_in_bits (const_tree decl)
11154 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
11157 /* Return the result of rounding T up to ALIGN. */
11159 static inline HOST_WIDE_INT
11160 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
11162 /* We must be careful if T is negative because HOST_WIDE_INT can be
11163 either "above" or "below" unsigned int as per the C promotion
11164 rules, depending on the host, thus making the signedness of the
11165 direct multiplication and division unpredictable. */
11166 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
11172 return (HOST_WIDE_INT) u;
11175 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
11176 lowest addressed byte of the "containing object" for the given FIELD_DECL,
11177 or return 0 if we are unable to determine what that offset is, either
11178 because the argument turns out to be a pointer to an ERROR_MARK node, or
11179 because the offset is actually variable. (We can't handle the latter case
11182 static HOST_WIDE_INT
11183 field_byte_offset (const_tree decl)
11185 HOST_WIDE_INT object_offset_in_bits;
11186 HOST_WIDE_INT bitpos_int;
11188 if (TREE_CODE (decl) == ERROR_MARK)
11191 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
11193 /* We cannot yet cope with fields whose positions are variable, so
11194 for now, when we see such things, we simply return 0. Someday, we may
11195 be able to handle such cases, but it will be damn difficult. */
11196 if (! host_integerp (bit_position (decl), 0))
11199 bitpos_int = int_bit_position (decl);
11201 #ifdef PCC_BITFIELD_TYPE_MATTERS
11202 if (PCC_BITFIELD_TYPE_MATTERS)
11205 tree field_size_tree;
11206 HOST_WIDE_INT deepest_bitpos;
11207 unsigned HOST_WIDE_INT field_size_in_bits;
11208 unsigned int type_align_in_bits;
11209 unsigned int decl_align_in_bits;
11210 unsigned HOST_WIDE_INT type_size_in_bits;
11212 type = field_type (decl);
11213 type_size_in_bits = simple_type_size_in_bits (type);
11214 type_align_in_bits = simple_type_align_in_bits (type);
11216 field_size_tree = DECL_SIZE (decl);
11218 /* The size could be unspecified if there was an error, or for
11219 a flexible array member. */
11220 if (!field_size_tree)
11221 field_size_tree = bitsize_zero_node;
11223 /* If the size of the field is not constant, use the type size. */
11224 if (host_integerp (field_size_tree, 1))
11225 field_size_in_bits = tree_low_cst (field_size_tree, 1);
11227 field_size_in_bits = type_size_in_bits;
11229 decl_align_in_bits = simple_decl_align_in_bits (decl);
11231 /* The GCC front-end doesn't make any attempt to keep track of the
11232 starting bit offset (relative to the start of the containing
11233 structure type) of the hypothetical "containing object" for a
11234 bit-field. Thus, when computing the byte offset value for the
11235 start of the "containing object" of a bit-field, we must deduce
11236 this information on our own. This can be rather tricky to do in
11237 some cases. For example, handling the following structure type
11238 definition when compiling for an i386/i486 target (which only
11239 aligns long long's to 32-bit boundaries) can be very tricky:
11241 struct S { int field1; long long field2:31; };
11243 Fortunately, there is a simple rule-of-thumb which can be used
11244 in such cases. When compiling for an i386/i486, GCC will
11245 allocate 8 bytes for the structure shown above. It decides to
11246 do this based upon one simple rule for bit-field allocation.
11247 GCC allocates each "containing object" for each bit-field at
11248 the first (i.e. lowest addressed) legitimate alignment boundary
11249 (based upon the required minimum alignment for the declared
11250 type of the field) which it can possibly use, subject to the
11251 condition that there is still enough available space remaining
11252 in the containing object (when allocated at the selected point)
11253 to fully accommodate all of the bits of the bit-field itself.
11255 This simple rule makes it obvious why GCC allocates 8 bytes for
11256 each object of the structure type shown above. When looking
11257 for a place to allocate the "containing object" for `field2',
11258 the compiler simply tries to allocate a 64-bit "containing
11259 object" at each successive 32-bit boundary (starting at zero)
11260 until it finds a place to allocate that 64- bit field such that
11261 at least 31 contiguous (and previously unallocated) bits remain
11262 within that selected 64 bit field. (As it turns out, for the
11263 example above, the compiler finds it is OK to allocate the
11264 "containing object" 64-bit field at bit-offset zero within the
11267 Here we attempt to work backwards from the limited set of facts
11268 we're given, and we try to deduce from those facts, where GCC
11269 must have believed that the containing object started (within
11270 the structure type). The value we deduce is then used (by the
11271 callers of this routine) to generate DW_AT_location and
11272 DW_AT_bit_offset attributes for fields (both bit-fields and, in
11273 the case of DW_AT_location, regular fields as well). */
11275 /* Figure out the bit-distance from the start of the structure to
11276 the "deepest" bit of the bit-field. */
11277 deepest_bitpos = bitpos_int + field_size_in_bits;
11279 /* This is the tricky part. Use some fancy footwork to deduce
11280 where the lowest addressed bit of the containing object must
11282 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
11284 /* Round up to type_align by default. This works best for
11286 object_offset_in_bits
11287 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
11289 if (object_offset_in_bits > bitpos_int)
11291 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
11293 /* Round up to decl_align instead. */
11294 object_offset_in_bits
11295 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
11300 object_offset_in_bits = bitpos_int;
11302 return object_offset_in_bits / BITS_PER_UNIT;
11305 /* The following routines define various Dwarf attributes and any data
11306 associated with them. */
11308 /* Add a location description attribute value to a DIE.
11310 This emits location attributes suitable for whole variables and
11311 whole parameters. Note that the location attributes for struct fields are
11312 generated by the routine `data_member_location_attribute' below. */
11315 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
11316 dw_loc_descr_ref descr)
11319 add_AT_loc (die, attr_kind, descr);
11322 /* Attach the specialized form of location attribute used for data members of
11323 struct and union types. In the special case of a FIELD_DECL node which
11324 represents a bit-field, the "offset" part of this special location
11325 descriptor must indicate the distance in bytes from the lowest-addressed
11326 byte of the containing struct or union type to the lowest-addressed byte of
11327 the "containing object" for the bit-field. (See the `field_byte_offset'
11330 For any given bit-field, the "containing object" is a hypothetical object
11331 (of some integral or enum type) within which the given bit-field lives. The
11332 type of this hypothetical "containing object" is always the same as the
11333 declared type of the individual bit-field itself (for GCC anyway... the
11334 DWARF spec doesn't actually mandate this). Note that it is the size (in
11335 bytes) of the hypothetical "containing object" which will be given in the
11336 DW_AT_byte_size attribute for this bit-field. (See the
11337 `byte_size_attribute' function below.) It is also used when calculating the
11338 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
11339 function below.) */
11342 add_data_member_location_attribute (dw_die_ref die, tree decl)
11344 HOST_WIDE_INT offset;
11345 dw_loc_descr_ref loc_descr = 0;
11347 if (TREE_CODE (decl) == TREE_BINFO)
11349 /* We're working on the TAG_inheritance for a base class. */
11350 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
11352 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
11353 aren't at a fixed offset from all (sub)objects of the same
11354 type. We need to extract the appropriate offset from our
11355 vtable. The following dwarf expression means
11357 BaseAddr = ObAddr + *((*ObAddr) - Offset)
11359 This is specific to the V3 ABI, of course. */
11361 dw_loc_descr_ref tmp;
11363 /* Make a copy of the object address. */
11364 tmp = new_loc_descr (DW_OP_dup, 0, 0);
11365 add_loc_descr (&loc_descr, tmp);
11367 /* Extract the vtable address. */
11368 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11369 add_loc_descr (&loc_descr, tmp);
11371 /* Calculate the address of the offset. */
11372 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
11373 gcc_assert (offset < 0);
11375 tmp = int_loc_descriptor (-offset);
11376 add_loc_descr (&loc_descr, tmp);
11377 tmp = new_loc_descr (DW_OP_minus, 0, 0);
11378 add_loc_descr (&loc_descr, tmp);
11380 /* Extract the offset. */
11381 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11382 add_loc_descr (&loc_descr, tmp);
11384 /* Add it to the object address. */
11385 tmp = new_loc_descr (DW_OP_plus, 0, 0);
11386 add_loc_descr (&loc_descr, tmp);
11389 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
11392 offset = field_byte_offset (decl);
11396 enum dwarf_location_atom op;
11398 /* The DWARF2 standard says that we should assume that the structure
11399 address is already on the stack, so we can specify a structure field
11400 address by using DW_OP_plus_uconst. */
11402 #ifdef MIPS_DEBUGGING_INFO
11403 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
11404 operator correctly. It works only if we leave the offset on the
11408 op = DW_OP_plus_uconst;
11411 loc_descr = new_loc_descr (op, offset, 0);
11414 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
11417 /* Writes integer values to dw_vec_const array. */
11420 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
11424 *dest++ = val & 0xff;
11430 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
11432 static HOST_WIDE_INT
11433 extract_int (const unsigned char *src, unsigned int size)
11435 HOST_WIDE_INT val = 0;
11441 val |= *--src & 0xff;
11447 /* Writes floating point values to dw_vec_const array. */
11450 insert_float (const_rtx rtl, unsigned char *array)
11452 REAL_VALUE_TYPE rv;
11456 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
11457 real_to_target (val, &rv, GET_MODE (rtl));
11459 /* real_to_target puts 32-bit pieces in each long. Pack them. */
11460 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
11462 insert_int (val[i], 4, array);
11467 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
11468 does not have a "location" either in memory or in a register. These
11469 things can arise in GNU C when a constant is passed as an actual parameter
11470 to an inlined function. They can also arise in C++ where declared
11471 constants do not necessarily get memory "homes". */
11474 add_const_value_attribute (dw_die_ref die, rtx rtl)
11476 switch (GET_CODE (rtl))
11480 HOST_WIDE_INT val = INTVAL (rtl);
11483 add_AT_int (die, DW_AT_const_value, val);
11485 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
11490 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
11491 floating-point constant. A CONST_DOUBLE is used whenever the
11492 constant requires more than one word in order to be adequately
11493 represented. We output CONST_DOUBLEs as blocks. */
11495 enum machine_mode mode = GET_MODE (rtl);
11497 if (SCALAR_FLOAT_MODE_P (mode))
11499 unsigned int length = GET_MODE_SIZE (mode);
11500 unsigned char *array = GGC_NEWVEC (unsigned char, length);
11502 insert_float (rtl, array);
11503 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
11507 /* ??? We really should be using HOST_WIDE_INT throughout. */
11508 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
11510 add_AT_long_long (die, DW_AT_const_value,
11511 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
11518 enum machine_mode mode = GET_MODE (rtl);
11519 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
11520 unsigned int length = CONST_VECTOR_NUNITS (rtl);
11521 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
11525 switch (GET_MODE_CLASS (mode))
11527 case MODE_VECTOR_INT:
11528 for (i = 0, p = array; i < length; i++, p += elt_size)
11530 rtx elt = CONST_VECTOR_ELT (rtl, i);
11531 HOST_WIDE_INT lo, hi;
11533 switch (GET_CODE (elt))
11541 lo = CONST_DOUBLE_LOW (elt);
11542 hi = CONST_DOUBLE_HIGH (elt);
11546 gcc_unreachable ();
11549 if (elt_size <= sizeof (HOST_WIDE_INT))
11550 insert_int (lo, elt_size, p);
11553 unsigned char *p0 = p;
11554 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
11556 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
11557 if (WORDS_BIG_ENDIAN)
11562 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
11563 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
11568 case MODE_VECTOR_FLOAT:
11569 for (i = 0, p = array; i < length; i++, p += elt_size)
11571 rtx elt = CONST_VECTOR_ELT (rtl, i);
11572 insert_float (elt, p);
11577 gcc_unreachable ();
11580 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
11585 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
11591 add_AT_addr (die, DW_AT_const_value, rtl);
11592 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11596 /* In cases where an inlined instance of an inline function is passed
11597 the address of an `auto' variable (which is local to the caller) we
11598 can get a situation where the DECL_RTL of the artificial local
11599 variable (for the inlining) which acts as a stand-in for the
11600 corresponding formal parameter (of the inline function) will look
11601 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
11602 exactly a compile-time constant expression, but it isn't the address
11603 of the (artificial) local variable either. Rather, it represents the
11604 *value* which the artificial local variable always has during its
11605 lifetime. We currently have no way to represent such quasi-constant
11606 values in Dwarf, so for now we just punt and generate nothing. */
11610 /* No other kinds of rtx should be possible here. */
11611 gcc_unreachable ();
11616 /* Determine whether the evaluation of EXPR references any variables
11617 or functions which aren't otherwise used (and therefore may not be
11620 reference_to_unused (tree * tp, int * walk_subtrees,
11621 void * data ATTRIBUTE_UNUSED)
11623 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
11624 *walk_subtrees = 0;
11626 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
11627 && ! TREE_ASM_WRITTEN (*tp))
11629 /* ??? The C++ FE emits debug information for using decls, so
11630 putting gcc_unreachable here falls over. See PR31899. For now
11631 be conservative. */
11632 else if (!cgraph_global_info_ready
11633 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
11635 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
11637 struct varpool_node *node = varpool_node (*tp);
11641 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
11642 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
11644 struct cgraph_node *node = cgraph_node (*tp);
11645 if (node->process || TREE_ASM_WRITTEN (*tp))
11648 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
11654 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
11655 for use in a later add_const_value_attribute call. */
11658 rtl_for_decl_init (tree init, tree type)
11660 rtx rtl = NULL_RTX;
11662 /* If a variable is initialized with a string constant without embedded
11663 zeros, build CONST_STRING. */
11664 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
11666 tree enttype = TREE_TYPE (type);
11667 tree domain = TYPE_DOMAIN (type);
11668 enum machine_mode mode = TYPE_MODE (enttype);
11670 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
11672 && integer_zerop (TYPE_MIN_VALUE (domain))
11673 && compare_tree_int (TYPE_MAX_VALUE (domain),
11674 TREE_STRING_LENGTH (init) - 1) == 0
11675 && ((size_t) TREE_STRING_LENGTH (init)
11676 == strlen (TREE_STRING_POINTER (init)) + 1))
11677 rtl = gen_rtx_CONST_STRING (VOIDmode,
11678 ggc_strdup (TREE_STRING_POINTER (init)));
11680 /* Other aggregates, and complex values, could be represented using
11682 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
11684 /* Vectors only work if their mode is supported by the target.
11685 FIXME: generic vectors ought to work too. */
11686 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
11688 /* If the initializer is something that we know will expand into an
11689 immediate RTL constant, expand it now. We must be careful not to
11690 reference variables which won't be output. */
11691 else if (initializer_constant_valid_p (init, type)
11692 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
11694 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
11696 if (TREE_CODE (type) == VECTOR_TYPE)
11697 switch (TREE_CODE (init))
11702 if (TREE_CONSTANT (init))
11704 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
11705 bool constant_p = true;
11707 unsigned HOST_WIDE_INT ix;
11709 /* Even when ctor is constant, it might contain non-*_CST
11710 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
11711 belong into VECTOR_CST nodes. */
11712 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
11713 if (!CONSTANT_CLASS_P (value))
11715 constant_p = false;
11721 init = build_vector_from_ctor (type, elts);
11731 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
11733 /* If expand_expr returns a MEM, it wasn't immediate. */
11734 gcc_assert (!rtl || !MEM_P (rtl));
11740 /* Generate RTL for the variable DECL to represent its location. */
11743 rtl_for_decl_location (tree decl)
11747 /* Here we have to decide where we are going to say the parameter "lives"
11748 (as far as the debugger is concerned). We only have a couple of
11749 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
11751 DECL_RTL normally indicates where the parameter lives during most of the
11752 activation of the function. If optimization is enabled however, this
11753 could be either NULL or else a pseudo-reg. Both of those cases indicate
11754 that the parameter doesn't really live anywhere (as far as the code
11755 generation parts of GCC are concerned) during most of the function's
11756 activation. That will happen (for example) if the parameter is never
11757 referenced within the function.
11759 We could just generate a location descriptor here for all non-NULL
11760 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
11761 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
11762 where DECL_RTL is NULL or is a pseudo-reg.
11764 Note however that we can only get away with using DECL_INCOMING_RTL as
11765 a backup substitute for DECL_RTL in certain limited cases. In cases
11766 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
11767 we can be sure that the parameter was passed using the same type as it is
11768 declared to have within the function, and that its DECL_INCOMING_RTL
11769 points us to a place where a value of that type is passed.
11771 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
11772 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
11773 because in these cases DECL_INCOMING_RTL points us to a value of some
11774 type which is *different* from the type of the parameter itself. Thus,
11775 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
11776 such cases, the debugger would end up (for example) trying to fetch a
11777 `float' from a place which actually contains the first part of a
11778 `double'. That would lead to really incorrect and confusing
11779 output at debug-time.
11781 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
11782 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
11783 are a couple of exceptions however. On little-endian machines we can
11784 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
11785 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
11786 an integral type that is smaller than TREE_TYPE (decl). These cases arise
11787 when (on a little-endian machine) a non-prototyped function has a
11788 parameter declared to be of type `short' or `char'. In such cases,
11789 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
11790 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
11791 passed `int' value. If the debugger then uses that address to fetch
11792 a `short' or a `char' (on a little-endian machine) the result will be
11793 the correct data, so we allow for such exceptional cases below.
11795 Note that our goal here is to describe the place where the given formal
11796 parameter lives during most of the function's activation (i.e. between the
11797 end of the prologue and the start of the epilogue). We'll do that as best
11798 as we can. Note however that if the given formal parameter is modified
11799 sometime during the execution of the function, then a stack backtrace (at
11800 debug-time) will show the function as having been called with the *new*
11801 value rather than the value which was originally passed in. This happens
11802 rarely enough that it is not a major problem, but it *is* a problem, and
11803 I'd like to fix it.
11805 A future version of dwarf2out.c may generate two additional attributes for
11806 any given DW_TAG_formal_parameter DIE which will describe the "passed
11807 type" and the "passed location" for the given formal parameter in addition
11808 to the attributes we now generate to indicate the "declared type" and the
11809 "active location" for each parameter. This additional set of attributes
11810 could be used by debuggers for stack backtraces. Separately, note that
11811 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
11812 This happens (for example) for inlined-instances of inline function formal
11813 parameters which are never referenced. This really shouldn't be
11814 happening. All PARM_DECL nodes should get valid non-NULL
11815 DECL_INCOMING_RTL values. FIXME. */
11817 /* Use DECL_RTL as the "location" unless we find something better. */
11818 rtl = DECL_RTL_IF_SET (decl);
11820 /* When generating abstract instances, ignore everything except
11821 constants, symbols living in memory, and symbols living in
11822 fixed registers. */
11823 if (! reload_completed)
11826 && (CONSTANT_P (rtl)
11828 && CONSTANT_P (XEXP (rtl, 0)))
11830 && TREE_CODE (decl) == VAR_DECL
11831 && TREE_STATIC (decl))))
11833 rtl = targetm.delegitimize_address (rtl);
11838 else if (TREE_CODE (decl) == PARM_DECL)
11840 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
11842 tree declared_type = TREE_TYPE (decl);
11843 tree passed_type = DECL_ARG_TYPE (decl);
11844 enum machine_mode dmode = TYPE_MODE (declared_type);
11845 enum machine_mode pmode = TYPE_MODE (passed_type);
11847 /* This decl represents a formal parameter which was optimized out.
11848 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
11849 all cases where (rtl == NULL_RTX) just below. */
11850 if (dmode == pmode)
11851 rtl = DECL_INCOMING_RTL (decl);
11852 else if (SCALAR_INT_MODE_P (dmode)
11853 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
11854 && DECL_INCOMING_RTL (decl))
11856 rtx inc = DECL_INCOMING_RTL (decl);
11859 else if (MEM_P (inc))
11861 if (BYTES_BIG_ENDIAN)
11862 rtl = adjust_address_nv (inc, dmode,
11863 GET_MODE_SIZE (pmode)
11864 - GET_MODE_SIZE (dmode));
11871 /* If the parm was passed in registers, but lives on the stack, then
11872 make a big endian correction if the mode of the type of the
11873 parameter is not the same as the mode of the rtl. */
11874 /* ??? This is the same series of checks that are made in dbxout.c before
11875 we reach the big endian correction code there. It isn't clear if all
11876 of these checks are necessary here, but keeping them all is the safe
11878 else if (MEM_P (rtl)
11879 && XEXP (rtl, 0) != const0_rtx
11880 && ! CONSTANT_P (XEXP (rtl, 0))
11881 /* Not passed in memory. */
11882 && !MEM_P (DECL_INCOMING_RTL (decl))
11883 /* Not passed by invisible reference. */
11884 && (!REG_P (XEXP (rtl, 0))
11885 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
11886 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
11887 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
11888 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
11891 /* Big endian correction check. */
11892 && BYTES_BIG_ENDIAN
11893 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
11894 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
11897 int offset = (UNITS_PER_WORD
11898 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
11900 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11901 plus_constant (XEXP (rtl, 0), offset));
11904 else if (TREE_CODE (decl) == VAR_DECL
11907 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
11908 && BYTES_BIG_ENDIAN)
11910 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
11911 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
11913 /* If a variable is declared "register" yet is smaller than
11914 a register, then if we store the variable to memory, it
11915 looks like we're storing a register-sized value, when in
11916 fact we are not. We need to adjust the offset of the
11917 storage location to reflect the actual value's bytes,
11918 else gdb will not be able to display it. */
11920 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11921 plus_constant (XEXP (rtl, 0), rsize-dsize));
11924 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
11925 and will have been substituted directly into all expressions that use it.
11926 C does not have such a concept, but C++ and other languages do. */
11927 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
11928 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
11931 rtl = targetm.delegitimize_address (rtl);
11933 /* If we don't look past the constant pool, we risk emitting a
11934 reference to a constant pool entry that isn't referenced from
11935 code, and thus is not emitted. */
11937 rtl = avoid_constant_pool_reference (rtl);
11942 /* We need to figure out what section we should use as the base for the
11943 address ranges where a given location is valid.
11944 1. If this particular DECL has a section associated with it, use that.
11945 2. If this function has a section associated with it, use that.
11946 3. Otherwise, use the text section.
11947 XXX: If you split a variable across multiple sections, we won't notice. */
11949 static const char *
11950 secname_for_decl (const_tree decl)
11952 const char *secname;
11954 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
11956 tree sectree = DECL_SECTION_NAME (decl);
11957 secname = TREE_STRING_POINTER (sectree);
11959 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
11961 tree sectree = DECL_SECTION_NAME (current_function_decl);
11962 secname = TREE_STRING_POINTER (sectree);
11964 else if (cfun && in_cold_section_p)
11965 secname = crtl->subsections.cold_section_label;
11967 secname = text_section_label;
11972 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
11973 returned. If so, the decl for the COMMON block is returned, and the
11974 value is the offset into the common block for the symbol. */
11977 fortran_common (tree decl, HOST_WIDE_INT *value)
11979 tree val_expr, cvar;
11980 enum machine_mode mode;
11981 HOST_WIDE_INT bitsize, bitpos;
11983 int volatilep = 0, unsignedp = 0;
11985 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
11986 it does not have a value (the offset into the common area), or if it
11987 is thread local (as opposed to global) then it isn't common, and shouldn't
11988 be handled as such. */
11989 if (TREE_CODE (decl) != VAR_DECL
11990 || !TREE_PUBLIC (decl)
11991 || !TREE_STATIC (decl)
11992 || !DECL_HAS_VALUE_EXPR_P (decl)
11996 val_expr = DECL_VALUE_EXPR (decl);
11997 if (TREE_CODE (val_expr) != COMPONENT_REF)
12000 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
12001 &mode, &unsignedp, &volatilep, true);
12003 if (cvar == NULL_TREE
12004 || TREE_CODE (cvar) != VAR_DECL
12005 || DECL_ARTIFICIAL (cvar)
12006 || !TREE_PUBLIC (cvar))
12010 if (offset != NULL)
12012 if (!host_integerp (offset, 0))
12014 *value = tree_low_cst (offset, 0);
12017 *value += bitpos / BITS_PER_UNIT;
12022 /* Dereference a location expression LOC if DECL is passed by invisible
12025 static dw_loc_descr_ref
12026 loc_by_reference (dw_loc_descr_ref loc, tree decl)
12028 HOST_WIDE_INT size;
12029 enum dwarf_location_atom op;
12034 if ((TREE_CODE (decl) != PARM_DECL
12035 && TREE_CODE (decl) != RESULT_DECL
12036 && TREE_CODE (decl) != VAR_DECL)
12037 || !DECL_BY_REFERENCE (decl))
12040 /* If loc is DW_OP_reg{0...31,x}, don't add DW_OP_deref, instead
12041 change it into corresponding DW_OP_breg{0...31,x} 0. Then the
12042 location expression is considered to be address of a memory location,
12043 rather than the register itself. */
12044 if (((loc->dw_loc_opc >= DW_OP_reg0 && loc->dw_loc_opc <= DW_OP_reg31)
12045 || loc->dw_loc_opc == DW_OP_regx)
12046 && (loc->dw_loc_next == NULL
12047 || (loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_uninit
12048 && loc->dw_loc_next->dw_loc_next == NULL)))
12050 if (loc->dw_loc_opc == DW_OP_regx)
12052 loc->dw_loc_opc = DW_OP_bregx;
12053 loc->dw_loc_oprnd2.v.val_int = 0;
12058 = (enum dwarf_location_atom)
12059 (loc->dw_loc_opc + (DW_OP_breg0 - DW_OP_reg0));
12060 loc->dw_loc_oprnd1.v.val_int = 0;
12065 size = int_size_in_bytes (TREE_TYPE (decl));
12066 if (size > DWARF2_ADDR_SIZE || size == -1)
12068 else if (size == DWARF2_ADDR_SIZE)
12071 op = DW_OP_deref_size;
12072 add_loc_descr (&loc, new_loc_descr (op, size, 0));
12076 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
12077 data attribute for a variable or a parameter. We generate the
12078 DW_AT_const_value attribute only in those cases where the given variable
12079 or parameter does not have a true "location" either in memory or in a
12080 register. This can happen (for example) when a constant is passed as an
12081 actual argument in a call to an inline function. (It's possible that
12082 these things can crop up in other ways also.) Note that one type of
12083 constant value which can be passed into an inlined function is a constant
12084 pointer. This can happen for example if an actual argument in an inlined
12085 function call evaluates to a compile-time constant address. */
12088 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
12089 enum dwarf_attribute attr)
12092 dw_loc_descr_ref descr;
12093 var_loc_list *loc_list;
12094 struct var_loc_node *node;
12095 if (TREE_CODE (decl) == ERROR_MARK)
12098 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
12099 || TREE_CODE (decl) == RESULT_DECL);
12101 /* See if we possibly have multiple locations for this variable. */
12102 loc_list = lookup_decl_loc (decl);
12104 /* If it truly has multiple locations, the first and last node will
12106 if (loc_list && loc_list->first != loc_list->last)
12108 const char *endname, *secname;
12109 dw_loc_list_ref list;
12111 enum var_init_status initialized;
12113 /* Now that we know what section we are using for a base,
12114 actually construct the list of locations.
12115 The first location information is what is passed to the
12116 function that creates the location list, and the remaining
12117 locations just get added on to that list.
12118 Note that we only know the start address for a location
12119 (IE location changes), so to build the range, we use
12120 the range [current location start, next location start].
12121 This means we have to special case the last node, and generate
12122 a range of [last location start, end of function label]. */
12124 node = loc_list->first;
12125 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
12126 secname = secname_for_decl (decl);
12128 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
12129 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
12131 initialized = VAR_INIT_STATUS_INITIALIZED;
12133 descr = loc_by_reference (loc_descriptor (varloc, initialized), decl);
12134 list = new_loc_list (descr, node->label, node->next->label, secname, 1);
12137 for (; node->next; node = node->next)
12138 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
12140 /* The variable has a location between NODE->LABEL and
12141 NODE->NEXT->LABEL. */
12142 enum var_init_status initialized =
12143 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
12144 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
12145 descr = loc_by_reference (loc_descriptor (varloc, initialized),
12147 add_loc_descr_to_loc_list (&list, descr,
12148 node->label, node->next->label, secname);
12151 /* If the variable has a location at the last label
12152 it keeps its location until the end of function. */
12153 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
12155 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
12156 enum var_init_status initialized =
12157 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
12159 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
12160 if (!current_function_decl)
12161 endname = text_end_label;
12164 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
12165 current_function_funcdef_no);
12166 endname = ggc_strdup (label_id);
12168 descr = loc_by_reference (loc_descriptor (varloc, initialized),
12170 add_loc_descr_to_loc_list (&list, descr,
12171 node->label, endname, secname);
12174 /* Finally, add the location list to the DIE, and we are done. */
12175 add_AT_loc_list (die, attr, list);
12179 /* Try to get some constant RTL for this decl, and use that as the value of
12182 rtl = rtl_for_decl_location (decl);
12183 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
12185 add_const_value_attribute (die, rtl);
12189 /* If we have tried to generate the location otherwise, and it
12190 didn't work out (we wouldn't be here if we did), and we have a one entry
12191 location list, try generating a location from that. */
12192 if (loc_list && loc_list->first)
12194 enum var_init_status status;
12195 node = loc_list->first;
12196 status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
12197 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note), status);
12200 descr = loc_by_reference (descr, decl);
12201 add_AT_location_description (die, attr, descr);
12206 /* We couldn't get any rtl, so try directly generating the location
12207 description from the tree. */
12208 descr = loc_descriptor_from_tree (decl);
12211 descr = loc_by_reference (descr, decl);
12212 add_AT_location_description (die, attr, descr);
12215 /* None of that worked, so it must not really have a location;
12216 try adding a constant value attribute from the DECL_INITIAL. */
12217 tree_add_const_value_attribute (die, decl);
12220 /* Add VARIABLE and DIE into deferred locations list. */
12223 defer_location (tree variable, dw_die_ref die)
12225 deferred_locations entry;
12226 entry.variable = variable;
12228 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
12231 /* Helper function for tree_add_const_value_attribute. Natively encode
12232 initializer INIT into an array. Return true if successful. */
12235 native_encode_initializer (tree init, unsigned char *array, int size)
12239 if (init == NULL_TREE)
12243 switch (TREE_CODE (init))
12246 type = TREE_TYPE (init);
12247 if (TREE_CODE (type) == ARRAY_TYPE)
12249 tree enttype = TREE_TYPE (type);
12250 enum machine_mode mode = TYPE_MODE (enttype);
12252 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
12254 if (int_size_in_bytes (type) != size)
12256 if (size > TREE_STRING_LENGTH (init))
12258 memcpy (array, TREE_STRING_POINTER (init),
12259 TREE_STRING_LENGTH (init));
12260 memset (array + TREE_STRING_LENGTH (init),
12261 '\0', size - TREE_STRING_LENGTH (init));
12264 memcpy (array, TREE_STRING_POINTER (init), size);
12269 type = TREE_TYPE (init);
12270 if (int_size_in_bytes (type) != size)
12272 if (TREE_CODE (type) == ARRAY_TYPE)
12274 HOST_WIDE_INT min_index;
12275 unsigned HOST_WIDE_INT cnt;
12276 int curpos = 0, fieldsize;
12277 constructor_elt *ce;
12279 if (TYPE_DOMAIN (type) == NULL_TREE
12280 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
12283 fieldsize = int_size_in_bytes (TREE_TYPE (type));
12284 if (fieldsize <= 0)
12287 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
12288 memset (array, '\0', size);
12290 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
12293 tree val = ce->value;
12294 tree index = ce->index;
12296 if (index && TREE_CODE (index) == RANGE_EXPR)
12297 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
12300 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
12305 if (!native_encode_initializer (val, array + pos, fieldsize))
12308 curpos = pos + fieldsize;
12309 if (index && TREE_CODE (index) == RANGE_EXPR)
12311 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
12312 - tree_low_cst (TREE_OPERAND (index, 0), 0);
12316 memcpy (array + curpos, array + pos, fieldsize);
12317 curpos += fieldsize;
12320 gcc_assert (curpos <= size);
12324 else if (TREE_CODE (type) == RECORD_TYPE
12325 || TREE_CODE (type) == UNION_TYPE)
12327 tree field = NULL_TREE;
12328 unsigned HOST_WIDE_INT cnt;
12329 constructor_elt *ce;
12331 if (int_size_in_bytes (type) != size)
12334 if (TREE_CODE (type) == RECORD_TYPE)
12335 field = TYPE_FIELDS (type);
12338 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
12339 cnt++, field = field ? TREE_CHAIN (field) : 0)
12341 tree val = ce->value;
12342 int pos, fieldsize;
12344 if (ce->index != 0)
12350 if (field == NULL_TREE || DECL_BIT_FIELD (field))
12353 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
12354 && TYPE_DOMAIN (TREE_TYPE (field))
12355 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
12357 else if (DECL_SIZE_UNIT (field) == NULL_TREE
12358 || !host_integerp (DECL_SIZE_UNIT (field), 0))
12360 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
12361 pos = int_byte_position (field);
12362 gcc_assert (pos + fieldsize <= size);
12364 && !native_encode_initializer (val, array + pos, fieldsize))
12370 case VIEW_CONVERT_EXPR:
12371 case NON_LVALUE_EXPR:
12372 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
12374 return native_encode_expr (init, array, size) == size;
12378 /* If we don't have a copy of this variable in memory for some reason (such
12379 as a C++ member constant that doesn't have an out-of-line definition),
12380 we should tell the debugger about the constant value. */
12383 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
12386 tree type = TREE_TYPE (decl);
12389 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
12392 init = DECL_INITIAL (decl);
12393 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
12398 rtl = rtl_for_decl_init (init, type);
12400 add_const_value_attribute (var_die, rtl);
12401 /* If the host and target are sane, try harder. */
12402 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
12403 && initializer_constant_valid_p (init, type))
12405 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
12406 if (size > 0 && (int) size == size)
12408 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
12410 if (native_encode_initializer (init, array, size))
12411 add_AT_vec (var_die, DW_AT_const_value, size, 1, array);
12416 /* Convert the CFI instructions for the current function into a
12417 location list. This is used for DW_AT_frame_base when we targeting
12418 a dwarf2 consumer that does not support the dwarf3
12419 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
12422 static dw_loc_list_ref
12423 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
12426 dw_loc_list_ref list, *list_tail;
12428 dw_cfa_location last_cfa, next_cfa;
12429 const char *start_label, *last_label, *section;
12430 dw_cfa_location remember;
12432 fde = current_fde ();
12433 gcc_assert (fde != NULL);
12435 section = secname_for_decl (current_function_decl);
12439 memset (&next_cfa, 0, sizeof (next_cfa));
12440 next_cfa.reg = INVALID_REGNUM;
12441 remember = next_cfa;
12443 start_label = fde->dw_fde_begin;
12445 /* ??? Bald assumption that the CIE opcode list does not contain
12446 advance opcodes. */
12447 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
12448 lookup_cfa_1 (cfi, &next_cfa, &remember);
12450 last_cfa = next_cfa;
12451 last_label = start_label;
12453 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
12454 switch (cfi->dw_cfi_opc)
12456 case DW_CFA_set_loc:
12457 case DW_CFA_advance_loc1:
12458 case DW_CFA_advance_loc2:
12459 case DW_CFA_advance_loc4:
12460 if (!cfa_equal_p (&last_cfa, &next_cfa))
12462 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12463 start_label, last_label, section,
12466 list_tail = &(*list_tail)->dw_loc_next;
12467 last_cfa = next_cfa;
12468 start_label = last_label;
12470 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
12473 case DW_CFA_advance_loc:
12474 /* The encoding is complex enough that we should never emit this. */
12475 gcc_unreachable ();
12478 lookup_cfa_1 (cfi, &next_cfa, &remember);
12482 if (!cfa_equal_p (&last_cfa, &next_cfa))
12484 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12485 start_label, last_label, section,
12487 list_tail = &(*list_tail)->dw_loc_next;
12488 start_label = last_label;
12490 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
12491 start_label, fde->dw_fde_end, section,
12497 /* Compute a displacement from the "steady-state frame pointer" to the
12498 frame base (often the same as the CFA), and store it in
12499 frame_pointer_fb_offset. OFFSET is added to the displacement
12500 before the latter is negated. */
12503 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
12507 #ifdef FRAME_POINTER_CFA_OFFSET
12508 reg = frame_pointer_rtx;
12509 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
12511 reg = arg_pointer_rtx;
12512 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
12515 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
12516 if (GET_CODE (elim) == PLUS)
12518 offset += INTVAL (XEXP (elim, 1));
12519 elim = XEXP (elim, 0);
12522 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12523 && (elim == hard_frame_pointer_rtx
12524 || elim == stack_pointer_rtx))
12525 || elim == (frame_pointer_needed
12526 ? hard_frame_pointer_rtx
12527 : stack_pointer_rtx));
12529 frame_pointer_fb_offset = -offset;
12532 /* Generate a DW_AT_name attribute given some string value to be included as
12533 the value of the attribute. */
12536 add_name_attribute (dw_die_ref die, const char *name_string)
12538 if (name_string != NULL && *name_string != 0)
12540 if (demangle_name_func)
12541 name_string = (*demangle_name_func) (name_string);
12543 add_AT_string (die, DW_AT_name, name_string);
12547 /* Generate a DW_AT_comp_dir attribute for DIE. */
12550 add_comp_dir_attribute (dw_die_ref die)
12552 const char *wd = get_src_pwd ();
12554 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
12557 /* Given a tree node describing an array bound (either lower or upper) output
12558 a representation for that bound. */
12561 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
12563 switch (TREE_CODE (bound))
12568 /* All fixed-bounds are represented by INTEGER_CST nodes. */
12570 if (! host_integerp (bound, 0)
12571 || (bound_attr == DW_AT_lower_bound
12572 && (((is_c_family () || is_java ()) && integer_zerop (bound))
12573 || (is_fortran () && integer_onep (bound)))))
12574 /* Use the default. */
12577 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
12581 case VIEW_CONVERT_EXPR:
12582 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
12592 dw_die_ref decl_die = lookup_decl_die (bound);
12593 dw_loc_descr_ref loc;
12595 /* ??? Can this happen, or should the variable have been bound
12596 first? Probably it can, since I imagine that we try to create
12597 the types of parameters in the order in which they exist in
12598 the list, and won't have created a forward reference to a
12599 later parameter. */
12600 if (decl_die != NULL)
12601 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12604 loc = loc_descriptor_from_tree_1 (bound, 0);
12605 add_AT_location_description (subrange_die, bound_attr, loc);
12612 /* Otherwise try to create a stack operation procedure to
12613 evaluate the value of the array bound. */
12615 dw_die_ref ctx, decl_die;
12616 dw_loc_descr_ref loc;
12618 loc = loc_descriptor_from_tree (bound);
12622 if (current_function_decl == 0)
12623 ctx = comp_unit_die;
12625 ctx = lookup_decl_die (current_function_decl);
12627 decl_die = new_die (DW_TAG_variable, ctx, bound);
12628 add_AT_flag (decl_die, DW_AT_artificial, 1);
12629 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
12630 add_AT_loc (decl_die, DW_AT_location, loc);
12632 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12638 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
12639 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
12640 Note that the block of subscript information for an array type also
12641 includes information about the element type of the given array type. */
12644 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
12646 unsigned dimension_number;
12648 dw_die_ref subrange_die;
12650 for (dimension_number = 0;
12651 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
12652 type = TREE_TYPE (type), dimension_number++)
12654 tree domain = TYPE_DOMAIN (type);
12656 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
12659 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
12660 and (in GNU C only) variable bounds. Handle all three forms
12662 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
12665 /* We have an array type with specified bounds. */
12666 lower = TYPE_MIN_VALUE (domain);
12667 upper = TYPE_MAX_VALUE (domain);
12669 /* Define the index type. */
12670 if (TREE_TYPE (domain))
12672 /* ??? This is probably an Ada unnamed subrange type. Ignore the
12673 TREE_TYPE field. We can't emit debug info for this
12674 because it is an unnamed integral type. */
12675 if (TREE_CODE (domain) == INTEGER_TYPE
12676 && TYPE_NAME (domain) == NULL_TREE
12677 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
12678 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
12681 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
12685 /* ??? If upper is NULL, the array has unspecified length,
12686 but it does have a lower bound. This happens with Fortran
12688 Since the debugger is definitely going to need to know N
12689 to produce useful results, go ahead and output the lower
12690 bound solo, and hope the debugger can cope. */
12692 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
12694 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
12697 /* Otherwise we have an array type with an unspecified length. The
12698 DWARF-2 spec does not say how to handle this; let's just leave out the
12704 add_byte_size_attribute (dw_die_ref die, tree tree_node)
12708 switch (TREE_CODE (tree_node))
12713 case ENUMERAL_TYPE:
12716 case QUAL_UNION_TYPE:
12717 size = int_size_in_bytes (tree_node);
12720 /* For a data member of a struct or union, the DW_AT_byte_size is
12721 generally given as the number of bytes normally allocated for an
12722 object of the *declared* type of the member itself. This is true
12723 even for bit-fields. */
12724 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
12727 gcc_unreachable ();
12730 /* Note that `size' might be -1 when we get to this point. If it is, that
12731 indicates that the byte size of the entity in question is variable. We
12732 have no good way of expressing this fact in Dwarf at the present time,
12733 so just let the -1 pass on through. */
12734 add_AT_unsigned (die, DW_AT_byte_size, size);
12737 /* For a FIELD_DECL node which represents a bit-field, output an attribute
12738 which specifies the distance in bits from the highest order bit of the
12739 "containing object" for the bit-field to the highest order bit of the
12742 For any given bit-field, the "containing object" is a hypothetical object
12743 (of some integral or enum type) within which the given bit-field lives. The
12744 type of this hypothetical "containing object" is always the same as the
12745 declared type of the individual bit-field itself. The determination of the
12746 exact location of the "containing object" for a bit-field is rather
12747 complicated. It's handled by the `field_byte_offset' function (above).
12749 Note that it is the size (in bytes) of the hypothetical "containing object"
12750 which will be given in the DW_AT_byte_size attribute for this bit-field.
12751 (See `byte_size_attribute' above). */
12754 add_bit_offset_attribute (dw_die_ref die, tree decl)
12756 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
12757 tree type = DECL_BIT_FIELD_TYPE (decl);
12758 HOST_WIDE_INT bitpos_int;
12759 HOST_WIDE_INT highest_order_object_bit_offset;
12760 HOST_WIDE_INT highest_order_field_bit_offset;
12761 HOST_WIDE_INT unsigned bit_offset;
12763 /* Must be a field and a bit field. */
12764 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
12766 /* We can't yet handle bit-fields whose offsets are variable, so if we
12767 encounter such things, just return without generating any attribute
12768 whatsoever. Likewise for variable or too large size. */
12769 if (! host_integerp (bit_position (decl), 0)
12770 || ! host_integerp (DECL_SIZE (decl), 1))
12773 bitpos_int = int_bit_position (decl);
12775 /* Note that the bit offset is always the distance (in bits) from the
12776 highest-order bit of the "containing object" to the highest-order bit of
12777 the bit-field itself. Since the "high-order end" of any object or field
12778 is different on big-endian and little-endian machines, the computation
12779 below must take account of these differences. */
12780 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
12781 highest_order_field_bit_offset = bitpos_int;
12783 if (! BYTES_BIG_ENDIAN)
12785 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
12786 highest_order_object_bit_offset += simple_type_size_in_bits (type);
12790 = (! BYTES_BIG_ENDIAN
12791 ? highest_order_object_bit_offset - highest_order_field_bit_offset
12792 : highest_order_field_bit_offset - highest_order_object_bit_offset);
12794 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
12797 /* For a FIELD_DECL node which represents a bit field, output an attribute
12798 which specifies the length in bits of the given field. */
12801 add_bit_size_attribute (dw_die_ref die, tree decl)
12803 /* Must be a field and a bit field. */
12804 gcc_assert (TREE_CODE (decl) == FIELD_DECL
12805 && DECL_BIT_FIELD_TYPE (decl));
12807 if (host_integerp (DECL_SIZE (decl), 1))
12808 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
12811 /* If the compiled language is ANSI C, then add a 'prototyped'
12812 attribute, if arg types are given for the parameters of a function. */
12815 add_prototyped_attribute (dw_die_ref die, tree func_type)
12817 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
12818 && TYPE_ARG_TYPES (func_type) != NULL)
12819 add_AT_flag (die, DW_AT_prototyped, 1);
12822 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
12823 by looking in either the type declaration or object declaration
12826 static inline dw_die_ref
12827 add_abstract_origin_attribute (dw_die_ref die, tree origin)
12829 dw_die_ref origin_die = NULL;
12831 if (TREE_CODE (origin) != FUNCTION_DECL)
12833 /* We may have gotten separated from the block for the inlined
12834 function, if we're in an exception handler or some such; make
12835 sure that the abstract function has been written out.
12837 Doing this for nested functions is wrong, however; functions are
12838 distinct units, and our context might not even be inline. */
12842 fn = TYPE_STUB_DECL (fn);
12844 fn = decl_function_context (fn);
12846 dwarf2out_abstract_function (fn);
12849 if (DECL_P (origin))
12850 origin_die = lookup_decl_die (origin);
12851 else if (TYPE_P (origin))
12852 origin_die = lookup_type_die (origin);
12854 /* XXX: Functions that are never lowered don't always have correct block
12855 trees (in the case of java, they simply have no block tree, in some other
12856 languages). For these functions, there is nothing we can really do to
12857 output correct debug info for inlined functions in all cases. Rather
12858 than die, we'll just produce deficient debug info now, in that we will
12859 have variables without a proper abstract origin. In the future, when all
12860 functions are lowered, we should re-add a gcc_assert (origin_die)
12864 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
12868 /* We do not currently support the pure_virtual attribute. */
12871 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
12873 if (DECL_VINDEX (func_decl))
12875 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12877 if (host_integerp (DECL_VINDEX (func_decl), 0))
12878 add_AT_loc (die, DW_AT_vtable_elem_location,
12879 new_loc_descr (DW_OP_constu,
12880 tree_low_cst (DECL_VINDEX (func_decl), 0),
12883 /* GNU extension: Record what type this method came from originally. */
12884 if (debug_info_level > DINFO_LEVEL_TERSE)
12885 add_AT_die_ref (die, DW_AT_containing_type,
12886 lookup_type_die (DECL_CONTEXT (func_decl)));
12890 /* Add source coordinate attributes for the given decl. */
12893 add_src_coords_attributes (dw_die_ref die, tree decl)
12895 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12897 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
12898 add_AT_unsigned (die, DW_AT_decl_line, s.line);
12901 /* Add a DW_AT_name attribute and source coordinate attribute for the
12902 given decl, but only if it actually has a name. */
12905 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
12909 decl_name = DECL_NAME (decl);
12910 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
12912 add_name_attribute (die, dwarf2_name (decl, 0));
12913 if (! DECL_ARTIFICIAL (decl))
12914 add_src_coords_attributes (die, decl);
12916 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
12917 && TREE_PUBLIC (decl)
12918 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
12919 && !DECL_ABSTRACT (decl)
12920 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
12922 add_AT_string (die, DW_AT_MIPS_linkage_name,
12923 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
12926 #ifdef VMS_DEBUGGING_INFO
12927 /* Get the function's name, as described by its RTL. This may be different
12928 from the DECL_NAME name used in the source file. */
12929 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
12931 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
12932 XEXP (DECL_RTL (decl), 0));
12933 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
12938 /* Push a new declaration scope. */
12941 push_decl_scope (tree scope)
12943 VEC_safe_push (tree, gc, decl_scope_table, scope);
12946 /* Pop a declaration scope. */
12949 pop_decl_scope (void)
12951 VEC_pop (tree, decl_scope_table);
12954 /* Return the DIE for the scope that immediately contains this type.
12955 Non-named types get global scope. Named types nested in other
12956 types get their containing scope if it's open, or global scope
12957 otherwise. All other types (i.e. function-local named types) get
12958 the current active scope. */
12961 scope_die_for (tree t, dw_die_ref context_die)
12963 dw_die_ref scope_die = NULL;
12964 tree containing_scope;
12967 /* Non-types always go in the current scope. */
12968 gcc_assert (TYPE_P (t));
12970 containing_scope = TYPE_CONTEXT (t);
12972 /* Use the containing namespace if it was passed in (for a declaration). */
12973 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
12975 if (context_die == lookup_decl_die (containing_scope))
12978 containing_scope = NULL_TREE;
12981 /* Ignore function type "scopes" from the C frontend. They mean that
12982 a tagged type is local to a parmlist of a function declarator, but
12983 that isn't useful to DWARF. */
12984 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
12985 containing_scope = NULL_TREE;
12987 if (containing_scope == NULL_TREE)
12988 scope_die = comp_unit_die;
12989 else if (TYPE_P (containing_scope))
12991 /* For types, we can just look up the appropriate DIE. But
12992 first we check to see if we're in the middle of emitting it
12993 so we know where the new DIE should go. */
12994 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
12995 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
13000 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
13001 || TREE_ASM_WRITTEN (containing_scope));
13003 /* If none of the current dies are suitable, we get file scope. */
13004 scope_die = comp_unit_die;
13007 scope_die = lookup_type_die (containing_scope);
13010 scope_die = context_die;
13015 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
13018 local_scope_p (dw_die_ref context_die)
13020 for (; context_die; context_die = context_die->die_parent)
13021 if (context_die->die_tag == DW_TAG_inlined_subroutine
13022 || context_die->die_tag == DW_TAG_subprogram)
13028 /* Returns nonzero if CONTEXT_DIE is a class. */
13031 class_scope_p (dw_die_ref context_die)
13033 return (context_die
13034 && (context_die->die_tag == DW_TAG_structure_type
13035 || context_die->die_tag == DW_TAG_class_type
13036 || context_die->die_tag == DW_TAG_interface_type
13037 || context_die->die_tag == DW_TAG_union_type));
13040 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
13041 whether or not to treat a DIE in this context as a declaration. */
13044 class_or_namespace_scope_p (dw_die_ref context_die)
13046 return (class_scope_p (context_die)
13047 || (context_die && context_die->die_tag == DW_TAG_namespace));
13050 /* Many forms of DIEs require a "type description" attribute. This
13051 routine locates the proper "type descriptor" die for the type given
13052 by 'type', and adds a DW_AT_type attribute below the given die. */
13055 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
13056 int decl_volatile, dw_die_ref context_die)
13058 enum tree_code code = TREE_CODE (type);
13059 dw_die_ref type_die = NULL;
13061 /* ??? If this type is an unnamed subrange type of an integral, floating-point
13062 or fixed-point type, use the inner type. This is because we have no
13063 support for unnamed types in base_type_die. This can happen if this is
13064 an Ada subrange type. Correct solution is emit a subrange type die. */
13065 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
13066 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
13067 type = TREE_TYPE (type), code = TREE_CODE (type);
13069 if (code == ERROR_MARK
13070 /* Handle a special case. For functions whose return type is void, we
13071 generate *no* type attribute. (Note that no object may have type
13072 `void', so this only applies to function return types). */
13073 || code == VOID_TYPE)
13076 type_die = modified_type_die (type,
13077 decl_const || TYPE_READONLY (type),
13078 decl_volatile || TYPE_VOLATILE (type),
13081 if (type_die != NULL)
13082 add_AT_die_ref (object_die, DW_AT_type, type_die);
13085 /* Given an object die, add the calling convention attribute for the
13086 function call type. */
13088 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
13090 enum dwarf_calling_convention value = DW_CC_normal;
13092 value = ((enum dwarf_calling_convention)
13093 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
13095 /* DWARF doesn't provide a way to identify a program's source-level
13096 entry point. DW_AT_calling_convention attributes are only meant
13097 to describe functions' calling conventions. However, lacking a
13098 better way to signal the Fortran main program, we use this for the
13099 time being, following existing custom. */
13101 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
13102 value = DW_CC_program;
13104 /* Only add the attribute if the backend requests it, and
13105 is not DW_CC_normal. */
13106 if (value && (value != DW_CC_normal))
13107 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
13110 /* Given a tree pointer to a struct, class, union, or enum type node, return
13111 a pointer to the (string) tag name for the given type, or zero if the type
13112 was declared without a tag. */
13114 static const char *
13115 type_tag (const_tree type)
13117 const char *name = 0;
13119 if (TYPE_NAME (type) != 0)
13123 /* Find the IDENTIFIER_NODE for the type name. */
13124 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
13125 t = TYPE_NAME (type);
13127 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
13128 a TYPE_DECL node, regardless of whether or not a `typedef' was
13130 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
13131 && ! DECL_IGNORED_P (TYPE_NAME (type)))
13133 /* We want to be extra verbose. Don't call dwarf_name if
13134 DECL_NAME isn't set. The default hook for decl_printable_name
13135 doesn't like that, and in this context it's correct to return
13136 0, instead of "<anonymous>" or the like. */
13137 if (DECL_NAME (TYPE_NAME (type)))
13138 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
13141 /* Now get the name as a string, or invent one. */
13142 if (!name && t != 0)
13143 name = IDENTIFIER_POINTER (t);
13146 return (name == 0 || *name == '\0') ? 0 : name;
13149 /* Return the type associated with a data member, make a special check
13150 for bit field types. */
13153 member_declared_type (const_tree member)
13155 return (DECL_BIT_FIELD_TYPE (member)
13156 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
13159 /* Get the decl's label, as described by its RTL. This may be different
13160 from the DECL_NAME name used in the source file. */
13163 static const char *
13164 decl_start_label (tree decl)
13167 const char *fnname;
13169 x = DECL_RTL (decl);
13170 gcc_assert (MEM_P (x));
13173 gcc_assert (GET_CODE (x) == SYMBOL_REF);
13175 fnname = XSTR (x, 0);
13180 /* These routines generate the internal representation of the DIE's for
13181 the compilation unit. Debugging information is collected by walking
13182 the declaration trees passed in from dwarf2out_decl(). */
13185 gen_array_type_die (tree type, dw_die_ref context_die)
13187 dw_die_ref scope_die = scope_die_for (type, context_die);
13188 dw_die_ref array_die;
13190 /* GNU compilers represent multidimensional array types as sequences of one
13191 dimensional array types whose element types are themselves array types.
13192 We sometimes squish that down to a single array_type DIE with multiple
13193 subscripts in the Dwarf debugging info. The draft Dwarf specification
13194 say that we are allowed to do this kind of compression in C, because
13195 there is no difference between an array of arrays and a multidimensional
13196 array. We don't do this for Ada to remain as close as possible to the
13197 actual representation, which is especially important against the language
13198 flexibilty wrt arrays of variable size. */
13200 bool collapse_nested_arrays = !is_ada ();
13203 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
13204 DW_TAG_string_type doesn't have DW_AT_type attribute). */
13205 if (TYPE_STRING_FLAG (type)
13206 && TREE_CODE (type) == ARRAY_TYPE
13208 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
13210 HOST_WIDE_INT size;
13212 array_die = new_die (DW_TAG_string_type, scope_die, type);
13213 add_name_attribute (array_die, type_tag (type));
13214 equate_type_number_to_die (type, array_die);
13215 size = int_size_in_bytes (type);
13217 add_AT_unsigned (array_die, DW_AT_byte_size, size);
13218 else if (TYPE_DOMAIN (type) != NULL_TREE
13219 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
13220 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
13222 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
13223 dw_loc_descr_ref loc = loc_descriptor_from_tree (szdecl);
13225 size = int_size_in_bytes (TREE_TYPE (szdecl));
13226 if (loc && size > 0)
13228 add_AT_loc (array_die, DW_AT_string_length, loc);
13229 if (size != DWARF2_ADDR_SIZE)
13230 add_AT_unsigned (array_die, DW_AT_byte_size, size);
13236 /* ??? The SGI dwarf reader fails for array of array of enum types
13237 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
13238 array type comes before the outer array type. We thus call gen_type_die
13239 before we new_die and must prevent nested array types collapsing for this
13242 #ifdef MIPS_DEBUGGING_INFO
13243 gen_type_die (TREE_TYPE (type), context_die);
13244 collapse_nested_arrays = false;
13247 array_die = new_die (DW_TAG_array_type, scope_die, type);
13248 add_name_attribute (array_die, type_tag (type));
13249 equate_type_number_to_die (type, array_die);
13251 if (TREE_CODE (type) == VECTOR_TYPE)
13253 /* The frontend feeds us a representation for the vector as a struct
13254 containing an array. Pull out the array type. */
13255 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
13256 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
13259 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
13261 && TREE_CODE (type) == ARRAY_TYPE
13262 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
13263 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
13264 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
13267 /* We default the array ordering. SDB will probably do
13268 the right things even if DW_AT_ordering is not present. It's not even
13269 an issue until we start to get into multidimensional arrays anyway. If
13270 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
13271 then we'll have to put the DW_AT_ordering attribute back in. (But if
13272 and when we find out that we need to put these in, we will only do so
13273 for multidimensional arrays. */
13274 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
13277 #ifdef MIPS_DEBUGGING_INFO
13278 /* The SGI compilers handle arrays of unknown bound by setting
13279 AT_declaration and not emitting any subrange DIEs. */
13280 if (! TYPE_DOMAIN (type))
13281 add_AT_flag (array_die, DW_AT_declaration, 1);
13284 add_subscript_info (array_die, type, collapse_nested_arrays);
13286 /* Add representation of the type of the elements of this array type and
13287 emit the corresponding DIE if we haven't done it already. */
13288 element_type = TREE_TYPE (type);
13289 if (collapse_nested_arrays)
13290 while (TREE_CODE (element_type) == ARRAY_TYPE)
13292 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
13294 element_type = TREE_TYPE (element_type);
13297 #ifndef MIPS_DEBUGGING_INFO
13298 gen_type_die (element_type, context_die);
13301 add_type_attribute (array_die, element_type, 0, 0, context_die);
13303 if (get_AT (array_die, DW_AT_name))
13304 add_pubtype (type, array_die);
13307 static dw_loc_descr_ref
13308 descr_info_loc (tree val, tree base_decl)
13310 HOST_WIDE_INT size;
13311 dw_loc_descr_ref loc, loc2;
13312 enum dwarf_location_atom op;
13314 if (val == base_decl)
13315 return new_loc_descr (DW_OP_push_object_address, 0, 0);
13317 switch (TREE_CODE (val))
13320 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13322 return loc_descriptor_from_tree_1 (val, 0);
13324 if (host_integerp (val, 0))
13325 return int_loc_descriptor (tree_low_cst (val, 0));
13328 size = int_size_in_bytes (TREE_TYPE (val));
13331 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13334 if (size == DWARF2_ADDR_SIZE)
13335 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
13337 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
13339 case POINTER_PLUS_EXPR:
13341 if (host_integerp (TREE_OPERAND (val, 1), 1)
13342 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
13345 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13348 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
13354 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13357 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
13360 add_loc_descr (&loc, loc2);
13361 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
13383 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
13384 tree val, tree base_decl)
13386 dw_loc_descr_ref loc;
13388 if (host_integerp (val, 0))
13390 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
13394 loc = descr_info_loc (val, base_decl);
13398 add_AT_loc (die, attr, loc);
13401 /* This routine generates DIE for array with hidden descriptor, details
13402 are filled into *info by a langhook. */
13405 gen_descr_array_type_die (tree type, struct array_descr_info *info,
13406 dw_die_ref context_die)
13408 dw_die_ref scope_die = scope_die_for (type, context_die);
13409 dw_die_ref array_die;
13412 array_die = new_die (DW_TAG_array_type, scope_die, type);
13413 add_name_attribute (array_die, type_tag (type));
13414 equate_type_number_to_die (type, array_die);
13416 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
13418 && info->ndimensions >= 2)
13419 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
13421 if (info->data_location)
13422 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
13424 if (info->associated)
13425 add_descr_info_field (array_die, DW_AT_associated, info->associated,
13427 if (info->allocated)
13428 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
13431 for (dim = 0; dim < info->ndimensions; dim++)
13433 dw_die_ref subrange_die
13434 = new_die (DW_TAG_subrange_type, array_die, NULL);
13436 if (info->dimen[dim].lower_bound)
13438 /* If it is the default value, omit it. */
13439 if ((is_c_family () || is_java ())
13440 && integer_zerop (info->dimen[dim].lower_bound))
13442 else if (is_fortran ()
13443 && integer_onep (info->dimen[dim].lower_bound))
13446 add_descr_info_field (subrange_die, DW_AT_lower_bound,
13447 info->dimen[dim].lower_bound,
13450 if (info->dimen[dim].upper_bound)
13451 add_descr_info_field (subrange_die, DW_AT_upper_bound,
13452 info->dimen[dim].upper_bound,
13454 if (info->dimen[dim].stride)
13455 add_descr_info_field (subrange_die, DW_AT_byte_stride,
13456 info->dimen[dim].stride,
13460 gen_type_die (info->element_type, context_die);
13461 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
13463 if (get_AT (array_die, DW_AT_name))
13464 add_pubtype (type, array_die);
13469 gen_entry_point_die (tree decl, dw_die_ref context_die)
13471 tree origin = decl_ultimate_origin (decl);
13472 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
13474 if (origin != NULL)
13475 add_abstract_origin_attribute (decl_die, origin);
13478 add_name_and_src_coords_attributes (decl_die, decl);
13479 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
13480 0, 0, context_die);
13483 if (DECL_ABSTRACT (decl))
13484 equate_decl_number_to_die (decl, decl_die);
13486 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
13490 /* Walk through the list of incomplete types again, trying once more to
13491 emit full debugging info for them. */
13494 retry_incomplete_types (void)
13498 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
13499 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
13502 /* Determine what tag to use for a record type. */
13504 static enum dwarf_tag
13505 record_type_tag (tree type)
13507 if (! lang_hooks.types.classify_record)
13508 return DW_TAG_structure_type;
13510 switch (lang_hooks.types.classify_record (type))
13512 case RECORD_IS_STRUCT:
13513 return DW_TAG_structure_type;
13515 case RECORD_IS_CLASS:
13516 return DW_TAG_class_type;
13518 case RECORD_IS_INTERFACE:
13519 return DW_TAG_interface_type;
13522 gcc_unreachable ();
13526 /* Generate a DIE to represent an enumeration type. Note that these DIEs
13527 include all of the information about the enumeration values also. Each
13528 enumerated type name/value is listed as a child of the enumerated type
13532 gen_enumeration_type_die (tree type, dw_die_ref context_die)
13534 dw_die_ref type_die = lookup_type_die (type);
13536 if (type_die == NULL)
13538 type_die = new_die (DW_TAG_enumeration_type,
13539 scope_die_for (type, context_die), type);
13540 equate_type_number_to_die (type, type_die);
13541 add_name_attribute (type_die, type_tag (type));
13543 else if (! TYPE_SIZE (type))
13546 remove_AT (type_die, DW_AT_declaration);
13548 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
13549 given enum type is incomplete, do not generate the DW_AT_byte_size
13550 attribute or the DW_AT_element_list attribute. */
13551 if (TYPE_SIZE (type))
13555 TREE_ASM_WRITTEN (type) = 1;
13556 add_byte_size_attribute (type_die, type);
13557 if (TYPE_STUB_DECL (type) != NULL_TREE)
13558 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
13560 /* If the first reference to this type was as the return type of an
13561 inline function, then it may not have a parent. Fix this now. */
13562 if (type_die->die_parent == NULL)
13563 add_child_die (scope_die_for (type, context_die), type_die);
13565 for (link = TYPE_VALUES (type);
13566 link != NULL; link = TREE_CHAIN (link))
13568 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
13569 tree value = TREE_VALUE (link);
13571 add_name_attribute (enum_die,
13572 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
13574 if (TREE_CODE (value) == CONST_DECL)
13575 value = DECL_INITIAL (value);
13577 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
13578 /* DWARF2 does not provide a way of indicating whether or
13579 not enumeration constants are signed or unsigned. GDB
13580 always assumes the values are signed, so we output all
13581 values as if they were signed. That means that
13582 enumeration constants with very large unsigned values
13583 will appear to have negative values in the debugger. */
13584 add_AT_int (enum_die, DW_AT_const_value,
13585 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
13589 add_AT_flag (type_die, DW_AT_declaration, 1);
13591 if (get_AT (type_die, DW_AT_name))
13592 add_pubtype (type, type_die);
13597 /* Generate a DIE to represent either a real live formal parameter decl or to
13598 represent just the type of some formal parameter position in some function
13601 Note that this routine is a bit unusual because its argument may be a
13602 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
13603 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
13604 node. If it's the former then this function is being called to output a
13605 DIE to represent a formal parameter object (or some inlining thereof). If
13606 it's the latter, then this function is only being called to output a
13607 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
13608 argument type of some subprogram type. */
13611 gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
13613 tree node_or_origin = node ? node : origin;
13614 dw_die_ref parm_die
13615 = new_die (DW_TAG_formal_parameter, context_die, node);
13617 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
13619 case tcc_declaration:
13621 origin = decl_ultimate_origin (node);
13622 if (origin != NULL)
13623 add_abstract_origin_attribute (parm_die, origin);
13626 tree type = TREE_TYPE (node);
13627 add_name_and_src_coords_attributes (parm_die, node);
13628 if (DECL_BY_REFERENCE (node))
13629 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
13632 add_type_attribute (parm_die, type,
13633 TREE_READONLY (node),
13634 TREE_THIS_VOLATILE (node),
13636 if (DECL_ARTIFICIAL (node))
13637 add_AT_flag (parm_die, DW_AT_artificial, 1);
13641 equate_decl_number_to_die (node, parm_die);
13642 if (! DECL_ABSTRACT (node_or_origin))
13643 add_location_or_const_value_attribute (parm_die, node_or_origin,
13649 /* We were called with some kind of a ..._TYPE node. */
13650 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
13654 gcc_unreachable ();
13660 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
13661 at the end of an (ANSI prototyped) formal parameters list. */
13664 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
13666 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
13669 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
13670 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
13671 parameters as specified in some function type specification (except for
13672 those which appear as part of a function *definition*). */
13675 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
13678 tree formal_type = NULL;
13679 tree first_parm_type;
13682 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
13684 arg = DECL_ARGUMENTS (function_or_method_type);
13685 function_or_method_type = TREE_TYPE (function_or_method_type);
13690 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
13692 /* Make our first pass over the list of formal parameter types and output a
13693 DW_TAG_formal_parameter DIE for each one. */
13694 for (link = first_parm_type; link; )
13696 dw_die_ref parm_die;
13698 formal_type = TREE_VALUE (link);
13699 if (formal_type == void_type_node)
13702 /* Output a (nameless) DIE to represent the formal parameter itself. */
13703 parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
13704 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
13705 && link == first_parm_type)
13706 || (arg && DECL_ARTIFICIAL (arg)))
13707 add_AT_flag (parm_die, DW_AT_artificial, 1);
13709 link = TREE_CHAIN (link);
13711 arg = TREE_CHAIN (arg);
13714 /* If this function type has an ellipsis, add a
13715 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
13716 if (formal_type != void_type_node)
13717 gen_unspecified_parameters_die (function_or_method_type, context_die);
13719 /* Make our second (and final) pass over the list of formal parameter types
13720 and output DIEs to represent those types (as necessary). */
13721 for (link = TYPE_ARG_TYPES (function_or_method_type);
13722 link && TREE_VALUE (link);
13723 link = TREE_CHAIN (link))
13724 gen_type_die (TREE_VALUE (link), context_die);
13727 /* We want to generate the DIE for TYPE so that we can generate the
13728 die for MEMBER, which has been defined; we will need to refer back
13729 to the member declaration nested within TYPE. If we're trying to
13730 generate minimal debug info for TYPE, processing TYPE won't do the
13731 trick; we need to attach the member declaration by hand. */
13734 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
13736 gen_type_die (type, context_die);
13738 /* If we're trying to avoid duplicate debug info, we may not have
13739 emitted the member decl for this function. Emit it now. */
13740 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
13741 && ! lookup_decl_die (member))
13743 dw_die_ref type_die;
13744 gcc_assert (!decl_ultimate_origin (member));
13746 push_decl_scope (type);
13747 type_die = lookup_type_die (type);
13748 if (TREE_CODE (member) == FUNCTION_DECL)
13749 gen_subprogram_die (member, type_die);
13750 else if (TREE_CODE (member) == FIELD_DECL)
13752 /* Ignore the nameless fields that are used to skip bits but handle
13753 C++ anonymous unions and structs. */
13754 if (DECL_NAME (member) != NULL_TREE
13755 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
13756 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
13758 gen_type_die (member_declared_type (member), type_die);
13759 gen_field_die (member, type_die);
13763 gen_variable_die (member, NULL_TREE, type_die);
13769 /* Generate the DWARF2 info for the "abstract" instance of a function which we
13770 may later generate inlined and/or out-of-line instances of. */
13773 dwarf2out_abstract_function (tree decl)
13775 dw_die_ref old_die;
13778 int was_abstract = DECL_ABSTRACT (decl);
13780 /* Make sure we have the actual abstract inline, not a clone. */
13781 decl = DECL_ORIGIN (decl);
13783 old_die = lookup_decl_die (decl);
13784 if (old_die && get_AT (old_die, DW_AT_inline))
13785 /* We've already generated the abstract instance. */
13788 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
13789 we don't get confused by DECL_ABSTRACT. */
13790 if (debug_info_level > DINFO_LEVEL_TERSE)
13792 context = decl_class_context (decl);
13794 gen_type_die_for_member
13795 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
13798 /* Pretend we've just finished compiling this function. */
13799 save_fn = current_function_decl;
13800 current_function_decl = decl;
13801 push_cfun (DECL_STRUCT_FUNCTION (decl));
13803 set_decl_abstract_flags (decl, 1);
13804 dwarf2out_decl (decl);
13805 if (! was_abstract)
13806 set_decl_abstract_flags (decl, 0);
13808 current_function_decl = save_fn;
13812 /* Helper function of premark_used_types() which gets called through
13813 htab_traverse_resize().
13815 Marks the DIE of a given type in *SLOT as perennial, so it never gets
13816 marked as unused by prune_unused_types. */
13818 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
13823 type = (tree) *slot;
13824 die = lookup_type_die (type);
13826 die->die_perennial_p = 1;
13830 /* Mark all members of used_types_hash as perennial. */
13832 premark_used_types (void)
13834 if (cfun && cfun->used_types_hash)
13835 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
13838 /* Generate a DIE to represent a declared function (either file-scope or
13842 gen_subprogram_die (tree decl, dw_die_ref context_die)
13844 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
13845 tree origin = decl_ultimate_origin (decl);
13846 dw_die_ref subr_die;
13849 dw_die_ref old_die = lookup_decl_die (decl);
13850 int declaration = (current_function_decl != decl
13851 || class_or_namespace_scope_p (context_die));
13853 premark_used_types ();
13855 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
13856 started to generate the abstract instance of an inline, decided to output
13857 its containing class, and proceeded to emit the declaration of the inline
13858 from the member list for the class. If so, DECLARATION takes priority;
13859 we'll get back to the abstract instance when done with the class. */
13861 /* The class-scope declaration DIE must be the primary DIE. */
13862 if (origin && declaration && class_or_namespace_scope_p (context_die))
13865 gcc_assert (!old_die);
13868 /* Now that the C++ front end lazily declares artificial member fns, we
13869 might need to retrofit the declaration into its class. */
13870 if (!declaration && !origin && !old_die
13871 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
13872 && !class_or_namespace_scope_p (context_die)
13873 && debug_info_level > DINFO_LEVEL_TERSE)
13874 old_die = force_decl_die (decl);
13876 if (origin != NULL)
13878 gcc_assert (!declaration || local_scope_p (context_die));
13880 /* Fixup die_parent for the abstract instance of a nested
13881 inline function. */
13882 if (old_die && old_die->die_parent == NULL)
13883 add_child_die (context_die, old_die);
13885 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13886 add_abstract_origin_attribute (subr_die, origin);
13890 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
13891 struct dwarf_file_data * file_index = lookup_filename (s.file);
13893 if (!get_AT_flag (old_die, DW_AT_declaration)
13894 /* We can have a normal definition following an inline one in the
13895 case of redefinition of GNU C extern inlines.
13896 It seems reasonable to use AT_specification in this case. */
13897 && !get_AT (old_die, DW_AT_inline))
13899 /* Detect and ignore this case, where we are trying to output
13900 something we have already output. */
13904 /* If the definition comes from the same place as the declaration,
13905 maybe use the old DIE. We always want the DIE for this function
13906 that has the *_pc attributes to be under comp_unit_die so the
13907 debugger can find it. We also need to do this for abstract
13908 instances of inlines, since the spec requires the out-of-line copy
13909 to have the same parent. For local class methods, this doesn't
13910 apply; we just use the old DIE. */
13911 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
13912 && (DECL_ARTIFICIAL (decl)
13913 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
13914 && (get_AT_unsigned (old_die, DW_AT_decl_line)
13915 == (unsigned) s.line))))
13917 subr_die = old_die;
13919 /* Clear out the declaration attribute and the formal parameters.
13920 Do not remove all children, because it is possible that this
13921 declaration die was forced using force_decl_die(). In such
13922 cases die that forced declaration die (e.g. TAG_imported_module)
13923 is one of the children that we do not want to remove. */
13924 remove_AT (subr_die, DW_AT_declaration);
13925 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
13929 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13930 add_AT_specification (subr_die, old_die);
13931 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
13932 add_AT_file (subr_die, DW_AT_decl_file, file_index);
13933 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
13934 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
13939 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13941 if (TREE_PUBLIC (decl))
13942 add_AT_flag (subr_die, DW_AT_external, 1);
13944 add_name_and_src_coords_attributes (subr_die, decl);
13945 if (debug_info_level > DINFO_LEVEL_TERSE)
13947 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
13948 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
13949 0, 0, context_die);
13952 add_pure_or_virtual_attribute (subr_die, decl);
13953 if (DECL_ARTIFICIAL (decl))
13954 add_AT_flag (subr_die, DW_AT_artificial, 1);
13956 if (TREE_PROTECTED (decl))
13957 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
13958 else if (TREE_PRIVATE (decl))
13959 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
13964 if (!old_die || !get_AT (old_die, DW_AT_inline))
13966 add_AT_flag (subr_die, DW_AT_declaration, 1);
13968 /* If this is an explicit function declaration then generate
13969 a DW_AT_explicit attribute. */
13970 if (lang_hooks.decls.function_decl_explicit_p (decl))
13971 add_AT_flag (subr_die, DW_AT_explicit, 1);
13973 /* The first time we see a member function, it is in the context of
13974 the class to which it belongs. We make sure of this by emitting
13975 the class first. The next time is the definition, which is
13976 handled above. The two may come from the same source text.
13978 Note that force_decl_die() forces function declaration die. It is
13979 later reused to represent definition. */
13980 equate_decl_number_to_die (decl, subr_die);
13983 else if (DECL_ABSTRACT (decl))
13985 if (DECL_DECLARED_INLINE_P (decl))
13987 if (cgraph_function_possibly_inlined_p (decl))
13988 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
13990 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
13994 if (cgraph_function_possibly_inlined_p (decl))
13995 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
13997 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
14000 if (DECL_DECLARED_INLINE_P (decl)
14001 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
14002 add_AT_flag (subr_die, DW_AT_artificial, 1);
14004 equate_decl_number_to_die (decl, subr_die);
14006 else if (!DECL_EXTERNAL (decl))
14008 HOST_WIDE_INT cfa_fb_offset;
14010 if (!old_die || !get_AT (old_die, DW_AT_inline))
14011 equate_decl_number_to_die (decl, subr_die);
14013 if (!flag_reorder_blocks_and_partition)
14015 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
14016 current_function_funcdef_no);
14017 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
14018 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
14019 current_function_funcdef_no);
14020 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
14022 add_pubname (decl, subr_die);
14023 add_arange (decl, subr_die);
14026 { /* Do nothing for now; maybe need to duplicate die, one for
14027 hot section and one for cold section, then use the hot/cold
14028 section begin/end labels to generate the aranges... */
14030 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
14031 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
14032 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
14033 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
14035 add_pubname (decl, subr_die);
14036 add_arange (decl, subr_die);
14037 add_arange (decl, subr_die);
14041 #ifdef MIPS_DEBUGGING_INFO
14042 /* Add a reference to the FDE for this routine. */
14043 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
14046 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
14048 /* We define the "frame base" as the function's CFA. This is more
14049 convenient for several reasons: (1) It's stable across the prologue
14050 and epilogue, which makes it better than just a frame pointer,
14051 (2) With dwarf3, there exists a one-byte encoding that allows us
14052 to reference the .debug_frame data by proxy, but failing that,
14053 (3) We can at least reuse the code inspection and interpretation
14054 code that determines the CFA position at various points in the
14056 /* ??? Use some command-line or configury switch to enable the use
14057 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
14058 consumers that understand it; fall back to "pure" dwarf2 and
14059 convert the CFA data into a location list. */
14061 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
14062 if (list->dw_loc_next)
14063 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
14065 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
14068 /* Compute a displacement from the "steady-state frame pointer" to
14069 the CFA. The former is what all stack slots and argument slots
14070 will reference in the rtl; the later is what we've told the
14071 debugger about. We'll need to adjust all frame_base references
14072 by this displacement. */
14073 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
14075 if (cfun->static_chain_decl)
14076 add_AT_location_description (subr_die, DW_AT_static_link,
14077 loc_descriptor_from_tree (cfun->static_chain_decl));
14080 /* Now output descriptions of the arguments for this function. This gets
14081 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
14082 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
14083 `...' at the end of the formal parameter list. In order to find out if
14084 there was a trailing ellipsis or not, we must instead look at the type
14085 associated with the FUNCTION_DECL. This will be a node of type
14086 FUNCTION_TYPE. If the chain of type nodes hanging off of this
14087 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
14088 an ellipsis at the end. */
14090 /* In the case where we are describing a mere function declaration, all we
14091 need to do here (and all we *can* do here) is to describe the *types* of
14092 its formal parameters. */
14093 if (debug_info_level <= DINFO_LEVEL_TERSE)
14095 else if (declaration)
14096 gen_formal_types_die (decl, subr_die);
14099 /* Generate DIEs to represent all known formal parameters. */
14100 tree arg_decls = DECL_ARGUMENTS (decl);
14103 /* When generating DIEs, generate the unspecified_parameters DIE
14104 instead if we come across the arg "__builtin_va_alist" */
14105 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
14106 if (TREE_CODE (parm) == PARM_DECL)
14108 if (DECL_NAME (parm)
14109 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
14110 "__builtin_va_alist"))
14111 gen_unspecified_parameters_die (parm, subr_die);
14113 gen_decl_die (parm, NULL, subr_die);
14116 /* Decide whether we need an unspecified_parameters DIE at the end.
14117 There are 2 more cases to do this for: 1) the ansi ... declaration -
14118 this is detectable when the end of the arg list is not a
14119 void_type_node 2) an unprototyped function declaration (not a
14120 definition). This just means that we have no info about the
14121 parameters at all. */
14122 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
14123 if (fn_arg_types != NULL)
14125 /* This is the prototyped case, check for.... */
14126 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
14127 gen_unspecified_parameters_die (decl, subr_die);
14129 else if (DECL_INITIAL (decl) == NULL_TREE)
14130 gen_unspecified_parameters_die (decl, subr_die);
14133 /* Output Dwarf info for all of the stuff within the body of the function
14134 (if it has one - it may be just a declaration). */
14135 outer_scope = DECL_INITIAL (decl);
14137 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
14138 a function. This BLOCK actually represents the outermost binding contour
14139 for the function, i.e. the contour in which the function's formal
14140 parameters and labels get declared. Curiously, it appears that the front
14141 end doesn't actually put the PARM_DECL nodes for the current function onto
14142 the BLOCK_VARS list for this outer scope, but are strung off of the
14143 DECL_ARGUMENTS list for the function instead.
14145 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
14146 the LABEL_DECL nodes for the function however, and we output DWARF info
14147 for those in decls_for_scope. Just within the `outer_scope' there will be
14148 a BLOCK node representing the function's outermost pair of curly braces,
14149 and any blocks used for the base and member initializers of a C++
14150 constructor function. */
14151 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
14153 /* Emit a DW_TAG_variable DIE for a named return value. */
14154 if (DECL_NAME (DECL_RESULT (decl)))
14155 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
14157 current_function_has_inlines = 0;
14158 decls_for_scope (outer_scope, subr_die, 0);
14160 #if 0 && defined (MIPS_DEBUGGING_INFO)
14161 if (current_function_has_inlines)
14163 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
14164 if (! comp_unit_has_inlines)
14166 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
14167 comp_unit_has_inlines = 1;
14172 /* Add the calling convention attribute if requested. */
14173 add_calling_convention_attribute (subr_die, decl);
14177 /* Returns a hash value for X (which really is a die_struct). */
14180 common_block_die_table_hash (const void *x)
14182 const_dw_die_ref d = (const_dw_die_ref) x;
14183 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
14186 /* Return nonzero if decl_id and die_parent of die_struct X is the same
14187 as decl_id and die_parent of die_struct Y. */
14190 common_block_die_table_eq (const void *x, const void *y)
14192 const_dw_die_ref d = (const_dw_die_ref) x;
14193 const_dw_die_ref e = (const_dw_die_ref) y;
14194 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
14197 /* Generate a DIE to represent a declared data object.
14198 Either DECL or ORIGIN must be non-null. */
14201 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
14205 tree decl_or_origin = decl ? decl : origin;
14206 dw_die_ref var_die;
14207 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
14208 dw_die_ref origin_die;
14209 int declaration = (DECL_EXTERNAL (decl_or_origin)
14210 /* If DECL is COMDAT and has not actually been
14211 emitted, we cannot take its address; there
14212 might end up being no definition anywhere in
14213 the program. For example, consider the C++
14217 struct S { static const int i = 7; };
14222 int f() { return S<int>::i; }
14224 Here, S<int>::i is not DECL_EXTERNAL, but no
14225 definition is required, so the compiler will
14226 not emit a definition. */
14227 || (TREE_CODE (decl_or_origin) == VAR_DECL
14228 && DECL_COMDAT (decl_or_origin)
14229 && !TREE_ASM_WRITTEN (decl_or_origin))
14230 || class_or_namespace_scope_p (context_die));
14233 origin = decl_ultimate_origin (decl);
14235 com_decl = fortran_common (decl_or_origin, &off);
14237 /* Symbol in common gets emitted as a child of the common block, in the form
14238 of a data member. */
14242 dw_die_ref com_die;
14243 dw_loc_descr_ref loc;
14244 die_node com_die_arg;
14246 var_die = lookup_decl_die (decl_or_origin);
14249 if (get_AT (var_die, DW_AT_location) == NULL)
14251 loc = loc_descriptor_from_tree (com_decl);
14256 /* Optimize the common case. */
14257 if (loc->dw_loc_opc == DW_OP_addr
14258 && loc->dw_loc_next == NULL
14259 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr)
14261 loc->dw_loc_oprnd1.v.val_addr
14262 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
14264 loc_descr_plus_const (&loc, off);
14266 add_AT_loc (var_die, DW_AT_location, loc);
14267 remove_AT (var_die, DW_AT_declaration);
14273 if (common_block_die_table == NULL)
14274 common_block_die_table
14275 = htab_create_ggc (10, common_block_die_table_hash,
14276 common_block_die_table_eq, NULL);
14278 field = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
14279 com_die_arg.decl_id = DECL_UID (com_decl);
14280 com_die_arg.die_parent = context_die;
14281 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
14282 loc = loc_descriptor_from_tree (com_decl);
14283 if (com_die == NULL)
14286 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
14289 com_die = new_die (DW_TAG_common_block, context_die, decl);
14290 add_name_and_src_coords_attributes (com_die, com_decl);
14293 add_AT_loc (com_die, DW_AT_location, loc);
14294 /* Avoid sharing the same loc descriptor between
14295 DW_TAG_common_block and DW_TAG_variable. */
14296 loc = loc_descriptor_from_tree (com_decl);
14298 else if (DECL_EXTERNAL (decl))
14299 add_AT_flag (com_die, DW_AT_declaration, 1);
14300 add_pubname_string (cnam, com_die); /* ??? needed? */
14301 com_die->decl_id = DECL_UID (com_decl);
14302 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
14303 *slot = (void *) com_die;
14305 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
14307 add_AT_loc (com_die, DW_AT_location, loc);
14308 loc = loc_descriptor_from_tree (com_decl);
14309 remove_AT (com_die, DW_AT_declaration);
14311 var_die = new_die (DW_TAG_variable, com_die, decl);
14312 add_name_and_src_coords_attributes (var_die, decl);
14313 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
14314 TREE_THIS_VOLATILE (decl), context_die);
14315 add_AT_flag (var_die, DW_AT_external, 1);
14320 /* Optimize the common case. */
14321 if (loc->dw_loc_opc == DW_OP_addr
14322 && loc->dw_loc_next == NULL
14323 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
14324 loc->dw_loc_oprnd1.v.val_addr
14325 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
14327 loc_descr_plus_const (&loc, off);
14329 add_AT_loc (var_die, DW_AT_location, loc);
14331 else if (DECL_EXTERNAL (decl))
14332 add_AT_flag (var_die, DW_AT_declaration, 1);
14333 equate_decl_number_to_die (decl, var_die);
14337 /* If the compiler emitted a definition for the DECL declaration
14338 and if we already emitted a DIE for it, don't emit a second
14339 DIE for it again. */
14342 && old_die->die_parent == context_die)
14345 /* For static data members, the declaration in the class is supposed
14346 to have DW_TAG_member tag; the specification should still be
14347 DW_TAG_variable referencing the DW_TAG_member DIE. */
14348 if (declaration && class_scope_p (context_die))
14349 var_die = new_die (DW_TAG_member, context_die, decl);
14351 var_die = new_die (DW_TAG_variable, context_die, decl);
14354 if (origin != NULL)
14355 origin_die = add_abstract_origin_attribute (var_die, origin);
14357 /* Loop unrolling can create multiple blocks that refer to the same
14358 static variable, so we must test for the DW_AT_declaration flag.
14360 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
14361 copy decls and set the DECL_ABSTRACT flag on them instead of
14364 ??? Duplicated blocks have been rewritten to use .debug_ranges.
14366 ??? The declare_in_namespace support causes us to get two DIEs for one
14367 variable, both of which are declarations. We want to avoid considering
14368 one to be a specification, so we must test that this DIE is not a
14370 else if (old_die && TREE_STATIC (decl) && ! declaration
14371 && get_AT_flag (old_die, DW_AT_declaration) == 1)
14373 /* This is a definition of a C++ class level static. */
14374 add_AT_specification (var_die, old_die);
14375 if (DECL_NAME (decl))
14377 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
14378 struct dwarf_file_data * file_index = lookup_filename (s.file);
14380 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
14381 add_AT_file (var_die, DW_AT_decl_file, file_index);
14383 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
14384 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
14389 tree type = TREE_TYPE (decl);
14391 add_name_and_src_coords_attributes (var_die, decl);
14392 if ((TREE_CODE (decl) == PARM_DECL
14393 || TREE_CODE (decl) == RESULT_DECL
14394 || TREE_CODE (decl) == VAR_DECL)
14395 && DECL_BY_REFERENCE (decl))
14396 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
14398 add_type_attribute (var_die, type, TREE_READONLY (decl),
14399 TREE_THIS_VOLATILE (decl), context_die);
14401 if (TREE_PUBLIC (decl))
14402 add_AT_flag (var_die, DW_AT_external, 1);
14404 if (DECL_ARTIFICIAL (decl))
14405 add_AT_flag (var_die, DW_AT_artificial, 1);
14407 if (TREE_PROTECTED (decl))
14408 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
14409 else if (TREE_PRIVATE (decl))
14410 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
14414 add_AT_flag (var_die, DW_AT_declaration, 1);
14416 if (decl && (DECL_ABSTRACT (decl) || declaration))
14417 equate_decl_number_to_die (decl, var_die);
14420 && (! DECL_ABSTRACT (decl_or_origin)
14421 /* Local static vars are shared between all clones/inlines,
14422 so emit DW_AT_location on the abstract DIE if DECL_RTL is
14424 || (TREE_CODE (decl_or_origin) == VAR_DECL
14425 && TREE_STATIC (decl_or_origin)
14426 && DECL_RTL_SET_P (decl_or_origin)))
14427 /* When abstract origin already has DW_AT_location attribute, no need
14428 to add it again. */
14429 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
14431 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
14432 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
14433 defer_location (decl_or_origin, var_die);
14435 add_location_or_const_value_attribute (var_die,
14438 add_pubname (decl_or_origin, var_die);
14441 tree_add_const_value_attribute (var_die, decl_or_origin);
14444 /* Generate a DIE to represent a named constant. */
14447 gen_const_die (tree decl, dw_die_ref context_die)
14449 dw_die_ref const_die;
14450 tree type = TREE_TYPE (decl);
14452 const_die = new_die (DW_TAG_constant, context_die, decl);
14453 add_name_and_src_coords_attributes (const_die, decl);
14454 add_type_attribute (const_die, type, 1, 0, context_die);
14455 if (TREE_PUBLIC (decl))
14456 add_AT_flag (const_die, DW_AT_external, 1);
14457 if (DECL_ARTIFICIAL (decl))
14458 add_AT_flag (const_die, DW_AT_artificial, 1);
14459 tree_add_const_value_attribute (const_die, decl);
14462 /* Generate a DIE to represent a label identifier. */
14465 gen_label_die (tree decl, dw_die_ref context_die)
14467 tree origin = decl_ultimate_origin (decl);
14468 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
14470 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14472 if (origin != NULL)
14473 add_abstract_origin_attribute (lbl_die, origin);
14475 add_name_and_src_coords_attributes (lbl_die, decl);
14477 if (DECL_ABSTRACT (decl))
14478 equate_decl_number_to_die (decl, lbl_die);
14481 insn = DECL_RTL_IF_SET (decl);
14483 /* Deleted labels are programmer specified labels which have been
14484 eliminated because of various optimizations. We still emit them
14485 here so that it is possible to put breakpoints on them. */
14489 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
14491 /* When optimization is enabled (via -O) some parts of the compiler
14492 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
14493 represent source-level labels which were explicitly declared by
14494 the user. This really shouldn't be happening though, so catch
14495 it if it ever does happen. */
14496 gcc_assert (!INSN_DELETED_P (insn));
14498 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
14499 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
14504 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
14505 attributes to the DIE for a block STMT, to describe where the inlined
14506 function was called from. This is similar to add_src_coords_attributes. */
14509 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
14511 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
14513 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
14514 add_AT_unsigned (die, DW_AT_call_line, s.line);
14518 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
14519 Add low_pc and high_pc attributes to the DIE for a block STMT. */
14522 add_high_low_attributes (tree stmt, dw_die_ref die)
14524 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14526 if (BLOCK_FRAGMENT_CHAIN (stmt))
14530 if (inlined_function_outer_scope_p (stmt))
14532 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14533 BLOCK_NUMBER (stmt));
14534 add_AT_lbl_id (die, DW_AT_entry_pc, label);
14537 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
14539 chain = BLOCK_FRAGMENT_CHAIN (stmt);
14542 add_ranges (chain);
14543 chain = BLOCK_FRAGMENT_CHAIN (chain);
14550 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14551 BLOCK_NUMBER (stmt));
14552 add_AT_lbl_id (die, DW_AT_low_pc, label);
14553 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
14554 BLOCK_NUMBER (stmt));
14555 add_AT_lbl_id (die, DW_AT_high_pc, label);
14559 /* Generate a DIE for a lexical block. */
14562 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
14564 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
14566 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
14567 add_high_low_attributes (stmt, stmt_die);
14569 decls_for_scope (stmt, stmt_die, depth);
14572 /* Generate a DIE for an inlined subprogram. */
14575 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
14577 tree decl = block_ultimate_origin (stmt);
14579 /* Emit info for the abstract instance first, if we haven't yet. We
14580 must emit this even if the block is abstract, otherwise when we
14581 emit the block below (or elsewhere), we may end up trying to emit
14582 a die whose origin die hasn't been emitted, and crashing. */
14583 dwarf2out_abstract_function (decl);
14585 if (! BLOCK_ABSTRACT (stmt))
14587 dw_die_ref subr_die
14588 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
14590 add_abstract_origin_attribute (subr_die, decl);
14591 if (TREE_ASM_WRITTEN (stmt))
14592 add_high_low_attributes (stmt, subr_die);
14593 add_call_src_coords_attributes (stmt, subr_die);
14595 decls_for_scope (stmt, subr_die, depth);
14596 current_function_has_inlines = 1;
14599 /* We may get here if we're the outer block of function A that was
14600 inlined into function B that was inlined into function C. When
14601 generating debugging info for C, dwarf2out_abstract_function(B)
14602 would mark all inlined blocks as abstract, including this one.
14603 So, we wouldn't (and shouldn't) expect labels to be generated
14604 for this one. Instead, just emit debugging info for
14605 declarations within the block. This is particularly important
14606 in the case of initializers of arguments passed from B to us:
14607 if they're statement expressions containing declarations, we
14608 wouldn't generate dies for their abstract variables, and then,
14609 when generating dies for the real variables, we'd die (pun
14611 gen_lexical_block_die (stmt, context_die, depth);
14614 /* Generate a DIE for a field in a record, or structure. */
14617 gen_field_die (tree decl, dw_die_ref context_die)
14619 dw_die_ref decl_die;
14621 if (TREE_TYPE (decl) == error_mark_node)
14624 decl_die = new_die (DW_TAG_member, context_die, decl);
14625 add_name_and_src_coords_attributes (decl_die, decl);
14626 add_type_attribute (decl_die, member_declared_type (decl),
14627 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
14630 if (DECL_BIT_FIELD_TYPE (decl))
14632 add_byte_size_attribute (decl_die, decl);
14633 add_bit_size_attribute (decl_die, decl);
14634 add_bit_offset_attribute (decl_die, decl);
14637 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
14638 add_data_member_location_attribute (decl_die, decl);
14640 if (DECL_ARTIFICIAL (decl))
14641 add_AT_flag (decl_die, DW_AT_artificial, 1);
14643 if (TREE_PROTECTED (decl))
14644 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
14645 else if (TREE_PRIVATE (decl))
14646 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
14648 /* Equate decl number to die, so that we can look up this decl later on. */
14649 equate_decl_number_to_die (decl, decl_die);
14653 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14654 Use modified_type_die instead.
14655 We keep this code here just in case these types of DIEs may be needed to
14656 represent certain things in other languages (e.g. Pascal) someday. */
14659 gen_pointer_type_die (tree type, dw_die_ref context_die)
14662 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
14664 equate_type_number_to_die (type, ptr_die);
14665 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14666 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14669 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14670 Use modified_type_die instead.
14671 We keep this code here just in case these types of DIEs may be needed to
14672 represent certain things in other languages (e.g. Pascal) someday. */
14675 gen_reference_type_die (tree type, dw_die_ref context_die)
14678 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
14680 equate_type_number_to_die (type, ref_die);
14681 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
14682 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14686 /* Generate a DIE for a pointer to a member type. */
14689 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
14692 = new_die (DW_TAG_ptr_to_member_type,
14693 scope_die_for (type, context_die), type);
14695 equate_type_number_to_die (type, ptr_die);
14696 add_AT_die_ref (ptr_die, DW_AT_containing_type,
14697 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
14698 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14701 /* Generate the DIE for the compilation unit. */
14704 gen_compile_unit_die (const char *filename)
14707 char producer[250];
14708 const char *language_string = lang_hooks.name;
14711 die = new_die (DW_TAG_compile_unit, NULL, NULL);
14715 add_name_attribute (die, filename);
14716 /* Don't add cwd for <built-in>. */
14717 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
14718 add_comp_dir_attribute (die);
14721 sprintf (producer, "%s %s", language_string, version_string);
14723 #ifdef MIPS_DEBUGGING_INFO
14724 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
14725 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
14726 not appear in the producer string, the debugger reaches the conclusion
14727 that the object file is stripped and has no debugging information.
14728 To get the MIPS/SGI debugger to believe that there is debugging
14729 information in the object file, we add a -g to the producer string. */
14730 if (debug_info_level > DINFO_LEVEL_TERSE)
14731 strcat (producer, " -g");
14734 add_AT_string (die, DW_AT_producer, producer);
14736 if (strcmp (language_string, "GNU C++") == 0)
14737 language = DW_LANG_C_plus_plus;
14738 else if (strcmp (language_string, "GNU Ada") == 0)
14739 language = DW_LANG_Ada95;
14740 else if (strcmp (language_string, "GNU F77") == 0)
14741 language = DW_LANG_Fortran77;
14742 else if (strcmp (language_string, "GNU Fortran") == 0)
14743 language = DW_LANG_Fortran95;
14744 else if (strcmp (language_string, "GNU Pascal") == 0)
14745 language = DW_LANG_Pascal83;
14746 else if (strcmp (language_string, "GNU Java") == 0)
14747 language = DW_LANG_Java;
14748 else if (strcmp (language_string, "GNU Objective-C") == 0)
14749 language = DW_LANG_ObjC;
14750 else if (strcmp (language_string, "GNU Objective-C++") == 0)
14751 language = DW_LANG_ObjC_plus_plus;
14753 language = DW_LANG_C89;
14755 add_AT_unsigned (die, DW_AT_language, language);
14759 /* Generate the DIE for a base class. */
14762 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
14764 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
14766 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
14767 add_data_member_location_attribute (die, binfo);
14769 if (BINFO_VIRTUAL_P (binfo))
14770 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
14772 if (access == access_public_node)
14773 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
14774 else if (access == access_protected_node)
14775 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
14778 /* Generate a DIE for a class member. */
14781 gen_member_die (tree type, dw_die_ref context_die)
14784 tree binfo = TYPE_BINFO (type);
14787 /* If this is not an incomplete type, output descriptions of each of its
14788 members. Note that as we output the DIEs necessary to represent the
14789 members of this record or union type, we will also be trying to output
14790 DIEs to represent the *types* of those members. However the `type'
14791 function (above) will specifically avoid generating type DIEs for member
14792 types *within* the list of member DIEs for this (containing) type except
14793 for those types (of members) which are explicitly marked as also being
14794 members of this (containing) type themselves. The g++ front- end can
14795 force any given type to be treated as a member of some other (containing)
14796 type by setting the TYPE_CONTEXT of the given (member) type to point to
14797 the TREE node representing the appropriate (containing) type. */
14799 /* First output info about the base classes. */
14802 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
14806 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
14807 gen_inheritance_die (base,
14808 (accesses ? VEC_index (tree, accesses, i)
14809 : access_public_node), context_die);
14812 /* Now output info about the data members and type members. */
14813 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
14815 /* If we thought we were generating minimal debug info for TYPE
14816 and then changed our minds, some of the member declarations
14817 may have already been defined. Don't define them again, but
14818 do put them in the right order. */
14820 child = lookup_decl_die (member);
14822 splice_child_die (context_die, child);
14824 gen_decl_die (member, NULL, context_die);
14827 /* Now output info about the function members (if any). */
14828 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
14830 /* Don't include clones in the member list. */
14831 if (DECL_ABSTRACT_ORIGIN (member))
14834 child = lookup_decl_die (member);
14836 splice_child_die (context_die, child);
14838 gen_decl_die (member, NULL, context_die);
14842 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
14843 is set, we pretend that the type was never defined, so we only get the
14844 member DIEs needed by later specification DIEs. */
14847 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
14848 enum debug_info_usage usage)
14850 dw_die_ref type_die = lookup_type_die (type);
14851 dw_die_ref scope_die = 0;
14853 int complete = (TYPE_SIZE (type)
14854 && (! TYPE_STUB_DECL (type)
14855 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
14856 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
14857 complete = complete && should_emit_struct_debug (type, usage);
14859 if (type_die && ! complete)
14862 if (TYPE_CONTEXT (type) != NULL_TREE
14863 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14864 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
14867 scope_die = scope_die_for (type, context_die);
14869 if (! type_die || (nested && scope_die == comp_unit_die))
14870 /* First occurrence of type or toplevel definition of nested class. */
14872 dw_die_ref old_die = type_die;
14874 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
14875 ? record_type_tag (type) : DW_TAG_union_type,
14877 equate_type_number_to_die (type, type_die);
14879 add_AT_specification (type_die, old_die);
14881 add_name_attribute (type_die, type_tag (type));
14884 remove_AT (type_die, DW_AT_declaration);
14886 /* If this type has been completed, then give it a byte_size attribute and
14887 then give a list of members. */
14888 if (complete && !ns_decl)
14890 /* Prevent infinite recursion in cases where the type of some member of
14891 this type is expressed in terms of this type itself. */
14892 TREE_ASM_WRITTEN (type) = 1;
14893 add_byte_size_attribute (type_die, type);
14894 if (TYPE_STUB_DECL (type) != NULL_TREE)
14895 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
14897 /* If the first reference to this type was as the return type of an
14898 inline function, then it may not have a parent. Fix this now. */
14899 if (type_die->die_parent == NULL)
14900 add_child_die (scope_die, type_die);
14902 push_decl_scope (type);
14903 gen_member_die (type, type_die);
14906 /* GNU extension: Record what type our vtable lives in. */
14907 if (TYPE_VFIELD (type))
14909 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
14911 gen_type_die (vtype, context_die);
14912 add_AT_die_ref (type_die, DW_AT_containing_type,
14913 lookup_type_die (vtype));
14918 add_AT_flag (type_die, DW_AT_declaration, 1);
14920 /* We don't need to do this for function-local types. */
14921 if (TYPE_STUB_DECL (type)
14922 && ! decl_function_context (TYPE_STUB_DECL (type)))
14923 VEC_safe_push (tree, gc, incomplete_types, type);
14926 if (get_AT (type_die, DW_AT_name))
14927 add_pubtype (type, type_die);
14930 /* Generate a DIE for a subroutine _type_. */
14933 gen_subroutine_type_die (tree type, dw_die_ref context_die)
14935 tree return_type = TREE_TYPE (type);
14936 dw_die_ref subr_die
14937 = new_die (DW_TAG_subroutine_type,
14938 scope_die_for (type, context_die), type);
14940 equate_type_number_to_die (type, subr_die);
14941 add_prototyped_attribute (subr_die, type);
14942 add_type_attribute (subr_die, return_type, 0, 0, context_die);
14943 gen_formal_types_die (type, subr_die);
14945 if (get_AT (subr_die, DW_AT_name))
14946 add_pubtype (type, subr_die);
14949 /* Generate a DIE for a type definition. */
14952 gen_typedef_die (tree decl, dw_die_ref context_die)
14954 dw_die_ref type_die;
14957 if (TREE_ASM_WRITTEN (decl))
14960 TREE_ASM_WRITTEN (decl) = 1;
14961 type_die = new_die (DW_TAG_typedef, context_die, decl);
14962 origin = decl_ultimate_origin (decl);
14963 if (origin != NULL)
14964 add_abstract_origin_attribute (type_die, origin);
14969 add_name_and_src_coords_attributes (type_die, decl);
14970 if (DECL_ORIGINAL_TYPE (decl))
14972 type = DECL_ORIGINAL_TYPE (decl);
14974 gcc_assert (type != TREE_TYPE (decl));
14975 equate_type_number_to_die (TREE_TYPE (decl), type_die);
14978 type = TREE_TYPE (decl);
14980 add_type_attribute (type_die, type, TREE_READONLY (decl),
14981 TREE_THIS_VOLATILE (decl), context_die);
14984 if (DECL_ABSTRACT (decl))
14985 equate_decl_number_to_die (decl, type_die);
14987 if (get_AT (type_die, DW_AT_name))
14988 add_pubtype (decl, type_die);
14991 /* Generate a type description DIE. */
14994 gen_type_die_with_usage (tree type, dw_die_ref context_die,
14995 enum debug_info_usage usage)
14998 struct array_descr_info info;
15000 if (type == NULL_TREE || type == error_mark_node)
15003 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
15004 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
15006 if (TREE_ASM_WRITTEN (type))
15009 /* Prevent broken recursion; we can't hand off to the same type. */
15010 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
15012 /* Use the DIE of the containing namespace as the parent DIE of
15013 the type description DIE we want to generate. */
15014 if (DECL_CONTEXT (TYPE_NAME (type))
15015 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
15016 context_die = lookup_decl_die (DECL_CONTEXT (TYPE_NAME (type)));
15018 TREE_ASM_WRITTEN (type) = 1;
15019 gen_decl_die (TYPE_NAME (type), NULL, context_die);
15023 /* If this is an array type with hidden descriptor, handle it first. */
15024 if (!TREE_ASM_WRITTEN (type)
15025 && lang_hooks.types.get_array_descr_info
15026 && lang_hooks.types.get_array_descr_info (type, &info))
15028 gen_descr_array_type_die (type, &info, context_die);
15029 TREE_ASM_WRITTEN (type) = 1;
15033 /* We are going to output a DIE to represent the unqualified version
15034 of this type (i.e. without any const or volatile qualifiers) so
15035 get the main variant (i.e. the unqualified version) of this type
15036 now. (Vectors are special because the debugging info is in the
15037 cloned type itself). */
15038 if (TREE_CODE (type) != VECTOR_TYPE)
15039 type = type_main_variant (type);
15041 if (TREE_ASM_WRITTEN (type))
15044 switch (TREE_CODE (type))
15050 case REFERENCE_TYPE:
15051 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
15052 ensures that the gen_type_die recursion will terminate even if the
15053 type is recursive. Recursive types are possible in Ada. */
15054 /* ??? We could perhaps do this for all types before the switch
15056 TREE_ASM_WRITTEN (type) = 1;
15058 /* For these types, all that is required is that we output a DIE (or a
15059 set of DIEs) to represent the "basis" type. */
15060 gen_type_die_with_usage (TREE_TYPE (type), context_die,
15061 DINFO_USAGE_IND_USE);
15065 /* This code is used for C++ pointer-to-data-member types.
15066 Output a description of the relevant class type. */
15067 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
15068 DINFO_USAGE_IND_USE);
15070 /* Output a description of the type of the object pointed to. */
15071 gen_type_die_with_usage (TREE_TYPE (type), context_die,
15072 DINFO_USAGE_IND_USE);
15074 /* Now output a DIE to represent this pointer-to-data-member type
15076 gen_ptr_to_mbr_type_die (type, context_die);
15079 case FUNCTION_TYPE:
15080 /* Force out return type (in case it wasn't forced out already). */
15081 gen_type_die_with_usage (TREE_TYPE (type), context_die,
15082 DINFO_USAGE_DIR_USE);
15083 gen_subroutine_type_die (type, context_die);
15087 /* Force out return type (in case it wasn't forced out already). */
15088 gen_type_die_with_usage (TREE_TYPE (type), context_die,
15089 DINFO_USAGE_DIR_USE);
15090 gen_subroutine_type_die (type, context_die);
15094 gen_array_type_die (type, context_die);
15098 gen_array_type_die (type, context_die);
15101 case ENUMERAL_TYPE:
15104 case QUAL_UNION_TYPE:
15105 /* If this is a nested type whose containing class hasn't been written
15106 out yet, writing it out will cover this one, too. This does not apply
15107 to instantiations of member class templates; they need to be added to
15108 the containing class as they are generated. FIXME: This hurts the
15109 idea of combining type decls from multiple TUs, since we can't predict
15110 what set of template instantiations we'll get. */
15111 if (TYPE_CONTEXT (type)
15112 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
15113 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
15115 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
15117 if (TREE_ASM_WRITTEN (type))
15120 /* If that failed, attach ourselves to the stub. */
15121 push_decl_scope (TYPE_CONTEXT (type));
15122 context_die = lookup_type_die (TYPE_CONTEXT (type));
15127 context_die = declare_in_namespace (type, context_die);
15131 if (TREE_CODE (type) == ENUMERAL_TYPE)
15133 /* This might have been written out by the call to
15134 declare_in_namespace. */
15135 if (!TREE_ASM_WRITTEN (type))
15136 gen_enumeration_type_die (type, context_die);
15139 gen_struct_or_union_type_die (type, context_die, usage);
15144 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
15145 it up if it is ever completed. gen_*_type_die will set it for us
15146 when appropriate. */
15152 case FIXED_POINT_TYPE:
15155 /* No DIEs needed for fundamental types. */
15159 /* No Dwarf representation currently defined. */
15163 gcc_unreachable ();
15166 TREE_ASM_WRITTEN (type) = 1;
15170 gen_type_die (tree type, dw_die_ref context_die)
15172 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
15175 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
15176 things which are local to the given block. */
15179 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
15181 int must_output_die = 0;
15184 /* Ignore blocks that are NULL. */
15185 if (stmt == NULL_TREE)
15188 inlined_func = inlined_function_outer_scope_p (stmt);
15190 /* If the block is one fragment of a non-contiguous block, do not
15191 process the variables, since they will have been done by the
15192 origin block. Do process subblocks. */
15193 if (BLOCK_FRAGMENT_ORIGIN (stmt))
15197 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
15198 gen_block_die (sub, context_die, depth + 1);
15203 /* Determine if we need to output any Dwarf DIEs at all to represent this
15206 /* The outer scopes for inlinings *must* always be represented. We
15207 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
15208 must_output_die = 1;
15211 /* Determine if this block directly contains any "significant"
15212 local declarations which we will need to output DIEs for. */
15213 if (debug_info_level > DINFO_LEVEL_TERSE)
15214 /* We are not in terse mode so *any* local declaration counts
15215 as being a "significant" one. */
15216 must_output_die = ((BLOCK_VARS (stmt) != NULL
15217 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
15218 && (TREE_USED (stmt)
15219 || TREE_ASM_WRITTEN (stmt)
15220 || BLOCK_ABSTRACT (stmt)));
15221 else if ((TREE_USED (stmt)
15222 || TREE_ASM_WRITTEN (stmt)
15223 || BLOCK_ABSTRACT (stmt))
15224 && !dwarf2out_ignore_block (stmt))
15225 must_output_die = 1;
15228 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
15229 DIE for any block which contains no significant local declarations at
15230 all. Rather, in such cases we just call `decls_for_scope' so that any
15231 needed Dwarf info for any sub-blocks will get properly generated. Note
15232 that in terse mode, our definition of what constitutes a "significant"
15233 local declaration gets restricted to include only inlined function
15234 instances and local (nested) function definitions. */
15235 if (must_output_die)
15238 gen_inlined_subroutine_die (stmt, context_die, depth);
15240 gen_lexical_block_die (stmt, context_die, depth);
15243 decls_for_scope (stmt, context_die, depth);
15246 /* Process variable DECL (or variable with origin ORIGIN) within
15247 block STMT and add it to CONTEXT_DIE. */
15249 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
15252 tree decl_or_origin = decl ? decl : origin;
15253 tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
15255 if (ultimate_origin)
15256 origin = ultimate_origin;
15258 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
15259 die = lookup_decl_die (decl_or_origin);
15260 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
15261 && TYPE_DECL_IS_STUB (decl_or_origin))
15262 die = lookup_type_die (TREE_TYPE (decl_or_origin));
15266 if (die != NULL && die->die_parent == NULL)
15267 add_child_die (context_die, die);
15268 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
15269 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
15270 stmt, context_die);
15272 gen_decl_die (decl, origin, context_die);
15275 /* Generate all of the decls declared within a given scope and (recursively)
15276 all of its sub-blocks. */
15279 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
15285 /* Ignore NULL blocks. */
15286 if (stmt == NULL_TREE)
15289 /* Output the DIEs to represent all of the data objects and typedefs
15290 declared directly within this block but not within any nested
15291 sub-blocks. Also, nested function and tag DIEs have been
15292 generated with a parent of NULL; fix that up now. */
15293 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
15294 process_scope_var (stmt, decl, NULL_TREE, context_die);
15295 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
15296 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
15299 /* If we're at -g1, we're not interested in subblocks. */
15300 if (debug_info_level <= DINFO_LEVEL_TERSE)
15303 /* Output the DIEs to represent all sub-blocks (and the items declared
15304 therein) of this block. */
15305 for (subblocks = BLOCK_SUBBLOCKS (stmt);
15307 subblocks = BLOCK_CHAIN (subblocks))
15308 gen_block_die (subblocks, context_die, depth + 1);
15311 /* Is this a typedef we can avoid emitting? */
15314 is_redundant_typedef (const_tree decl)
15316 if (TYPE_DECL_IS_STUB (decl))
15319 if (DECL_ARTIFICIAL (decl)
15320 && DECL_CONTEXT (decl)
15321 && is_tagged_type (DECL_CONTEXT (decl))
15322 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
15323 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
15324 /* Also ignore the artificial member typedef for the class name. */
15330 /* Returns the DIE for a context. */
15332 static inline dw_die_ref
15333 get_context_die (tree context)
15337 /* Find die that represents this context. */
15338 if (TYPE_P (context))
15339 return force_type_die (context);
15341 return force_decl_die (context);
15343 return comp_unit_die;
15346 /* Returns the DIE for decl. A DIE will always be returned. */
15349 force_decl_die (tree decl)
15351 dw_die_ref decl_die;
15352 unsigned saved_external_flag;
15353 tree save_fn = NULL_TREE;
15354 decl_die = lookup_decl_die (decl);
15357 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
15359 decl_die = lookup_decl_die (decl);
15363 switch (TREE_CODE (decl))
15365 case FUNCTION_DECL:
15366 /* Clear current_function_decl, so that gen_subprogram_die thinks
15367 that this is a declaration. At this point, we just want to force
15368 declaration die. */
15369 save_fn = current_function_decl;
15370 current_function_decl = NULL_TREE;
15371 gen_subprogram_die (decl, context_die);
15372 current_function_decl = save_fn;
15376 /* Set external flag to force declaration die. Restore it after
15377 gen_decl_die() call. */
15378 saved_external_flag = DECL_EXTERNAL (decl);
15379 DECL_EXTERNAL (decl) = 1;
15380 gen_decl_die (decl, NULL, context_die);
15381 DECL_EXTERNAL (decl) = saved_external_flag;
15384 case NAMESPACE_DECL:
15385 dwarf2out_decl (decl);
15389 gcc_unreachable ();
15392 /* We should be able to find the DIE now. */
15394 decl_die = lookup_decl_die (decl);
15395 gcc_assert (decl_die);
15401 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
15402 always returned. */
15405 force_type_die (tree type)
15407 dw_die_ref type_die;
15409 type_die = lookup_type_die (type);
15412 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
15414 type_die = modified_type_die (type, TYPE_READONLY (type),
15415 TYPE_VOLATILE (type), context_die);
15416 gcc_assert (type_die);
15421 /* Force out any required namespaces to be able to output DECL,
15422 and return the new context_die for it, if it's changed. */
15425 setup_namespace_context (tree thing, dw_die_ref context_die)
15427 tree context = (DECL_P (thing)
15428 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
15429 if (context && TREE_CODE (context) == NAMESPACE_DECL)
15430 /* Force out the namespace. */
15431 context_die = force_decl_die (context);
15433 return context_die;
15436 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
15437 type) within its namespace, if appropriate.
15439 For compatibility with older debuggers, namespace DIEs only contain
15440 declarations; all definitions are emitted at CU scope. */
15443 declare_in_namespace (tree thing, dw_die_ref context_die)
15445 dw_die_ref ns_context;
15447 if (debug_info_level <= DINFO_LEVEL_TERSE)
15448 return context_die;
15450 /* If this decl is from an inlined function, then don't try to emit it in its
15451 namespace, as we will get confused. It would have already been emitted
15452 when the abstract instance of the inline function was emitted anyways. */
15453 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
15454 return context_die;
15456 ns_context = setup_namespace_context (thing, context_die);
15458 if (ns_context != context_die)
15462 if (DECL_P (thing))
15463 gen_decl_die (thing, NULL, ns_context);
15465 gen_type_die (thing, ns_context);
15467 return context_die;
15470 /* Generate a DIE for a namespace or namespace alias. */
15473 gen_namespace_die (tree decl, dw_die_ref context_die)
15475 dw_die_ref namespace_die;
15477 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
15478 they are an alias of. */
15479 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
15481 /* Output a real namespace or module. */
15482 context_die = setup_namespace_context (decl, comp_unit_die);
15483 namespace_die = new_die (is_fortran ()
15484 ? DW_TAG_module : DW_TAG_namespace,
15485 context_die, decl);
15486 /* For Fortran modules defined in different CU don't add src coords. */
15487 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
15488 add_name_attribute (namespace_die, dwarf2_name (decl, 0));
15490 add_name_and_src_coords_attributes (namespace_die, decl);
15491 if (DECL_EXTERNAL (decl))
15492 add_AT_flag (namespace_die, DW_AT_declaration, 1);
15493 equate_decl_number_to_die (decl, namespace_die);
15497 /* Output a namespace alias. */
15499 /* Force out the namespace we are an alias of, if necessary. */
15500 dw_die_ref origin_die
15501 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
15503 if (DECL_CONTEXT (decl) == NULL_TREE
15504 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
15505 context_die = setup_namespace_context (decl, comp_unit_die);
15506 /* Now create the namespace alias DIE. */
15507 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
15508 add_name_and_src_coords_attributes (namespace_die, decl);
15509 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
15510 equate_decl_number_to_die (decl, namespace_die);
15514 /* Generate Dwarf debug information for a decl described by DECL. */
15517 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
15519 tree decl_or_origin = decl ? decl : origin;
15520 tree class_origin = NULL;
15522 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
15525 switch (TREE_CODE (decl_or_origin))
15531 if (!is_fortran ())
15533 /* The individual enumerators of an enum type get output when we output
15534 the Dwarf representation of the relevant enum type itself. */
15538 /* Emit its type. */
15539 gen_type_die (TREE_TYPE (decl), context_die);
15541 /* And its containing namespace. */
15542 context_die = declare_in_namespace (decl, context_die);
15544 gen_const_die (decl, context_die);
15547 case FUNCTION_DECL:
15548 /* Don't output any DIEs to represent mere function declarations,
15549 unless they are class members or explicit block externs. */
15550 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
15551 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
15552 && (current_function_decl == NULL_TREE
15553 || DECL_ARTIFICIAL (decl_or_origin)))
15558 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
15559 on local redeclarations of global functions. That seems broken. */
15560 if (current_function_decl != decl)
15561 /* This is only a declaration. */;
15564 /* If we're emitting a clone, emit info for the abstract instance. */
15565 if (origin || DECL_ORIGIN (decl) != decl)
15566 dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
15568 /* If we're emitting an out-of-line copy of an inline function,
15569 emit info for the abstract instance and set up to refer to it. */
15570 else if (cgraph_function_possibly_inlined_p (decl)
15571 && ! DECL_ABSTRACT (decl)
15572 && ! class_or_namespace_scope_p (context_die)
15573 /* dwarf2out_abstract_function won't emit a die if this is just
15574 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
15575 that case, because that works only if we have a die. */
15576 && DECL_INITIAL (decl) != NULL_TREE)
15578 dwarf2out_abstract_function (decl);
15579 set_decl_origin_self (decl);
15582 /* Otherwise we're emitting the primary DIE for this decl. */
15583 else if (debug_info_level > DINFO_LEVEL_TERSE)
15585 /* Before we describe the FUNCTION_DECL itself, make sure that we
15586 have described its return type. */
15587 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
15589 /* And its virtual context. */
15590 if (DECL_VINDEX (decl) != NULL_TREE)
15591 gen_type_die (DECL_CONTEXT (decl), context_die);
15593 /* And its containing type. */
15595 origin = decl_class_context (decl);
15596 if (origin != NULL_TREE)
15597 gen_type_die_for_member (origin, decl, context_die);
15599 /* And its containing namespace. */
15600 context_die = declare_in_namespace (decl, context_die);
15603 /* Now output a DIE to represent the function itself. */
15605 gen_subprogram_die (decl, context_die);
15609 /* If we are in terse mode, don't generate any DIEs to represent any
15610 actual typedefs. */
15611 if (debug_info_level <= DINFO_LEVEL_TERSE)
15614 /* In the special case of a TYPE_DECL node representing the declaration
15615 of some type tag, if the given TYPE_DECL is marked as having been
15616 instantiated from some other (original) TYPE_DECL node (e.g. one which
15617 was generated within the original definition of an inline function) we
15618 used to generate a special (abbreviated) DW_TAG_structure_type,
15619 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
15620 should be actually referencing those DIEs, as variable DIEs with that
15621 type would be emitted already in the abstract origin, so it was always
15622 removed during unused type prunning. Don't add anything in this
15624 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
15627 if (is_redundant_typedef (decl))
15628 gen_type_die (TREE_TYPE (decl), context_die);
15630 /* Output a DIE to represent the typedef itself. */
15631 gen_typedef_die (decl, context_die);
15635 if (debug_info_level >= DINFO_LEVEL_NORMAL)
15636 gen_label_die (decl, context_die);
15641 /* If we are in terse mode, don't generate any DIEs to represent any
15642 variable declarations or definitions. */
15643 if (debug_info_level <= DINFO_LEVEL_TERSE)
15646 /* Output any DIEs that are needed to specify the type of this data
15648 if ((TREE_CODE (decl_or_origin) == RESULT_DECL
15649 || TREE_CODE (decl_or_origin) == VAR_DECL)
15650 && DECL_BY_REFERENCE (decl_or_origin))
15651 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15653 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15655 /* And its containing type. */
15656 class_origin = decl_class_context (decl_or_origin);
15657 if (class_origin != NULL_TREE)
15658 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
15660 /* And its containing namespace. */
15661 context_die = declare_in_namespace (decl_or_origin, context_die);
15663 /* Now output the DIE to represent the data object itself. This gets
15664 complicated because of the possibility that the VAR_DECL really
15665 represents an inlined instance of a formal parameter for an inline
15668 origin = decl_ultimate_origin (decl);
15669 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
15670 gen_formal_parameter_die (decl, origin, context_die);
15672 gen_variable_die (decl, origin, context_die);
15676 /* Ignore the nameless fields that are used to skip bits but handle C++
15677 anonymous unions and structs. */
15678 if (DECL_NAME (decl) != NULL_TREE
15679 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
15680 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
15682 gen_type_die (member_declared_type (decl), context_die);
15683 gen_field_die (decl, context_die);
15688 if (DECL_BY_REFERENCE (decl_or_origin))
15689 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15691 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15692 gen_formal_parameter_die (decl, origin, context_die);
15695 case NAMESPACE_DECL:
15696 case IMPORTED_DECL:
15697 gen_namespace_die (decl, context_die);
15701 /* Probably some frontend-internal decl. Assume we don't care. */
15702 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
15707 /* Output debug information for global decl DECL. Called from toplev.c after
15708 compilation proper has finished. */
15711 dwarf2out_global_decl (tree decl)
15713 /* Output DWARF2 information for file-scope tentative data object
15714 declarations, file-scope (extern) function declarations (which
15715 had no corresponding body) and file-scope tagged type declarations
15716 and definitions which have not yet been forced out. */
15717 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
15718 dwarf2out_decl (decl);
15721 /* Output debug information for type decl DECL. Called from toplev.c
15722 and from language front ends (to record built-in types). */
15724 dwarf2out_type_decl (tree decl, int local)
15727 dwarf2out_decl (decl);
15730 /* Output debug information for imported module or decl DECL.
15731 NAME is non-NULL name in the lexical block if the decl has been renamed.
15732 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
15733 that DECL belongs to.
15734 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
15736 dwarf2out_imported_module_or_decl_1 (tree decl,
15738 tree lexical_block,
15739 dw_die_ref lexical_block_die)
15741 expanded_location xloc;
15742 dw_die_ref imported_die = NULL;
15743 dw_die_ref at_import_die;
15745 if (TREE_CODE (decl) == IMPORTED_DECL)
15747 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
15748 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
15752 xloc = expand_location (input_location);
15754 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
15756 if (is_base_type (TREE_TYPE (decl)))
15757 at_import_die = base_type_die (TREE_TYPE (decl));
15759 at_import_die = force_type_die (TREE_TYPE (decl));
15760 /* For namespace N { typedef void T; } using N::T; base_type_die
15761 returns NULL, but DW_TAG_imported_declaration requires
15762 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
15763 if (!at_import_die)
15765 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
15766 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
15767 at_import_die = lookup_type_die (TREE_TYPE (decl));
15768 gcc_assert (at_import_die);
15773 at_import_die = lookup_decl_die (decl);
15774 if (!at_import_die)
15776 /* If we're trying to avoid duplicate debug info, we may not have
15777 emitted the member decl for this field. Emit it now. */
15778 if (TREE_CODE (decl) == FIELD_DECL)
15780 tree type = DECL_CONTEXT (decl);
15782 if (TYPE_CONTEXT (type)
15783 && TYPE_P (TYPE_CONTEXT (type))
15784 && !should_emit_struct_debug (TYPE_CONTEXT (type),
15785 DINFO_USAGE_DIR_USE))
15787 gen_type_die_for_member (type, decl,
15788 get_context_die (TYPE_CONTEXT (type)));
15790 at_import_die = force_decl_die (decl);
15794 if (TREE_CODE (decl) == NAMESPACE_DECL)
15795 imported_die = new_die (DW_TAG_imported_module,
15799 imported_die = new_die (DW_TAG_imported_declaration,
15803 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
15804 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
15806 add_AT_string (imported_die, DW_AT_name,
15807 IDENTIFIER_POINTER (name));
15808 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
15811 /* Output debug information for imported module or decl DECL.
15812 NAME is non-NULL name in context if the decl has been renamed.
15813 CHILD is true if decl is one of the renamed decls as part of
15814 importing whole module. */
15817 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
15820 /* dw_die_ref at_import_die; */
15821 dw_die_ref scope_die;
15823 if (debug_info_level <= DINFO_LEVEL_TERSE)
15828 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
15829 We need decl DIE for reference and scope die. First, get DIE for the decl
15832 /* Get the scope die for decl context. Use comp_unit_die for global module
15833 or decl. If die is not found for non globals, force new die. */
15835 && TYPE_P (context)
15836 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
15838 scope_die = get_context_die (context);
15842 gcc_assert (scope_die->die_child);
15843 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
15844 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
15845 scope_die = scope_die->die_child;
15848 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
15849 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
15853 /* Write the debugging output for DECL. */
15856 dwarf2out_decl (tree decl)
15858 dw_die_ref context_die = comp_unit_die;
15860 switch (TREE_CODE (decl))
15865 case FUNCTION_DECL:
15866 /* What we would really like to do here is to filter out all mere
15867 file-scope declarations of file-scope functions which are never
15868 referenced later within this translation unit (and keep all of ones
15869 that *are* referenced later on) but we aren't clairvoyant, so we have
15870 no idea which functions will be referenced in the future (i.e. later
15871 on within the current translation unit). So here we just ignore all
15872 file-scope function declarations which are not also definitions. If
15873 and when the debugger needs to know something about these functions,
15874 it will have to hunt around and find the DWARF information associated
15875 with the definition of the function.
15877 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
15878 nodes represent definitions and which ones represent mere
15879 declarations. We have to check DECL_INITIAL instead. That's because
15880 the C front-end supports some weird semantics for "extern inline"
15881 function definitions. These can get inlined within the current
15882 translation unit (and thus, we need to generate Dwarf info for their
15883 abstract instances so that the Dwarf info for the concrete inlined
15884 instances can have something to refer to) but the compiler never
15885 generates any out-of-lines instances of such things (despite the fact
15886 that they *are* definitions).
15888 The important point is that the C front-end marks these "extern
15889 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
15890 them anyway. Note that the C++ front-end also plays some similar games
15891 for inline function definitions appearing within include files which
15892 also contain `#pragma interface' pragmas. */
15893 if (DECL_INITIAL (decl) == NULL_TREE)
15896 /* If we're a nested function, initially use a parent of NULL; if we're
15897 a plain function, this will be fixed up in decls_for_scope. If
15898 we're a method, it will be ignored, since we already have a DIE. */
15899 if (decl_function_context (decl)
15900 /* But if we're in terse mode, we don't care about scope. */
15901 && debug_info_level > DINFO_LEVEL_TERSE)
15902 context_die = NULL;
15906 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
15907 declaration and if the declaration was never even referenced from
15908 within this entire compilation unit. We suppress these DIEs in
15909 order to save space in the .debug section (by eliminating entries
15910 which are probably useless). Note that we must not suppress
15911 block-local extern declarations (whether used or not) because that
15912 would screw-up the debugger's name lookup mechanism and cause it to
15913 miss things which really ought to be in scope at a given point. */
15914 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
15917 /* For local statics lookup proper context die. */
15918 if (TREE_STATIC (decl) && decl_function_context (decl))
15919 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15921 /* If we are in terse mode, don't generate any DIEs to represent any
15922 variable declarations or definitions. */
15923 if (debug_info_level <= DINFO_LEVEL_TERSE)
15928 if (debug_info_level <= DINFO_LEVEL_TERSE)
15930 if (!is_fortran ())
15932 if (TREE_STATIC (decl) && decl_function_context (decl))
15933 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15936 case NAMESPACE_DECL:
15937 case IMPORTED_DECL:
15938 if (debug_info_level <= DINFO_LEVEL_TERSE)
15940 if (lookup_decl_die (decl) != NULL)
15945 /* Don't emit stubs for types unless they are needed by other DIEs. */
15946 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
15949 /* Don't bother trying to generate any DIEs to represent any of the
15950 normal built-in types for the language we are compiling. */
15951 if (DECL_IS_BUILTIN (decl))
15953 /* OK, we need to generate one for `bool' so GDB knows what type
15954 comparisons have. */
15956 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
15957 && ! DECL_IGNORED_P (decl))
15958 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
15963 /* If we are in terse mode, don't generate any DIEs for types. */
15964 if (debug_info_level <= DINFO_LEVEL_TERSE)
15967 /* If we're a function-scope tag, initially use a parent of NULL;
15968 this will be fixed up in decls_for_scope. */
15969 if (decl_function_context (decl))
15970 context_die = NULL;
15978 gen_decl_die (decl, NULL, context_die);
15981 /* Output a marker (i.e. a label) for the beginning of the generated code for
15982 a lexical block. */
15985 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
15986 unsigned int blocknum)
15988 switch_to_section (current_function_section ());
15989 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
15992 /* Output a marker (i.e. a label) for the end of the generated code for a
15996 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
15998 switch_to_section (current_function_section ());
15999 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
16002 /* Returns nonzero if it is appropriate not to emit any debugging
16003 information for BLOCK, because it doesn't contain any instructions.
16005 Don't allow this for blocks with nested functions or local classes
16006 as we would end up with orphans, and in the presence of scheduling
16007 we may end up calling them anyway. */
16010 dwarf2out_ignore_block (const_tree block)
16015 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
16016 if (TREE_CODE (decl) == FUNCTION_DECL
16017 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
16019 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
16021 decl = BLOCK_NONLOCALIZED_VAR (block, i);
16022 if (TREE_CODE (decl) == FUNCTION_DECL
16023 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
16030 /* Hash table routines for file_hash. */
16033 file_table_eq (const void *p1_p, const void *p2_p)
16035 const struct dwarf_file_data *const p1 =
16036 (const struct dwarf_file_data *) p1_p;
16037 const char *const p2 = (const char *) p2_p;
16038 return strcmp (p1->filename, p2) == 0;
16042 file_table_hash (const void *p_p)
16044 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
16045 return htab_hash_string (p->filename);
16048 /* Lookup FILE_NAME (in the list of filenames that we know about here in
16049 dwarf2out.c) and return its "index". The index of each (known) filename is
16050 just a unique number which is associated with only that one filename. We
16051 need such numbers for the sake of generating labels (in the .debug_sfnames
16052 section) and references to those files numbers (in the .debug_srcinfo
16053 and.debug_macinfo sections). If the filename given as an argument is not
16054 found in our current list, add it to the list and assign it the next
16055 available unique index number. In order to speed up searches, we remember
16056 the index of the filename was looked up last. This handles the majority of
16059 static struct dwarf_file_data *
16060 lookup_filename (const char *file_name)
16063 struct dwarf_file_data * created;
16065 /* Check to see if the file name that was searched on the previous
16066 call matches this file name. If so, return the index. */
16067 if (file_table_last_lookup
16068 && (file_name == file_table_last_lookup->filename
16069 || strcmp (file_table_last_lookup->filename, file_name) == 0))
16070 return file_table_last_lookup;
16072 /* Didn't match the previous lookup, search the table. */
16073 slot = htab_find_slot_with_hash (file_table, file_name,
16074 htab_hash_string (file_name), INSERT);
16076 return (struct dwarf_file_data *) *slot;
16078 created = GGC_NEW (struct dwarf_file_data);
16079 created->filename = file_name;
16080 created->emitted_number = 0;
16085 /* If the assembler will construct the file table, then translate the compiler
16086 internal file table number into the assembler file table number, and emit
16087 a .file directive if we haven't already emitted one yet. The file table
16088 numbers are different because we prune debug info for unused variables and
16089 types, which may include filenames. */
16092 maybe_emit_file (struct dwarf_file_data * fd)
16094 if (! fd->emitted_number)
16096 if (last_emitted_file)
16097 fd->emitted_number = last_emitted_file->emitted_number + 1;
16099 fd->emitted_number = 1;
16100 last_emitted_file = fd;
16102 if (DWARF2_ASM_LINE_DEBUG_INFO)
16104 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
16105 output_quoted_string (asm_out_file,
16106 remap_debug_filename (fd->filename));
16107 fputc ('\n', asm_out_file);
16111 return fd->emitted_number;
16114 /* Replace DW_AT_name for the decl with name. */
16117 dwarf2out_set_name (tree decl, tree name)
16122 die = TYPE_SYMTAB_DIE (decl);
16126 attr = get_AT (die, DW_AT_name);
16129 struct indirect_string_node *node;
16131 node = find_AT_string (dwarf2_name (name, 0));
16132 /* replace the string. */
16133 attr->dw_attr_val.v.val_str = node;
16137 add_name_attribute (die, dwarf2_name (name, 0));
16139 /* Called by the final INSN scan whenever we see a var location. We
16140 use it to drop labels in the right places, and throw the location in
16141 our lookup table. */
16144 dwarf2out_var_location (rtx loc_note)
16146 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
16147 struct var_loc_node *newloc;
16149 static rtx last_insn;
16150 static const char *last_label;
16153 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
16155 prev_insn = PREV_INSN (loc_note);
16157 newloc = GGC_CNEW (struct var_loc_node);
16158 /* If the insn we processed last time is the previous insn
16159 and it is also a var location note, use the label we emitted
16161 if (last_insn != NULL_RTX
16162 && last_insn == prev_insn
16163 && NOTE_P (prev_insn)
16164 && NOTE_KIND (prev_insn) == NOTE_INSN_VAR_LOCATION)
16166 newloc->label = last_label;
16170 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
16171 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
16173 newloc->label = ggc_strdup (loclabel);
16175 newloc->var_loc_note = loc_note;
16176 newloc->next = NULL;
16178 if (cfun && in_cold_section_p)
16179 newloc->section_label = crtl->subsections.cold_section_label;
16181 newloc->section_label = text_section_label;
16183 last_insn = loc_note;
16184 last_label = newloc->label;
16185 decl = NOTE_VAR_LOCATION_DECL (loc_note);
16186 add_var_loc_to_decl (decl, newloc);
16189 /* We need to reset the locations at the beginning of each
16190 function. We can't do this in the end_function hook, because the
16191 declarations that use the locations won't have been output when
16192 that hook is called. Also compute have_multiple_function_sections here. */
16195 dwarf2out_begin_function (tree fun)
16197 htab_empty (decl_loc_table);
16199 if (function_section (fun) != text_section)
16200 have_multiple_function_sections = true;
16202 dwarf2out_note_section_used ();
16205 /* Output a label to mark the beginning of a source code line entry
16206 and record information relating to this source line, in
16207 'line_info_table' for later output of the .debug_line section. */
16210 dwarf2out_source_line (unsigned int line, const char *filename,
16213 if (debug_info_level >= DINFO_LEVEL_NORMAL
16216 int file_num = maybe_emit_file (lookup_filename (filename));
16218 switch_to_section (current_function_section ());
16220 /* If requested, emit something human-readable. */
16221 if (flag_debug_asm)
16222 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
16225 if (DWARF2_ASM_LINE_DEBUG_INFO)
16227 /* Emit the .loc directive understood by GNU as. */
16228 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
16229 #ifdef HAVE_GAS_DISCRIMINATOR
16230 if (discriminator != 0)
16231 fprintf (asm_out_file, " discriminator %d", discriminator);
16232 #endif /* HAVE_GAS_DISCRIMINATOR */
16233 fputc ('\n', asm_out_file);
16235 /* Indicate that line number info exists. */
16236 line_info_table_in_use++;
16238 else if (function_section (current_function_decl) != text_section)
16240 dw_separate_line_info_ref line_info;
16241 targetm.asm_out.internal_label (asm_out_file,
16242 SEPARATE_LINE_CODE_LABEL,
16243 separate_line_info_table_in_use);
16245 /* Expand the line info table if necessary. */
16246 if (separate_line_info_table_in_use
16247 == separate_line_info_table_allocated)
16249 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
16250 separate_line_info_table
16251 = GGC_RESIZEVEC (dw_separate_line_info_entry,
16252 separate_line_info_table,
16253 separate_line_info_table_allocated);
16254 memset (separate_line_info_table
16255 + separate_line_info_table_in_use,
16257 (LINE_INFO_TABLE_INCREMENT
16258 * sizeof (dw_separate_line_info_entry)));
16261 /* Add the new entry at the end of the line_info_table. */
16263 = &separate_line_info_table[separate_line_info_table_in_use++];
16264 line_info->dw_file_num = file_num;
16265 line_info->dw_line_num = line;
16266 line_info->function = current_function_funcdef_no;
16270 dw_line_info_ref line_info;
16272 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
16273 line_info_table_in_use);
16275 /* Expand the line info table if necessary. */
16276 if (line_info_table_in_use == line_info_table_allocated)
16278 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
16280 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
16281 line_info_table_allocated);
16282 memset (line_info_table + line_info_table_in_use, 0,
16283 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
16286 /* Add the new entry at the end of the line_info_table. */
16287 line_info = &line_info_table[line_info_table_in_use++];
16288 line_info->dw_file_num = file_num;
16289 line_info->dw_line_num = line;
16294 /* Record the beginning of a new source file. */
16297 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
16299 if (flag_eliminate_dwarf2_dups)
16301 /* Record the beginning of the file for break_out_includes. */
16302 dw_die_ref bincl_die;
16304 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
16305 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
16308 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16310 int file_num = maybe_emit_file (lookup_filename (filename));
16312 switch_to_section (debug_macinfo_section);
16313 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
16314 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
16317 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
16321 /* Record the end of a source file. */
16324 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
16326 if (flag_eliminate_dwarf2_dups)
16327 /* Record the end of the file for break_out_includes. */
16328 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
16330 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16332 switch_to_section (debug_macinfo_section);
16333 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
16337 /* Called from debug_define in toplev.c. The `buffer' parameter contains
16338 the tail part of the directive line, i.e. the part which is past the
16339 initial whitespace, #, whitespace, directive-name, whitespace part. */
16342 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
16343 const char *buffer ATTRIBUTE_UNUSED)
16345 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16347 switch_to_section (debug_macinfo_section);
16348 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
16349 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
16350 dw2_asm_output_nstring (buffer, -1, "The macro");
16354 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
16355 the tail part of the directive line, i.e. the part which is past the
16356 initial whitespace, #, whitespace, directive-name, whitespace part. */
16359 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
16360 const char *buffer ATTRIBUTE_UNUSED)
16362 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16364 switch_to_section (debug_macinfo_section);
16365 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
16366 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
16367 dw2_asm_output_nstring (buffer, -1, "The macro");
16371 /* Set up for Dwarf output at the start of compilation. */
16374 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
16376 /* Allocate the file_table. */
16377 file_table = htab_create_ggc (50, file_table_hash,
16378 file_table_eq, NULL);
16380 /* Allocate the decl_die_table. */
16381 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
16382 decl_die_table_eq, NULL);
16384 /* Allocate the decl_loc_table. */
16385 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
16386 decl_loc_table_eq, NULL);
16388 /* Allocate the initial hunk of the decl_scope_table. */
16389 decl_scope_table = VEC_alloc (tree, gc, 256);
16391 /* Allocate the initial hunk of the abbrev_die_table. */
16392 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
16393 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
16394 /* Zero-th entry is allocated, but unused. */
16395 abbrev_die_table_in_use = 1;
16397 /* Allocate the initial hunk of the line_info_table. */
16398 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
16399 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
16401 /* Zero-th entry is allocated, but unused. */
16402 line_info_table_in_use = 1;
16404 /* Allocate the pubtypes and pubnames vectors. */
16405 pubname_table = VEC_alloc (pubname_entry, gc, 32);
16406 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
16408 /* Generate the initial DIE for the .debug section. Note that the (string)
16409 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
16410 will (typically) be a relative pathname and that this pathname should be
16411 taken as being relative to the directory from which the compiler was
16412 invoked when the given (base) source file was compiled. We will fill
16413 in this value in dwarf2out_finish. */
16414 comp_unit_die = gen_compile_unit_die (NULL);
16416 incomplete_types = VEC_alloc (tree, gc, 64);
16418 used_rtx_array = VEC_alloc (rtx, gc, 32);
16420 debug_info_section = get_section (DEBUG_INFO_SECTION,
16421 SECTION_DEBUG, NULL);
16422 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
16423 SECTION_DEBUG, NULL);
16424 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
16425 SECTION_DEBUG, NULL);
16426 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
16427 SECTION_DEBUG, NULL);
16428 debug_line_section = get_section (DEBUG_LINE_SECTION,
16429 SECTION_DEBUG, NULL);
16430 debug_loc_section = get_section (DEBUG_LOC_SECTION,
16431 SECTION_DEBUG, NULL);
16432 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
16433 SECTION_DEBUG, NULL);
16434 #ifdef DEBUG_PUBTYPES_SECTION
16435 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
16436 SECTION_DEBUG, NULL);
16438 debug_str_section = get_section (DEBUG_STR_SECTION,
16439 DEBUG_STR_SECTION_FLAGS, NULL);
16440 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
16441 SECTION_DEBUG, NULL);
16442 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
16443 SECTION_DEBUG, NULL);
16445 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
16446 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
16447 DEBUG_ABBREV_SECTION_LABEL, 0);
16448 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
16449 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
16450 COLD_TEXT_SECTION_LABEL, 0);
16451 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
16453 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
16454 DEBUG_INFO_SECTION_LABEL, 0);
16455 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
16456 DEBUG_LINE_SECTION_LABEL, 0);
16457 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
16458 DEBUG_RANGES_SECTION_LABEL, 0);
16459 switch_to_section (debug_abbrev_section);
16460 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
16461 switch_to_section (debug_info_section);
16462 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
16463 switch_to_section (debug_line_section);
16464 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
16466 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16468 switch_to_section (debug_macinfo_section);
16469 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
16470 DEBUG_MACINFO_SECTION_LABEL, 0);
16471 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
16474 switch_to_section (text_section);
16475 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
16476 if (flag_reorder_blocks_and_partition)
16478 cold_text_section = unlikely_text_section ();
16479 switch_to_section (cold_text_section);
16480 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
16484 /* A helper function for dwarf2out_finish called through
16485 ht_forall. Emit one queued .debug_str string. */
16488 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
16490 struct indirect_string_node *node = (struct indirect_string_node *) *h;
16492 if (node->form == DW_FORM_strp)
16494 switch_to_section (debug_str_section);
16495 ASM_OUTPUT_LABEL (asm_out_file, node->label);
16496 assemble_string (node->str, strlen (node->str) + 1);
16502 #if ENABLE_ASSERT_CHECKING
16503 /* Verify that all marks are clear. */
16506 verify_marks_clear (dw_die_ref die)
16510 gcc_assert (! die->die_mark);
16511 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
16513 #endif /* ENABLE_ASSERT_CHECKING */
16515 /* Clear the marks for a die and its children.
16516 Be cool if the mark isn't set. */
16519 prune_unmark_dies (dw_die_ref die)
16525 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
16528 /* Given DIE that we're marking as used, find any other dies
16529 it references as attributes and mark them as used. */
16532 prune_unused_types_walk_attribs (dw_die_ref die)
16537 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16539 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
16541 /* A reference to another DIE.
16542 Make sure that it will get emitted. */
16543 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
16545 /* Set the string's refcount to 0 so that prune_unused_types_mark
16546 accounts properly for it. */
16547 if (AT_class (a) == dw_val_class_str)
16548 a->dw_attr_val.v.val_str->refcount = 0;
16553 /* Mark DIE as being used. If DOKIDS is true, then walk down
16554 to DIE's children. */
16557 prune_unused_types_mark (dw_die_ref die, int dokids)
16561 if (die->die_mark == 0)
16563 /* We haven't done this node yet. Mark it as used. */
16566 /* We also have to mark its parents as used.
16567 (But we don't want to mark our parents' kids due to this.) */
16568 if (die->die_parent)
16569 prune_unused_types_mark (die->die_parent, 0);
16571 /* Mark any referenced nodes. */
16572 prune_unused_types_walk_attribs (die);
16574 /* If this node is a specification,
16575 also mark the definition, if it exists. */
16576 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
16577 prune_unused_types_mark (die->die_definition, 1);
16580 if (dokids && die->die_mark != 2)
16582 /* We need to walk the children, but haven't done so yet.
16583 Remember that we've walked the kids. */
16586 /* If this is an array type, we need to make sure our
16587 kids get marked, even if they're types. */
16588 if (die->die_tag == DW_TAG_array_type)
16589 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
16591 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16595 /* For local classes, look if any static member functions were emitted
16596 and if so, mark them. */
16599 prune_unused_types_walk_local_classes (dw_die_ref die)
16603 if (die->die_mark == 2)
16606 switch (die->die_tag)
16608 case DW_TAG_structure_type:
16609 case DW_TAG_union_type:
16610 case DW_TAG_class_type:
16613 case DW_TAG_subprogram:
16614 if (!get_AT_flag (die, DW_AT_declaration)
16615 || die->die_definition != NULL)
16616 prune_unused_types_mark (die, 1);
16623 /* Mark children. */
16624 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
16627 /* Walk the tree DIE and mark types that we actually use. */
16630 prune_unused_types_walk (dw_die_ref die)
16634 /* Don't do anything if this node is already marked and
16635 children have been marked as well. */
16636 if (die->die_mark == 2)
16639 switch (die->die_tag)
16641 case DW_TAG_structure_type:
16642 case DW_TAG_union_type:
16643 case DW_TAG_class_type:
16644 if (die->die_perennial_p)
16647 for (c = die->die_parent; c; c = c->die_parent)
16648 if (c->die_tag == DW_TAG_subprogram)
16651 /* Finding used static member functions inside of classes
16652 is needed just for local classes, because for other classes
16653 static member function DIEs with DW_AT_specification
16654 are emitted outside of the DW_TAG_*_type. If we ever change
16655 it, we'd need to call this even for non-local classes. */
16657 prune_unused_types_walk_local_classes (die);
16659 /* It's a type node --- don't mark it. */
16662 case DW_TAG_const_type:
16663 case DW_TAG_packed_type:
16664 case DW_TAG_pointer_type:
16665 case DW_TAG_reference_type:
16666 case DW_TAG_volatile_type:
16667 case DW_TAG_typedef:
16668 case DW_TAG_array_type:
16669 case DW_TAG_interface_type:
16670 case DW_TAG_friend:
16671 case DW_TAG_variant_part:
16672 case DW_TAG_enumeration_type:
16673 case DW_TAG_subroutine_type:
16674 case DW_TAG_string_type:
16675 case DW_TAG_set_type:
16676 case DW_TAG_subrange_type:
16677 case DW_TAG_ptr_to_member_type:
16678 case DW_TAG_file_type:
16679 if (die->die_perennial_p)
16682 /* It's a type node --- don't mark it. */
16686 /* Mark everything else. */
16690 if (die->die_mark == 0)
16694 /* Now, mark any dies referenced from here. */
16695 prune_unused_types_walk_attribs (die);
16700 /* Mark children. */
16701 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16704 /* Increment the string counts on strings referred to from DIE's
16708 prune_unused_types_update_strings (dw_die_ref die)
16713 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16714 if (AT_class (a) == dw_val_class_str)
16716 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
16718 /* Avoid unnecessarily putting strings that are used less than
16719 twice in the hash table. */
16721 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
16724 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
16725 htab_hash_string (s->str),
16727 gcc_assert (*slot == NULL);
16733 /* Remove from the tree DIE any dies that aren't marked. */
16736 prune_unused_types_prune (dw_die_ref die)
16740 gcc_assert (die->die_mark);
16741 prune_unused_types_update_strings (die);
16743 if (! die->die_child)
16746 c = die->die_child;
16748 dw_die_ref prev = c;
16749 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
16750 if (c == die->die_child)
16752 /* No marked children between 'prev' and the end of the list. */
16754 /* No marked children at all. */
16755 die->die_child = NULL;
16758 prev->die_sib = c->die_sib;
16759 die->die_child = prev;
16764 if (c != prev->die_sib)
16766 prune_unused_types_prune (c);
16767 } while (c != die->die_child);
16771 /* Remove dies representing declarations that we never use. */
16774 prune_unused_types (void)
16777 limbo_die_node *node;
16780 #if ENABLE_ASSERT_CHECKING
16781 /* All the marks should already be clear. */
16782 verify_marks_clear (comp_unit_die);
16783 for (node = limbo_die_list; node; node = node->next)
16784 verify_marks_clear (node->die);
16785 #endif /* ENABLE_ASSERT_CHECKING */
16787 /* Set the mark on nodes that are actually used. */
16788 prune_unused_types_walk (comp_unit_die);
16789 for (node = limbo_die_list; node; node = node->next)
16790 prune_unused_types_walk (node->die);
16792 /* Also set the mark on nodes referenced from the
16793 pubname_table or arange_table. */
16794 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
16795 prune_unused_types_mark (pub->die, 1);
16796 for (i = 0; i < arange_table_in_use; i++)
16797 prune_unused_types_mark (arange_table[i], 1);
16799 /* Get rid of nodes that aren't marked; and update the string counts. */
16800 if (debug_str_hash)
16801 htab_empty (debug_str_hash);
16802 prune_unused_types_prune (comp_unit_die);
16803 for (node = limbo_die_list; node; node = node->next)
16804 prune_unused_types_prune (node->die);
16806 /* Leave the marks clear. */
16807 prune_unmark_dies (comp_unit_die);
16808 for (node = limbo_die_list; node; node = node->next)
16809 prune_unmark_dies (node->die);
16812 /* Set the parameter to true if there are any relative pathnames in
16815 file_table_relative_p (void ** slot, void *param)
16817 bool *p = (bool *) param;
16818 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
16819 if (!IS_ABSOLUTE_PATH (d->filename))
16827 /* Output stuff that dwarf requires at the end of every file,
16828 and generate the DWARF-2 debugging info. */
16831 dwarf2out_finish (const char *filename)
16833 limbo_die_node *node, *next_node;
16834 dw_die_ref die = 0;
16837 /* Add the name for the main input file now. We delayed this from
16838 dwarf2out_init to avoid complications with PCH. */
16839 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
16840 if (!IS_ABSOLUTE_PATH (filename))
16841 add_comp_dir_attribute (comp_unit_die);
16842 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
16845 htab_traverse (file_table, file_table_relative_p, &p);
16847 add_comp_dir_attribute (comp_unit_die);
16850 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
16852 add_location_or_const_value_attribute (
16853 VEC_index (deferred_locations, deferred_locations_list, i)->die,
16854 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
16858 /* Traverse the limbo die list, and add parent/child links. The only
16859 dies without parents that should be here are concrete instances of
16860 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
16861 For concrete instances, we can get the parent die from the abstract
16863 for (node = limbo_die_list; node; node = next_node)
16865 next_node = node->next;
16868 if (die->die_parent == NULL)
16870 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
16873 add_child_die (origin->die_parent, die);
16874 else if (die == comp_unit_die)
16876 else if (errorcount > 0 || sorrycount > 0)
16877 /* It's OK to be confused by errors in the input. */
16878 add_child_die (comp_unit_die, die);
16881 /* In certain situations, the lexical block containing a
16882 nested function can be optimized away, which results
16883 in the nested function die being orphaned. Likewise
16884 with the return type of that nested function. Force
16885 this to be a child of the containing function.
16887 It may happen that even the containing function got fully
16888 inlined and optimized out. In that case we are lost and
16889 assign the empty child. This should not be big issue as
16890 the function is likely unreachable too. */
16891 tree context = NULL_TREE;
16893 gcc_assert (node->created_for);
16895 if (DECL_P (node->created_for))
16896 context = DECL_CONTEXT (node->created_for);
16897 else if (TYPE_P (node->created_for))
16898 context = TYPE_CONTEXT (node->created_for);
16900 gcc_assert (context
16901 && (TREE_CODE (context) == FUNCTION_DECL
16902 || TREE_CODE (context) == NAMESPACE_DECL));
16904 origin = lookup_decl_die (context);
16906 add_child_die (origin, die);
16908 add_child_die (comp_unit_die, die);
16913 limbo_die_list = NULL;
16915 /* Walk through the list of incomplete types again, trying once more to
16916 emit full debugging info for them. */
16917 retry_incomplete_types ();
16919 if (flag_eliminate_unused_debug_types)
16920 prune_unused_types ();
16922 /* Generate separate CUs for each of the include files we've seen.
16923 They will go into limbo_die_list. */
16924 if (flag_eliminate_dwarf2_dups)
16925 break_out_includes (comp_unit_die);
16927 /* Traverse the DIE's and add add sibling attributes to those DIE's
16928 that have children. */
16929 add_sibling_attributes (comp_unit_die);
16930 for (node = limbo_die_list; node; node = node->next)
16931 add_sibling_attributes (node->die);
16933 /* Output a terminator label for the .text section. */
16934 switch_to_section (text_section);
16935 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
16936 if (flag_reorder_blocks_and_partition)
16938 switch_to_section (unlikely_text_section ());
16939 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
16942 /* We can only use the low/high_pc attributes if all of the code was
16944 if (!have_multiple_function_sections)
16946 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
16947 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
16952 unsigned fde_idx = 0;
16954 /* We need to give .debug_loc and .debug_ranges an appropriate
16955 "base address". Use zero so that these addresses become
16956 absolute. Historically, we've emitted the unexpected
16957 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
16958 Emit both to give time for other tools to adapt. */
16959 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
16960 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
16962 add_AT_range_list (comp_unit_die, DW_AT_ranges,
16963 add_ranges_by_labels (text_section_label,
16965 if (flag_reorder_blocks_and_partition)
16966 add_ranges_by_labels (cold_text_section_label,
16969 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
16971 dw_fde_ref fde = &fde_table[fde_idx];
16973 if (fde->dw_fde_switched_sections)
16975 add_ranges_by_labels (fde->dw_fde_hot_section_label,
16976 fde->dw_fde_hot_section_end_label);
16977 add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
16978 fde->dw_fde_unlikely_section_end_label);
16981 add_ranges_by_labels (fde->dw_fde_begin,
16988 /* Output location list section if necessary. */
16989 if (have_location_lists)
16991 /* Output the location lists info. */
16992 switch_to_section (debug_loc_section);
16993 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
16994 DEBUG_LOC_SECTION_LABEL, 0);
16995 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
16996 output_location_lists (die);
16999 if (debug_info_level >= DINFO_LEVEL_NORMAL)
17000 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
17001 debug_line_section_label);
17003 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
17004 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
17006 /* Output all of the compilation units. We put the main one last so that
17007 the offsets are available to output_pubnames. */
17008 for (node = limbo_die_list; node; node = node->next)
17009 output_comp_unit (node->die, 0);
17011 /* Output the main compilation unit if non-empty or if .debug_macinfo
17012 has been emitted. */
17013 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
17015 /* Output the abbreviation table. */
17016 switch_to_section (debug_abbrev_section);
17017 output_abbrev_section ();
17019 /* Output public names table if necessary. */
17020 if (!VEC_empty (pubname_entry, pubname_table))
17022 switch_to_section (debug_pubnames_section);
17023 output_pubnames (pubname_table);
17026 #ifdef DEBUG_PUBTYPES_SECTION
17027 /* Output public types table if necessary. */
17028 if (!VEC_empty (pubname_entry, pubtype_table))
17030 switch_to_section (debug_pubtypes_section);
17031 output_pubnames (pubtype_table);
17035 /* Output the address range information. We only put functions in the arange
17036 table, so don't write it out if we don't have any. */
17037 if (fde_table_in_use)
17039 switch_to_section (debug_aranges_section);
17043 /* Output ranges section if necessary. */
17044 if (ranges_table_in_use)
17046 switch_to_section (debug_ranges_section);
17047 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
17051 /* Output the source line correspondence table. We must do this
17052 even if there is no line information. Otherwise, on an empty
17053 translation unit, we will generate a present, but empty,
17054 .debug_info section. IRIX 6.5 `nm' will then complain when
17055 examining the file. This is done late so that any filenames
17056 used by the debug_info section are marked as 'used'. */
17057 if (! DWARF2_ASM_LINE_DEBUG_INFO)
17059 switch_to_section (debug_line_section);
17060 output_line_info ();
17063 /* Have to end the macro section. */
17064 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
17066 switch_to_section (debug_macinfo_section);
17067 dw2_asm_output_data (1, 0, "End compilation unit");
17070 /* If we emitted any DW_FORM_strp form attribute, output the string
17072 if (debug_str_hash)
17073 htab_traverse (debug_str_hash, output_indirect_string, NULL);
17077 /* This should never be used, but its address is needed for comparisons. */
17078 const struct gcc_debug_hooks dwarf2_debug_hooks;
17080 #endif /* DWARF2_DEBUGGING_INFO */
17082 #include "gt-dwarf2out.h"