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 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 2, 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 COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
25 /* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
31 /* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
39 #include "coretypes.h"
46 #include "hard-reg-set.h"
48 #include "insn-config.h"
56 #include "dwarf2out.h"
57 #include "dwarf2asm.h"
63 #include "diagnostic.h"
66 #include "langhooks.h"
71 #ifdef DWARF2_DEBUGGING_INFO
72 static void dwarf2out_source_line (unsigned int, const char *);
75 /* DWARF2 Abbreviation Glossary:
76 CFA = Canonical Frame Address
77 a fixed address on the stack which identifies a call frame.
78 We define it to be the value of SP just before the call insn.
79 The CFA register and offset, which may change during the course
80 of the function, are used to calculate its value at runtime.
81 CFI = Call Frame Instruction
82 an instruction for the DWARF2 abstract machine
83 CIE = Common Information Entry
84 information describing information common to one or more FDEs
85 DIE = Debugging Information Entry
86 FDE = Frame Description Entry
87 information describing the stack call frame, in particular,
88 how to restore registers
90 DW_CFA_... = DWARF2 CFA call frame instruction
91 DW_TAG_... = DWARF2 DIE tag */
93 #ifndef DWARF2_FRAME_INFO
94 # ifdef DWARF2_DEBUGGING_INFO
95 # define DWARF2_FRAME_INFO \
96 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
98 # define DWARF2_FRAME_INFO 0
102 /* Map register numbers held in the call frame info that gcc has
103 collected using DWARF_FRAME_REGNUM to those that should be output in
104 .debug_frame and .eh_frame. */
105 #ifndef DWARF2_FRAME_REG_OUT
106 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
109 /* Decide whether we want to emit frame unwind information for the current
113 dwarf2out_do_frame (void)
115 /* We want to emit correct CFA location expressions or lists, so we
116 have to return true if we're going to output debug info, even if
117 we're not going to output frame or unwind info. */
118 return (write_symbols == DWARF2_DEBUG
119 || write_symbols == VMS_AND_DWARF2_DEBUG
121 #ifdef DWARF2_UNWIND_INFO
122 || (DWARF2_UNWIND_INFO
123 && (flag_unwind_tables
124 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
129 /* The size of the target's pointer type. */
131 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
134 /* Array of RTXes referenced by the debugging information, which therefore
135 must be kept around forever. */
136 static GTY(()) VEC(rtx,gc) *used_rtx_array;
138 /* A pointer to the base of a list of incomplete types which might be
139 completed at some later time. incomplete_types_list needs to be a
140 VEC(tree,gc) because we want to tell the garbage collector about
142 static GTY(()) VEC(tree,gc) *incomplete_types;
144 /* A pointer to the base of a table of references to declaration
145 scopes. This table is a display which tracks the nesting
146 of declaration scopes at the current scope and containing
147 scopes. This table is used to find the proper place to
148 define type declaration DIE's. */
149 static GTY(()) VEC(tree,gc) *decl_scope_table;
151 /* Pointers to various DWARF2 sections. */
152 static GTY(()) section *debug_info_section;
153 static GTY(()) section *debug_abbrev_section;
154 static GTY(()) section *debug_aranges_section;
155 static GTY(()) section *debug_macinfo_section;
156 static GTY(()) section *debug_line_section;
157 static GTY(()) section *debug_loc_section;
158 static GTY(()) section *debug_pubnames_section;
159 static GTY(()) section *debug_pubtypes_section;
160 static GTY(()) section *debug_str_section;
161 static GTY(()) section *debug_ranges_section;
162 static GTY(()) section *debug_frame_section;
164 /* How to start an assembler comment. */
165 #ifndef ASM_COMMENT_START
166 #define ASM_COMMENT_START ";#"
169 typedef struct dw_cfi_struct *dw_cfi_ref;
170 typedef struct dw_fde_struct *dw_fde_ref;
171 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
173 /* Call frames are described using a sequence of Call Frame
174 Information instructions. The register number, offset
175 and address fields are provided as possible operands;
176 their use is selected by the opcode field. */
178 enum dw_cfi_oprnd_type {
180 dw_cfi_oprnd_reg_num,
186 typedef union dw_cfi_oprnd_struct GTY(())
188 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
189 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
190 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
191 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
195 typedef struct dw_cfi_struct GTY(())
197 dw_cfi_ref dw_cfi_next;
198 enum dwarf_call_frame_info dw_cfi_opc;
199 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
201 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
206 /* This is how we define the location of the CFA. We use to handle it
207 as REG + OFFSET all the time, but now it can be more complex.
208 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
209 Instead of passing around REG and OFFSET, we pass a copy
210 of this structure. */
211 typedef struct cfa_loc GTY(())
213 HOST_WIDE_INT offset;
214 HOST_WIDE_INT base_offset;
216 int indirect; /* 1 if CFA is accessed via a dereference. */
219 /* All call frame descriptions (FDE's) in the GCC generated DWARF
220 refer to a single Common Information Entry (CIE), defined at
221 the beginning of the .debug_frame section. This use of a single
222 CIE obviates the need to keep track of multiple CIE's
223 in the DWARF generation routines below. */
225 typedef struct dw_fde_struct GTY(())
228 const char *dw_fde_begin;
229 const char *dw_fde_current_label;
230 const char *dw_fde_end;
231 const char *dw_fde_hot_section_label;
232 const char *dw_fde_hot_section_end_label;
233 const char *dw_fde_unlikely_section_label;
234 const char *dw_fde_unlikely_section_end_label;
235 bool dw_fde_switched_sections;
236 dw_cfi_ref dw_fde_cfi;
237 unsigned funcdef_number;
238 unsigned all_throwers_are_sibcalls : 1;
239 unsigned nothrow : 1;
240 unsigned uses_eh_lsda : 1;
244 /* Maximum size (in bytes) of an artificially generated label. */
245 #define MAX_ARTIFICIAL_LABEL_BYTES 30
247 /* The size of addresses as they appear in the Dwarf 2 data.
248 Some architectures use word addresses to refer to code locations,
249 but Dwarf 2 info always uses byte addresses. On such machines,
250 Dwarf 2 addresses need to be larger than the architecture's
252 #ifndef DWARF2_ADDR_SIZE
253 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
256 /* The size in bytes of a DWARF field indicating an offset or length
257 relative to a debug info section, specified to be 4 bytes in the
258 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
261 #ifndef DWARF_OFFSET_SIZE
262 #define DWARF_OFFSET_SIZE 4
265 /* According to the (draft) DWARF 3 specification, the initial length
266 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
267 bytes are 0xffffffff, followed by the length stored in the next 8
270 However, the SGI/MIPS ABI uses an initial length which is equal to
271 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
273 #ifndef DWARF_INITIAL_LENGTH_SIZE
274 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
277 #define DWARF_VERSION 2
279 /* Round SIZE up to the nearest BOUNDARY. */
280 #define DWARF_ROUND(SIZE,BOUNDARY) \
281 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
283 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
284 #ifndef DWARF_CIE_DATA_ALIGNMENT
285 #ifdef STACK_GROWS_DOWNWARD
286 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
288 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
292 /* CIE identifier. */
293 #if HOST_BITS_PER_WIDE_INT >= 64
294 #define DWARF_CIE_ID \
295 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
297 #define DWARF_CIE_ID DW_CIE_ID
300 /* A pointer to the base of a table that contains frame description
301 information for each routine. */
302 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
304 /* Number of elements currently allocated for fde_table. */
305 static GTY(()) unsigned fde_table_allocated;
307 /* Number of elements in fde_table currently in use. */
308 static GTY(()) unsigned fde_table_in_use;
310 /* Size (in elements) of increments by which we may expand the
312 #define FDE_TABLE_INCREMENT 256
314 /* A list of call frame insns for the CIE. */
315 static GTY(()) dw_cfi_ref cie_cfi_head;
317 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
318 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
319 attribute that accelerates the lookup of the FDE associated
320 with the subprogram. This variable holds the table index of the FDE
321 associated with the current function (body) definition. */
322 static unsigned current_funcdef_fde;
325 struct indirect_string_node GTY(())
328 unsigned int refcount;
333 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
335 static GTY(()) int dw2_string_counter;
336 static GTY(()) unsigned long dwarf2out_cfi_label_num;
338 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
340 /* Forward declarations for functions defined in this file. */
342 static char *stripattributes (const char *);
343 static const char *dwarf_cfi_name (unsigned);
344 static dw_cfi_ref new_cfi (void);
345 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
346 static void add_fde_cfi (const char *, dw_cfi_ref);
347 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
348 static void lookup_cfa (dw_cfa_location *);
349 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
350 static void initial_return_save (rtx);
351 static HOST_WIDE_INT stack_adjust_offset (rtx);
352 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
353 static void output_call_frame_info (int);
354 static void dwarf2out_stack_adjust (rtx, bool);
355 static void flush_queued_reg_saves (void);
356 static bool clobbers_queued_reg_save (rtx);
357 static void dwarf2out_frame_debug_expr (rtx, const char *);
359 /* Support for complex CFA locations. */
360 static void output_cfa_loc (dw_cfi_ref);
361 static void get_cfa_from_loc_descr (dw_cfa_location *,
362 struct dw_loc_descr_struct *);
363 static struct dw_loc_descr_struct *build_cfa_loc
364 (dw_cfa_location *, HOST_WIDE_INT);
365 static void def_cfa_1 (const char *, dw_cfa_location *);
367 /* How to start an assembler comment. */
368 #ifndef ASM_COMMENT_START
369 #define ASM_COMMENT_START ";#"
372 /* Data and reference forms for relocatable data. */
373 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
374 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
376 #ifndef DEBUG_FRAME_SECTION
377 #define DEBUG_FRAME_SECTION ".debug_frame"
380 #ifndef FUNC_BEGIN_LABEL
381 #define FUNC_BEGIN_LABEL "LFB"
384 #ifndef FUNC_END_LABEL
385 #define FUNC_END_LABEL "LFE"
388 #ifndef FRAME_BEGIN_LABEL
389 #define FRAME_BEGIN_LABEL "Lframe"
391 #define CIE_AFTER_SIZE_LABEL "LSCIE"
392 #define CIE_END_LABEL "LECIE"
393 #define FDE_LABEL "LSFDE"
394 #define FDE_AFTER_SIZE_LABEL "LASFDE"
395 #define FDE_END_LABEL "LEFDE"
396 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
397 #define LINE_NUMBER_END_LABEL "LELT"
398 #define LN_PROLOG_AS_LABEL "LASLTP"
399 #define LN_PROLOG_END_LABEL "LELTP"
400 #define DIE_LABEL_PREFIX "DW"
402 /* The DWARF 2 CFA column which tracks the return address. Normally this
403 is the column for PC, or the first column after all of the hard
405 #ifndef DWARF_FRAME_RETURN_COLUMN
407 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
409 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
413 /* The mapping from gcc register number to DWARF 2 CFA column number. By
414 default, we just provide columns for all registers. */
415 #ifndef DWARF_FRAME_REGNUM
416 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
419 /* Hook used by __throw. */
422 expand_builtin_dwarf_sp_column (void)
424 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
425 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
428 /* Return a pointer to a copy of the section string name S with all
429 attributes stripped off, and an asterisk prepended (for assemble_name). */
432 stripattributes (const char *s)
434 char *stripped = XNEWVEC (char, strlen (s) + 2);
439 while (*s && *s != ',')
446 /* Generate code to initialize the register size table. */
449 expand_builtin_init_dwarf_reg_sizes (tree address)
452 enum machine_mode mode = TYPE_MODE (char_type_node);
453 rtx addr = expand_normal (address);
454 rtx mem = gen_rtx_MEM (BLKmode, addr);
455 bool wrote_return_column = false;
457 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
459 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
461 if (rnum < DWARF_FRAME_REGISTERS)
463 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
464 enum machine_mode save_mode = reg_raw_mode[i];
467 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
468 save_mode = choose_hard_reg_mode (i, 1, true);
469 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
471 if (save_mode == VOIDmode)
473 wrote_return_column = true;
475 size = GET_MODE_SIZE (save_mode);
479 emit_move_insn (adjust_address (mem, mode, offset),
480 gen_int_mode (size, mode));
484 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
485 gcc_assert (wrote_return_column);
486 i = DWARF_ALT_FRAME_RETURN_COLUMN;
487 wrote_return_column = false;
489 i = DWARF_FRAME_RETURN_COLUMN;
492 if (! wrote_return_column)
494 enum machine_mode save_mode = Pmode;
495 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
496 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
497 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
501 /* Convert a DWARF call frame info. operation to its string name */
504 dwarf_cfi_name (unsigned int cfi_opc)
508 case DW_CFA_advance_loc:
509 return "DW_CFA_advance_loc";
511 return "DW_CFA_offset";
513 return "DW_CFA_restore";
517 return "DW_CFA_set_loc";
518 case DW_CFA_advance_loc1:
519 return "DW_CFA_advance_loc1";
520 case DW_CFA_advance_loc2:
521 return "DW_CFA_advance_loc2";
522 case DW_CFA_advance_loc4:
523 return "DW_CFA_advance_loc4";
524 case DW_CFA_offset_extended:
525 return "DW_CFA_offset_extended";
526 case DW_CFA_restore_extended:
527 return "DW_CFA_restore_extended";
528 case DW_CFA_undefined:
529 return "DW_CFA_undefined";
530 case DW_CFA_same_value:
531 return "DW_CFA_same_value";
532 case DW_CFA_register:
533 return "DW_CFA_register";
534 case DW_CFA_remember_state:
535 return "DW_CFA_remember_state";
536 case DW_CFA_restore_state:
537 return "DW_CFA_restore_state";
539 return "DW_CFA_def_cfa";
540 case DW_CFA_def_cfa_register:
541 return "DW_CFA_def_cfa_register";
542 case DW_CFA_def_cfa_offset:
543 return "DW_CFA_def_cfa_offset";
546 case DW_CFA_def_cfa_expression:
547 return "DW_CFA_def_cfa_expression";
548 case DW_CFA_expression:
549 return "DW_CFA_expression";
550 case DW_CFA_offset_extended_sf:
551 return "DW_CFA_offset_extended_sf";
552 case DW_CFA_def_cfa_sf:
553 return "DW_CFA_def_cfa_sf";
554 case DW_CFA_def_cfa_offset_sf:
555 return "DW_CFA_def_cfa_offset_sf";
557 /* SGI/MIPS specific */
558 case DW_CFA_MIPS_advance_loc8:
559 return "DW_CFA_MIPS_advance_loc8";
562 case DW_CFA_GNU_window_save:
563 return "DW_CFA_GNU_window_save";
564 case DW_CFA_GNU_args_size:
565 return "DW_CFA_GNU_args_size";
566 case DW_CFA_GNU_negative_offset_extended:
567 return "DW_CFA_GNU_negative_offset_extended";
570 return "DW_CFA_<unknown>";
574 /* Return a pointer to a newly allocated Call Frame Instruction. */
576 static inline dw_cfi_ref
579 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
581 cfi->dw_cfi_next = NULL;
582 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
583 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
588 /* Add a Call Frame Instruction to list of instructions. */
591 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
595 /* Find the end of the chain. */
596 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
602 /* Generate a new label for the CFI info to refer to. */
605 dwarf2out_cfi_label (void)
607 static char label[20];
609 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
610 ASM_OUTPUT_LABEL (asm_out_file, label);
614 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
615 or to the CIE if LABEL is NULL. */
618 add_fde_cfi (const char *label, dw_cfi_ref cfi)
622 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
625 label = dwarf2out_cfi_label ();
627 if (fde->dw_fde_current_label == NULL
628 || strcmp (label, fde->dw_fde_current_label) != 0)
632 label = xstrdup (label);
634 /* Set the location counter to the new label. */
636 /* If we have a current label, advance from there, otherwise
637 set the location directly using set_loc. */
638 xcfi->dw_cfi_opc = fde->dw_fde_current_label
639 ? DW_CFA_advance_loc4
641 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
642 add_cfi (&fde->dw_fde_cfi, xcfi);
644 fde->dw_fde_current_label = label;
647 add_cfi (&fde->dw_fde_cfi, cfi);
651 add_cfi (&cie_cfi_head, cfi);
654 /* Subroutine of lookup_cfa. */
657 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
659 switch (cfi->dw_cfi_opc)
661 case DW_CFA_def_cfa_offset:
662 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
664 case DW_CFA_def_cfa_offset_sf:
666 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
668 case DW_CFA_def_cfa_register:
669 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
672 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
673 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
675 case DW_CFA_def_cfa_sf:
676 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
678 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
680 case DW_CFA_def_cfa_expression:
681 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
688 /* Find the previous value for the CFA. */
691 lookup_cfa (dw_cfa_location *loc)
695 loc->reg = INVALID_REGNUM;
698 loc->base_offset = 0;
700 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
701 lookup_cfa_1 (cfi, loc);
703 if (fde_table_in_use)
705 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
706 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
707 lookup_cfa_1 (cfi, loc);
711 /* The current rule for calculating the DWARF2 canonical frame address. */
712 static dw_cfa_location cfa;
714 /* The register used for saving registers to the stack, and its offset
716 static dw_cfa_location cfa_store;
718 /* The running total of the size of arguments pushed onto the stack. */
719 static HOST_WIDE_INT args_size;
721 /* The last args_size we actually output. */
722 static HOST_WIDE_INT old_args_size;
724 /* Entry point to update the canonical frame address (CFA).
725 LABEL is passed to add_fde_cfi. The value of CFA is now to be
726 calculated from REG+OFFSET. */
729 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
736 def_cfa_1 (label, &loc);
739 /* Determine if two dw_cfa_location structures define the same data. */
742 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
744 return (loc1->reg == loc2->reg
745 && loc1->offset == loc2->offset
746 && loc1->indirect == loc2->indirect
747 && (loc1->indirect == 0
748 || loc1->base_offset == loc2->base_offset));
751 /* This routine does the actual work. The CFA is now calculated from
752 the dw_cfa_location structure. */
755 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
758 dw_cfa_location old_cfa, loc;
763 if (cfa_store.reg == loc.reg && loc.indirect == 0)
764 cfa_store.offset = loc.offset;
766 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
767 lookup_cfa (&old_cfa);
769 /* If nothing changed, no need to issue any call frame instructions. */
770 if (cfa_equal_p (&loc, &old_cfa))
775 if (loc.reg == old_cfa.reg && !loc.indirect)
777 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
778 the CFA register did not change but the offset did. */
781 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
782 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
784 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
785 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
789 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
790 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
794 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
795 else if (loc.offset == old_cfa.offset
796 && old_cfa.reg != INVALID_REGNUM
799 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
800 indicating the CFA register has changed to <register> but the
801 offset has not changed. */
802 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
803 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
807 else if (loc.indirect == 0)
809 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
810 indicating the CFA register has changed to <register> with
811 the specified offset. */
814 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
815 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
817 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
818 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
819 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
823 cfi->dw_cfi_opc = DW_CFA_def_cfa;
824 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
825 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
830 /* Construct a DW_CFA_def_cfa_expression instruction to
831 calculate the CFA using a full location expression since no
832 register-offset pair is available. */
833 struct dw_loc_descr_struct *loc_list;
835 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
836 loc_list = build_cfa_loc (&loc, 0);
837 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
840 add_fde_cfi (label, cfi);
843 /* Add the CFI for saving a register. REG is the CFA column number.
844 LABEL is passed to add_fde_cfi.
845 If SREG is -1, the register is saved at OFFSET from the CFA;
846 otherwise it is saved in SREG. */
849 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
851 dw_cfi_ref cfi = new_cfi ();
853 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
855 if (sreg == INVALID_REGNUM)
858 /* The register number won't fit in 6 bits, so we have to use
860 cfi->dw_cfi_opc = DW_CFA_offset_extended;
862 cfi->dw_cfi_opc = DW_CFA_offset;
864 #ifdef ENABLE_CHECKING
866 /* If we get an offset that is not a multiple of
867 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
868 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
870 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
872 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
875 offset /= DWARF_CIE_DATA_ALIGNMENT;
877 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
879 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
881 else if (sreg == reg)
882 cfi->dw_cfi_opc = DW_CFA_same_value;
885 cfi->dw_cfi_opc = DW_CFA_register;
886 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
889 add_fde_cfi (label, cfi);
892 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
893 This CFI tells the unwinder that it needs to restore the window registers
894 from the previous frame's window save area.
896 ??? Perhaps we should note in the CIE where windows are saved (instead of
897 assuming 0(cfa)) and what registers are in the window. */
900 dwarf2out_window_save (const char *label)
902 dw_cfi_ref cfi = new_cfi ();
904 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
905 add_fde_cfi (label, cfi);
908 /* Add a CFI to update the running total of the size of arguments
909 pushed onto the stack. */
912 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
916 if (size == old_args_size)
919 old_args_size = size;
922 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
923 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
924 add_fde_cfi (label, cfi);
927 /* Entry point for saving a register to the stack. REG is the GCC register
928 number. LABEL and OFFSET are passed to reg_save. */
931 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
933 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
936 /* Entry point for saving the return address in the stack.
937 LABEL and OFFSET are passed to reg_save. */
940 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
942 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
945 /* Entry point for saving the return address in a register.
946 LABEL and SREG are passed to reg_save. */
949 dwarf2out_return_reg (const char *label, unsigned int sreg)
951 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
954 /* Record the initial position of the return address. RTL is
955 INCOMING_RETURN_ADDR_RTX. */
958 initial_return_save (rtx rtl)
960 unsigned int reg = INVALID_REGNUM;
961 HOST_WIDE_INT offset = 0;
963 switch (GET_CODE (rtl))
966 /* RA is in a register. */
967 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
971 /* RA is on the stack. */
973 switch (GET_CODE (rtl))
976 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
981 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
982 offset = INTVAL (XEXP (rtl, 1));
986 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
987 offset = -INTVAL (XEXP (rtl, 1));
997 /* The return address is at some offset from any value we can
998 actually load. For instance, on the SPARC it is in %i7+8. Just
999 ignore the offset for now; it doesn't matter for unwinding frames. */
1000 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1001 initial_return_save (XEXP (rtl, 0));
1008 if (reg != DWARF_FRAME_RETURN_COLUMN)
1009 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1012 /* Given a SET, calculate the amount of stack adjustment it
1015 static HOST_WIDE_INT
1016 stack_adjust_offset (rtx pattern)
1018 rtx src = SET_SRC (pattern);
1019 rtx dest = SET_DEST (pattern);
1020 HOST_WIDE_INT offset = 0;
1023 if (dest == stack_pointer_rtx)
1025 /* (set (reg sp) (plus (reg sp) (const_int))) */
1026 code = GET_CODE (src);
1027 if (! (code == PLUS || code == MINUS)
1028 || XEXP (src, 0) != stack_pointer_rtx
1029 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1032 offset = INTVAL (XEXP (src, 1));
1036 else if (MEM_P (dest))
1038 /* (set (mem (pre_dec (reg sp))) (foo)) */
1039 src = XEXP (dest, 0);
1040 code = GET_CODE (src);
1046 if (XEXP (src, 0) == stack_pointer_rtx)
1048 rtx val = XEXP (XEXP (src, 1), 1);
1049 /* We handle only adjustments by constant amount. */
1050 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1051 && GET_CODE (val) == CONST_INT);
1052 offset = -INTVAL (val);
1059 if (XEXP (src, 0) == stack_pointer_rtx)
1061 offset = GET_MODE_SIZE (GET_MODE (dest));
1068 if (XEXP (src, 0) == stack_pointer_rtx)
1070 offset = -GET_MODE_SIZE (GET_MODE (dest));
1085 /* Check INSN to see if it looks like a push or a stack adjustment, and
1086 make a note of it if it does. EH uses this information to find out how
1087 much extra space it needs to pop off the stack. */
1090 dwarf2out_stack_adjust (rtx insn, bool after_p)
1092 HOST_WIDE_INT offset;
1096 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1097 with this function. Proper support would require all frame-related
1098 insns to be marked, and to be able to handle saving state around
1099 epilogues textually in the middle of the function. */
1100 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1103 /* If only calls can throw, and we have a frame pointer,
1104 save up adjustments until we see the CALL_INSN. */
1105 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1107 if (CALL_P (insn) && !after_p)
1109 /* Extract the size of the args from the CALL rtx itself. */
1110 insn = PATTERN (insn);
1111 if (GET_CODE (insn) == PARALLEL)
1112 insn = XVECEXP (insn, 0, 0);
1113 if (GET_CODE (insn) == SET)
1114 insn = SET_SRC (insn);
1115 gcc_assert (GET_CODE (insn) == CALL);
1116 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1121 if (CALL_P (insn) && !after_p)
1123 if (!flag_asynchronous_unwind_tables)
1124 dwarf2out_args_size ("", args_size);
1127 else if (BARRIER_P (insn))
1129 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1130 the compiler will have already emitted a stack adjustment, but
1131 doesn't bother for calls to noreturn functions. */
1132 #ifdef STACK_GROWS_DOWNWARD
1133 offset = -args_size;
1138 else if (GET_CODE (PATTERN (insn)) == SET)
1139 offset = stack_adjust_offset (PATTERN (insn));
1140 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1141 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1143 /* There may be stack adjustments inside compound insns. Search
1145 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1146 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1147 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1155 if (cfa.reg == STACK_POINTER_REGNUM)
1156 cfa.offset += offset;
1158 #ifndef STACK_GROWS_DOWNWARD
1162 args_size += offset;
1166 label = dwarf2out_cfi_label ();
1167 def_cfa_1 (label, &cfa);
1168 if (flag_asynchronous_unwind_tables)
1169 dwarf2out_args_size (label, args_size);
1174 /* We delay emitting a register save until either (a) we reach the end
1175 of the prologue or (b) the register is clobbered. This clusters
1176 register saves so that there are fewer pc advances. */
1178 struct queued_reg_save GTY(())
1180 struct queued_reg_save *next;
1182 HOST_WIDE_INT cfa_offset;
1186 static GTY(()) struct queued_reg_save *queued_reg_saves;
1188 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1189 struct reg_saved_in_data GTY(()) {
1194 /* A list of registers saved in other registers.
1195 The list intentionally has a small maximum capacity of 4; if your
1196 port needs more than that, you might consider implementing a
1197 more efficient data structure. */
1198 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1199 static GTY(()) size_t num_regs_saved_in_regs;
1201 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1202 static const char *last_reg_save_label;
1204 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1205 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1208 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1210 struct queued_reg_save *q;
1212 /* Duplicates waste space, but it's also necessary to remove them
1213 for correctness, since the queue gets output in reverse
1215 for (q = queued_reg_saves; q != NULL; q = q->next)
1216 if (REGNO (q->reg) == REGNO (reg))
1221 q = ggc_alloc (sizeof (*q));
1222 q->next = queued_reg_saves;
1223 queued_reg_saves = q;
1227 q->cfa_offset = offset;
1228 q->saved_reg = sreg;
1230 last_reg_save_label = label;
1233 /* Output all the entries in QUEUED_REG_SAVES. */
1236 flush_queued_reg_saves (void)
1238 struct queued_reg_save *q;
1240 for (q = queued_reg_saves; q; q = q->next)
1243 unsigned int reg, sreg;
1245 for (i = 0; i < num_regs_saved_in_regs; i++)
1246 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1248 if (q->saved_reg && i == num_regs_saved_in_regs)
1250 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1251 num_regs_saved_in_regs++;
1253 if (i != num_regs_saved_in_regs)
1255 regs_saved_in_regs[i].orig_reg = q->reg;
1256 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1259 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1261 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1263 sreg = INVALID_REGNUM;
1264 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1267 queued_reg_saves = NULL;
1268 last_reg_save_label = NULL;
1271 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1272 location for? Or, does it clobber a register which we've previously
1273 said that some other register is saved in, and for which we now
1274 have a new location for? */
1277 clobbers_queued_reg_save (rtx insn)
1279 struct queued_reg_save *q;
1281 for (q = queued_reg_saves; q; q = q->next)
1284 if (modified_in_p (q->reg, insn))
1286 for (i = 0; i < num_regs_saved_in_regs; i++)
1287 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1288 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1295 /* Entry point for saving the first register into the second. */
1298 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1301 unsigned int regno, sregno;
1303 for (i = 0; i < num_regs_saved_in_regs; i++)
1304 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1306 if (i == num_regs_saved_in_regs)
1308 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1309 num_regs_saved_in_regs++;
1311 regs_saved_in_regs[i].orig_reg = reg;
1312 regs_saved_in_regs[i].saved_in_reg = sreg;
1314 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1315 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1316 reg_save (label, regno, sregno, 0);
1319 /* What register, if any, is currently saved in REG? */
1322 reg_saved_in (rtx reg)
1324 unsigned int regn = REGNO (reg);
1326 struct queued_reg_save *q;
1328 for (q = queued_reg_saves; q; q = q->next)
1329 if (q->saved_reg && regn == REGNO (q->saved_reg))
1332 for (i = 0; i < num_regs_saved_in_regs; i++)
1333 if (regs_saved_in_regs[i].saved_in_reg
1334 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1335 return regs_saved_in_regs[i].orig_reg;
1341 /* A temporary register holding an integral value used in adjusting SP
1342 or setting up the store_reg. The "offset" field holds the integer
1343 value, not an offset. */
1344 static dw_cfa_location cfa_temp;
1346 /* Record call frame debugging information for an expression EXPR,
1347 which either sets SP or FP (adjusting how we calculate the frame
1348 address) or saves a register to the stack or another register.
1349 LABEL indicates the address of EXPR.
1351 This function encodes a state machine mapping rtxes to actions on
1352 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1353 users need not read the source code.
1355 The High-Level Picture
1357 Changes in the register we use to calculate the CFA: Currently we
1358 assume that if you copy the CFA register into another register, we
1359 should take the other one as the new CFA register; this seems to
1360 work pretty well. If it's wrong for some target, it's simple
1361 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1363 Changes in the register we use for saving registers to the stack:
1364 This is usually SP, but not always. Again, we deduce that if you
1365 copy SP into another register (and SP is not the CFA register),
1366 then the new register is the one we will be using for register
1367 saves. This also seems to work.
1369 Register saves: There's not much guesswork about this one; if
1370 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1371 register save, and the register used to calculate the destination
1372 had better be the one we think we're using for this purpose.
1373 It's also assumed that a copy from a call-saved register to another
1374 register is saving that register if RTX_FRAME_RELATED_P is set on
1375 that instruction. If the copy is from a call-saved register to
1376 the *same* register, that means that the register is now the same
1377 value as in the caller.
1379 Except: If the register being saved is the CFA register, and the
1380 offset is nonzero, we are saving the CFA, so we assume we have to
1381 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1382 the intent is to save the value of SP from the previous frame.
1384 In addition, if a register has previously been saved to a different
1387 Invariants / Summaries of Rules
1389 cfa current rule for calculating the CFA. It usually
1390 consists of a register and an offset.
1391 cfa_store register used by prologue code to save things to the stack
1392 cfa_store.offset is the offset from the value of
1393 cfa_store.reg to the actual CFA
1394 cfa_temp register holding an integral value. cfa_temp.offset
1395 stores the value, which will be used to adjust the
1396 stack pointer. cfa_temp is also used like cfa_store,
1397 to track stores to the stack via fp or a temp reg.
1399 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1400 with cfa.reg as the first operand changes the cfa.reg and its
1401 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1404 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1405 expression yielding a constant. This sets cfa_temp.reg
1406 and cfa_temp.offset.
1408 Rule 5: Create a new register cfa_store used to save items to the
1411 Rules 10-14: Save a register to the stack. Define offset as the
1412 difference of the original location and cfa_store's
1413 location (or cfa_temp's location if cfa_temp is used).
1417 "{a,b}" indicates a choice of a xor b.
1418 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1421 (set <reg1> <reg2>:cfa.reg)
1422 effects: cfa.reg = <reg1>
1423 cfa.offset unchanged
1424 cfa_temp.reg = <reg1>
1425 cfa_temp.offset = cfa.offset
1428 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1429 {<const_int>,<reg>:cfa_temp.reg}))
1430 effects: cfa.reg = sp if fp used
1431 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1432 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1433 if cfa_store.reg==sp
1436 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1437 effects: cfa.reg = fp
1438 cfa_offset += +/- <const_int>
1441 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1442 constraints: <reg1> != fp
1444 effects: cfa.reg = <reg1>
1445 cfa_temp.reg = <reg1>
1446 cfa_temp.offset = cfa.offset
1449 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1450 constraints: <reg1> != fp
1452 effects: cfa_store.reg = <reg1>
1453 cfa_store.offset = cfa.offset - cfa_temp.offset
1456 (set <reg> <const_int>)
1457 effects: cfa_temp.reg = <reg>
1458 cfa_temp.offset = <const_int>
1461 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1462 effects: cfa_temp.reg = <reg1>
1463 cfa_temp.offset |= <const_int>
1466 (set <reg> (high <exp>))
1470 (set <reg> (lo_sum <exp> <const_int>))
1471 effects: cfa_temp.reg = <reg>
1472 cfa_temp.offset = <const_int>
1475 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1476 effects: cfa_store.offset -= <const_int>
1477 cfa.offset = cfa_store.offset if cfa.reg == sp
1479 cfa.base_offset = -cfa_store.offset
1482 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1483 effects: cfa_store.offset += -/+ mode_size(mem)
1484 cfa.offset = cfa_store.offset if cfa.reg == sp
1486 cfa.base_offset = -cfa_store.offset
1489 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1492 effects: cfa.reg = <reg1>
1493 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1496 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1497 effects: cfa.reg = <reg1>
1498 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1501 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1502 effects: cfa.reg = <reg1>
1503 cfa.base_offset = -cfa_temp.offset
1504 cfa_temp.offset -= mode_size(mem)
1507 (set <reg> {unspec, unspec_volatile})
1508 effects: target-dependent */
1511 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1514 HOST_WIDE_INT offset;
1516 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1517 the PARALLEL independently. The first element is always processed if
1518 it is a SET. This is for backward compatibility. Other elements
1519 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1520 flag is set in them. */
1521 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1524 int limit = XVECLEN (expr, 0);
1526 for (par_index = 0; par_index < limit; par_index++)
1527 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1528 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1530 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1535 gcc_assert (GET_CODE (expr) == SET);
1537 src = SET_SRC (expr);
1538 dest = SET_DEST (expr);
1542 rtx rsi = reg_saved_in (src);
1547 switch (GET_CODE (dest))
1550 switch (GET_CODE (src))
1552 /* Setting FP from SP. */
1554 if (cfa.reg == (unsigned) REGNO (src))
1557 /* Update the CFA rule wrt SP or FP. Make sure src is
1558 relative to the current CFA register.
1560 We used to require that dest be either SP or FP, but the
1561 ARM copies SP to a temporary register, and from there to
1562 FP. So we just rely on the backends to only set
1563 RTX_FRAME_RELATED_P on appropriate insns. */
1564 cfa.reg = REGNO (dest);
1565 cfa_temp.reg = cfa.reg;
1566 cfa_temp.offset = cfa.offset;
1570 /* Saving a register in a register. */
1571 gcc_assert (!fixed_regs [REGNO (dest)]
1572 /* For the SPARC and its register window. */
1573 || (DWARF_FRAME_REGNUM (REGNO (src))
1574 == DWARF_FRAME_RETURN_COLUMN));
1575 queue_reg_save (label, src, dest, 0);
1582 if (dest == stack_pointer_rtx)
1586 switch (GET_CODE (XEXP (src, 1)))
1589 offset = INTVAL (XEXP (src, 1));
1592 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1594 offset = cfa_temp.offset;
1600 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1602 /* Restoring SP from FP in the epilogue. */
1603 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1604 cfa.reg = STACK_POINTER_REGNUM;
1606 else if (GET_CODE (src) == LO_SUM)
1607 /* Assume we've set the source reg of the LO_SUM from sp. */
1610 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1612 if (GET_CODE (src) != MINUS)
1614 if (cfa.reg == STACK_POINTER_REGNUM)
1615 cfa.offset += offset;
1616 if (cfa_store.reg == STACK_POINTER_REGNUM)
1617 cfa_store.offset += offset;
1619 else if (dest == hard_frame_pointer_rtx)
1622 /* Either setting the FP from an offset of the SP,
1623 or adjusting the FP */
1624 gcc_assert (frame_pointer_needed);
1626 gcc_assert (REG_P (XEXP (src, 0))
1627 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1628 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1629 offset = INTVAL (XEXP (src, 1));
1630 if (GET_CODE (src) != MINUS)
1632 cfa.offset += offset;
1633 cfa.reg = HARD_FRAME_POINTER_REGNUM;
1637 gcc_assert (GET_CODE (src) != MINUS);
1640 if (REG_P (XEXP (src, 0))
1641 && REGNO (XEXP (src, 0)) == cfa.reg
1642 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1644 /* Setting a temporary CFA register that will be copied
1645 into the FP later on. */
1646 offset = - INTVAL (XEXP (src, 1));
1647 cfa.offset += offset;
1648 cfa.reg = REGNO (dest);
1649 /* Or used to save regs to the stack. */
1650 cfa_temp.reg = cfa.reg;
1651 cfa_temp.offset = cfa.offset;
1655 else if (REG_P (XEXP (src, 0))
1656 && REGNO (XEXP (src, 0)) == cfa_temp.reg
1657 && XEXP (src, 1) == stack_pointer_rtx)
1659 /* Setting a scratch register that we will use instead
1660 of SP for saving registers to the stack. */
1661 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1662 cfa_store.reg = REGNO (dest);
1663 cfa_store.offset = cfa.offset - cfa_temp.offset;
1667 else if (GET_CODE (src) == LO_SUM
1668 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1670 cfa_temp.reg = REGNO (dest);
1671 cfa_temp.offset = INTVAL (XEXP (src, 1));
1680 cfa_temp.reg = REGNO (dest);
1681 cfa_temp.offset = INTVAL (src);
1686 gcc_assert (REG_P (XEXP (src, 0))
1687 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1688 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1690 if ((unsigned) REGNO (dest) != cfa_temp.reg)
1691 cfa_temp.reg = REGNO (dest);
1692 cfa_temp.offset |= INTVAL (XEXP (src, 1));
1695 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1696 which will fill in all of the bits. */
1703 case UNSPEC_VOLATILE:
1704 gcc_assert (targetm.dwarf_handle_frame_unspec);
1705 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1712 def_cfa_1 (label, &cfa);
1716 gcc_assert (REG_P (src));
1718 /* Saving a register to the stack. Make sure dest is relative to the
1720 switch (GET_CODE (XEXP (dest, 0)))
1725 /* We can't handle variable size modifications. */
1726 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1728 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1730 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1731 && cfa_store.reg == STACK_POINTER_REGNUM);
1733 cfa_store.offset += offset;
1734 if (cfa.reg == STACK_POINTER_REGNUM)
1735 cfa.offset = cfa_store.offset;
1737 offset = -cfa_store.offset;
1743 offset = GET_MODE_SIZE (GET_MODE (dest));
1744 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1747 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1748 && cfa_store.reg == STACK_POINTER_REGNUM);
1750 cfa_store.offset += offset;
1751 if (cfa.reg == STACK_POINTER_REGNUM)
1752 cfa.offset = cfa_store.offset;
1754 offset = -cfa_store.offset;
1758 /* With an offset. */
1765 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
1766 && REG_P (XEXP (XEXP (dest, 0), 0)));
1767 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1768 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1771 regno = REGNO (XEXP (XEXP (dest, 0), 0));
1773 if (cfa_store.reg == (unsigned) regno)
1774 offset -= cfa_store.offset;
1777 gcc_assert (cfa_temp.reg == (unsigned) regno);
1778 offset -= cfa_temp.offset;
1784 /* Without an offset. */
1787 int regno = REGNO (XEXP (dest, 0));
1789 if (cfa_store.reg == (unsigned) regno)
1790 offset = -cfa_store.offset;
1793 gcc_assert (cfa_temp.reg == (unsigned) regno);
1794 offset = -cfa_temp.offset;
1801 gcc_assert (cfa_temp.reg
1802 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1803 offset = -cfa_temp.offset;
1804 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1811 if (REGNO (src) != STACK_POINTER_REGNUM
1812 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1813 && (unsigned) REGNO (src) == cfa.reg)
1815 /* We're storing the current CFA reg into the stack. */
1817 if (cfa.offset == 0)
1819 /* If the source register is exactly the CFA, assume
1820 we're saving SP like any other register; this happens
1822 def_cfa_1 (label, &cfa);
1823 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1828 /* Otherwise, we'll need to look in the stack to
1829 calculate the CFA. */
1830 rtx x = XEXP (dest, 0);
1834 gcc_assert (REG_P (x));
1836 cfa.reg = REGNO (x);
1837 cfa.base_offset = offset;
1839 def_cfa_1 (label, &cfa);
1844 def_cfa_1 (label, &cfa);
1845 queue_reg_save (label, src, NULL_RTX, offset);
1853 /* Record call frame debugging information for INSN, which either
1854 sets SP or FP (adjusting how we calculate the frame address) or saves a
1855 register to the stack. If INSN is NULL_RTX, initialize our state.
1857 If AFTER_P is false, we're being called before the insn is emitted,
1858 otherwise after. Call instructions get invoked twice. */
1861 dwarf2out_frame_debug (rtx insn, bool after_p)
1866 if (insn == NULL_RTX)
1870 /* Flush any queued register saves. */
1871 flush_queued_reg_saves ();
1873 /* Set up state for generating call frame debug info. */
1876 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1878 cfa.reg = STACK_POINTER_REGNUM;
1881 cfa_temp.offset = 0;
1883 for (i = 0; i < num_regs_saved_in_regs; i++)
1885 regs_saved_in_regs[i].orig_reg = NULL_RTX;
1886 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1888 num_regs_saved_in_regs = 0;
1892 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1893 flush_queued_reg_saves ();
1895 if (! RTX_FRAME_RELATED_P (insn))
1897 if (!ACCUMULATE_OUTGOING_ARGS)
1898 dwarf2out_stack_adjust (insn, after_p);
1902 label = dwarf2out_cfi_label ();
1903 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1905 insn = XEXP (src, 0);
1907 insn = PATTERN (insn);
1909 dwarf2out_frame_debug_expr (insn, label);
1914 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
1915 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1916 (enum dwarf_call_frame_info cfi);
1918 static enum dw_cfi_oprnd_type
1919 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1924 case DW_CFA_GNU_window_save:
1925 return dw_cfi_oprnd_unused;
1927 case DW_CFA_set_loc:
1928 case DW_CFA_advance_loc1:
1929 case DW_CFA_advance_loc2:
1930 case DW_CFA_advance_loc4:
1931 case DW_CFA_MIPS_advance_loc8:
1932 return dw_cfi_oprnd_addr;
1935 case DW_CFA_offset_extended:
1936 case DW_CFA_def_cfa:
1937 case DW_CFA_offset_extended_sf:
1938 case DW_CFA_def_cfa_sf:
1939 case DW_CFA_restore_extended:
1940 case DW_CFA_undefined:
1941 case DW_CFA_same_value:
1942 case DW_CFA_def_cfa_register:
1943 case DW_CFA_register:
1944 return dw_cfi_oprnd_reg_num;
1946 case DW_CFA_def_cfa_offset:
1947 case DW_CFA_GNU_args_size:
1948 case DW_CFA_def_cfa_offset_sf:
1949 return dw_cfi_oprnd_offset;
1951 case DW_CFA_def_cfa_expression:
1952 case DW_CFA_expression:
1953 return dw_cfi_oprnd_loc;
1960 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
1961 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1962 (enum dwarf_call_frame_info cfi);
1964 static enum dw_cfi_oprnd_type
1965 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1969 case DW_CFA_def_cfa:
1970 case DW_CFA_def_cfa_sf:
1972 case DW_CFA_offset_extended_sf:
1973 case DW_CFA_offset_extended:
1974 return dw_cfi_oprnd_offset;
1976 case DW_CFA_register:
1977 return dw_cfi_oprnd_reg_num;
1980 return dw_cfi_oprnd_unused;
1984 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1986 /* Switch to eh_frame_section. If we don't have an eh_frame_section,
1987 switch to the data section instead, and write out a synthetic label
1991 switch_to_eh_frame_section (void)
1995 #ifdef EH_FRAME_SECTION_NAME
1996 if (eh_frame_section == 0)
2000 if (EH_TABLES_CAN_BE_READ_ONLY)
2006 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2008 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2010 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2012 flags = ((! flag_pic
2013 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2014 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2015 && (per_encoding & 0x70) != DW_EH_PE_absptr
2016 && (per_encoding & 0x70) != DW_EH_PE_aligned
2017 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2018 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2019 ? 0 : SECTION_WRITE);
2022 flags = SECTION_WRITE;
2023 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2027 if (eh_frame_section)
2028 switch_to_section (eh_frame_section);
2031 /* We have no special eh_frame section. Put the information in
2032 the data section and emit special labels to guide collect2. */
2033 switch_to_section (data_section);
2034 label = get_file_function_name ("F");
2035 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2036 targetm.asm_out.globalize_label (asm_out_file,
2037 IDENTIFIER_POINTER (label));
2038 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2042 /* Output a Call Frame Information opcode and its operand(s). */
2045 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2048 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2049 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2050 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2051 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2052 cfi->dw_cfi_oprnd1.dw_cfi_offset);
2053 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2055 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2056 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2057 "DW_CFA_offset, column 0x%lx", r);
2058 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2060 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2062 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2063 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2064 "DW_CFA_restore, column 0x%lx", r);
2068 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2069 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2071 switch (cfi->dw_cfi_opc)
2073 case DW_CFA_set_loc:
2075 dw2_asm_output_encoded_addr_rtx (
2076 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2077 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2080 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2081 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2082 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2085 case DW_CFA_advance_loc1:
2086 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2087 fde->dw_fde_current_label, NULL);
2088 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2091 case DW_CFA_advance_loc2:
2092 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2093 fde->dw_fde_current_label, NULL);
2094 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2097 case DW_CFA_advance_loc4:
2098 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2099 fde->dw_fde_current_label, NULL);
2100 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2103 case DW_CFA_MIPS_advance_loc8:
2104 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2105 fde->dw_fde_current_label, NULL);
2106 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2109 case DW_CFA_offset_extended:
2110 case DW_CFA_def_cfa:
2111 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2112 dw2_asm_output_data_uleb128 (r, NULL);
2113 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2116 case DW_CFA_offset_extended_sf:
2117 case DW_CFA_def_cfa_sf:
2118 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2119 dw2_asm_output_data_uleb128 (r, NULL);
2120 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2123 case DW_CFA_restore_extended:
2124 case DW_CFA_undefined:
2125 case DW_CFA_same_value:
2126 case DW_CFA_def_cfa_register:
2127 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2128 dw2_asm_output_data_uleb128 (r, NULL);
2131 case DW_CFA_register:
2132 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2133 dw2_asm_output_data_uleb128 (r, NULL);
2134 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2135 dw2_asm_output_data_uleb128 (r, NULL);
2138 case DW_CFA_def_cfa_offset:
2139 case DW_CFA_GNU_args_size:
2140 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2143 case DW_CFA_def_cfa_offset_sf:
2144 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2147 case DW_CFA_GNU_window_save:
2150 case DW_CFA_def_cfa_expression:
2151 case DW_CFA_expression:
2152 output_cfa_loc (cfi);
2155 case DW_CFA_GNU_negative_offset_extended:
2156 /* Obsoleted by DW_CFA_offset_extended_sf. */
2165 /* Output the call frame information used to record information
2166 that relates to calculating the frame pointer, and records the
2167 location of saved registers. */
2170 output_call_frame_info (int for_eh)
2175 char l1[20], l2[20], section_start_label[20];
2176 bool any_lsda_needed = false;
2177 char augmentation[6];
2178 int augmentation_size;
2179 int fde_encoding = DW_EH_PE_absptr;
2180 int per_encoding = DW_EH_PE_absptr;
2181 int lsda_encoding = DW_EH_PE_absptr;
2184 /* Don't emit a CIE if there won't be any FDEs. */
2185 if (fde_table_in_use == 0)
2188 /* If we make FDEs linkonce, we may have to emit an empty label for
2189 an FDE that wouldn't otherwise be emitted. We want to avoid
2190 having an FDE kept around when the function it refers to is
2191 discarded. Example where this matters: a primary function
2192 template in C++ requires EH information, but an explicit
2193 specialization doesn't. */
2194 if (TARGET_USES_WEAK_UNWIND_INFO
2195 && ! flag_asynchronous_unwind_tables
2196 /* APPLE LOCAL begin for-fsf-4_4 5480287 */ \
2198 /* APPLE LOCAL end for-fsf-4_4 5480287 */ \
2200 for (i = 0; i < fde_table_in_use; i++)
2201 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2202 && !fde_table[i].uses_eh_lsda
2203 && ! DECL_WEAK (fde_table[i].decl))
2204 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2205 for_eh, /* empty */ 1);
2207 /* If we don't have any functions we'll want to unwind out of, don't
2208 emit any EH unwind information. Note that if exceptions aren't
2209 enabled, we won't have collected nothrow information, and if we
2210 asked for asynchronous tables, we always want this info. */
2213 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2215 for (i = 0; i < fde_table_in_use; i++)
2216 if (fde_table[i].uses_eh_lsda)
2217 any_eh_needed = any_lsda_needed = true;
2218 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2219 any_eh_needed = true;
2220 else if (! fde_table[i].nothrow
2221 && ! fde_table[i].all_throwers_are_sibcalls)
2222 any_eh_needed = true;
2224 if (! any_eh_needed)
2228 /* We're going to be generating comments, so turn on app. */
2233 switch_to_eh_frame_section ();
2236 if (!debug_frame_section)
2237 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
2238 SECTION_DEBUG, NULL);
2239 switch_to_section (debug_frame_section);
2242 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2243 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2245 /* Output the CIE. */
2246 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2247 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2248 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2249 dw2_asm_output_data (4, 0xffffffff,
2250 "Initial length escape value indicating 64-bit DWARF extension");
2251 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2252 "Length of Common Information Entry");
2253 ASM_OUTPUT_LABEL (asm_out_file, l1);
2255 /* Now that the CIE pointer is PC-relative for EH,
2256 use 0 to identify the CIE. */
2257 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2258 (for_eh ? 0 : DWARF_CIE_ID),
2259 "CIE Identifier Tag");
2261 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2263 augmentation[0] = 0;
2264 augmentation_size = 0;
2270 z Indicates that a uleb128 is present to size the
2271 augmentation section.
2272 L Indicates the encoding (and thus presence) of
2273 an LSDA pointer in the FDE augmentation.
2274 R Indicates a non-default pointer encoding for
2276 P Indicates the presence of an encoding + language
2277 personality routine in the CIE augmentation. */
2279 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2280 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2281 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2283 p = augmentation + 1;
2284 if (eh_personality_libfunc)
2287 augmentation_size += 1 + size_of_encoded_value (per_encoding);
2289 if (any_lsda_needed)
2292 augmentation_size += 1;
2294 if (fde_encoding != DW_EH_PE_absptr)
2297 augmentation_size += 1;
2299 if (p > augmentation + 1)
2301 augmentation[0] = 'z';
2305 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2306 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2308 int offset = ( 4 /* Length */
2310 + 1 /* CIE version */
2311 + strlen (augmentation) + 1 /* Augmentation */
2312 + size_of_uleb128 (1) /* Code alignment */
2313 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2315 + 1 /* Augmentation size */
2316 + 1 /* Personality encoding */ );
2317 int pad = -offset & (PTR_SIZE - 1);
2319 augmentation_size += pad;
2321 /* Augmentations should be small, so there's scarce need to
2322 iterate for a solution. Die if we exceed one uleb128 byte. */
2323 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2327 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2328 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2329 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2330 "CIE Data Alignment Factor");
2332 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2333 if (DW_CIE_VERSION == 1)
2334 dw2_asm_output_data (1, return_reg, "CIE RA Column");
2336 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2338 if (augmentation[0])
2340 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2341 if (eh_personality_libfunc)
2343 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2344 eh_data_format_name (per_encoding));
2345 dw2_asm_output_encoded_addr_rtx (per_encoding,
2346 eh_personality_libfunc,
2350 if (any_lsda_needed)
2351 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2352 eh_data_format_name (lsda_encoding));
2354 if (fde_encoding != DW_EH_PE_absptr)
2355 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2356 eh_data_format_name (fde_encoding));
2359 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2360 output_cfi (cfi, NULL, for_eh);
2362 /* Pad the CIE out to an address sized boundary. */
2363 ASM_OUTPUT_ALIGN (asm_out_file,
2364 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2365 ASM_OUTPUT_LABEL (asm_out_file, l2);
2367 /* Loop through all of the FDE's. */
2368 for (i = 0; i < fde_table_in_use; i++)
2370 fde = &fde_table[i];
2372 /* Don't emit EH unwind info for leaf functions that don't need it. */
2373 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2374 && (fde->nothrow || fde->all_throwers_are_sibcalls)
2375 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2376 && !fde->uses_eh_lsda)
2379 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2380 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2381 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2382 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2383 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2384 dw2_asm_output_data (4, 0xffffffff,
2385 "Initial length escape value indicating 64-bit DWARF extension");
2386 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2388 ASM_OUTPUT_LABEL (asm_out_file, l1);
2391 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2393 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2394 debug_frame_section, "FDE CIE offset");
2398 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2399 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2400 dw2_asm_output_encoded_addr_rtx (fde_encoding,
2403 "FDE initial location");
2404 if (fde->dw_fde_switched_sections)
2406 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2407 fde->dw_fde_unlikely_section_label);
2408 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2409 fde->dw_fde_hot_section_label);
2410 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2411 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2412 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
2413 "FDE initial location");
2414 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2415 fde->dw_fde_hot_section_end_label,
2416 fde->dw_fde_hot_section_label,
2417 "FDE address range");
2418 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
2419 "FDE initial location");
2420 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2421 fde->dw_fde_unlikely_section_end_label,
2422 fde->dw_fde_unlikely_section_label,
2423 "FDE address range");
2426 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2427 fde->dw_fde_end, fde->dw_fde_begin,
2428 "FDE address range");
2432 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2433 "FDE initial location");
2434 if (fde->dw_fde_switched_sections)
2436 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2437 fde->dw_fde_hot_section_label,
2438 "FDE initial location");
2439 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2440 fde->dw_fde_hot_section_end_label,
2441 fde->dw_fde_hot_section_label,
2442 "FDE address range");
2443 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2444 fde->dw_fde_unlikely_section_label,
2445 "FDE initial location");
2446 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2447 fde->dw_fde_unlikely_section_end_label,
2448 fde->dw_fde_unlikely_section_label,
2449 "FDE address range");
2452 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2453 fde->dw_fde_end, fde->dw_fde_begin,
2454 "FDE address range");
2457 if (augmentation[0])
2459 if (any_lsda_needed)
2461 int size = size_of_encoded_value (lsda_encoding);
2463 if (lsda_encoding == DW_EH_PE_aligned)
2465 int offset = ( 4 /* Length */
2466 + 4 /* CIE offset */
2467 + 2 * size_of_encoded_value (fde_encoding)
2468 + 1 /* Augmentation size */ );
2469 int pad = -offset & (PTR_SIZE - 1);
2472 gcc_assert (size_of_uleb128 (size) == 1);
2475 dw2_asm_output_data_uleb128 (size, "Augmentation size");
2477 if (fde->uses_eh_lsda)
2479 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2480 fde->funcdef_number);
2481 dw2_asm_output_encoded_addr_rtx (
2482 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2483 false, "Language Specific Data Area");
2487 if (lsda_encoding == DW_EH_PE_aligned)
2488 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2490 (size_of_encoded_value (lsda_encoding), 0,
2491 "Language Specific Data Area (none)");
2495 dw2_asm_output_data_uleb128 (0, "Augmentation size");
2498 /* Loop through the Call Frame Instructions associated with
2500 fde->dw_fde_current_label = fde->dw_fde_begin;
2501 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2502 output_cfi (cfi, fde, for_eh);
2504 /* Pad the FDE out to an address sized boundary. */
2505 ASM_OUTPUT_ALIGN (asm_out_file,
2506 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2507 ASM_OUTPUT_LABEL (asm_out_file, l2);
2510 if (for_eh && targetm.terminate_dw2_eh_frame_info)
2511 dw2_asm_output_data (4, 0, "End of Table");
2512 #ifdef MIPS_DEBUGGING_INFO
2513 /* Work around Irix 6 assembler bug whereby labels at the end of a section
2514 get a value of 0. Putting .align 0 after the label fixes it. */
2515 ASM_OUTPUT_ALIGN (asm_out_file, 0);
2518 /* Turn off app to make assembly quicker. */
2523 /* Output a marker (i.e. a label) for the beginning of a function, before
2527 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2528 const char *file ATTRIBUTE_UNUSED)
2530 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2534 current_function_func_begin_label = NULL;
2536 #ifdef TARGET_UNWIND_INFO
2537 /* ??? current_function_func_begin_label is also used by except.c
2538 for call-site information. We must emit this label if it might
2540 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2541 && ! dwarf2out_do_frame ())
2544 if (! dwarf2out_do_frame ())
2548 switch_to_section (function_section (current_function_decl));
2549 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2550 current_function_funcdef_no);
2551 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2552 current_function_funcdef_no);
2553 dup_label = xstrdup (label);
2554 current_function_func_begin_label = dup_label;
2556 #ifdef TARGET_UNWIND_INFO
2557 /* We can elide the fde allocation if we're not emitting debug info. */
2558 if (! dwarf2out_do_frame ())
2562 /* Expand the fde table if necessary. */
2563 if (fde_table_in_use == fde_table_allocated)
2565 fde_table_allocated += FDE_TABLE_INCREMENT;
2566 fde_table = ggc_realloc (fde_table,
2567 fde_table_allocated * sizeof (dw_fde_node));
2568 memset (fde_table + fde_table_in_use, 0,
2569 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2572 /* Record the FDE associated with this function. */
2573 current_funcdef_fde = fde_table_in_use;
2575 /* Add the new FDE at the end of the fde_table. */
2576 fde = &fde_table[fde_table_in_use++];
2577 fde->decl = current_function_decl;
2578 fde->dw_fde_begin = dup_label;
2579 fde->dw_fde_current_label = dup_label;
2580 fde->dw_fde_hot_section_label = NULL;
2581 fde->dw_fde_hot_section_end_label = NULL;
2582 fde->dw_fde_unlikely_section_label = NULL;
2583 fde->dw_fde_unlikely_section_end_label = NULL;
2584 fde->dw_fde_switched_sections = false;
2585 fde->dw_fde_end = NULL;
2586 fde->dw_fde_cfi = NULL;
2587 fde->funcdef_number = current_function_funcdef_no;
2588 fde->nothrow = TREE_NOTHROW (current_function_decl);
2589 fde->uses_eh_lsda = cfun->uses_eh_lsda;
2590 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2592 args_size = old_args_size = 0;
2594 /* We only want to output line number information for the genuine dwarf2
2595 prologue case, not the eh frame case. */
2596 #ifdef DWARF2_DEBUGGING_INFO
2598 dwarf2out_source_line (line, file);
2602 /* Output a marker (i.e. a label) for the absolute end of the generated code
2603 for a function definition. This gets called *after* the epilogue code has
2607 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2608 const char *file ATTRIBUTE_UNUSED)
2611 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2613 /* Output a label to mark the endpoint of the code generated for this
2615 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2616 current_function_funcdef_no);
2617 ASM_OUTPUT_LABEL (asm_out_file, label);
2618 fde = &fde_table[fde_table_in_use - 1];
2619 fde->dw_fde_end = xstrdup (label);
2623 dwarf2out_frame_init (void)
2625 /* Allocate the initial hunk of the fde_table. */
2626 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2627 fde_table_allocated = FDE_TABLE_INCREMENT;
2628 fde_table_in_use = 0;
2630 /* Generate the CFA instructions common to all FDE's. Do it now for the
2631 sake of lookup_cfa. */
2633 /* On entry, the Canonical Frame Address is at SP. */
2634 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2636 #ifdef DWARF2_UNWIND_INFO
2637 if (DWARF2_UNWIND_INFO)
2638 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2643 dwarf2out_frame_finish (void)
2645 /* Output call frame information. */
2646 if (DWARF2_FRAME_INFO)
2647 output_call_frame_info (0);
2649 #ifndef TARGET_UNWIND_INFO
2650 /* Output another copy for the unwinder. */
2651 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2652 output_call_frame_info (1);
2657 /* And now, the subset of the debugging information support code necessary
2658 for emitting location expressions. */
2660 /* Data about a single source file. */
2661 struct dwarf_file_data GTY(())
2663 const char * filename;
2667 /* We need some way to distinguish DW_OP_addr with a direct symbol
2668 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
2669 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
2672 typedef struct dw_val_struct *dw_val_ref;
2673 typedef struct die_struct *dw_die_ref;
2674 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2675 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2677 /* Each DIE may have a series of attribute/value pairs. Values
2678 can take on several forms. The forms that are used in this
2679 implementation are listed below. */
2684 dw_val_class_offset,
2686 dw_val_class_loc_list,
2687 dw_val_class_range_list,
2689 dw_val_class_unsigned_const,
2690 dw_val_class_long_long,
2693 dw_val_class_die_ref,
2694 dw_val_class_fde_ref,
2695 dw_val_class_lbl_id,
2696 dw_val_class_lineptr,
2698 dw_val_class_macptr,
2702 /* Describe a double word constant value. */
2703 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
2705 typedef struct dw_long_long_struct GTY(())
2712 /* Describe a floating point constant value, or a vector constant value. */
2714 typedef struct dw_vec_struct GTY(())
2716 unsigned char * GTY((length ("%h.length"))) array;
2722 /* The dw_val_node describes an attribute's value, as it is
2723 represented internally. */
2725 typedef struct dw_val_struct GTY(())
2727 enum dw_val_class val_class;
2728 union dw_val_struct_union
2730 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2731 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2732 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2733 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2734 HOST_WIDE_INT GTY ((default)) val_int;
2735 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2736 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2737 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2738 struct dw_val_die_union
2742 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2743 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2744 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2745 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2746 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2747 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
2749 GTY ((desc ("%1.val_class"))) v;
2753 /* Locations in memory are described using a sequence of stack machine
2756 typedef struct dw_loc_descr_struct GTY(())
2758 dw_loc_descr_ref dw_loc_next;
2759 enum dwarf_location_atom dw_loc_opc;
2760 dw_val_node dw_loc_oprnd1;
2761 dw_val_node dw_loc_oprnd2;
2766 /* Location lists are ranges + location descriptions for that range,
2767 so you can track variables that are in different places over
2768 their entire life. */
2769 typedef struct dw_loc_list_struct GTY(())
2771 dw_loc_list_ref dw_loc_next;
2772 const char *begin; /* Label for begin address of range */
2773 const char *end; /* Label for end address of range */
2774 char *ll_symbol; /* Label for beginning of location list.
2775 Only on head of list */
2776 const char *section; /* Section this loclist is relative to */
2777 dw_loc_descr_ref expr;
2780 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2782 static const char *dwarf_stack_op_name (unsigned);
2783 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2784 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2785 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2786 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2787 static unsigned long size_of_locs (dw_loc_descr_ref);
2788 static void output_loc_operands (dw_loc_descr_ref);
2789 static void output_loc_sequence (dw_loc_descr_ref);
2791 /* Convert a DWARF stack opcode into its string name. */
2794 dwarf_stack_op_name (unsigned int op)
2799 case INTERNAL_DW_OP_tls_addr:
2800 return "DW_OP_addr";
2802 return "DW_OP_deref";
2804 return "DW_OP_const1u";
2806 return "DW_OP_const1s";
2808 return "DW_OP_const2u";
2810 return "DW_OP_const2s";
2812 return "DW_OP_const4u";
2814 return "DW_OP_const4s";
2816 return "DW_OP_const8u";
2818 return "DW_OP_const8s";
2820 return "DW_OP_constu";
2822 return "DW_OP_consts";
2826 return "DW_OP_drop";
2828 return "DW_OP_over";
2830 return "DW_OP_pick";
2832 return "DW_OP_swap";
2836 return "DW_OP_xderef";
2844 return "DW_OP_minus";
2856 return "DW_OP_plus";
2857 case DW_OP_plus_uconst:
2858 return "DW_OP_plus_uconst";
2864 return "DW_OP_shra";
2882 return "DW_OP_skip";
2884 return "DW_OP_lit0";
2886 return "DW_OP_lit1";
2888 return "DW_OP_lit2";
2890 return "DW_OP_lit3";
2892 return "DW_OP_lit4";
2894 return "DW_OP_lit5";
2896 return "DW_OP_lit6";
2898 return "DW_OP_lit7";
2900 return "DW_OP_lit8";
2902 return "DW_OP_lit9";
2904 return "DW_OP_lit10";
2906 return "DW_OP_lit11";
2908 return "DW_OP_lit12";
2910 return "DW_OP_lit13";
2912 return "DW_OP_lit14";
2914 return "DW_OP_lit15";
2916 return "DW_OP_lit16";
2918 return "DW_OP_lit17";
2920 return "DW_OP_lit18";
2922 return "DW_OP_lit19";
2924 return "DW_OP_lit20";
2926 return "DW_OP_lit21";
2928 return "DW_OP_lit22";
2930 return "DW_OP_lit23";
2932 return "DW_OP_lit24";
2934 return "DW_OP_lit25";
2936 return "DW_OP_lit26";
2938 return "DW_OP_lit27";
2940 return "DW_OP_lit28";
2942 return "DW_OP_lit29";
2944 return "DW_OP_lit30";
2946 return "DW_OP_lit31";
2948 return "DW_OP_reg0";
2950 return "DW_OP_reg1";
2952 return "DW_OP_reg2";
2954 return "DW_OP_reg3";
2956 return "DW_OP_reg4";
2958 return "DW_OP_reg5";
2960 return "DW_OP_reg6";
2962 return "DW_OP_reg7";
2964 return "DW_OP_reg8";
2966 return "DW_OP_reg9";
2968 return "DW_OP_reg10";
2970 return "DW_OP_reg11";
2972 return "DW_OP_reg12";
2974 return "DW_OP_reg13";
2976 return "DW_OP_reg14";
2978 return "DW_OP_reg15";
2980 return "DW_OP_reg16";
2982 return "DW_OP_reg17";
2984 return "DW_OP_reg18";
2986 return "DW_OP_reg19";
2988 return "DW_OP_reg20";
2990 return "DW_OP_reg21";
2992 return "DW_OP_reg22";
2994 return "DW_OP_reg23";
2996 return "DW_OP_reg24";
2998 return "DW_OP_reg25";
3000 return "DW_OP_reg26";
3002 return "DW_OP_reg27";
3004 return "DW_OP_reg28";
3006 return "DW_OP_reg29";
3008 return "DW_OP_reg30";
3010 return "DW_OP_reg31";
3012 return "DW_OP_breg0";
3014 return "DW_OP_breg1";
3016 return "DW_OP_breg2";
3018 return "DW_OP_breg3";
3020 return "DW_OP_breg4";
3022 return "DW_OP_breg5";
3024 return "DW_OP_breg6";
3026 return "DW_OP_breg7";
3028 return "DW_OP_breg8";
3030 return "DW_OP_breg9";
3032 return "DW_OP_breg10";
3034 return "DW_OP_breg11";
3036 return "DW_OP_breg12";
3038 return "DW_OP_breg13";
3040 return "DW_OP_breg14";
3042 return "DW_OP_breg15";
3044 return "DW_OP_breg16";
3046 return "DW_OP_breg17";
3048 return "DW_OP_breg18";
3050 return "DW_OP_breg19";
3052 return "DW_OP_breg20";
3054 return "DW_OP_breg21";
3056 return "DW_OP_breg22";
3058 return "DW_OP_breg23";
3060 return "DW_OP_breg24";
3062 return "DW_OP_breg25";
3064 return "DW_OP_breg26";
3066 return "DW_OP_breg27";
3068 return "DW_OP_breg28";
3070 return "DW_OP_breg29";
3072 return "DW_OP_breg30";
3074 return "DW_OP_breg31";
3076 return "DW_OP_regx";
3078 return "DW_OP_fbreg";
3080 return "DW_OP_bregx";
3082 return "DW_OP_piece";
3083 case DW_OP_deref_size:
3084 return "DW_OP_deref_size";
3085 case DW_OP_xderef_size:
3086 return "DW_OP_xderef_size";
3089 case DW_OP_push_object_address:
3090 return "DW_OP_push_object_address";
3092 return "DW_OP_call2";
3094 return "DW_OP_call4";
3095 case DW_OP_call_ref:
3096 return "DW_OP_call_ref";
3097 case DW_OP_GNU_push_tls_address:
3098 return "DW_OP_GNU_push_tls_address";
3100 return "OP_<unknown>";
3104 /* Return a pointer to a newly allocated location description. Location
3105 descriptions are simple expression terms that can be strung
3106 together to form more complicated location (address) descriptions. */
3108 static inline dw_loc_descr_ref
3109 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3110 unsigned HOST_WIDE_INT oprnd2)
3112 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
3114 descr->dw_loc_opc = op;
3115 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3116 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3117 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3118 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3123 /* Add a location description term to a location description expression. */
3126 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3128 dw_loc_descr_ref *d;
3130 /* Find the end of the chain. */
3131 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3137 /* Return the size of a location descriptor. */
3139 static unsigned long
3140 size_of_loc_descr (dw_loc_descr_ref loc)
3142 unsigned long size = 1;
3144 switch (loc->dw_loc_opc)
3147 case INTERNAL_DW_OP_tls_addr:
3148 size += DWARF2_ADDR_SIZE;
3167 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3170 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3175 case DW_OP_plus_uconst:
3176 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3214 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3217 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3220 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3223 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3224 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3227 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3229 case DW_OP_deref_size:
3230 case DW_OP_xderef_size:
3239 case DW_OP_call_ref:
3240 size += DWARF2_ADDR_SIZE;
3249 /* Return the size of a series of location descriptors. */
3251 static unsigned long
3252 size_of_locs (dw_loc_descr_ref loc)
3257 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
3258 field, to avoid writing to a PCH file. */
3259 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3261 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
3263 size += size_of_loc_descr (l);
3268 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
3270 l->dw_loc_addr = size;
3271 size += size_of_loc_descr (l);
3277 /* Output location description stack opcode's operands (if any). */
3280 output_loc_operands (dw_loc_descr_ref loc)
3282 dw_val_ref val1 = &loc->dw_loc_oprnd1;
3283 dw_val_ref val2 = &loc->dw_loc_oprnd2;
3285 switch (loc->dw_loc_opc)
3287 #ifdef DWARF2_DEBUGGING_INFO
3289 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3293 dw2_asm_output_data (2, val1->v.val_int, NULL);
3297 dw2_asm_output_data (4, val1->v.val_int, NULL);
3301 gcc_assert (HOST_BITS_PER_LONG >= 64);
3302 dw2_asm_output_data (8, val1->v.val_int, NULL);
3309 gcc_assert (val1->val_class == dw_val_class_loc);
3310 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3312 dw2_asm_output_data (2, offset, NULL);
3325 /* We currently don't make any attempt to make sure these are
3326 aligned properly like we do for the main unwind info, so
3327 don't support emitting things larger than a byte if we're
3328 only doing unwinding. */
3333 dw2_asm_output_data (1, val1->v.val_int, NULL);
3336 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3339 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3342 dw2_asm_output_data (1, val1->v.val_int, NULL);
3344 case DW_OP_plus_uconst:
3345 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3379 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3382 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3385 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3388 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3389 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3392 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3394 case DW_OP_deref_size:
3395 case DW_OP_xderef_size:
3396 dw2_asm_output_data (1, val1->v.val_int, NULL);
3399 case INTERNAL_DW_OP_tls_addr:
3400 if (targetm.asm_out.output_dwarf_dtprel)
3402 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3405 fputc ('\n', asm_out_file);
3412 /* Other codes have no operands. */
3417 /* Output a sequence of location operations. */
3420 output_loc_sequence (dw_loc_descr_ref loc)
3422 for (; loc != NULL; loc = loc->dw_loc_next)
3424 /* Output the opcode. */
3425 dw2_asm_output_data (1, loc->dw_loc_opc,
3426 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3428 /* Output the operand(s) (if any). */
3429 output_loc_operands (loc);
3433 /* This routine will generate the correct assembly data for a location
3434 description based on a cfi entry with a complex address. */
3437 output_cfa_loc (dw_cfi_ref cfi)
3439 dw_loc_descr_ref loc;
3442 /* Output the size of the block. */
3443 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3444 size = size_of_locs (loc);
3445 dw2_asm_output_data_uleb128 (size, NULL);
3447 /* Now output the operations themselves. */
3448 output_loc_sequence (loc);
3451 /* This function builds a dwarf location descriptor sequence from a
3452 dw_cfa_location, adding the given OFFSET to the result of the
3455 static struct dw_loc_descr_struct *
3456 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
3458 struct dw_loc_descr_struct *head, *tmp;
3460 offset += cfa->offset;
3464 if (cfa->base_offset)
3467 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3469 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3471 else if (cfa->reg <= 31)
3472 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3474 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3476 head->dw_loc_oprnd1.val_class = dw_val_class_const;
3477 tmp = new_loc_descr (DW_OP_deref, 0, 0);
3478 add_loc_descr (&head, tmp);
3481 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
3482 add_loc_descr (&head, tmp);
3489 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3491 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3492 else if (cfa->reg <= 31)
3493 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
3495 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
3501 /* This function fills in aa dw_cfa_location structure from a dwarf location
3502 descriptor sequence. */
3505 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3507 struct dw_loc_descr_struct *ptr;
3509 cfa->base_offset = 0;
3513 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3515 enum dwarf_location_atom op = ptr->dw_loc_opc;
3551 cfa->reg = op - DW_OP_reg0;
3554 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3588 cfa->reg = op - DW_OP_breg0;
3589 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3592 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3593 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3598 case DW_OP_plus_uconst:
3599 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3602 internal_error ("DW_LOC_OP %s not implemented",
3603 dwarf_stack_op_name (ptr->dw_loc_opc));
3607 #endif /* .debug_frame support */
3609 /* And now, the support for symbolic debugging information. */
3610 #ifdef DWARF2_DEBUGGING_INFO
3612 /* .debug_str support. */
3613 static int output_indirect_string (void **, void *);
3615 static void dwarf2out_init (const char *);
3616 static void dwarf2out_finish (const char *);
3617 static void dwarf2out_define (unsigned int, const char *);
3618 static void dwarf2out_undef (unsigned int, const char *);
3619 static void dwarf2out_start_source_file (unsigned, const char *);
3620 static void dwarf2out_end_source_file (unsigned);
3621 static void dwarf2out_begin_block (unsigned, unsigned);
3622 static void dwarf2out_end_block (unsigned, unsigned);
3623 static bool dwarf2out_ignore_block (tree);
3624 static void dwarf2out_global_decl (tree);
3625 static void dwarf2out_type_decl (tree, int);
3626 static void dwarf2out_imported_module_or_decl (tree, tree);
3627 static void dwarf2out_abstract_function (tree);
3628 static void dwarf2out_var_location (rtx);
3629 static void dwarf2out_begin_function (tree);
3630 static void dwarf2out_switch_text_section (void);
3632 /* The debug hooks structure. */
3634 const struct gcc_debug_hooks dwarf2_debug_hooks =
3640 dwarf2out_start_source_file,
3641 dwarf2out_end_source_file,
3642 dwarf2out_begin_block,
3643 dwarf2out_end_block,
3644 dwarf2out_ignore_block,
3645 dwarf2out_source_line,
3646 dwarf2out_begin_prologue,
3647 debug_nothing_int_charstar, /* end_prologue */
3648 dwarf2out_end_epilogue,
3649 dwarf2out_begin_function,
3650 debug_nothing_int, /* end_function */
3651 dwarf2out_decl, /* function_decl */
3652 dwarf2out_global_decl,
3653 dwarf2out_type_decl, /* type_decl */
3654 dwarf2out_imported_module_or_decl,
3655 debug_nothing_tree, /* deferred_inline_function */
3656 /* The DWARF 2 backend tries to reduce debugging bloat by not
3657 emitting the abstract description of inline functions until
3658 something tries to reference them. */
3659 dwarf2out_abstract_function, /* outlining_inline_function */
3660 debug_nothing_rtx, /* label */
3661 debug_nothing_int, /* handle_pch */
3662 dwarf2out_var_location,
3663 dwarf2out_switch_text_section,
3664 1 /* start_end_main_source_file */
3668 /* NOTE: In the comments in this file, many references are made to
3669 "Debugging Information Entries". This term is abbreviated as `DIE'
3670 throughout the remainder of this file. */
3672 /* An internal representation of the DWARF output is built, and then
3673 walked to generate the DWARF debugging info. The walk of the internal
3674 representation is done after the entire program has been compiled.
3675 The types below are used to describe the internal representation. */
3677 /* Various DIE's use offsets relative to the beginning of the
3678 .debug_info section to refer to each other. */
3680 typedef long int dw_offset;
3682 /* Define typedefs here to avoid circular dependencies. */
3684 typedef struct dw_attr_struct *dw_attr_ref;
3685 typedef struct dw_line_info_struct *dw_line_info_ref;
3686 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3687 typedef struct pubname_struct *pubname_ref;
3688 typedef struct dw_ranges_struct *dw_ranges_ref;
3690 /* Each entry in the line_info_table maintains the file and
3691 line number associated with the label generated for that
3692 entry. The label gives the PC value associated with
3693 the line number entry. */
3695 typedef struct dw_line_info_struct GTY(())
3697 unsigned long dw_file_num;
3698 unsigned long dw_line_num;
3702 /* Line information for functions in separate sections; each one gets its
3704 typedef struct dw_separate_line_info_struct GTY(())
3706 unsigned long dw_file_num;
3707 unsigned long dw_line_num;
3708 unsigned long function;
3710 dw_separate_line_info_entry;
3712 /* Each DIE attribute has a field specifying the attribute kind,
3713 a link to the next attribute in the chain, and an attribute value.
3714 Attributes are typically linked below the DIE they modify. */
3716 typedef struct dw_attr_struct GTY(())
3718 enum dwarf_attribute dw_attr;
3719 dw_val_node dw_attr_val;
3723 DEF_VEC_O(dw_attr_node);
3724 DEF_VEC_ALLOC_O(dw_attr_node,gc);
3726 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3727 The children of each node form a circular list linked by
3728 die_sib. die_child points to the node *before* the "first" child node. */
3730 typedef struct die_struct GTY(())
3732 enum dwarf_tag die_tag;
3734 VEC(dw_attr_node,gc) * die_attr;
3735 dw_die_ref die_parent;
3736 dw_die_ref die_child;
3738 dw_die_ref die_definition; /* ref from a specification to its definition */
3739 dw_offset die_offset;
3740 unsigned long die_abbrev;
3742 /* Die is used and must not be pruned as unused. */
3743 int die_perennial_p;
3744 unsigned int decl_id;
3748 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3749 #define FOR_EACH_CHILD(die, c, expr) do { \
3750 c = die->die_child; \
3754 } while (c != die->die_child); \
3757 /* The pubname structure */
3759 typedef struct pubname_struct GTY(())
3766 DEF_VEC_O(pubname_entry);
3767 DEF_VEC_ALLOC_O(pubname_entry, gc);
3769 struct dw_ranges_struct GTY(())
3774 /* The limbo die list structure. */
3775 typedef struct limbo_die_struct GTY(())
3779 struct limbo_die_struct *next;
3783 /* How to start an assembler comment. */
3784 #ifndef ASM_COMMENT_START
3785 #define ASM_COMMENT_START ";#"
3788 /* Define a macro which returns nonzero for a TYPE_DECL which was
3789 implicitly generated for a tagged type.
3791 Note that unlike the gcc front end (which generates a NULL named
3792 TYPE_DECL node for each complete tagged type, each array type, and
3793 each function type node created) the g++ front end generates a
3794 _named_ TYPE_DECL node for each tagged type node created.
3795 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3796 generate a DW_TAG_typedef DIE for them. */
3798 #define TYPE_DECL_IS_STUB(decl) \
3799 (DECL_NAME (decl) == NULL_TREE \
3800 || (DECL_ARTIFICIAL (decl) \
3801 && is_tagged_type (TREE_TYPE (decl)) \
3802 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3803 /* This is necessary for stub decls that \
3804 appear in nested inline functions. */ \
3805 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3806 && (decl_ultimate_origin (decl) \
3807 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3809 /* Information concerning the compilation unit's programming
3810 language, and compiler version. */
3812 /* Fixed size portion of the DWARF compilation unit header. */
3813 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3814 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3816 /* Fixed size portion of public names info. */
3817 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3819 /* Fixed size portion of the address range info. */
3820 #define DWARF_ARANGES_HEADER_SIZE \
3821 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3822 DWARF2_ADDR_SIZE * 2) \
3823 - DWARF_INITIAL_LENGTH_SIZE)
3825 /* Size of padding portion in the address range info. It must be
3826 aligned to twice the pointer size. */
3827 #define DWARF_ARANGES_PAD_SIZE \
3828 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3829 DWARF2_ADDR_SIZE * 2) \
3830 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3832 /* Use assembler line directives if available. */
3833 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3834 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3835 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3837 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3841 /* Minimum line offset in a special line info. opcode.
3842 This value was chosen to give a reasonable range of values. */
3843 #define DWARF_LINE_BASE -10
3845 /* First special line opcode - leave room for the standard opcodes. */
3846 #define DWARF_LINE_OPCODE_BASE 10
3848 /* Range of line offsets in a special line info. opcode. */
3849 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3851 /* Flag that indicates the initial value of the is_stmt_start flag.
3852 In the present implementation, we do not mark any lines as
3853 the beginning of a source statement, because that information
3854 is not made available by the GCC front-end. */
3855 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3857 #ifdef DWARF2_DEBUGGING_INFO
3858 /* This location is used by calc_die_sizes() to keep track
3859 the offset of each DIE within the .debug_info section. */
3860 static unsigned long next_die_offset;
3863 /* Record the root of the DIE's built for the current compilation unit. */
3864 static GTY(()) dw_die_ref comp_unit_die;
3866 /* A list of DIEs with a NULL parent waiting to be relocated. */
3867 static GTY(()) limbo_die_node *limbo_die_list;
3869 /* Filenames referenced by this compilation unit. */
3870 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
3872 /* A hash table of references to DIE's that describe declarations.
3873 The key is a DECL_UID() which is a unique number identifying each decl. */
3874 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3876 /* Node of the variable location list. */
3877 struct var_loc_node GTY ((chain_next ("%h.next")))
3879 rtx GTY (()) var_loc_note;
3880 const char * GTY (()) label;
3881 const char * GTY (()) section_label;
3882 struct var_loc_node * GTY (()) next;
3885 /* Variable location list. */
3886 struct var_loc_list_def GTY (())
3888 struct var_loc_node * GTY (()) first;
3890 /* Do not mark the last element of the chained list because
3891 it is marked through the chain. */
3892 struct var_loc_node * GTY ((skip ("%h"))) last;
3894 /* DECL_UID of the variable decl. */
3895 unsigned int decl_id;
3897 typedef struct var_loc_list_def var_loc_list;
3900 /* Table of decl location linked lists. */
3901 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3903 /* A pointer to the base of a list of references to DIE's that
3904 are uniquely identified by their tag, presence/absence of
3905 children DIE's, and list of attribute/value pairs. */
3906 static GTY((length ("abbrev_die_table_allocated")))
3907 dw_die_ref *abbrev_die_table;
3909 /* Number of elements currently allocated for abbrev_die_table. */
3910 static GTY(()) unsigned abbrev_die_table_allocated;
3912 /* Number of elements in type_die_table currently in use. */
3913 static GTY(()) unsigned abbrev_die_table_in_use;
3915 /* Size (in elements) of increments by which we may expand the
3916 abbrev_die_table. */
3917 #define ABBREV_DIE_TABLE_INCREMENT 256
3919 /* A pointer to the base of a table that contains line information
3920 for each source code line in .text in the compilation unit. */
3921 static GTY((length ("line_info_table_allocated")))
3922 dw_line_info_ref line_info_table;
3924 /* Number of elements currently allocated for line_info_table. */
3925 static GTY(()) unsigned line_info_table_allocated;
3927 /* Number of elements in line_info_table currently in use. */
3928 static GTY(()) unsigned line_info_table_in_use;
3930 /* True if the compilation unit places functions in more than one section. */
3931 static GTY(()) bool have_multiple_function_sections = false;
3933 /* A pointer to the base of a table that contains line information
3934 for each source code line outside of .text in the compilation unit. */
3935 static GTY ((length ("separate_line_info_table_allocated")))
3936 dw_separate_line_info_ref separate_line_info_table;
3938 /* Number of elements currently allocated for separate_line_info_table. */
3939 static GTY(()) unsigned separate_line_info_table_allocated;
3941 /* Number of elements in separate_line_info_table currently in use. */
3942 static GTY(()) unsigned separate_line_info_table_in_use;
3944 /* Size (in elements) of increments by which we may expand the
3946 #define LINE_INFO_TABLE_INCREMENT 1024
3948 /* A pointer to the base of a table that contains a list of publicly
3949 accessible names. */
3950 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
3952 /* A pointer to the base of a table that contains a list of publicly
3953 accessible types. */
3954 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
3956 /* Array of dies for which we should generate .debug_arange info. */
3957 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3959 /* Number of elements currently allocated for arange_table. */
3960 static GTY(()) unsigned arange_table_allocated;
3962 /* Number of elements in arange_table currently in use. */
3963 static GTY(()) unsigned arange_table_in_use;
3965 /* Size (in elements) of increments by which we may expand the
3967 #define ARANGE_TABLE_INCREMENT 64
3969 /* Array of dies for which we should generate .debug_ranges info. */
3970 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3972 /* Number of elements currently allocated for ranges_table. */
3973 static GTY(()) unsigned ranges_table_allocated;
3975 /* Number of elements in ranges_table currently in use. */
3976 static GTY(()) unsigned ranges_table_in_use;
3978 /* Size (in elements) of increments by which we may expand the
3980 #define RANGES_TABLE_INCREMENT 64
3982 /* Whether we have location lists that need outputting */
3983 static GTY(()) bool have_location_lists;
3985 /* Unique label counter. */
3986 static GTY(()) unsigned int loclabel_num;
3988 #ifdef DWARF2_DEBUGGING_INFO
3989 /* Record whether the function being analyzed contains inlined functions. */
3990 static int current_function_has_inlines;
3992 #if 0 && defined (MIPS_DEBUGGING_INFO)
3993 static int comp_unit_has_inlines;
3996 /* The last file entry emitted by maybe_emit_file(). */
3997 static GTY(()) struct dwarf_file_data * last_emitted_file;
3999 /* Number of internal labels generated by gen_internal_sym(). */
4000 static GTY(()) int label_num;
4002 /* Cached result of previous call to lookup_filename. */
4003 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
4005 #ifdef DWARF2_DEBUGGING_INFO
4007 /* Offset from the "steady-state frame pointer" to the frame base,
4008 within the current function. */
4009 static HOST_WIDE_INT frame_pointer_fb_offset;
4011 /* Forward declarations for functions defined in this file. */
4013 static int is_pseudo_reg (rtx);
4014 static tree type_main_variant (tree);
4015 static int is_tagged_type (tree);
4016 static const char *dwarf_tag_name (unsigned);
4017 static const char *dwarf_attr_name (unsigned);
4018 static const char *dwarf_form_name (unsigned);
4019 static tree decl_ultimate_origin (tree);
4020 static tree block_ultimate_origin (tree);
4021 static tree decl_class_context (tree);
4022 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4023 static inline enum dw_val_class AT_class (dw_attr_ref);
4024 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4025 static inline unsigned AT_flag (dw_attr_ref);
4026 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4027 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4028 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4029 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4030 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4032 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4033 unsigned int, unsigned char *);
4034 static hashval_t debug_str_do_hash (const void *);
4035 static int debug_str_eq (const void *, const void *);
4036 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4037 static inline const char *AT_string (dw_attr_ref);
4038 static int AT_string_form (dw_attr_ref);
4039 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4040 static void add_AT_specification (dw_die_ref, dw_die_ref);
4041 static inline dw_die_ref AT_ref (dw_attr_ref);
4042 static inline int AT_ref_external (dw_attr_ref);
4043 static inline void set_AT_ref_external (dw_attr_ref, int);
4044 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4045 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4046 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4047 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4049 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4050 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4051 static inline rtx AT_addr (dw_attr_ref);
4052 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4053 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4054 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4055 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4056 unsigned HOST_WIDE_INT);
4057 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
4059 static inline const char *AT_lbl (dw_attr_ref);
4060 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
4061 static const char *get_AT_low_pc (dw_die_ref);
4062 static const char *get_AT_hi_pc (dw_die_ref);
4063 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
4064 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
4065 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
4066 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
4067 static bool is_c_family (void);
4068 static bool is_cxx (void);
4069 static bool is_java (void);
4070 static bool is_fortran (void);
4071 static bool is_ada (void);
4072 static void remove_AT (dw_die_ref, enum dwarf_attribute);
4073 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4074 static void add_child_die (dw_die_ref, dw_die_ref);
4075 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4076 static dw_die_ref lookup_type_die (tree);
4077 static void equate_type_number_to_die (tree, dw_die_ref);
4078 static hashval_t decl_die_table_hash (const void *);
4079 static int decl_die_table_eq (const void *, const void *);
4080 static dw_die_ref lookup_decl_die (tree);
4081 static hashval_t decl_loc_table_hash (const void *);
4082 static int decl_loc_table_eq (const void *, const void *);
4083 static var_loc_list *lookup_decl_loc (tree);
4084 static void equate_decl_number_to_die (tree, dw_die_ref);
4085 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4086 static void print_spaces (FILE *);
4087 static void print_die (dw_die_ref, FILE *);
4088 static void print_dwarf_line_table (FILE *);
4089 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4090 static dw_die_ref pop_compile_unit (dw_die_ref);
4091 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4092 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4093 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4094 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4095 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4096 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4097 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4098 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4099 static void compute_section_prefix (dw_die_ref);
4100 static int is_type_die (dw_die_ref);
4101 static int is_comdat_die (dw_die_ref);
4102 static int is_symbol_die (dw_die_ref);
4103 static void assign_symbol_names (dw_die_ref);
4104 static void break_out_includes (dw_die_ref);
4105 static hashval_t htab_cu_hash (const void *);
4106 static int htab_cu_eq (const void *, const void *);
4107 static void htab_cu_del (void *);
4108 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4109 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4110 static void add_sibling_attributes (dw_die_ref);
4111 static void build_abbrev_table (dw_die_ref);
4112 static void output_location_lists (dw_die_ref);
4113 static int constant_size (long unsigned);
4114 static unsigned long size_of_die (dw_die_ref);
4115 static void calc_die_sizes (dw_die_ref);
4116 static void mark_dies (dw_die_ref);
4117 static void unmark_dies (dw_die_ref);
4118 static void unmark_all_dies (dw_die_ref);
4119 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
4120 static unsigned long size_of_aranges (void);
4121 static enum dwarf_form value_format (dw_attr_ref);
4122 static void output_value_format (dw_attr_ref);
4123 static void output_abbrev_section (void);
4124 static void output_die_symbol (dw_die_ref);
4125 static void output_die (dw_die_ref);
4126 static void output_compilation_unit_header (void);
4127 static void output_comp_unit (dw_die_ref, int);
4128 static const char *dwarf2_name (tree, int);
4129 static void add_pubname (tree, dw_die_ref);
4130 static void add_pubtype (tree, dw_die_ref);
4131 static void output_pubnames (VEC (pubname_entry,gc) *);
4132 static void add_arange (tree, dw_die_ref);
4133 static void output_aranges (void);
4134 static unsigned int add_ranges (tree);
4135 static void output_ranges (void);
4136 static void output_line_info (void);
4137 static void output_file_names (void);
4138 static dw_die_ref base_type_die (tree);
4139 static tree root_type (tree);
4140 static int is_base_type (tree);
4141 static bool is_subrange_type (tree);
4142 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4143 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4144 static int type_is_enum (tree);
4145 static unsigned int dbx_reg_number (rtx);
4146 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4147 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4148 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4149 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4150 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4151 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4152 static int is_based_loc (rtx);
4153 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4154 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4155 static dw_loc_descr_ref loc_descriptor (rtx);
4156 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4157 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4158 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4159 static tree field_type (tree);
4160 static unsigned int simple_type_align_in_bits (tree);
4161 static unsigned int simple_decl_align_in_bits (tree);
4162 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4163 static HOST_WIDE_INT field_byte_offset (tree);
4164 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4166 static void add_data_member_location_attribute (dw_die_ref, tree);
4167 static void add_const_value_attribute (dw_die_ref, rtx);
4168 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4169 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4170 static void insert_float (rtx, unsigned char *);
4171 static rtx rtl_for_decl_location (tree);
4172 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4173 enum dwarf_attribute);
4174 static void tree_add_const_value_attribute (dw_die_ref, tree);
4175 static void add_name_attribute (dw_die_ref, const char *);
4176 static void add_comp_dir_attribute (dw_die_ref);
4177 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4178 static void add_subscript_info (dw_die_ref, tree);
4179 static void add_byte_size_attribute (dw_die_ref, tree);
4180 static void add_bit_offset_attribute (dw_die_ref, tree);
4181 static void add_bit_size_attribute (dw_die_ref, tree);
4182 static void add_prototyped_attribute (dw_die_ref, tree);
4183 static void add_abstract_origin_attribute (dw_die_ref, tree);
4184 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4185 static void add_src_coords_attributes (dw_die_ref, tree);
4186 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4187 static void push_decl_scope (tree);
4188 static void pop_decl_scope (void);
4189 static dw_die_ref scope_die_for (tree, dw_die_ref);
4190 static inline int local_scope_p (dw_die_ref);
4191 static inline int class_or_namespace_scope_p (dw_die_ref);
4192 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4193 static void add_calling_convention_attribute (dw_die_ref, tree);
4194 static const char *type_tag (tree);
4195 static tree member_declared_type (tree);
4197 static const char *decl_start_label (tree);
4199 static void gen_array_type_die (tree, dw_die_ref);
4201 static void gen_entry_point_die (tree, dw_die_ref);
4203 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4204 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4205 static void gen_inlined_union_type_die (tree, dw_die_ref);
4206 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4207 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4208 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4209 static void gen_formal_types_die (tree, dw_die_ref);
4210 static void gen_subprogram_die (tree, dw_die_ref);
4211 static void gen_variable_die (tree, dw_die_ref);
4212 static void gen_label_die (tree, dw_die_ref);
4213 static void gen_lexical_block_die (tree, dw_die_ref, int);
4214 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4215 static void gen_field_die (tree, dw_die_ref);
4216 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4217 static dw_die_ref gen_compile_unit_die (const char *);
4218 static void gen_inheritance_die (tree, tree, dw_die_ref);
4219 static void gen_member_die (tree, dw_die_ref);
4220 static void gen_struct_or_union_type_die (tree, dw_die_ref,
4221 enum debug_info_usage);
4222 static void gen_subroutine_type_die (tree, dw_die_ref);
4223 static void gen_typedef_die (tree, dw_die_ref);
4224 static void gen_type_die (tree, dw_die_ref);
4225 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4226 static void gen_block_die (tree, dw_die_ref, int);
4227 static void decls_for_scope (tree, dw_die_ref, int);
4228 static int is_redundant_typedef (tree);
4229 static void gen_namespace_die (tree);
4230 static void gen_decl_die (tree, dw_die_ref);
4231 static dw_die_ref force_decl_die (tree);
4232 static dw_die_ref force_type_die (tree);
4233 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4234 static void declare_in_namespace (tree, dw_die_ref);
4235 static struct dwarf_file_data * lookup_filename (const char *);
4236 static void retry_incomplete_types (void);
4237 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4238 static void splice_child_die (dw_die_ref, dw_die_ref);
4239 static int file_info_cmp (const void *, const void *);
4240 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4241 const char *, const char *, unsigned);
4242 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4243 const char *, const char *,
4245 static void output_loc_list (dw_loc_list_ref);
4246 static char *gen_internal_sym (const char *);
4248 static void prune_unmark_dies (dw_die_ref);
4249 static void prune_unused_types_mark (dw_die_ref, int);
4250 static void prune_unused_types_walk (dw_die_ref);
4251 static void prune_unused_types_walk_attribs (dw_die_ref);
4252 static void prune_unused_types_prune (dw_die_ref);
4253 static void prune_unused_types (void);
4254 static int maybe_emit_file (struct dwarf_file_data *fd);
4256 /* Section names used to hold DWARF debugging information. */
4257 #ifndef DEBUG_INFO_SECTION
4258 #define DEBUG_INFO_SECTION ".debug_info"
4260 #ifndef DEBUG_ABBREV_SECTION
4261 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
4263 #ifndef DEBUG_ARANGES_SECTION
4264 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4266 #ifndef DEBUG_MACINFO_SECTION
4267 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4269 #ifndef DEBUG_LINE_SECTION
4270 #define DEBUG_LINE_SECTION ".debug_line"
4272 #ifndef DEBUG_LOC_SECTION
4273 #define DEBUG_LOC_SECTION ".debug_loc"
4275 #ifndef DEBUG_PUBNAMES_SECTION
4276 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
4278 #ifndef DEBUG_STR_SECTION
4279 #define DEBUG_STR_SECTION ".debug_str"
4281 #ifndef DEBUG_RANGES_SECTION
4282 #define DEBUG_RANGES_SECTION ".debug_ranges"
4285 /* Standard ELF section names for compiled code and data. */
4286 #ifndef TEXT_SECTION_NAME
4287 #define TEXT_SECTION_NAME ".text"
4290 /* Section flags for .debug_str section. */
4291 #define DEBUG_STR_SECTION_FLAGS \
4292 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
4293 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4296 /* Labels we insert at beginning sections we can reference instead of
4297 the section names themselves. */
4299 #ifndef TEXT_SECTION_LABEL
4300 #define TEXT_SECTION_LABEL "Ltext"
4302 #ifndef COLD_TEXT_SECTION_LABEL
4303 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4305 #ifndef DEBUG_LINE_SECTION_LABEL
4306 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4308 #ifndef DEBUG_INFO_SECTION_LABEL
4309 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4311 #ifndef DEBUG_ABBREV_SECTION_LABEL
4312 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4314 #ifndef DEBUG_LOC_SECTION_LABEL
4315 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4317 #ifndef DEBUG_RANGES_SECTION_LABEL
4318 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4320 #ifndef DEBUG_MACINFO_SECTION_LABEL
4321 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4324 /* Definitions of defaults for formats and names of various special
4325 (artificial) labels which may be generated within this file (when the -g
4326 options is used and DWARF2_DEBUGGING_INFO is in effect.
4327 If necessary, these may be overridden from within the tm.h file, but
4328 typically, overriding these defaults is unnecessary. */
4330 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4331 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4332 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4333 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4334 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4335 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4336 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4337 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4338 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4339 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4341 #ifndef TEXT_END_LABEL
4342 #define TEXT_END_LABEL "Letext"
4344 #ifndef COLD_END_LABEL
4345 #define COLD_END_LABEL "Letext_cold"
4347 #ifndef BLOCK_BEGIN_LABEL
4348 #define BLOCK_BEGIN_LABEL "LBB"
4350 #ifndef BLOCK_END_LABEL
4351 #define BLOCK_END_LABEL "LBE"
4353 #ifndef LINE_CODE_LABEL
4354 #define LINE_CODE_LABEL "LM"
4356 #ifndef SEPARATE_LINE_CODE_LABEL
4357 #define SEPARATE_LINE_CODE_LABEL "LSM"
4360 /* We allow a language front-end to designate a function that is to be
4361 called to "demangle" any name before it is put into a DIE. */
4363 static const char *(*demangle_name_func) (const char *);
4366 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4368 demangle_name_func = func;
4371 /* Test if rtl node points to a pseudo register. */
4374 is_pseudo_reg (rtx rtl)
4376 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4377 || (GET_CODE (rtl) == SUBREG
4378 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4381 /* Return a reference to a type, with its const and volatile qualifiers
4385 type_main_variant (tree type)
4387 type = TYPE_MAIN_VARIANT (type);
4389 /* ??? There really should be only one main variant among any group of
4390 variants of a given type (and all of the MAIN_VARIANT values for all
4391 members of the group should point to that one type) but sometimes the C
4392 front-end messes this up for array types, so we work around that bug
4394 if (TREE_CODE (type) == ARRAY_TYPE)
4395 while (type != TYPE_MAIN_VARIANT (type))
4396 type = TYPE_MAIN_VARIANT (type);
4401 /* Return nonzero if the given type node represents a tagged type. */
4404 is_tagged_type (tree type)
4406 enum tree_code code = TREE_CODE (type);
4408 return (code == RECORD_TYPE || code == UNION_TYPE
4409 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4412 /* Convert a DIE tag into its string name. */
4415 dwarf_tag_name (unsigned int tag)
4419 case DW_TAG_padding:
4420 return "DW_TAG_padding";
4421 case DW_TAG_array_type:
4422 return "DW_TAG_array_type";
4423 case DW_TAG_class_type:
4424 return "DW_TAG_class_type";
4425 case DW_TAG_entry_point:
4426 return "DW_TAG_entry_point";
4427 case DW_TAG_enumeration_type:
4428 return "DW_TAG_enumeration_type";
4429 case DW_TAG_formal_parameter:
4430 return "DW_TAG_formal_parameter";
4431 case DW_TAG_imported_declaration:
4432 return "DW_TAG_imported_declaration";
4434 return "DW_TAG_label";
4435 case DW_TAG_lexical_block:
4436 return "DW_TAG_lexical_block";
4438 return "DW_TAG_member";
4439 case DW_TAG_pointer_type:
4440 return "DW_TAG_pointer_type";
4441 case DW_TAG_reference_type:
4442 return "DW_TAG_reference_type";
4443 case DW_TAG_compile_unit:
4444 return "DW_TAG_compile_unit";
4445 case DW_TAG_string_type:
4446 return "DW_TAG_string_type";
4447 case DW_TAG_structure_type:
4448 return "DW_TAG_structure_type";
4449 case DW_TAG_subroutine_type:
4450 return "DW_TAG_subroutine_type";
4451 case DW_TAG_typedef:
4452 return "DW_TAG_typedef";
4453 case DW_TAG_union_type:
4454 return "DW_TAG_union_type";
4455 case DW_TAG_unspecified_parameters:
4456 return "DW_TAG_unspecified_parameters";
4457 case DW_TAG_variant:
4458 return "DW_TAG_variant";
4459 case DW_TAG_common_block:
4460 return "DW_TAG_common_block";
4461 case DW_TAG_common_inclusion:
4462 return "DW_TAG_common_inclusion";
4463 case DW_TAG_inheritance:
4464 return "DW_TAG_inheritance";
4465 case DW_TAG_inlined_subroutine:
4466 return "DW_TAG_inlined_subroutine";
4468 return "DW_TAG_module";
4469 case DW_TAG_ptr_to_member_type:
4470 return "DW_TAG_ptr_to_member_type";
4471 case DW_TAG_set_type:
4472 return "DW_TAG_set_type";
4473 case DW_TAG_subrange_type:
4474 return "DW_TAG_subrange_type";
4475 case DW_TAG_with_stmt:
4476 return "DW_TAG_with_stmt";
4477 case DW_TAG_access_declaration:
4478 return "DW_TAG_access_declaration";
4479 case DW_TAG_base_type:
4480 return "DW_TAG_base_type";
4481 case DW_TAG_catch_block:
4482 return "DW_TAG_catch_block";
4483 case DW_TAG_const_type:
4484 return "DW_TAG_const_type";
4485 case DW_TAG_constant:
4486 return "DW_TAG_constant";
4487 case DW_TAG_enumerator:
4488 return "DW_TAG_enumerator";
4489 case DW_TAG_file_type:
4490 return "DW_TAG_file_type";
4492 return "DW_TAG_friend";
4493 case DW_TAG_namelist:
4494 return "DW_TAG_namelist";
4495 case DW_TAG_namelist_item:
4496 return "DW_TAG_namelist_item";
4497 case DW_TAG_namespace:
4498 return "DW_TAG_namespace";
4499 case DW_TAG_packed_type:
4500 return "DW_TAG_packed_type";
4501 case DW_TAG_subprogram:
4502 return "DW_TAG_subprogram";
4503 case DW_TAG_template_type_param:
4504 return "DW_TAG_template_type_param";
4505 case DW_TAG_template_value_param:
4506 return "DW_TAG_template_value_param";
4507 case DW_TAG_thrown_type:
4508 return "DW_TAG_thrown_type";
4509 case DW_TAG_try_block:
4510 return "DW_TAG_try_block";
4511 case DW_TAG_variant_part:
4512 return "DW_TAG_variant_part";
4513 case DW_TAG_variable:
4514 return "DW_TAG_variable";
4515 case DW_TAG_volatile_type:
4516 return "DW_TAG_volatile_type";
4517 case DW_TAG_imported_module:
4518 return "DW_TAG_imported_module";
4519 case DW_TAG_MIPS_loop:
4520 return "DW_TAG_MIPS_loop";
4521 case DW_TAG_format_label:
4522 return "DW_TAG_format_label";
4523 case DW_TAG_function_template:
4524 return "DW_TAG_function_template";
4525 case DW_TAG_class_template:
4526 return "DW_TAG_class_template";
4527 case DW_TAG_GNU_BINCL:
4528 return "DW_TAG_GNU_BINCL";
4529 case DW_TAG_GNU_EINCL:
4530 return "DW_TAG_GNU_EINCL";
4532 return "DW_TAG_<unknown>";
4536 /* Convert a DWARF attribute code into its string name. */
4539 dwarf_attr_name (unsigned int attr)
4544 return "DW_AT_sibling";
4545 case DW_AT_location:
4546 return "DW_AT_location";
4548 return "DW_AT_name";
4549 case DW_AT_ordering:
4550 return "DW_AT_ordering";
4551 case DW_AT_subscr_data:
4552 return "DW_AT_subscr_data";
4553 case DW_AT_byte_size:
4554 return "DW_AT_byte_size";
4555 case DW_AT_bit_offset:
4556 return "DW_AT_bit_offset";
4557 case DW_AT_bit_size:
4558 return "DW_AT_bit_size";
4559 case DW_AT_element_list:
4560 return "DW_AT_element_list";
4561 case DW_AT_stmt_list:
4562 return "DW_AT_stmt_list";
4564 return "DW_AT_low_pc";
4566 return "DW_AT_high_pc";
4567 case DW_AT_language:
4568 return "DW_AT_language";
4570 return "DW_AT_member";
4572 return "DW_AT_discr";
4573 case DW_AT_discr_value:
4574 return "DW_AT_discr_value";
4575 case DW_AT_visibility:
4576 return "DW_AT_visibility";
4578 return "DW_AT_import";
4579 case DW_AT_string_length:
4580 return "DW_AT_string_length";
4581 case DW_AT_common_reference:
4582 return "DW_AT_common_reference";
4583 case DW_AT_comp_dir:
4584 return "DW_AT_comp_dir";
4585 case DW_AT_const_value:
4586 return "DW_AT_const_value";
4587 case DW_AT_containing_type:
4588 return "DW_AT_containing_type";
4589 case DW_AT_default_value:
4590 return "DW_AT_default_value";
4592 return "DW_AT_inline";
4593 case DW_AT_is_optional:
4594 return "DW_AT_is_optional";
4595 case DW_AT_lower_bound:
4596 return "DW_AT_lower_bound";
4597 case DW_AT_producer:
4598 return "DW_AT_producer";
4599 case DW_AT_prototyped:
4600 return "DW_AT_prototyped";
4601 case DW_AT_return_addr:
4602 return "DW_AT_return_addr";
4603 case DW_AT_start_scope:
4604 return "DW_AT_start_scope";
4605 case DW_AT_stride_size:
4606 return "DW_AT_stride_size";
4607 case DW_AT_upper_bound:
4608 return "DW_AT_upper_bound";
4609 case DW_AT_abstract_origin:
4610 return "DW_AT_abstract_origin";
4611 case DW_AT_accessibility:
4612 return "DW_AT_accessibility";
4613 case DW_AT_address_class:
4614 return "DW_AT_address_class";
4615 case DW_AT_artificial:
4616 return "DW_AT_artificial";
4617 case DW_AT_base_types:
4618 return "DW_AT_base_types";
4619 case DW_AT_calling_convention:
4620 return "DW_AT_calling_convention";
4622 return "DW_AT_count";
4623 case DW_AT_data_member_location:
4624 return "DW_AT_data_member_location";
4625 case DW_AT_decl_column:
4626 return "DW_AT_decl_column";
4627 case DW_AT_decl_file:
4628 return "DW_AT_decl_file";
4629 case DW_AT_decl_line:
4630 return "DW_AT_decl_line";
4631 case DW_AT_declaration:
4632 return "DW_AT_declaration";
4633 case DW_AT_discr_list:
4634 return "DW_AT_discr_list";
4635 case DW_AT_encoding:
4636 return "DW_AT_encoding";
4637 case DW_AT_external:
4638 return "DW_AT_external";
4639 case DW_AT_frame_base:
4640 return "DW_AT_frame_base";
4642 return "DW_AT_friend";
4643 case DW_AT_identifier_case:
4644 return "DW_AT_identifier_case";
4645 case DW_AT_macro_info:
4646 return "DW_AT_macro_info";
4647 case DW_AT_namelist_items:
4648 return "DW_AT_namelist_items";
4649 case DW_AT_priority:
4650 return "DW_AT_priority";
4652 return "DW_AT_segment";
4653 case DW_AT_specification:
4654 return "DW_AT_specification";
4655 case DW_AT_static_link:
4656 return "DW_AT_static_link";
4658 return "DW_AT_type";
4659 case DW_AT_use_location:
4660 return "DW_AT_use_location";
4661 case DW_AT_variable_parameter:
4662 return "DW_AT_variable_parameter";
4663 case DW_AT_virtuality:
4664 return "DW_AT_virtuality";
4665 case DW_AT_vtable_elem_location:
4666 return "DW_AT_vtable_elem_location";
4668 case DW_AT_allocated:
4669 return "DW_AT_allocated";
4670 case DW_AT_associated:
4671 return "DW_AT_associated";
4672 case DW_AT_data_location:
4673 return "DW_AT_data_location";
4675 return "DW_AT_stride";
4676 case DW_AT_entry_pc:
4677 return "DW_AT_entry_pc";
4678 case DW_AT_use_UTF8:
4679 return "DW_AT_use_UTF8";
4680 case DW_AT_extension:
4681 return "DW_AT_extension";
4683 return "DW_AT_ranges";
4684 case DW_AT_trampoline:
4685 return "DW_AT_trampoline";
4686 case DW_AT_call_column:
4687 return "DW_AT_call_column";
4688 case DW_AT_call_file:
4689 return "DW_AT_call_file";
4690 case DW_AT_call_line:
4691 return "DW_AT_call_line";
4693 case DW_AT_MIPS_fde:
4694 return "DW_AT_MIPS_fde";
4695 case DW_AT_MIPS_loop_begin:
4696 return "DW_AT_MIPS_loop_begin";
4697 case DW_AT_MIPS_tail_loop_begin:
4698 return "DW_AT_MIPS_tail_loop_begin";
4699 case DW_AT_MIPS_epilog_begin:
4700 return "DW_AT_MIPS_epilog_begin";
4701 case DW_AT_MIPS_loop_unroll_factor:
4702 return "DW_AT_MIPS_loop_unroll_factor";
4703 case DW_AT_MIPS_software_pipeline_depth:
4704 return "DW_AT_MIPS_software_pipeline_depth";
4705 case DW_AT_MIPS_linkage_name:
4706 return "DW_AT_MIPS_linkage_name";
4707 case DW_AT_MIPS_stride:
4708 return "DW_AT_MIPS_stride";
4709 case DW_AT_MIPS_abstract_name:
4710 return "DW_AT_MIPS_abstract_name";
4711 case DW_AT_MIPS_clone_origin:
4712 return "DW_AT_MIPS_clone_origin";
4713 case DW_AT_MIPS_has_inlines:
4714 return "DW_AT_MIPS_has_inlines";
4716 case DW_AT_sf_names:
4717 return "DW_AT_sf_names";
4718 case DW_AT_src_info:
4719 return "DW_AT_src_info";
4720 case DW_AT_mac_info:
4721 return "DW_AT_mac_info";
4722 case DW_AT_src_coords:
4723 return "DW_AT_src_coords";
4724 case DW_AT_body_begin:
4725 return "DW_AT_body_begin";
4726 case DW_AT_body_end:
4727 return "DW_AT_body_end";
4728 case DW_AT_GNU_vector:
4729 return "DW_AT_GNU_vector";
4731 case DW_AT_VMS_rtnbeg_pd_address:
4732 return "DW_AT_VMS_rtnbeg_pd_address";
4734 /* APPLE LOCAL begin radar 5811943 - Fix type of pointers to Blocks */
4735 case DW_AT_APPLE_block:
4736 return "DW_AT_APPLE_block";
4737 /* APPLE LOCAL end radar 5811943 - Fix type of pointers to Blocks */
4740 return "DW_AT_<unknown>";
4744 /* Convert a DWARF value form code into its string name. */
4747 dwarf_form_name (unsigned int form)
4752 return "DW_FORM_addr";
4753 case DW_FORM_block2:
4754 return "DW_FORM_block2";
4755 case DW_FORM_block4:
4756 return "DW_FORM_block4";
4758 return "DW_FORM_data2";
4760 return "DW_FORM_data4";
4762 return "DW_FORM_data8";
4763 case DW_FORM_string:
4764 return "DW_FORM_string";
4766 return "DW_FORM_block";
4767 case DW_FORM_block1:
4768 return "DW_FORM_block1";
4770 return "DW_FORM_data1";
4772 return "DW_FORM_flag";
4774 return "DW_FORM_sdata";
4776 return "DW_FORM_strp";
4778 return "DW_FORM_udata";
4779 case DW_FORM_ref_addr:
4780 return "DW_FORM_ref_addr";
4782 return "DW_FORM_ref1";
4784 return "DW_FORM_ref2";
4786 return "DW_FORM_ref4";
4788 return "DW_FORM_ref8";
4789 case DW_FORM_ref_udata:
4790 return "DW_FORM_ref_udata";
4791 case DW_FORM_indirect:
4792 return "DW_FORM_indirect";
4794 return "DW_FORM_<unknown>";
4798 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4799 instance of an inlined instance of a decl which is local to an inline
4800 function, so we have to trace all of the way back through the origin chain
4801 to find out what sort of node actually served as the original seed for the
4805 decl_ultimate_origin (tree decl)
4807 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4810 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4811 nodes in the function to point to themselves; ignore that if
4812 we're trying to output the abstract instance of this function. */
4813 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4816 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4817 most distant ancestor, this should never happen. */
4818 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4820 return DECL_ABSTRACT_ORIGIN (decl);
4823 /* Determine the "ultimate origin" of a block. The block may be an inlined
4824 instance of an inlined instance of a block which is local to an inline
4825 function, so we have to trace all of the way back through the origin chain
4826 to find out what sort of node actually served as the original seed for the
4830 block_ultimate_origin (tree block)
4832 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4834 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4835 nodes in the function to point to themselves; ignore that if
4836 we're trying to output the abstract instance of this function. */
4837 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4840 if (immediate_origin == NULL_TREE)
4845 tree lookahead = immediate_origin;
4849 ret_val = lookahead;
4850 lookahead = (TREE_CODE (ret_val) == BLOCK
4851 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4853 while (lookahead != NULL && lookahead != ret_val);
4855 /* The block's abstract origin chain may not be the *ultimate* origin of
4856 the block. It could lead to a DECL that has an abstract origin set.
4857 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4858 will give us if it has one). Note that DECL's abstract origins are
4859 supposed to be the most distant ancestor (or so decl_ultimate_origin
4860 claims), so we don't need to loop following the DECL origins. */
4861 if (DECL_P (ret_val))
4862 return DECL_ORIGIN (ret_val);
4868 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4869 of a virtual function may refer to a base class, so we check the 'this'
4873 decl_class_context (tree decl)
4875 tree context = NULL_TREE;
4877 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4878 context = DECL_CONTEXT (decl);
4880 context = TYPE_MAIN_VARIANT
4881 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4883 if (context && !TYPE_P (context))
4884 context = NULL_TREE;
4889 /* Add an attribute/value pair to a DIE. */
4892 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4894 /* Maybe this should be an assert? */
4898 if (die->die_attr == NULL)
4899 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
4900 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
4903 static inline enum dw_val_class
4904 AT_class (dw_attr_ref a)
4906 return a->dw_attr_val.val_class;
4909 /* Add a flag value attribute to a DIE. */
4912 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4916 attr.dw_attr = attr_kind;
4917 attr.dw_attr_val.val_class = dw_val_class_flag;
4918 attr.dw_attr_val.v.val_flag = flag;
4919 add_dwarf_attr (die, &attr);
4922 static inline unsigned
4923 AT_flag (dw_attr_ref a)
4925 gcc_assert (a && AT_class (a) == dw_val_class_flag);
4926 return a->dw_attr_val.v.val_flag;
4929 /* Add a signed integer attribute value to a DIE. */
4932 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4936 attr.dw_attr = attr_kind;
4937 attr.dw_attr_val.val_class = dw_val_class_const;
4938 attr.dw_attr_val.v.val_int = int_val;
4939 add_dwarf_attr (die, &attr);
4942 static inline HOST_WIDE_INT
4943 AT_int (dw_attr_ref a)
4945 gcc_assert (a && AT_class (a) == dw_val_class_const);
4946 return a->dw_attr_val.v.val_int;
4949 /* Add an unsigned integer attribute value to a DIE. */
4952 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4953 unsigned HOST_WIDE_INT unsigned_val)
4957 attr.dw_attr = attr_kind;
4958 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
4959 attr.dw_attr_val.v.val_unsigned = unsigned_val;
4960 add_dwarf_attr (die, &attr);
4963 static inline unsigned HOST_WIDE_INT
4964 AT_unsigned (dw_attr_ref a)
4966 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4967 return a->dw_attr_val.v.val_unsigned;
4970 /* Add an unsigned double integer attribute value to a DIE. */
4973 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4974 long unsigned int val_hi, long unsigned int val_low)
4978 attr.dw_attr = attr_kind;
4979 attr.dw_attr_val.val_class = dw_val_class_long_long;
4980 attr.dw_attr_val.v.val_long_long.hi = val_hi;
4981 attr.dw_attr_val.v.val_long_long.low = val_low;
4982 add_dwarf_attr (die, &attr);
4985 /* Add a floating point attribute value to a DIE and return it. */
4988 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4989 unsigned int length, unsigned int elt_size, unsigned char *array)
4993 attr.dw_attr = attr_kind;
4994 attr.dw_attr_val.val_class = dw_val_class_vec;
4995 attr.dw_attr_val.v.val_vec.length = length;
4996 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
4997 attr.dw_attr_val.v.val_vec.array = array;
4998 add_dwarf_attr (die, &attr);
5001 /* Hash and equality functions for debug_str_hash. */
5004 debug_str_do_hash (const void *x)
5006 return htab_hash_string (((const struct indirect_string_node *)x)->str);
5010 debug_str_eq (const void *x1, const void *x2)
5012 return strcmp ((((const struct indirect_string_node *)x1)->str),
5013 (const char *)x2) == 0;
5016 /* Add a string attribute value to a DIE. */
5019 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5022 struct indirect_string_node *node;
5025 if (! debug_str_hash)
5026 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5027 debug_str_eq, NULL);
5029 slot = htab_find_slot_with_hash (debug_str_hash, str,
5030 htab_hash_string (str), INSERT);
5032 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
5033 node = (struct indirect_string_node *) *slot;
5034 node->str = ggc_strdup (str);
5037 attr.dw_attr = attr_kind;
5038 attr.dw_attr_val.val_class = dw_val_class_str;
5039 attr.dw_attr_val.v.val_str = node;
5040 add_dwarf_attr (die, &attr);
5043 static inline const char *
5044 AT_string (dw_attr_ref a)
5046 gcc_assert (a && AT_class (a) == dw_val_class_str);
5047 return a->dw_attr_val.v.val_str->str;
5050 /* Find out whether a string should be output inline in DIE
5051 or out-of-line in .debug_str section. */
5054 AT_string_form (dw_attr_ref a)
5056 struct indirect_string_node *node;
5060 gcc_assert (a && AT_class (a) == dw_val_class_str);
5062 node = a->dw_attr_val.v.val_str;
5066 len = strlen (node->str) + 1;
5068 /* If the string is shorter or equal to the size of the reference, it is
5069 always better to put it inline. */
5070 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5071 return node->form = DW_FORM_string;
5073 /* If we cannot expect the linker to merge strings in .debug_str
5074 section, only put it into .debug_str if it is worth even in this
5076 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5077 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5078 return node->form = DW_FORM_string;
5080 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5081 ++dw2_string_counter;
5082 node->label = xstrdup (label);
5084 return node->form = DW_FORM_strp;
5087 /* Add a DIE reference attribute value to a DIE. */
5090 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5094 attr.dw_attr = attr_kind;
5095 attr.dw_attr_val.val_class = dw_val_class_die_ref;
5096 attr.dw_attr_val.v.val_die_ref.die = targ_die;
5097 attr.dw_attr_val.v.val_die_ref.external = 0;
5098 add_dwarf_attr (die, &attr);
5101 /* Add an AT_specification attribute to a DIE, and also make the back
5102 pointer from the specification to the definition. */
5105 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5107 add_AT_die_ref (die, DW_AT_specification, targ_die);
5108 gcc_assert (!targ_die->die_definition);
5109 targ_die->die_definition = die;
5112 static inline dw_die_ref
5113 AT_ref (dw_attr_ref a)
5115 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5116 return a->dw_attr_val.v.val_die_ref.die;
5120 AT_ref_external (dw_attr_ref a)
5122 if (a && AT_class (a) == dw_val_class_die_ref)
5123 return a->dw_attr_val.v.val_die_ref.external;
5129 set_AT_ref_external (dw_attr_ref a, int i)
5131 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5132 a->dw_attr_val.v.val_die_ref.external = i;
5135 /* Add an FDE reference attribute value to a DIE. */
5138 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5142 attr.dw_attr = attr_kind;
5143 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
5144 attr.dw_attr_val.v.val_fde_index = targ_fde;
5145 add_dwarf_attr (die, &attr);
5148 /* Add a location description attribute value to a DIE. */
5151 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5155 attr.dw_attr = attr_kind;
5156 attr.dw_attr_val.val_class = dw_val_class_loc;
5157 attr.dw_attr_val.v.val_loc = loc;
5158 add_dwarf_attr (die, &attr);
5161 static inline dw_loc_descr_ref
5162 AT_loc (dw_attr_ref a)
5164 gcc_assert (a && AT_class (a) == dw_val_class_loc);
5165 return a->dw_attr_val.v.val_loc;
5169 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5173 attr.dw_attr = attr_kind;
5174 attr.dw_attr_val.val_class = dw_val_class_loc_list;
5175 attr.dw_attr_val.v.val_loc_list = loc_list;
5176 add_dwarf_attr (die, &attr);
5177 have_location_lists = true;
5180 static inline dw_loc_list_ref
5181 AT_loc_list (dw_attr_ref a)
5183 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5184 return a->dw_attr_val.v.val_loc_list;
5187 /* Add an address constant attribute value to a DIE. */
5190 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5194 attr.dw_attr = attr_kind;
5195 attr.dw_attr_val.val_class = dw_val_class_addr;
5196 attr.dw_attr_val.v.val_addr = addr;
5197 add_dwarf_attr (die, &attr);
5200 /* Get the RTX from to an address DIE attribute. */
5203 AT_addr (dw_attr_ref a)
5205 gcc_assert (a && AT_class (a) == dw_val_class_addr);
5206 return a->dw_attr_val.v.val_addr;
5209 /* Add a file attribute value to a DIE. */
5212 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
5213 struct dwarf_file_data *fd)
5217 attr.dw_attr = attr_kind;
5218 attr.dw_attr_val.val_class = dw_val_class_file;
5219 attr.dw_attr_val.v.val_file = fd;
5220 add_dwarf_attr (die, &attr);
5223 /* Get the dwarf_file_data from a file DIE attribute. */
5225 static inline struct dwarf_file_data *
5226 AT_file (dw_attr_ref a)
5228 gcc_assert (a && AT_class (a) == dw_val_class_file);
5229 return a->dw_attr_val.v.val_file;
5232 /* Add a label identifier attribute value to a DIE. */
5235 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5239 attr.dw_attr = attr_kind;
5240 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
5241 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5242 add_dwarf_attr (die, &attr);
5245 /* Add a section offset attribute value to a DIE, an offset into the
5246 debug_line section. */
5249 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5254 attr.dw_attr = attr_kind;
5255 attr.dw_attr_val.val_class = dw_val_class_lineptr;
5256 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5257 add_dwarf_attr (die, &attr);
5260 /* Add a section offset attribute value to a DIE, an offset into the
5261 debug_macinfo section. */
5264 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5269 attr.dw_attr = attr_kind;
5270 attr.dw_attr_val.val_class = dw_val_class_macptr;
5271 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5272 add_dwarf_attr (die, &attr);
5275 /* Add an offset attribute value to a DIE. */
5278 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5279 unsigned HOST_WIDE_INT offset)
5283 attr.dw_attr = attr_kind;
5284 attr.dw_attr_val.val_class = dw_val_class_offset;
5285 attr.dw_attr_val.v.val_offset = offset;
5286 add_dwarf_attr (die, &attr);
5289 /* Add an range_list attribute value to a DIE. */
5292 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5293 long unsigned int offset)
5297 attr.dw_attr = attr_kind;
5298 attr.dw_attr_val.val_class = dw_val_class_range_list;
5299 attr.dw_attr_val.v.val_offset = offset;
5300 add_dwarf_attr (die, &attr);
5303 static inline const char *
5304 AT_lbl (dw_attr_ref a)
5306 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5307 || AT_class (a) == dw_val_class_lineptr
5308 || AT_class (a) == dw_val_class_macptr));
5309 return a->dw_attr_val.v.val_lbl_id;
5312 /* Get the attribute of type attr_kind. */
5315 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5319 dw_die_ref spec = NULL;
5324 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5325 if (a->dw_attr == attr_kind)
5327 else if (a->dw_attr == DW_AT_specification
5328 || a->dw_attr == DW_AT_abstract_origin)
5332 return get_AT (spec, attr_kind);
5337 /* Return the "low pc" attribute value, typically associated with a subprogram
5338 DIE. Return null if the "low pc" attribute is either not present, or if it
5339 cannot be represented as an assembler label identifier. */
5341 static inline const char *
5342 get_AT_low_pc (dw_die_ref die)
5344 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5346 return a ? AT_lbl (a) : NULL;
5349 /* Return the "high pc" attribute value, typically associated with a subprogram
5350 DIE. Return null if the "high pc" attribute is either not present, or if it
5351 cannot be represented as an assembler label identifier. */
5353 static inline const char *
5354 get_AT_hi_pc (dw_die_ref die)
5356 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5358 return a ? AT_lbl (a) : NULL;
5361 /* Return the value of the string attribute designated by ATTR_KIND, or
5362 NULL if it is not present. */
5364 static inline const char *
5365 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5367 dw_attr_ref a = get_AT (die, attr_kind);
5369 return a ? AT_string (a) : NULL;
5372 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5373 if it is not present. */
5376 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5378 dw_attr_ref a = get_AT (die, attr_kind);
5380 return a ? AT_flag (a) : 0;
5383 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5384 if it is not present. */
5386 static inline unsigned
5387 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5389 dw_attr_ref a = get_AT (die, attr_kind);
5391 return a ? AT_unsigned (a) : 0;
5394 static inline dw_die_ref
5395 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5397 dw_attr_ref a = get_AT (die, attr_kind);
5399 return a ? AT_ref (a) : NULL;
5402 static inline struct dwarf_file_data *
5403 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
5405 dw_attr_ref a = get_AT (die, attr_kind);
5407 return a ? AT_file (a) : NULL;
5410 /* Return TRUE if the language is C or C++. */
5415 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5417 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
5418 || lang == DW_LANG_C99
5419 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
5422 /* Return TRUE if the language is C++. */
5427 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5429 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
5432 /* Return TRUE if the language is Fortran. */
5437 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5439 return (lang == DW_LANG_Fortran77
5440 || lang == DW_LANG_Fortran90
5441 || lang == DW_LANG_Fortran95);
5444 /* Return TRUE if the language is Java. */
5449 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5451 return lang == DW_LANG_Java;
5454 /* Return TRUE if the language is Ada. */
5459 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5461 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5464 /* Remove the specified attribute if present. */
5467 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5475 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5476 if (a->dw_attr == attr_kind)
5478 if (AT_class (a) == dw_val_class_str)
5479 if (a->dw_attr_val.v.val_str->refcount)
5480 a->dw_attr_val.v.val_str->refcount--;
5482 /* VEC_ordered_remove should help reduce the number of abbrevs
5484 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
5489 /* Remove CHILD from its parent. PREV must have the property that
5490 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5493 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
5495 gcc_assert (child->die_parent == prev->die_parent);
5496 gcc_assert (prev->die_sib == child);
5499 gcc_assert (child->die_parent->die_child == child);
5503 prev->die_sib = child->die_sib;
5504 if (child->die_parent->die_child == child)
5505 child->die_parent->die_child = prev;
5508 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5512 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5518 dw_die_ref prev = c;
5520 while (c->die_tag == tag)
5522 remove_child_with_prev (c, prev);
5523 /* Might have removed every child. */
5524 if (c == c->die_sib)
5528 } while (c != die->die_child);
5531 /* Add a CHILD_DIE as the last child of DIE. */
5534 add_child_die (dw_die_ref die, dw_die_ref child_die)
5536 /* FIXME this should probably be an assert. */
5537 if (! die || ! child_die)
5539 gcc_assert (die != child_die);
5541 child_die->die_parent = die;
5544 child_die->die_sib = die->die_child->die_sib;
5545 die->die_child->die_sib = child_die;
5548 child_die->die_sib = child_die;
5549 die->die_child = child_die;
5552 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5553 is the specification, to the end of PARENT's list of children.
5554 This is done by removing and re-adding it. */
5557 splice_child_die (dw_die_ref parent, dw_die_ref child)
5561 /* We want the declaration DIE from inside the class, not the
5562 specification DIE at toplevel. */
5563 if (child->die_parent != parent)
5565 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5571 gcc_assert (child->die_parent == parent
5572 || (child->die_parent
5573 == get_AT_ref (parent, DW_AT_specification)));
5575 for (p = child->die_parent->die_child; ; p = p->die_sib)
5576 if (p->die_sib == child)
5578 remove_child_with_prev (child, p);
5582 add_child_die (parent, child);
5585 /* Return a pointer to a newly created DIE node. */
5587 static inline dw_die_ref
5588 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5590 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5592 die->die_tag = tag_value;
5594 if (parent_die != NULL)
5595 add_child_die (parent_die, die);
5598 limbo_die_node *limbo_node;
5600 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5601 limbo_node->die = die;
5602 limbo_node->created_for = t;
5603 limbo_node->next = limbo_die_list;
5604 limbo_die_list = limbo_node;
5610 /* Return the DIE associated with the given type specifier. */
5612 static inline dw_die_ref
5613 lookup_type_die (tree type)
5615 return TYPE_SYMTAB_DIE (type);
5618 /* Equate a DIE to a given type specifier. */
5621 equate_type_number_to_die (tree type, dw_die_ref type_die)
5623 TYPE_SYMTAB_DIE (type) = type_die;
5626 /* Returns a hash value for X (which really is a die_struct). */
5629 decl_die_table_hash (const void *x)
5631 return (hashval_t) ((const dw_die_ref) x)->decl_id;
5634 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5637 decl_die_table_eq (const void *x, const void *y)
5639 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5642 /* Return the DIE associated with a given declaration. */
5644 static inline dw_die_ref
5645 lookup_decl_die (tree decl)
5647 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5650 /* Returns a hash value for X (which really is a var_loc_list). */
5653 decl_loc_table_hash (const void *x)
5655 return (hashval_t) ((const var_loc_list *) x)->decl_id;
5658 /* Return nonzero if decl_id of var_loc_list X is the same as
5662 decl_loc_table_eq (const void *x, const void *y)
5664 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5667 /* Return the var_loc list associated with a given declaration. */
5669 static inline var_loc_list *
5670 lookup_decl_loc (tree decl)
5672 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5675 /* Equate a DIE to a particular declaration. */
5678 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5680 unsigned int decl_id = DECL_UID (decl);
5683 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5685 decl_die->decl_id = decl_id;
5688 /* Add a variable location node to the linked list for DECL. */
5691 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5693 unsigned int decl_id = DECL_UID (decl);
5697 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5700 temp = ggc_alloc_cleared (sizeof (var_loc_list));
5701 temp->decl_id = decl_id;
5709 /* If the current location is the same as the end of the list,
5710 we have nothing to do. */
5711 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5712 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5714 /* Add LOC to the end of list and update LAST. */
5715 temp->last->next = loc;
5719 /* Do not add empty location to the beginning of the list. */
5720 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5727 /* Keep track of the number of spaces used to indent the
5728 output of the debugging routines that print the structure of
5729 the DIE internal representation. */
5730 static int print_indent;
5732 /* Indent the line the number of spaces given by print_indent. */
5735 print_spaces (FILE *outfile)
5737 fprintf (outfile, "%*s", print_indent, "");
5740 /* Print the information associated with a given DIE, and its children.
5741 This routine is a debugging aid only. */
5744 print_die (dw_die_ref die, FILE *outfile)
5750 print_spaces (outfile);
5751 fprintf (outfile, "DIE %4ld: %s\n",
5752 die->die_offset, dwarf_tag_name (die->die_tag));
5753 print_spaces (outfile);
5754 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5755 fprintf (outfile, " offset: %ld\n", die->die_offset);
5757 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
5759 print_spaces (outfile);
5760 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5762 switch (AT_class (a))
5764 case dw_val_class_addr:
5765 fprintf (outfile, "address");
5767 case dw_val_class_offset:
5768 fprintf (outfile, "offset");
5770 case dw_val_class_loc:
5771 fprintf (outfile, "location descriptor");
5773 case dw_val_class_loc_list:
5774 fprintf (outfile, "location list -> label:%s",
5775 AT_loc_list (a)->ll_symbol);
5777 case dw_val_class_range_list:
5778 fprintf (outfile, "range list");
5780 case dw_val_class_const:
5781 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5783 case dw_val_class_unsigned_const:
5784 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5786 case dw_val_class_long_long:
5787 fprintf (outfile, "constant (%lu,%lu)",
5788 a->dw_attr_val.v.val_long_long.hi,
5789 a->dw_attr_val.v.val_long_long.low);
5791 case dw_val_class_vec:
5792 fprintf (outfile, "floating-point or vector constant");
5794 case dw_val_class_flag:
5795 fprintf (outfile, "%u", AT_flag (a));
5797 case dw_val_class_die_ref:
5798 if (AT_ref (a) != NULL)
5800 if (AT_ref (a)->die_symbol)
5801 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5803 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
5806 fprintf (outfile, "die -> <null>");
5808 case dw_val_class_lbl_id:
5809 case dw_val_class_lineptr:
5810 case dw_val_class_macptr:
5811 fprintf (outfile, "label: %s", AT_lbl (a));
5813 case dw_val_class_str:
5814 if (AT_string (a) != NULL)
5815 fprintf (outfile, "\"%s\"", AT_string (a));
5817 fprintf (outfile, "<null>");
5819 case dw_val_class_file:
5820 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
5821 AT_file (a)->emitted_number);
5827 fprintf (outfile, "\n");
5830 if (die->die_child != NULL)
5833 FOR_EACH_CHILD (die, c, print_die (c, outfile));
5836 if (print_indent == 0)
5837 fprintf (outfile, "\n");
5840 /* Print the contents of the source code line number correspondence table.
5841 This routine is a debugging aid only. */
5844 print_dwarf_line_table (FILE *outfile)
5847 dw_line_info_ref line_info;
5849 fprintf (outfile, "\n\nDWARF source line information\n");
5850 for (i = 1; i < line_info_table_in_use; i++)
5852 line_info = &line_info_table[i];
5853 fprintf (outfile, "%5d: %4ld %6ld\n", i,
5854 line_info->dw_file_num,
5855 line_info->dw_line_num);
5858 fprintf (outfile, "\n\n");
5861 /* Print the information collected for a given DIE. */
5864 debug_dwarf_die (dw_die_ref die)
5866 print_die (die, stderr);
5869 /* Print all DWARF information collected for the compilation unit.
5870 This routine is a debugging aid only. */
5876 print_die (comp_unit_die, stderr);
5877 if (! DWARF2_ASM_LINE_DEBUG_INFO)
5878 print_dwarf_line_table (stderr);
5881 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5882 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5883 DIE that marks the start of the DIEs for this include file. */
5886 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5888 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5889 dw_die_ref new_unit = gen_compile_unit_die (filename);
5891 new_unit->die_sib = old_unit;
5895 /* Close an include-file CU and reopen the enclosing one. */
5898 pop_compile_unit (dw_die_ref old_unit)
5900 dw_die_ref new_unit = old_unit->die_sib;
5902 old_unit->die_sib = NULL;
5906 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5907 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5909 /* Calculate the checksum of a location expression. */
5912 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5914 CHECKSUM (loc->dw_loc_opc);
5915 CHECKSUM (loc->dw_loc_oprnd1);
5916 CHECKSUM (loc->dw_loc_oprnd2);
5919 /* Calculate the checksum of an attribute. */
5922 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5924 dw_loc_descr_ref loc;
5927 CHECKSUM (at->dw_attr);
5929 /* We don't care that this was compiled with a different compiler
5930 snapshot; if the output is the same, that's what matters. */
5931 if (at->dw_attr == DW_AT_producer)
5934 switch (AT_class (at))
5936 case dw_val_class_const:
5937 CHECKSUM (at->dw_attr_val.v.val_int);
5939 case dw_val_class_unsigned_const:
5940 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5942 case dw_val_class_long_long:
5943 CHECKSUM (at->dw_attr_val.v.val_long_long);
5945 case dw_val_class_vec:
5946 CHECKSUM (at->dw_attr_val.v.val_vec);
5948 case dw_val_class_flag:
5949 CHECKSUM (at->dw_attr_val.v.val_flag);
5951 case dw_val_class_str:
5952 CHECKSUM_STRING (AT_string (at));
5955 case dw_val_class_addr:
5957 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5958 CHECKSUM_STRING (XSTR (r, 0));
5961 case dw_val_class_offset:
5962 CHECKSUM (at->dw_attr_val.v.val_offset);
5965 case dw_val_class_loc:
5966 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5967 loc_checksum (loc, ctx);
5970 case dw_val_class_die_ref:
5971 die_checksum (AT_ref (at), ctx, mark);
5974 case dw_val_class_fde_ref:
5975 case dw_val_class_lbl_id:
5976 case dw_val_class_lineptr:
5977 case dw_val_class_macptr:
5980 case dw_val_class_file:
5981 CHECKSUM_STRING (AT_file (at)->filename);
5989 /* Calculate the checksum of a DIE. */
5992 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5998 /* To avoid infinite recursion. */
6001 CHECKSUM (die->die_mark);
6004 die->die_mark = ++(*mark);
6006 CHECKSUM (die->die_tag);
6008 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6009 attr_checksum (a, ctx, mark);
6011 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6015 #undef CHECKSUM_STRING
6017 /* Do the location expressions look same? */
6019 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6021 return loc1->dw_loc_opc == loc2->dw_loc_opc
6022 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6023 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6026 /* Do the values look the same? */
6028 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
6030 dw_loc_descr_ref loc1, loc2;
6033 if (v1->val_class != v2->val_class)
6036 switch (v1->val_class)
6038 case dw_val_class_const:
6039 return v1->v.val_int == v2->v.val_int;
6040 case dw_val_class_unsigned_const:
6041 return v1->v.val_unsigned == v2->v.val_unsigned;
6042 case dw_val_class_long_long:
6043 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6044 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6045 case dw_val_class_vec:
6046 if (v1->v.val_vec.length != v2->v.val_vec.length
6047 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6049 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6050 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6053 case dw_val_class_flag:
6054 return v1->v.val_flag == v2->v.val_flag;
6055 case dw_val_class_str:
6056 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6058 case dw_val_class_addr:
6059 r1 = v1->v.val_addr;
6060 r2 = v2->v.val_addr;
6061 if (GET_CODE (r1) != GET_CODE (r2))
6063 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6064 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6066 case dw_val_class_offset:
6067 return v1->v.val_offset == v2->v.val_offset;
6069 case dw_val_class_loc:
6070 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6072 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6073 if (!same_loc_p (loc1, loc2, mark))
6075 return !loc1 && !loc2;
6077 case dw_val_class_die_ref:
6078 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6080 case dw_val_class_fde_ref:
6081 case dw_val_class_lbl_id:
6082 case dw_val_class_lineptr:
6083 case dw_val_class_macptr:
6086 case dw_val_class_file:
6087 return v1->v.val_file == v2->v.val_file;
6094 /* Do the attributes look the same? */
6097 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6099 if (at1->dw_attr != at2->dw_attr)
6102 /* We don't care that this was compiled with a different compiler
6103 snapshot; if the output is the same, that's what matters. */
6104 if (at1->dw_attr == DW_AT_producer)
6107 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6110 /* Do the dies look the same? */
6113 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6119 /* To avoid infinite recursion. */
6121 return die1->die_mark == die2->die_mark;
6122 die1->die_mark = die2->die_mark = ++(*mark);
6124 if (die1->die_tag != die2->die_tag)
6127 if (VEC_length (dw_attr_node, die1->die_attr)
6128 != VEC_length (dw_attr_node, die2->die_attr))
6131 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
6132 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
6135 c1 = die1->die_child;
6136 c2 = die2->die_child;
6145 if (!same_die_p (c1, c2, mark))
6149 if (c1 == die1->die_child)
6151 if (c2 == die2->die_child)
6161 /* Do the dies look the same? Wrapper around same_die_p. */
6164 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6167 int ret = same_die_p (die1, die2, &mark);
6169 unmark_all_dies (die1);
6170 unmark_all_dies (die2);
6175 /* The prefix to attach to symbols on DIEs in the current comdat debug
6177 static char *comdat_symbol_id;
6179 /* The index of the current symbol within the current comdat CU. */
6180 static unsigned int comdat_symbol_number;
6182 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6183 children, and set comdat_symbol_id accordingly. */
6186 compute_section_prefix (dw_die_ref unit_die)
6188 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6189 const char *base = die_name ? lbasename (die_name) : "anonymous";
6190 char *name = alloca (strlen (base) + 64);
6193 unsigned char checksum[16];
6196 /* Compute the checksum of the DIE, then append part of it as hex digits to
6197 the name filename of the unit. */
6199 md5_init_ctx (&ctx);
6201 die_checksum (unit_die, &ctx, &mark);
6202 unmark_all_dies (unit_die);
6203 md5_finish_ctx (&ctx, checksum);
6205 sprintf (name, "%s.", base);
6206 clean_symbol_name (name);
6208 p = name + strlen (name);
6209 for (i = 0; i < 4; i++)
6211 sprintf (p, "%.2x", checksum[i]);
6215 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6216 comdat_symbol_number = 0;
6219 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6222 is_type_die (dw_die_ref die)
6224 switch (die->die_tag)
6226 case DW_TAG_array_type:
6227 case DW_TAG_class_type:
6228 case DW_TAG_enumeration_type:
6229 case DW_TAG_pointer_type:
6230 case DW_TAG_reference_type:
6231 case DW_TAG_string_type:
6232 case DW_TAG_structure_type:
6233 case DW_TAG_subroutine_type:
6234 case DW_TAG_union_type:
6235 case DW_TAG_ptr_to_member_type:
6236 case DW_TAG_set_type:
6237 case DW_TAG_subrange_type:
6238 case DW_TAG_base_type:
6239 case DW_TAG_const_type:
6240 case DW_TAG_file_type:
6241 case DW_TAG_packed_type:
6242 case DW_TAG_volatile_type:
6243 case DW_TAG_typedef:
6250 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6251 Basically, we want to choose the bits that are likely to be shared between
6252 compilations (types) and leave out the bits that are specific to individual
6253 compilations (functions). */
6256 is_comdat_die (dw_die_ref c)
6258 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6259 we do for stabs. The advantage is a greater likelihood of sharing between
6260 objects that don't include headers in the same order (and therefore would
6261 put the base types in a different comdat). jason 8/28/00 */
6263 if (c->die_tag == DW_TAG_base_type)
6266 if (c->die_tag == DW_TAG_pointer_type
6267 || c->die_tag == DW_TAG_reference_type
6268 || c->die_tag == DW_TAG_const_type
6269 || c->die_tag == DW_TAG_volatile_type)
6271 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6273 return t ? is_comdat_die (t) : 0;
6276 return is_type_die (c);
6279 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6280 compilation unit. */
6283 is_symbol_die (dw_die_ref c)
6285 return (is_type_die (c)
6286 || (get_AT (c, DW_AT_declaration)
6287 && !get_AT (c, DW_AT_specification))
6288 || c->die_tag == DW_TAG_namespace);
6292 gen_internal_sym (const char *prefix)
6296 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6297 return xstrdup (buf);
6300 /* Assign symbols to all worthy DIEs under DIE. */
6303 assign_symbol_names (dw_die_ref die)
6307 if (is_symbol_die (die))
6309 if (comdat_symbol_id)
6311 char *p = alloca (strlen (comdat_symbol_id) + 64);
6313 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6314 comdat_symbol_id, comdat_symbol_number++);
6315 die->die_symbol = xstrdup (p);
6318 die->die_symbol = gen_internal_sym ("LDIE");
6321 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
6324 struct cu_hash_table_entry
6327 unsigned min_comdat_num, max_comdat_num;
6328 struct cu_hash_table_entry *next;
6331 /* Routines to manipulate hash table of CUs. */
6333 htab_cu_hash (const void *of)
6335 const struct cu_hash_table_entry *entry = of;
6337 return htab_hash_string (entry->cu->die_symbol);
6341 htab_cu_eq (const void *of1, const void *of2)
6343 const struct cu_hash_table_entry *entry1 = of1;
6344 const struct die_struct *entry2 = of2;
6346 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6350 htab_cu_del (void *what)
6352 struct cu_hash_table_entry *next, *entry = what;
6362 /* Check whether we have already seen this CU and set up SYM_NUM
6365 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6367 struct cu_hash_table_entry dummy;
6368 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6370 dummy.max_comdat_num = 0;
6372 slot = (struct cu_hash_table_entry **)
6373 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6377 for (; entry; last = entry, entry = entry->next)
6379 if (same_die_p_wrap (cu, entry->cu))
6385 *sym_num = entry->min_comdat_num;
6389 entry = XCNEW (struct cu_hash_table_entry);
6391 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6392 entry->next = *slot;
6398 /* Record SYM_NUM to record of CU in HTABLE. */
6400 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6402 struct cu_hash_table_entry **slot, *entry;
6404 slot = (struct cu_hash_table_entry **)
6405 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6409 entry->max_comdat_num = sym_num;
6412 /* Traverse the DIE (which is always comp_unit_die), and set up
6413 additional compilation units for each of the include files we see
6414 bracketed by BINCL/EINCL. */
6417 break_out_includes (dw_die_ref die)
6420 dw_die_ref unit = NULL;
6421 limbo_die_node *node, **pnode;
6422 htab_t cu_hash_table;
6426 dw_die_ref prev = c;
6428 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6429 || (unit && is_comdat_die (c)))
6431 dw_die_ref next = c->die_sib;
6433 /* This DIE is for a secondary CU; remove it from the main one. */
6434 remove_child_with_prev (c, prev);
6436 if (c->die_tag == DW_TAG_GNU_BINCL)
6437 unit = push_new_compile_unit (unit, c);
6438 else if (c->die_tag == DW_TAG_GNU_EINCL)
6439 unit = pop_compile_unit (unit);
6441 add_child_die (unit, c);
6443 if (c == die->die_child)
6446 } while (c != die->die_child);
6449 /* We can only use this in debugging, since the frontend doesn't check
6450 to make sure that we leave every include file we enter. */
6454 assign_symbol_names (die);
6455 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6456 for (node = limbo_die_list, pnode = &limbo_die_list;
6462 compute_section_prefix (node->die);
6463 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6464 &comdat_symbol_number);
6465 assign_symbol_names (node->die);
6467 *pnode = node->next;
6470 pnode = &node->next;
6471 record_comdat_symbol_number (node->die, cu_hash_table,
6472 comdat_symbol_number);
6475 htab_delete (cu_hash_table);
6478 /* Traverse the DIE and add a sibling attribute if it may have the
6479 effect of speeding up access to siblings. To save some space,
6480 avoid generating sibling attributes for DIE's without children. */
6483 add_sibling_attributes (dw_die_ref die)
6487 if (! die->die_child)
6490 if (die->die_parent && die != die->die_parent->die_child)
6491 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6493 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
6496 /* Output all location lists for the DIE and its children. */
6499 output_location_lists (dw_die_ref die)
6505 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6506 if (AT_class (a) == dw_val_class_loc_list)
6507 output_loc_list (AT_loc_list (a));
6509 FOR_EACH_CHILD (die, c, output_location_lists (c));
6512 /* The format of each DIE (and its attribute value pairs) is encoded in an
6513 abbreviation table. This routine builds the abbreviation table and assigns
6514 a unique abbreviation id for each abbreviation entry. The children of each
6515 die are visited recursively. */
6518 build_abbrev_table (dw_die_ref die)
6520 unsigned long abbrev_id;
6521 unsigned int n_alloc;
6526 /* Scan the DIE references, and mark as external any that refer to
6527 DIEs from other CUs (i.e. those which are not marked). */
6528 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6529 if (AT_class (a) == dw_val_class_die_ref
6530 && AT_ref (a)->die_mark == 0)
6532 gcc_assert (AT_ref (a)->die_symbol);
6534 set_AT_ref_external (a, 1);
6537 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6539 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6540 dw_attr_ref die_a, abbrev_a;
6544 if (abbrev->die_tag != die->die_tag)
6546 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
6549 if (VEC_length (dw_attr_node, abbrev->die_attr)
6550 != VEC_length (dw_attr_node, die->die_attr))
6553 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
6555 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
6556 if ((abbrev_a->dw_attr != die_a->dw_attr)
6557 || (value_format (abbrev_a) != value_format (die_a)))
6567 if (abbrev_id >= abbrev_die_table_in_use)
6569 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6571 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6572 abbrev_die_table = ggc_realloc (abbrev_die_table,
6573 sizeof (dw_die_ref) * n_alloc);
6575 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6576 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6577 abbrev_die_table_allocated = n_alloc;
6580 ++abbrev_die_table_in_use;
6581 abbrev_die_table[abbrev_id] = die;
6584 die->die_abbrev = abbrev_id;
6585 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
6588 /* Return the power-of-two number of bytes necessary to represent VALUE. */
6591 constant_size (long unsigned int value)
6598 log = floor_log2 (value);
6601 log = 1 << (floor_log2 (log) + 1);
6606 /* Return the size of a DIE as it is represented in the
6607 .debug_info section. */
6609 static unsigned long
6610 size_of_die (dw_die_ref die)
6612 unsigned long size = 0;
6616 size += size_of_uleb128 (die->die_abbrev);
6617 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6619 switch (AT_class (a))
6621 case dw_val_class_addr:
6622 size += DWARF2_ADDR_SIZE;
6624 case dw_val_class_offset:
6625 size += DWARF_OFFSET_SIZE;
6627 case dw_val_class_loc:
6629 unsigned long lsize = size_of_locs (AT_loc (a));
6632 size += constant_size (lsize);
6636 case dw_val_class_loc_list:
6637 size += DWARF_OFFSET_SIZE;
6639 case dw_val_class_range_list:
6640 size += DWARF_OFFSET_SIZE;
6642 case dw_val_class_const:
6643 size += size_of_sleb128 (AT_int (a));
6645 case dw_val_class_unsigned_const:
6646 size += constant_size (AT_unsigned (a));
6648 case dw_val_class_long_long:
6649 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6651 case dw_val_class_vec:
6652 size += 1 + (a->dw_attr_val.v.val_vec.length
6653 * a->dw_attr_val.v.val_vec.elt_size); /* block */
6655 case dw_val_class_flag:
6658 case dw_val_class_die_ref:
6659 if (AT_ref_external (a))
6660 size += DWARF2_ADDR_SIZE;
6662 size += DWARF_OFFSET_SIZE;
6664 case dw_val_class_fde_ref:
6665 size += DWARF_OFFSET_SIZE;
6667 case dw_val_class_lbl_id:
6668 size += DWARF2_ADDR_SIZE;
6670 case dw_val_class_lineptr:
6671 case dw_val_class_macptr:
6672 size += DWARF_OFFSET_SIZE;
6674 case dw_val_class_str:
6675 if (AT_string_form (a) == DW_FORM_strp)
6676 size += DWARF_OFFSET_SIZE;
6678 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6680 case dw_val_class_file:
6681 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
6691 /* Size the debugging information associated with a given DIE. Visits the
6692 DIE's children recursively. Updates the global variable next_die_offset, on
6693 each time through. Uses the current value of next_die_offset to update the
6694 die_offset field in each DIE. */
6697 calc_die_sizes (dw_die_ref die)
6701 die->die_offset = next_die_offset;
6702 next_die_offset += size_of_die (die);
6704 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
6706 if (die->die_child != NULL)
6707 /* Count the null byte used to terminate sibling lists. */
6708 next_die_offset += 1;
6711 /* Set the marks for a die and its children. We do this so
6712 that we know whether or not a reference needs to use FORM_ref_addr; only
6713 DIEs in the same CU will be marked. We used to clear out the offset
6714 and use that as the flag, but ran into ordering problems. */
6717 mark_dies (dw_die_ref die)
6721 gcc_assert (!die->die_mark);
6724 FOR_EACH_CHILD (die, c, mark_dies (c));
6727 /* Clear the marks for a die and its children. */
6730 unmark_dies (dw_die_ref die)
6734 gcc_assert (die->die_mark);
6737 FOR_EACH_CHILD (die, c, unmark_dies (c));
6740 /* Clear the marks for a die, its children and referred dies. */
6743 unmark_all_dies (dw_die_ref die)
6753 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
6755 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6756 if (AT_class (a) == dw_val_class_die_ref)
6757 unmark_all_dies (AT_ref (a));
6760 /* Return the size of the .debug_pubnames or .debug_pubtypes table
6761 generated for the compilation unit. */
6763 static unsigned long
6764 size_of_pubnames (VEC (pubname_entry, gc) * names)
6770 size = DWARF_PUBNAMES_HEADER_SIZE;
6771 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
6772 if (names != pubtype_table
6773 || p->die->die_offset != 0
6774 || !flag_eliminate_unused_debug_types)
6775 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
6777 size += DWARF_OFFSET_SIZE;
6781 /* Return the size of the information in the .debug_aranges section. */
6783 static unsigned long
6784 size_of_aranges (void)
6788 size = DWARF_ARANGES_HEADER_SIZE;
6790 /* Count the address/length pair for this compilation unit. */
6791 size += 2 * DWARF2_ADDR_SIZE;
6792 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6794 /* Count the two zero words used to terminated the address range table. */
6795 size += 2 * DWARF2_ADDR_SIZE;
6799 /* Select the encoding of an attribute value. */
6801 static enum dwarf_form
6802 value_format (dw_attr_ref a)
6804 switch (a->dw_attr_val.val_class)
6806 case dw_val_class_addr:
6807 return DW_FORM_addr;
6808 case dw_val_class_range_list:
6809 case dw_val_class_offset:
6810 case dw_val_class_loc_list:
6811 switch (DWARF_OFFSET_SIZE)
6814 return DW_FORM_data4;
6816 return DW_FORM_data8;
6820 case dw_val_class_loc:
6821 switch (constant_size (size_of_locs (AT_loc (a))))
6824 return DW_FORM_block1;
6826 return DW_FORM_block2;
6830 case dw_val_class_const:
6831 return DW_FORM_sdata;
6832 case dw_val_class_unsigned_const:
6833 switch (constant_size (AT_unsigned (a)))
6836 return DW_FORM_data1;
6838 return DW_FORM_data2;
6840 return DW_FORM_data4;
6842 return DW_FORM_data8;
6846 case dw_val_class_long_long:
6847 return DW_FORM_block1;
6848 case dw_val_class_vec:
6849 return DW_FORM_block1;
6850 case dw_val_class_flag:
6851 return DW_FORM_flag;
6852 case dw_val_class_die_ref:
6853 if (AT_ref_external (a))
6854 return DW_FORM_ref_addr;
6857 case dw_val_class_fde_ref:
6858 return DW_FORM_data;
6859 case dw_val_class_lbl_id:
6860 return DW_FORM_addr;
6861 case dw_val_class_lineptr:
6862 case dw_val_class_macptr:
6863 return DW_FORM_data;
6864 case dw_val_class_str:
6865 return AT_string_form (a);
6866 case dw_val_class_file:
6867 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
6870 return DW_FORM_data1;
6872 return DW_FORM_data2;
6874 return DW_FORM_data4;
6884 /* Output the encoding of an attribute value. */
6887 output_value_format (dw_attr_ref a)
6889 enum dwarf_form form = value_format (a);
6891 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6894 /* Output the .debug_abbrev section which defines the DIE abbreviation
6898 output_abbrev_section (void)
6900 unsigned long abbrev_id;
6902 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6904 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6908 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6909 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6910 dwarf_tag_name (abbrev->die_tag));
6912 if (abbrev->die_child != NULL)
6913 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6915 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6917 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
6920 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6921 dwarf_attr_name (a_attr->dw_attr));
6922 output_value_format (a_attr);
6925 dw2_asm_output_data (1, 0, NULL);
6926 dw2_asm_output_data (1, 0, NULL);
6929 /* Terminate the table. */
6930 dw2_asm_output_data (1, 0, NULL);
6933 /* Output a symbol we can use to refer to this DIE from another CU. */
6936 output_die_symbol (dw_die_ref die)
6938 char *sym = die->die_symbol;
6943 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6944 /* We make these global, not weak; if the target doesn't support
6945 .linkonce, it doesn't support combining the sections, so debugging
6947 targetm.asm_out.globalize_label (asm_out_file, sym);
6949 ASM_OUTPUT_LABEL (asm_out_file, sym);
6952 /* Return a new location list, given the begin and end range, and the
6953 expression. gensym tells us whether to generate a new internal symbol for
6954 this location list node, which is done for the head of the list only. */
6956 static inline dw_loc_list_ref
6957 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6958 const char *section, unsigned int gensym)
6960 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6962 retlist->begin = begin;
6964 retlist->expr = expr;
6965 retlist->section = section;
6967 retlist->ll_symbol = gen_internal_sym ("LLST");
6972 /* Add a location description expression to a location list. */
6975 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6976 const char *begin, const char *end,
6977 const char *section)
6981 /* Find the end of the chain. */
6982 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6985 /* Add a new location list node to the list. */
6986 *d = new_loc_list (descr, begin, end, section, 0);
6990 dwarf2out_switch_text_section (void)
6996 fde = &fde_table[fde_table_in_use - 1];
6997 fde->dw_fde_switched_sections = true;
6998 fde->dw_fde_hot_section_label = cfun->hot_section_label;
6999 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
7000 fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
7001 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
7002 have_multiple_function_sections = true;
7004 /* Reset the current label on switching text sections, so that we
7005 don't attempt to advance_loc4 between labels in different sections. */
7006 fde->dw_fde_current_label = NULL;
7009 /* Output the location list given to us. */
7012 output_loc_list (dw_loc_list_ref list_head)
7014 dw_loc_list_ref curr = list_head;
7016 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7018 /* Walk the location list, and output each range + expression. */
7019 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7022 if (!have_multiple_function_sections)
7024 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7025 "Location list begin address (%s)",
7026 list_head->ll_symbol);
7027 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7028 "Location list end address (%s)",
7029 list_head->ll_symbol);
7033 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7034 "Location list begin address (%s)",
7035 list_head->ll_symbol);
7036 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7037 "Location list end address (%s)",
7038 list_head->ll_symbol);
7040 size = size_of_locs (curr->expr);
7042 /* Output the block length for this list of location operations. */
7043 gcc_assert (size <= 0xffff);
7044 dw2_asm_output_data (2, size, "%s", "Location expression size");
7046 output_loc_sequence (curr->expr);
7049 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7050 "Location list terminator begin (%s)",
7051 list_head->ll_symbol);
7052 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7053 "Location list terminator end (%s)",
7054 list_head->ll_symbol);
7057 /* Output the DIE and its attributes. Called recursively to generate
7058 the definitions of each child DIE. */
7061 output_die (dw_die_ref die)
7068 /* If someone in another CU might refer to us, set up a symbol for
7069 them to point to. */
7070 if (die->die_symbol)
7071 output_die_symbol (die);
7073 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
7074 (unsigned long)die->die_offset,
7075 dwarf_tag_name (die->die_tag));
7077 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7079 const char *name = dwarf_attr_name (a->dw_attr);
7081 switch (AT_class (a))
7083 case dw_val_class_addr:
7084 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7087 case dw_val_class_offset:
7088 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7092 case dw_val_class_range_list:
7094 char *p = strchr (ranges_section_label, '\0');
7096 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7097 a->dw_attr_val.v.val_offset);
7098 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7099 debug_ranges_section, "%s", name);
7104 case dw_val_class_loc:
7105 size = size_of_locs (AT_loc (a));
7107 /* Output the block length for this list of location operations. */
7108 dw2_asm_output_data (constant_size (size), size, "%s", name);
7110 output_loc_sequence (AT_loc (a));
7113 case dw_val_class_const:
7114 /* ??? It would be slightly more efficient to use a scheme like is
7115 used for unsigned constants below, but gdb 4.x does not sign
7116 extend. Gdb 5.x does sign extend. */
7117 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7120 case dw_val_class_unsigned_const:
7121 dw2_asm_output_data (constant_size (AT_unsigned (a)),
7122 AT_unsigned (a), "%s", name);
7125 case dw_val_class_long_long:
7127 unsigned HOST_WIDE_INT first, second;
7129 dw2_asm_output_data (1,
7130 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7133 if (WORDS_BIG_ENDIAN)
7135 first = a->dw_attr_val.v.val_long_long.hi;
7136 second = a->dw_attr_val.v.val_long_long.low;
7140 first = a->dw_attr_val.v.val_long_long.low;
7141 second = a->dw_attr_val.v.val_long_long.hi;
7144 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7145 first, "long long constant");
7146 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7151 case dw_val_class_vec:
7153 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7154 unsigned int len = a->dw_attr_val.v.val_vec.length;
7158 dw2_asm_output_data (1, len * elt_size, "%s", name);
7159 if (elt_size > sizeof (HOST_WIDE_INT))
7164 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7167 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7168 "fp or vector constant word %u", i);
7172 case dw_val_class_flag:
7173 dw2_asm_output_data (1, AT_flag (a), "%s", name);
7176 case dw_val_class_loc_list:
7178 char *sym = AT_loc_list (a)->ll_symbol;
7181 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
7186 case dw_val_class_die_ref:
7187 if (AT_ref_external (a))
7189 char *sym = AT_ref (a)->die_symbol;
7192 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
7197 gcc_assert (AT_ref (a)->die_offset);
7198 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7203 case dw_val_class_fde_ref:
7207 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7208 a->dw_attr_val.v.val_fde_index * 2);
7209 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
7214 case dw_val_class_lbl_id:
7215 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7218 case dw_val_class_lineptr:
7219 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7220 debug_line_section, "%s", name);
7223 case dw_val_class_macptr:
7224 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7225 debug_macinfo_section, "%s", name);
7228 case dw_val_class_str:
7229 if (AT_string_form (a) == DW_FORM_strp)
7230 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7231 a->dw_attr_val.v.val_str->label,
7233 "%s: \"%s\"", name, AT_string (a));
7235 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7238 case dw_val_class_file:
7240 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
7242 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
7243 a->dw_attr_val.v.val_file->filename);
7252 FOR_EACH_CHILD (die, c, output_die (c));
7254 /* Add null byte to terminate sibling list. */
7255 if (die->die_child != NULL)
7256 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7257 (unsigned long) die->die_offset);
7260 /* Output the compilation unit that appears at the beginning of the
7261 .debug_info section, and precedes the DIE descriptions. */
7264 output_compilation_unit_header (void)
7266 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7267 dw2_asm_output_data (4, 0xffffffff,
7268 "Initial length escape value indicating 64-bit DWARF extension");
7269 dw2_asm_output_data (DWARF_OFFSET_SIZE,
7270 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7271 "Length of Compilation Unit Info");
7272 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7273 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7274 debug_abbrev_section,
7275 "Offset Into Abbrev. Section");
7276 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7279 /* Output the compilation unit DIE and its children. */
7282 output_comp_unit (dw_die_ref die, int output_if_empty)
7284 const char *secname;
7287 /* Unless we are outputting main CU, we may throw away empty ones. */
7288 if (!output_if_empty && die->die_child == NULL)
7291 /* Even if there are no children of this DIE, we must output the information
7292 about the compilation unit. Otherwise, on an empty translation unit, we
7293 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
7294 will then complain when examining the file. First mark all the DIEs in
7295 this CU so we know which get local refs. */
7298 build_abbrev_table (die);
7300 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
7301 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7302 calc_die_sizes (die);
7304 oldsym = die->die_symbol;
7307 tmp = alloca (strlen (oldsym) + 24);
7309 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7311 die->die_symbol = NULL;
7312 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7315 switch_to_section (debug_info_section);
7317 /* Output debugging information. */
7318 output_compilation_unit_header ();
7321 /* Leave the marks on the main CU, so we can check them in
7326 die->die_symbol = oldsym;
7330 /* Return the DWARF2/3 pubname associated with a decl. */
7333 dwarf2_name (tree decl, int scope)
7335 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
7338 /* Add a new entry to .debug_pubnames if appropriate. */
7341 add_pubname (tree decl, dw_die_ref die)
7345 if (! TREE_PUBLIC (decl))
7349 e.name = xstrdup (dwarf2_name (decl, 1));
7350 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
7353 /* Add a new entry to .debug_pubtypes if appropriate. */
7356 add_pubtype (tree decl, dw_die_ref die)
7361 if ((TREE_PUBLIC (decl)
7362 || die->die_parent == comp_unit_die)
7363 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
7368 if (TYPE_NAME (decl))
7370 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
7371 e.name = xstrdup ((const char *) IDENTIFIER_POINTER
7372 (TYPE_NAME (decl)));
7373 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
7374 && DECL_NAME (TYPE_NAME (decl)))
7375 e.name = xstrdup ((const char *) IDENTIFIER_POINTER
7376 (DECL_NAME (TYPE_NAME (decl))));
7378 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
7382 e.name = xstrdup (dwarf2_name (decl, 1));
7384 /* If we don't have a name for the type, there's no point in adding
7386 if (e.name && e.name[0] != '\0')
7387 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
7391 /* Output the public names table used to speed up access to externally
7392 visible names; or the public types table used to find type definitions. */
7395 output_pubnames (VEC (pubname_entry, gc) * names)
7398 unsigned long pubnames_length = size_of_pubnames (names);
7401 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7402 dw2_asm_output_data (4, 0xffffffff,
7403 "Initial length escape value indicating 64-bit DWARF extension");
7404 if (names == pubname_table)
7405 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7406 "Length of Public Names Info");
7408 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7409 "Length of Public Type Names Info");
7410 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7411 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7413 "Offset of Compilation Unit Info");
7414 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7415 "Compilation Unit Length");
7417 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
7419 /* We shouldn't see pubnames for DIEs outside of the main CU. */
7420 if (names == pubname_table)
7421 gcc_assert (pub->die->die_mark);
7423 if (names != pubtype_table
7424 || pub->die->die_offset != 0
7425 || !flag_eliminate_unused_debug_types)
7427 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7430 dw2_asm_output_nstring (pub->name, -1, "external name");
7434 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7437 /* Add a new entry to .debug_aranges if appropriate. */
7440 add_arange (tree decl, dw_die_ref die)
7442 if (! DECL_SECTION_NAME (decl))
7445 if (arange_table_in_use == arange_table_allocated)
7447 arange_table_allocated += ARANGE_TABLE_INCREMENT;
7448 arange_table = ggc_realloc (arange_table,
7449 (arange_table_allocated
7450 * sizeof (dw_die_ref)));
7451 memset (arange_table + arange_table_in_use, 0,
7452 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7455 arange_table[arange_table_in_use++] = die;
7458 /* Output the information that goes into the .debug_aranges table.
7459 Namely, define the beginning and ending address range of the
7460 text section generated for this compilation unit. */
7463 output_aranges (void)
7466 unsigned long aranges_length = size_of_aranges ();
7468 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7469 dw2_asm_output_data (4, 0xffffffff,
7470 "Initial length escape value indicating 64-bit DWARF extension");
7471 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7472 "Length of Address Ranges Info");
7473 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7474 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7476 "Offset of Compilation Unit Info");
7477 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7478 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7480 /* We need to align to twice the pointer size here. */
7481 if (DWARF_ARANGES_PAD_SIZE)
7483 /* Pad using a 2 byte words so that padding is correct for any
7485 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7486 2 * DWARF2_ADDR_SIZE);
7487 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7488 dw2_asm_output_data (2, 0, NULL);
7491 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7492 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7493 text_section_label, "Length");
7494 if (flag_reorder_blocks_and_partition)
7496 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7498 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7499 cold_text_section_label, "Length");
7502 for (i = 0; i < arange_table_in_use; i++)
7504 dw_die_ref die = arange_table[i];
7506 /* We shouldn't see aranges for DIEs outside of the main CU. */
7507 gcc_assert (die->die_mark);
7509 if (die->die_tag == DW_TAG_subprogram)
7511 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7513 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7514 get_AT_low_pc (die), "Length");
7518 /* A static variable; extract the symbol from DW_AT_location.
7519 Note that this code isn't currently hit, as we only emit
7520 aranges for functions (jason 9/23/99). */
7521 dw_attr_ref a = get_AT (die, DW_AT_location);
7522 dw_loc_descr_ref loc;
7524 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7527 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7529 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7530 loc->dw_loc_oprnd1.v.val_addr, "Address");
7531 dw2_asm_output_data (DWARF2_ADDR_SIZE,
7532 get_AT_unsigned (die, DW_AT_byte_size),
7537 /* Output the terminator words. */
7538 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7539 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7542 /* Add a new entry to .debug_ranges. Return the offset at which it
7546 add_ranges (tree block)
7548 unsigned int in_use = ranges_table_in_use;
7550 if (in_use == ranges_table_allocated)
7552 ranges_table_allocated += RANGES_TABLE_INCREMENT;
7554 = ggc_realloc (ranges_table, (ranges_table_allocated
7555 * sizeof (struct dw_ranges_struct)));
7556 memset (ranges_table + ranges_table_in_use, 0,
7557 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7560 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7561 ranges_table_in_use = in_use + 1;
7563 return in_use * 2 * DWARF2_ADDR_SIZE;
7567 output_ranges (void)
7570 static const char *const start_fmt = "Offset 0x%x";
7571 const char *fmt = start_fmt;
7573 for (i = 0; i < ranges_table_in_use; i++)
7575 int block_num = ranges_table[i].block_num;
7579 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7580 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7582 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7583 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7585 /* If all code is in the text section, then the compilation
7586 unit base address defaults to DW_AT_low_pc, which is the
7587 base of the text section. */
7588 if (!have_multiple_function_sections)
7590 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7592 fmt, i * 2 * DWARF2_ADDR_SIZE);
7593 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7594 text_section_label, NULL);
7597 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7598 compilation unit base address to zero, which allows us to
7599 use absolute addresses, and not worry about whether the
7600 target supports cross-section arithmetic. */
7603 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7604 fmt, i * 2 * DWARF2_ADDR_SIZE);
7605 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7612 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7613 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7619 /* Data structure containing information about input files. */
7622 const char *path; /* Complete file name. */
7623 const char *fname; /* File name part. */
7624 int length; /* Length of entire string. */
7625 struct dwarf_file_data * file_idx; /* Index in input file table. */
7626 int dir_idx; /* Index in directory table. */
7629 /* Data structure containing information about directories with source
7633 const char *path; /* Path including directory name. */
7634 int length; /* Path length. */
7635 int prefix; /* Index of directory entry which is a prefix. */
7636 int count; /* Number of files in this directory. */
7637 int dir_idx; /* Index of directory used as base. */
7640 /* Callback function for file_info comparison. We sort by looking at
7641 the directories in the path. */
7644 file_info_cmp (const void *p1, const void *p2)
7646 const struct file_info *s1 = p1;
7647 const struct file_info *s2 = p2;
7651 /* Take care of file names without directories. We need to make sure that
7652 we return consistent values to qsort since some will get confused if
7653 we return the same value when identical operands are passed in opposite
7654 orders. So if neither has a directory, return 0 and otherwise return
7655 1 or -1 depending on which one has the directory. */
7656 if ((s1->path == s1->fname || s2->path == s2->fname))
7657 return (s2->path == s2->fname) - (s1->path == s1->fname);
7659 cp1 = (unsigned char *) s1->path;
7660 cp2 = (unsigned char *) s2->path;
7666 /* Reached the end of the first path? If so, handle like above. */
7667 if ((cp1 == (unsigned char *) s1->fname)
7668 || (cp2 == (unsigned char *) s2->fname))
7669 return ((cp2 == (unsigned char *) s2->fname)
7670 - (cp1 == (unsigned char *) s1->fname));
7672 /* Character of current path component the same? */
7673 else if (*cp1 != *cp2)
7678 struct file_name_acquire_data
7680 struct file_info *files;
7685 /* Traversal function for the hash table. */
7688 file_name_acquire (void ** slot, void *data)
7690 struct file_name_acquire_data *fnad = data;
7691 struct dwarf_file_data *d = *slot;
7692 struct file_info *fi;
7695 gcc_assert (fnad->max_files >= d->emitted_number);
7697 if (! d->emitted_number)
7700 gcc_assert (fnad->max_files != fnad->used_files);
7702 fi = fnad->files + fnad->used_files++;
7704 /* Skip all leading "./". */
7706 while (f[0] == '.' && f[1] == '/')
7709 /* Create a new array entry. */
7711 fi->length = strlen (f);
7714 /* Search for the file name part. */
7715 f = strrchr (f, '/');
7716 fi->fname = f == NULL ? fi->path : f + 1;
7720 /* Output the directory table and the file name table. We try to minimize
7721 the total amount of memory needed. A heuristic is used to avoid large
7722 slowdowns with many input files. */
7725 output_file_names (void)
7727 struct file_name_acquire_data fnad;
7729 struct file_info *files;
7730 struct dir_info *dirs;
7739 if (!last_emitted_file)
7741 dw2_asm_output_data (1, 0, "End directory table");
7742 dw2_asm_output_data (1, 0, "End file name table");
7746 numfiles = last_emitted_file->emitted_number;
7748 /* Allocate the various arrays we need. */
7749 files = alloca (numfiles * sizeof (struct file_info));
7750 dirs = alloca (numfiles * sizeof (struct dir_info));
7753 fnad.used_files = 0;
7754 fnad.max_files = numfiles;
7755 htab_traverse (file_table, file_name_acquire, &fnad);
7756 gcc_assert (fnad.used_files == fnad.max_files);
7758 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
7760 /* Find all the different directories used. */
7761 dirs[0].path = files[0].path;
7762 dirs[0].length = files[0].fname - files[0].path;
7763 dirs[0].prefix = -1;
7765 dirs[0].dir_idx = 0;
7766 files[0].dir_idx = 0;
7769 for (i = 1; i < numfiles; i++)
7770 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7771 && memcmp (dirs[ndirs - 1].path, files[i].path,
7772 dirs[ndirs - 1].length) == 0)
7774 /* Same directory as last entry. */
7775 files[i].dir_idx = ndirs - 1;
7776 ++dirs[ndirs - 1].count;
7782 /* This is a new directory. */
7783 dirs[ndirs].path = files[i].path;
7784 dirs[ndirs].length = files[i].fname - files[i].path;
7785 dirs[ndirs].count = 1;
7786 dirs[ndirs].dir_idx = ndirs;
7787 files[i].dir_idx = ndirs;
7789 /* Search for a prefix. */
7790 dirs[ndirs].prefix = -1;
7791 for (j = 0; j < ndirs; j++)
7792 if (dirs[j].length < dirs[ndirs].length
7793 && dirs[j].length > 1
7794 && (dirs[ndirs].prefix == -1
7795 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7796 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7797 dirs[ndirs].prefix = j;
7802 /* Now to the actual work. We have to find a subset of the directories which
7803 allow expressing the file name using references to the directory table
7804 with the least amount of characters. We do not do an exhaustive search
7805 where we would have to check out every combination of every single
7806 possible prefix. Instead we use a heuristic which provides nearly optimal
7807 results in most cases and never is much off. */
7808 saved = alloca (ndirs * sizeof (int));
7809 savehere = alloca (ndirs * sizeof (int));
7811 memset (saved, '\0', ndirs * sizeof (saved[0]));
7812 for (i = 0; i < ndirs; i++)
7817 /* We can always save some space for the current directory. But this
7818 does not mean it will be enough to justify adding the directory. */
7819 savehere[i] = dirs[i].length;
7820 total = (savehere[i] - saved[i]) * dirs[i].count;
7822 for (j = i + 1; j < ndirs; j++)
7825 if (saved[j] < dirs[i].length)
7827 /* Determine whether the dirs[i] path is a prefix of the
7832 while (k != -1 && k != (int) i)
7837 /* Yes it is. We can possibly save some memory by
7838 writing the filenames in dirs[j] relative to
7840 savehere[j] = dirs[i].length;
7841 total += (savehere[j] - saved[j]) * dirs[j].count;
7846 /* Check whether we can save enough to justify adding the dirs[i]
7848 if (total > dirs[i].length + 1)
7850 /* It's worthwhile adding. */
7851 for (j = i; j < ndirs; j++)
7852 if (savehere[j] > 0)
7854 /* Remember how much we saved for this directory so far. */
7855 saved[j] = savehere[j];
7857 /* Remember the prefix directory. */
7858 dirs[j].dir_idx = i;
7863 /* Emit the directory name table. */
7865 idx_offset = dirs[0].length > 0 ? 1 : 0;
7866 for (i = 1 - idx_offset; i < ndirs; i++)
7867 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7868 "Directory Entry: 0x%x", i + idx_offset);
7870 dw2_asm_output_data (1, 0, "End directory table");
7872 /* We have to emit them in the order of emitted_number since that's
7873 used in the debug info generation. To do this efficiently we
7874 generate a back-mapping of the indices first. */
7875 backmap = alloca (numfiles * sizeof (int));
7876 for (i = 0; i < numfiles; i++)
7877 backmap[files[i].file_idx->emitted_number - 1] = i;
7879 /* Now write all the file names. */
7880 for (i = 0; i < numfiles; i++)
7882 int file_idx = backmap[i];
7883 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7885 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7886 "File Entry: 0x%x", (unsigned) i + 1);
7888 /* Include directory index. */
7889 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
7891 /* Modification time. */
7892 dw2_asm_output_data_uleb128 (0, NULL);
7894 /* File length in bytes. */
7895 dw2_asm_output_data_uleb128 (0, NULL);
7898 dw2_asm_output_data (1, 0, "End file name table");
7902 /* Output the source line number correspondence information. This
7903 information goes into the .debug_line section. */
7906 output_line_info (void)
7908 char l1[20], l2[20], p1[20], p2[20];
7909 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7910 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7913 unsigned long lt_index;
7914 unsigned long current_line;
7917 unsigned long current_file;
7918 unsigned long function;
7920 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7921 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7922 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7923 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7925 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7926 dw2_asm_output_data (4, 0xffffffff,
7927 "Initial length escape value indicating 64-bit DWARF extension");
7928 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7929 "Length of Source Line Info");
7930 ASM_OUTPUT_LABEL (asm_out_file, l1);
7932 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7933 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7934 ASM_OUTPUT_LABEL (asm_out_file, p1);
7936 /* Define the architecture-dependent minimum instruction length (in
7937 bytes). In this implementation of DWARF, this field is used for
7938 information purposes only. Since GCC generates assembly language,
7939 we have no a priori knowledge of how many instruction bytes are
7940 generated for each source line, and therefore can use only the
7941 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7942 commands. Accordingly, we fix this as `1', which is "correct
7943 enough" for all architectures, and don't let the target override. */
7944 dw2_asm_output_data (1, 1,
7945 "Minimum Instruction Length");
7947 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7948 "Default is_stmt_start flag");
7949 dw2_asm_output_data (1, DWARF_LINE_BASE,
7950 "Line Base Value (Special Opcodes)");
7951 dw2_asm_output_data (1, DWARF_LINE_RANGE,
7952 "Line Range Value (Special Opcodes)");
7953 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7954 "Special Opcode Base");
7956 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7960 case DW_LNS_advance_pc:
7961 case DW_LNS_advance_line:
7962 case DW_LNS_set_file:
7963 case DW_LNS_set_column:
7964 case DW_LNS_fixed_advance_pc:
7972 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7976 /* Write out the information about the files we use. */
7977 output_file_names ();
7978 ASM_OUTPUT_LABEL (asm_out_file, p2);
7980 /* We used to set the address register to the first location in the text
7981 section here, but that didn't accomplish anything since we already
7982 have a line note for the opening brace of the first function. */
7984 /* Generate the line number to PC correspondence table, encoded as
7985 a series of state machine operations. */
7989 if (cfun && in_cold_section_p)
7990 strcpy (prev_line_label, cfun->cold_section_label);
7992 strcpy (prev_line_label, text_section_label);
7993 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7995 dw_line_info_ref line_info = &line_info_table[lt_index];
7998 /* Disable this optimization for now; GDB wants to see two line notes
7999 at the beginning of a function so it can find the end of the
8002 /* Don't emit anything for redundant notes. Just updating the
8003 address doesn't accomplish anything, because we already assume
8004 that anything after the last address is this line. */
8005 if (line_info->dw_line_num == current_line
8006 && line_info->dw_file_num == current_file)
8010 /* Emit debug info for the address of the current line.
8012 Unfortunately, we have little choice here currently, and must always
8013 use the most general form. GCC does not know the address delta
8014 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
8015 attributes which will give an upper bound on the address range. We
8016 could perhaps use length attributes to determine when it is safe to
8017 use DW_LNS_fixed_advance_pc. */
8019 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
8022 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
8023 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8024 "DW_LNS_fixed_advance_pc");
8025 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8029 /* This can handle any delta. This takes
8030 4+DWARF2_ADDR_SIZE bytes. */
8031 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8032 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8033 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8034 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8037 strcpy (prev_line_label, line_label);
8039 /* Emit debug info for the source file of the current line, if
8040 different from the previous line. */
8041 if (line_info->dw_file_num != current_file)
8043 current_file = line_info->dw_file_num;
8044 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8045 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8048 /* Emit debug info for the current line number, choosing the encoding
8049 that uses the least amount of space. */
8050 if (line_info->dw_line_num != current_line)
8052 line_offset = line_info->dw_line_num - current_line;
8053 line_delta = line_offset - DWARF_LINE_BASE;
8054 current_line = line_info->dw_line_num;
8055 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8056 /* This can handle deltas from -10 to 234, using the current
8057 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
8059 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8060 "line %lu", current_line);
8063 /* This can handle any delta. This takes at least 4 bytes,
8064 depending on the value being encoded. */
8065 dw2_asm_output_data (1, DW_LNS_advance_line,
8066 "advance to line %lu", current_line);
8067 dw2_asm_output_data_sleb128 (line_offset, NULL);
8068 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8072 /* We still need to start a new row, so output a copy insn. */
8073 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8076 /* Emit debug info for the address of the end of the function. */
8079 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8080 "DW_LNS_fixed_advance_pc");
8081 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
8085 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8086 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8087 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8088 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
8091 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8092 dw2_asm_output_data_uleb128 (1, NULL);
8093 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8098 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
8100 dw_separate_line_info_ref line_info
8101 = &separate_line_info_table[lt_index];
8104 /* Don't emit anything for redundant notes. */
8105 if (line_info->dw_line_num == current_line
8106 && line_info->dw_file_num == current_file
8107 && line_info->function == function)
8111 /* Emit debug info for the address of the current line. If this is
8112 a new function, or the first line of a function, then we need
8113 to handle it differently. */
8114 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
8116 if (function != line_info->function)
8118 function = line_info->function;
8120 /* Set the address register to the first line in the function. */
8121 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8122 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8123 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8124 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8128 /* ??? See the DW_LNS_advance_pc comment above. */
8131 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8132 "DW_LNS_fixed_advance_pc");
8133 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8137 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8138 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8139 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8140 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8144 strcpy (prev_line_label, line_label);
8146 /* Emit debug info for the source file of the current line, if
8147 different from the previous line. */
8148 if (line_info->dw_file_num != current_file)
8150 current_file = line_info->dw_file_num;
8151 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8152 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
8155 /* Emit debug info for the current line number, choosing the encoding
8156 that uses the least amount of space. */
8157 if (line_info->dw_line_num != current_line)
8159 line_offset = line_info->dw_line_num - current_line;
8160 line_delta = line_offset - DWARF_LINE_BASE;
8161 current_line = line_info->dw_line_num;
8162 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8163 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8164 "line %lu", current_line);
8167 dw2_asm_output_data (1, DW_LNS_advance_line,
8168 "advance to line %lu", current_line);
8169 dw2_asm_output_data_sleb128 (line_offset, NULL);
8170 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8174 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8182 /* If we're done with a function, end its sequence. */
8183 if (lt_index == separate_line_info_table_in_use
8184 || separate_line_info_table[lt_index].function != function)
8189 /* Emit debug info for the address of the end of the function. */
8190 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8193 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8194 "DW_LNS_fixed_advance_pc");
8195 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8199 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8200 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8201 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8202 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8205 /* Output the marker for the end of this sequence. */
8206 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8207 dw2_asm_output_data_uleb128 (1, NULL);
8208 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8212 /* Output the marker for the end of the line number info. */
8213 ASM_OUTPUT_LABEL (asm_out_file, l2);
8216 /* Given a pointer to a tree node for some base type, return a pointer to
8217 a DIE that describes the given type.
8219 This routine must only be called for GCC type nodes that correspond to
8220 Dwarf base (fundamental) types. */
8223 base_type_die (tree type)
8225 dw_die_ref base_type_result;
8226 enum dwarf_type encoding;
8228 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8231 switch (TREE_CODE (type))
8234 if (TYPE_STRING_FLAG (type))
8236 if (TYPE_UNSIGNED (type))
8237 encoding = DW_ATE_unsigned_char;
8239 encoding = DW_ATE_signed_char;
8241 else if (TYPE_UNSIGNED (type))
8242 encoding = DW_ATE_unsigned;
8244 encoding = DW_ATE_signed;
8248 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8249 encoding = DW_ATE_decimal_float;
8251 encoding = DW_ATE_float;
8254 /* Dwarf2 doesn't know anything about complex ints, so use
8255 a user defined type for it. */
8257 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8258 encoding = DW_ATE_complex_float;
8260 encoding = DW_ATE_lo_user;
8264 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
8265 encoding = DW_ATE_boolean;
8269 /* No other TREE_CODEs are Dwarf fundamental types. */
8273 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8275 /* This probably indicates a bug. */
8276 if (! TYPE_NAME (type))
8277 add_name_attribute (base_type_result, "__unknown__");
8279 add_AT_unsigned (base_type_result, DW_AT_byte_size,
8280 int_size_in_bytes (type));
8281 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8283 return base_type_result;
8286 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8287 the Dwarf "root" type for the given input type. The Dwarf "root" type of
8288 a given type is generally the same as the given type, except that if the
8289 given type is a pointer or reference type, then the root type of the given
8290 type is the root type of the "basis" type for the pointer or reference
8291 type. (This definition of the "root" type is recursive.) Also, the root
8292 type of a `const' qualified type or a `volatile' qualified type is the
8293 root type of the given type without the qualifiers. */
8296 root_type (tree type)
8298 if (TREE_CODE (type) == ERROR_MARK)
8299 return error_mark_node;
8301 switch (TREE_CODE (type))
8304 return error_mark_node;
8306 /* APPLE LOCAL radar 5732232 - blocks */
8307 case BLOCK_POINTER_TYPE:
8309 case REFERENCE_TYPE:
8310 return type_main_variant (root_type (TREE_TYPE (type)));
8313 return type_main_variant (type);
8317 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8318 given input type is a Dwarf "fundamental" type. Otherwise return null. */
8321 is_base_type (tree type)
8323 switch (TREE_CODE (type))
8336 case QUAL_UNION_TYPE:
8340 /* APPLE LOCAL radar 5732232 - blocks */
8341 case BLOCK_POINTER_TYPE:
8343 case REFERENCE_TYPE:
8356 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8357 node, return the size in bits for the type if it is a constant, or else
8358 return the alignment for the type if the type's size is not constant, or
8359 else return BITS_PER_WORD if the type actually turns out to be an
8362 static inline unsigned HOST_WIDE_INT
8363 simple_type_size_in_bits (tree type)
8365 if (TREE_CODE (type) == ERROR_MARK)
8366 return BITS_PER_WORD;
8367 else if (TYPE_SIZE (type) == NULL_TREE)
8369 else if (host_integerp (TYPE_SIZE (type), 1))
8370 return tree_low_cst (TYPE_SIZE (type), 1);
8372 return TYPE_ALIGN (type);
8375 /* Return true if the debug information for the given type should be
8376 emitted as a subrange type. */
8379 is_subrange_type (tree type)
8381 tree subtype = TREE_TYPE (type);
8383 /* Subrange types are identified by the fact that they are integer
8384 types, and that they have a subtype which is either an integer type
8385 or an enumeral type. */
8387 if (TREE_CODE (type) != INTEGER_TYPE
8388 || subtype == NULL_TREE)
8391 if (TREE_CODE (subtype) != INTEGER_TYPE
8392 && TREE_CODE (subtype) != ENUMERAL_TYPE)
8395 if (TREE_CODE (type) == TREE_CODE (subtype)
8396 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8397 && TYPE_MIN_VALUE (type) != NULL
8398 && TYPE_MIN_VALUE (subtype) != NULL
8399 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8400 && TYPE_MAX_VALUE (type) != NULL
8401 && TYPE_MAX_VALUE (subtype) != NULL
8402 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8404 /* The type and its subtype have the same representation. If in
8405 addition the two types also have the same name, then the given
8406 type is not a subrange type, but rather a plain base type. */
8407 /* FIXME: brobecker/2004-03-22:
8408 Sizetype INTEGER_CSTs nodes are canonicalized. It should
8409 therefore be sufficient to check the TYPE_SIZE node pointers
8410 rather than checking the actual size. Unfortunately, we have
8411 found some cases, such as in the Ada "integer" type, where
8412 this is not the case. Until this problem is solved, we need to
8413 keep checking the actual size. */
8414 tree type_name = TYPE_NAME (type);
8415 tree subtype_name = TYPE_NAME (subtype);
8417 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8418 type_name = DECL_NAME (type_name);
8420 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8421 subtype_name = DECL_NAME (subtype_name);
8423 if (type_name == subtype_name)
8430 /* Given a pointer to a tree node for a subrange type, return a pointer
8431 to a DIE that describes the given type. */
8434 subrange_type_die (tree type, dw_die_ref context_die)
8436 dw_die_ref subrange_die;
8437 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8439 if (context_die == NULL)
8440 context_die = comp_unit_die;
8442 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8444 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8446 /* The size of the subrange type and its base type do not match,
8447 so we need to generate a size attribute for the subrange type. */
8448 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8451 if (TYPE_MIN_VALUE (type) != NULL)
8452 add_bound_info (subrange_die, DW_AT_lower_bound,
8453 TYPE_MIN_VALUE (type));
8454 if (TYPE_MAX_VALUE (type) != NULL)
8455 add_bound_info (subrange_die, DW_AT_upper_bound,
8456 TYPE_MAX_VALUE (type));
8458 return subrange_die;
8461 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8462 entry that chains various modifiers in front of the given type. */
8465 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8466 dw_die_ref context_die)
8468 enum tree_code code = TREE_CODE (type);
8469 dw_die_ref mod_type_die;
8470 dw_die_ref sub_die = NULL;
8471 tree item_type = NULL;
8472 tree qualified_type;
8475 if (code == ERROR_MARK)
8478 /* See if we already have the appropriately qualified variant of
8481 = get_qualified_type (type,
8482 ((is_const_type ? TYPE_QUAL_CONST : 0)
8483 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8485 /* If we do, then we can just use its DIE, if it exists. */
8488 mod_type_die = lookup_type_die (qualified_type);
8490 return mod_type_die;
8493 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8495 /* Handle C typedef types. */
8496 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8498 tree dtype = TREE_TYPE (name);
8500 if (qualified_type == dtype)
8502 /* For a named type, use the typedef. */
8503 gen_type_die (qualified_type, context_die);
8504 return lookup_type_die (qualified_type);
8506 else if (is_const_type < TYPE_READONLY (dtype)
8507 || is_volatile_type < TYPE_VOLATILE (dtype)
8508 || (is_const_type <= TYPE_READONLY (dtype)
8509 && is_volatile_type <= TYPE_VOLATILE (dtype)
8510 && DECL_ORIGINAL_TYPE (name) != type))
8511 /* cv-unqualified version of named type. Just use the unnamed
8512 type to which it refers. */
8513 return modified_type_die (DECL_ORIGINAL_TYPE (name),
8514 is_const_type, is_volatile_type,
8516 /* Else cv-qualified version of named type; fall through. */
8521 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8522 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8524 else if (is_volatile_type)
8526 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8527 sub_die = modified_type_die (type, 0, 0, context_die);
8529 /* APPLE LOCAL radar 5732232 - blocks */
8530 else if (code == POINTER_TYPE || code == BLOCK_POINTER_TYPE)
8532 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8533 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8534 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8535 item_type = TREE_TYPE (type);
8537 else if (code == REFERENCE_TYPE)
8539 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8540 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8541 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8542 item_type = TREE_TYPE (type);
8544 else if (is_subrange_type (type))
8546 mod_type_die = subrange_type_die (type, context_die);
8547 item_type = TREE_TYPE (type);
8549 else if (is_base_type (type))
8550 mod_type_die = base_type_die (type);
8553 gen_type_die (type, context_die);
8555 /* We have to get the type_main_variant here (and pass that to the
8556 `lookup_type_die' routine) because the ..._TYPE node we have
8557 might simply be a *copy* of some original type node (where the
8558 copy was created to help us keep track of typedef names) and
8559 that copy might have a different TYPE_UID from the original
8561 if (TREE_CODE (type) != VECTOR_TYPE)
8562 return lookup_type_die (type_main_variant (type));
8564 /* Vectors have the debugging information in the type,
8565 not the main variant. */
8566 return lookup_type_die (type);
8569 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
8570 don't output a DW_TAG_typedef, since there isn't one in the
8571 user's program; just attach a DW_AT_name to the type. */
8573 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8575 if (TREE_CODE (name) == TYPE_DECL)
8576 /* Could just call add_name_and_src_coords_attributes here,
8577 but since this is a builtin type it doesn't have any
8578 useful source coordinates anyway. */
8579 name = DECL_NAME (name);
8580 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8584 equate_type_number_to_die (qualified_type, mod_type_die);
8587 /* We must do this after the equate_type_number_to_die call, in case
8588 this is a recursive type. This ensures that the modified_type_die
8589 recursion will terminate even if the type is recursive. Recursive
8590 types are possible in Ada. */
8591 sub_die = modified_type_die (item_type,
8592 TYPE_READONLY (item_type),
8593 TYPE_VOLATILE (item_type),
8596 if (sub_die != NULL)
8597 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8599 return mod_type_die;
8602 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8603 an enumerated type. */
8606 type_is_enum (tree type)
8608 return TREE_CODE (type) == ENUMERAL_TYPE;
8611 /* Return the DBX register number described by a given RTL node. */
8614 dbx_reg_number (rtx rtl)
8616 unsigned regno = REGNO (rtl);
8618 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8620 #ifdef LEAF_REG_REMAP
8621 if (current_function_uses_only_leaf_regs)
8623 int leaf_reg = LEAF_REG_REMAP (regno);
8625 regno = (unsigned) leaf_reg;
8629 return DBX_REGISTER_NUMBER (regno);
8632 /* Optionally add a DW_OP_piece term to a location description expression.
8633 DW_OP_piece is only added if the location description expression already
8634 doesn't end with DW_OP_piece. */
8637 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8639 dw_loc_descr_ref loc;
8641 if (*list_head != NULL)
8643 /* Find the end of the chain. */
8644 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8647 if (loc->dw_loc_opc != DW_OP_piece)
8648 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8652 /* Return a location descriptor that designates a machine register or
8653 zero if there is none. */
8655 static dw_loc_descr_ref
8656 reg_loc_descriptor (rtx rtl)
8660 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8663 regs = targetm.dwarf_register_span (rtl);
8665 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8666 return multiple_reg_loc_descriptor (rtl, regs);
8668 return one_reg_loc_descriptor (dbx_reg_number (rtl));
8671 /* Return a location descriptor that designates a machine register for
8672 a given hard register number. */
8674 static dw_loc_descr_ref
8675 one_reg_loc_descriptor (unsigned int regno)
8678 return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8680 return new_loc_descr (DW_OP_regx, regno, 0);
8683 /* Given an RTL of a register, return a location descriptor that
8684 designates a value that spans more than one register. */
8686 static dw_loc_descr_ref
8687 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8691 dw_loc_descr_ref loc_result = NULL;
8694 #ifdef LEAF_REG_REMAP
8695 if (current_function_uses_only_leaf_regs)
8697 int leaf_reg = LEAF_REG_REMAP (reg);
8699 reg = (unsigned) leaf_reg;
8702 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8703 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8705 /* Simple, contiguous registers. */
8706 if (regs == NULL_RTX)
8708 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8715 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8716 add_loc_descr (&loc_result, t);
8717 add_loc_descr_op_piece (&loc_result, size);
8723 /* Now onto stupid register sets in non contiguous locations. */
8725 gcc_assert (GET_CODE (regs) == PARALLEL);
8727 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8730 for (i = 0; i < XVECLEN (regs, 0); ++i)
8734 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8735 add_loc_descr (&loc_result, t);
8736 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8737 add_loc_descr_op_piece (&loc_result, size);
8742 /* Return a location descriptor that designates a constant. */
8744 static dw_loc_descr_ref
8745 int_loc_descriptor (HOST_WIDE_INT i)
8747 enum dwarf_location_atom op;
8749 /* Pick the smallest representation of a constant, rather than just
8750 defaulting to the LEB encoding. */
8754 op = DW_OP_lit0 + i;
8757 else if (i <= 0xffff)
8759 else if (HOST_BITS_PER_WIDE_INT == 32
8769 else if (i >= -0x8000)
8771 else if (HOST_BITS_PER_WIDE_INT == 32
8772 || i >= -0x80000000)
8778 return new_loc_descr (op, i, 0);
8781 /* Return a location descriptor that designates a base+offset location. */
8783 static dw_loc_descr_ref
8784 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8788 /* We only use "frame base" when we're sure we're talking about the
8789 post-prologue local stack frame. We do this by *not* running
8790 register elimination until this point, and recognizing the special
8791 argument pointer and soft frame pointer rtx's. */
8792 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8794 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8798 if (GET_CODE (elim) == PLUS)
8800 offset += INTVAL (XEXP (elim, 1));
8801 elim = XEXP (elim, 0);
8803 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8804 : stack_pointer_rtx));
8805 offset += frame_pointer_fb_offset;
8807 return new_loc_descr (DW_OP_fbreg, offset, 0);
8811 regno = dbx_reg_number (reg);
8813 return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8815 return new_loc_descr (DW_OP_bregx, regno, offset);
8818 /* Return true if this RTL expression describes a base+offset calculation. */
8821 is_based_loc (rtx rtl)
8823 return (GET_CODE (rtl) == PLUS
8824 && ((REG_P (XEXP (rtl, 0))
8825 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8826 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8829 /* The following routine converts the RTL for a variable or parameter
8830 (resident in memory) into an equivalent Dwarf representation of a
8831 mechanism for getting the address of that same variable onto the top of a
8832 hypothetical "address evaluation" stack.
8834 When creating memory location descriptors, we are effectively transforming
8835 the RTL for a memory-resident object into its Dwarf postfix expression
8836 equivalent. This routine recursively descends an RTL tree, turning
8837 it into Dwarf postfix code as it goes.
8839 MODE is the mode of the memory reference, needed to handle some
8840 autoincrement addressing modes.
8842 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8843 location list for RTL.
8845 Return 0 if we can't represent the location. */
8847 static dw_loc_descr_ref
8848 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8850 dw_loc_descr_ref mem_loc_result = NULL;
8851 enum dwarf_location_atom op;
8853 /* Note that for a dynamically sized array, the location we will generate a
8854 description of here will be the lowest numbered location which is
8855 actually within the array. That's *not* necessarily the same as the
8856 zeroth element of the array. */
8858 rtl = targetm.delegitimize_address (rtl);
8860 switch (GET_CODE (rtl))
8865 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8866 just fall into the SUBREG code. */
8868 /* ... fall through ... */
8871 /* The case of a subreg may arise when we have a local (register)
8872 variable or a formal (register) parameter which doesn't quite fill
8873 up an entire register. For now, just assume that it is
8874 legitimate to make the Dwarf info refer to the whole register which
8875 contains the given subreg. */
8876 rtl = XEXP (rtl, 0);
8878 /* ... fall through ... */
8881 /* Whenever a register number forms a part of the description of the
8882 method for calculating the (dynamic) address of a memory resident
8883 object, DWARF rules require the register number be referred to as
8884 a "base register". This distinction is not based in any way upon
8885 what category of register the hardware believes the given register
8886 belongs to. This is strictly DWARF terminology we're dealing with
8887 here. Note that in cases where the location of a memory-resident
8888 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8889 OP_CONST (0)) the actual DWARF location descriptor that we generate
8890 may just be OP_BASEREG (basereg). This may look deceptively like
8891 the object in question was allocated to a register (rather than in
8892 memory) so DWARF consumers need to be aware of the subtle
8893 distinction between OP_REG and OP_BASEREG. */
8894 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8895 mem_loc_result = based_loc_descr (rtl, 0);
8899 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8900 if (mem_loc_result != 0)
8901 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8905 rtl = XEXP (rtl, 1);
8907 /* ... fall through ... */
8910 /* Some ports can transform a symbol ref into a label ref, because
8911 the symbol ref is too far away and has to be dumped into a constant
8915 /* Alternatively, the symbol in the constant pool might be referenced
8916 by a different symbol. */
8917 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8920 rtx tmp = get_pool_constant_mark (rtl, &marked);
8922 if (GET_CODE (tmp) == SYMBOL_REF)
8925 if (CONSTANT_POOL_ADDRESS_P (tmp))
8926 get_pool_constant_mark (tmp, &marked);
8931 /* If all references to this pool constant were optimized away,
8932 it was not output and thus we can't represent it.
8933 FIXME: might try to use DW_OP_const_value here, though
8934 DW_OP_piece complicates it. */
8939 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8940 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8941 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8942 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8946 /* Extract the PLUS expression nested inside and fall into
8948 rtl = XEXP (rtl, 1);
8953 /* Turn these into a PLUS expression and fall into the PLUS code
8955 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8956 GEN_INT (GET_CODE (rtl) == PRE_INC
8957 ? GET_MODE_UNIT_SIZE (mode)
8958 : -GET_MODE_UNIT_SIZE (mode)));
8960 /* ... fall through ... */
8964 if (is_based_loc (rtl))
8965 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8966 INTVAL (XEXP (rtl, 1)));
8969 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8970 if (mem_loc_result == 0)
8973 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8974 && INTVAL (XEXP (rtl, 1)) >= 0)
8975 add_loc_descr (&mem_loc_result,
8976 new_loc_descr (DW_OP_plus_uconst,
8977 INTVAL (XEXP (rtl, 1)), 0));
8980 add_loc_descr (&mem_loc_result,
8981 mem_loc_descriptor (XEXP (rtl, 1), mode));
8982 add_loc_descr (&mem_loc_result,
8983 new_loc_descr (DW_OP_plus, 0, 0));
8988 /* If a pseudo-reg is optimized away, it is possible for it to
8989 be replaced with a MEM containing a multiply or shift. */
9008 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
9009 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
9011 if (op0 == 0 || op1 == 0)
9014 mem_loc_result = op0;
9015 add_loc_descr (&mem_loc_result, op1);
9016 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
9021 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
9028 return mem_loc_result;
9031 /* Return a descriptor that describes the concatenation of two locations.
9032 This is typically a complex variable. */
9034 static dw_loc_descr_ref
9035 concat_loc_descriptor (rtx x0, rtx x1)
9037 dw_loc_descr_ref cc_loc_result = NULL;
9038 dw_loc_descr_ref x0_ref = loc_descriptor (x0);
9039 dw_loc_descr_ref x1_ref = loc_descriptor (x1);
9041 if (x0_ref == 0 || x1_ref == 0)
9044 cc_loc_result = x0_ref;
9045 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
9047 add_loc_descr (&cc_loc_result, x1_ref);
9048 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
9050 return cc_loc_result;
9053 /* Output a proper Dwarf location descriptor for a variable or parameter
9054 which is either allocated in a register or in a memory location. For a
9055 register, we just generate an OP_REG and the register number. For a
9056 memory location we provide a Dwarf postfix expression describing how to
9057 generate the (dynamic) address of the object onto the address stack.
9059 If we don't know how to describe it, return 0. */
9061 static dw_loc_descr_ref
9062 loc_descriptor (rtx rtl)
9064 dw_loc_descr_ref loc_result = NULL;
9066 switch (GET_CODE (rtl))
9069 /* The case of a subreg may arise when we have a local (register)
9070 variable or a formal (register) parameter which doesn't quite fill
9071 up an entire register. For now, just assume that it is
9072 legitimate to make the Dwarf info refer to the whole register which
9073 contains the given subreg. */
9074 rtl = SUBREG_REG (rtl);
9076 /* ... fall through ... */
9079 loc_result = reg_loc_descriptor (rtl);
9083 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
9087 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
9092 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
9094 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
9098 rtl = XEXP (rtl, 1);
9103 rtvec par_elems = XVEC (rtl, 0);
9104 int num_elem = GET_NUM_ELEM (par_elems);
9105 enum machine_mode mode;
9108 /* Create the first one, so we have something to add to. */
9109 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
9110 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
9111 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9112 for (i = 1; i < num_elem; i++)
9114 dw_loc_descr_ref temp;
9116 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
9117 add_loc_descr (&loc_result, temp);
9118 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
9119 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9131 /* Similar, but generate the descriptor from trees instead of rtl. This comes
9132 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
9133 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9134 top-level invocation, and we require the address of LOC; is 0 if we require
9135 the value of LOC. */
9137 static dw_loc_descr_ref
9138 loc_descriptor_from_tree_1 (tree loc, int want_address)
9140 dw_loc_descr_ref ret, ret1;
9141 int have_address = 0;
9142 enum dwarf_location_atom op;
9144 /* ??? Most of the time we do not take proper care for sign/zero
9145 extending the values properly. Hopefully this won't be a real
9148 switch (TREE_CODE (loc))
9153 case PLACEHOLDER_EXPR:
9154 /* This case involves extracting fields from an object to determine the
9155 position of other fields. We don't try to encode this here. The
9156 only user of this is Ada, which encodes the needed information using
9157 the names of types. */
9163 case PREINCREMENT_EXPR:
9164 case PREDECREMENT_EXPR:
9165 case POSTINCREMENT_EXPR:
9166 case POSTDECREMENT_EXPR:
9167 /* There are no opcodes for these operations. */
9171 /* If we already want an address, there's nothing we can do. */
9175 /* Otherwise, process the argument and look for the address. */
9176 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9179 if (DECL_THREAD_LOCAL_P (loc))
9183 /* If this is not defined, we have no way to emit the data. */
9184 if (!targetm.asm_out.output_dwarf_dtprel)
9187 /* The way DW_OP_GNU_push_tls_address is specified, we can only
9188 look up addresses of objects in the current module. */
9189 if (DECL_EXTERNAL (loc))
9192 rtl = rtl_for_decl_location (loc);
9193 if (rtl == NULL_RTX)
9198 rtl = XEXP (rtl, 0);
9199 if (! CONSTANT_P (rtl))
9202 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9203 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9204 ret->dw_loc_oprnd1.v.val_addr = rtl;
9206 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9207 add_loc_descr (&ret, ret1);
9215 if (DECL_HAS_VALUE_EXPR_P (loc))
9216 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9223 rtx rtl = rtl_for_decl_location (loc);
9225 if (rtl == NULL_RTX)
9227 else if (GET_CODE (rtl) == CONST_INT)
9229 HOST_WIDE_INT val = INTVAL (rtl);
9230 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9231 val &= GET_MODE_MASK (DECL_MODE (loc));
9232 ret = int_loc_descriptor (val);
9234 else if (GET_CODE (rtl) == CONST_STRING)
9236 else if (CONSTANT_P (rtl))
9238 ret = new_loc_descr (DW_OP_addr, 0, 0);
9239 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9240 ret->dw_loc_oprnd1.v.val_addr = rtl;
9244 enum machine_mode mode;
9246 /* Certain constructs can only be represented at top-level. */
9247 if (want_address == 2)
9248 return loc_descriptor (rtl);
9250 mode = GET_MODE (rtl);
9253 rtl = XEXP (rtl, 0);
9256 ret = mem_loc_descriptor (rtl, mode);
9262 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9267 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9271 case NON_LVALUE_EXPR:
9272 case VIEW_CONVERT_EXPR:
9275 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9280 case ARRAY_RANGE_REF:
9283 HOST_WIDE_INT bitsize, bitpos, bytepos;
9284 enum machine_mode mode;
9286 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9288 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9289 &unsignedp, &volatilep, false);
9294 ret = loc_descriptor_from_tree_1 (obj, 1);
9296 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9299 if (offset != NULL_TREE)
9301 /* Variable offset. */
9302 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9303 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9306 bytepos = bitpos / BITS_PER_UNIT;
9308 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9309 else if (bytepos < 0)
9311 add_loc_descr (&ret, int_loc_descriptor (bytepos));
9312 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9320 if (host_integerp (loc, 0))
9321 ret = int_loc_descriptor (tree_low_cst (loc, 0));
9328 /* Get an RTL for this, if something has been emitted. */
9329 rtx rtl = lookup_constant_def (loc);
9330 enum machine_mode mode;
9332 if (!rtl || !MEM_P (rtl))
9334 mode = GET_MODE (rtl);
9335 rtl = XEXP (rtl, 0);
9336 ret = mem_loc_descriptor (rtl, mode);
9341 case TRUTH_AND_EXPR:
9342 case TRUTH_ANDIF_EXPR:
9347 case TRUTH_XOR_EXPR:
9353 case TRUTH_ORIF_EXPR:
9358 case FLOOR_DIV_EXPR:
9360 case ROUND_DIV_EXPR:
9361 case TRUNC_DIV_EXPR:
9369 case FLOOR_MOD_EXPR:
9371 case ROUND_MOD_EXPR:
9372 case TRUNC_MOD_EXPR:
9385 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9389 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9390 && host_integerp (TREE_OPERAND (loc, 1), 0))
9392 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9396 add_loc_descr (&ret,
9397 new_loc_descr (DW_OP_plus_uconst,
9398 tree_low_cst (TREE_OPERAND (loc, 1),
9408 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9415 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9422 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9429 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9444 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9445 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9446 if (ret == 0 || ret1 == 0)
9449 add_loc_descr (&ret, ret1);
9450 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9453 case TRUTH_NOT_EXPR:
9467 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9471 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9477 const enum tree_code code =
9478 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9480 loc = build3 (COND_EXPR, TREE_TYPE (loc),
9481 build2 (code, integer_type_node,
9482 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9483 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9486 /* ... fall through ... */
9490 dw_loc_descr_ref lhs
9491 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9492 dw_loc_descr_ref rhs
9493 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9494 dw_loc_descr_ref bra_node, jump_node, tmp;
9496 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9497 if (ret == 0 || lhs == 0 || rhs == 0)
9500 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9501 add_loc_descr (&ret, bra_node);
9503 add_loc_descr (&ret, rhs);
9504 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9505 add_loc_descr (&ret, jump_node);
9507 add_loc_descr (&ret, lhs);
9508 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9509 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9511 /* ??? Need a node to point the skip at. Use a nop. */
9512 tmp = new_loc_descr (DW_OP_nop, 0, 0);
9513 add_loc_descr (&ret, tmp);
9514 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9515 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9519 case FIX_TRUNC_EXPR:
9521 case FIX_FLOOR_EXPR:
9522 case FIX_ROUND_EXPR:
9526 /* Leave front-end specific codes as simply unknown. This comes
9527 up, for instance, with the C STMT_EXPR. */
9528 if ((unsigned int) TREE_CODE (loc)
9529 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9532 #ifdef ENABLE_CHECKING
9533 /* Otherwise this is a generic code; we should just lists all of
9534 these explicitly. We forgot one. */
9537 /* In a release build, we want to degrade gracefully: better to
9538 generate incomplete debugging information than to crash. */
9543 /* Show if we can't fill the request for an address. */
9544 if (want_address && !have_address)
9547 /* If we've got an address and don't want one, dereference. */
9548 if (!want_address && have_address && ret)
9550 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9552 if (size > DWARF2_ADDR_SIZE || size == -1)
9554 else if (size == DWARF2_ADDR_SIZE)
9557 op = DW_OP_deref_size;
9559 add_loc_descr (&ret, new_loc_descr (op, size, 0));
9565 static inline dw_loc_descr_ref
9566 loc_descriptor_from_tree (tree loc)
9568 return loc_descriptor_from_tree_1 (loc, 2);
9571 /* Given a value, round it up to the lowest multiple of `boundary'
9572 which is not less than the value itself. */
9574 static inline HOST_WIDE_INT
9575 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9577 return (((value + boundary - 1) / boundary) * boundary);
9580 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9581 pointer to the declared type for the relevant field variable, or return
9582 `integer_type_node' if the given node turns out to be an
9586 field_type (tree decl)
9590 if (TREE_CODE (decl) == ERROR_MARK)
9591 return integer_type_node;
9593 type = DECL_BIT_FIELD_TYPE (decl);
9594 if (type == NULL_TREE)
9595 type = TREE_TYPE (decl);
9600 /* Given a pointer to a tree node, return the alignment in bits for
9601 it, or else return BITS_PER_WORD if the node actually turns out to
9602 be an ERROR_MARK node. */
9604 static inline unsigned
9605 simple_type_align_in_bits (tree type)
9607 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9610 static inline unsigned
9611 simple_decl_align_in_bits (tree decl)
9613 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9616 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9617 lowest addressed byte of the "containing object" for the given FIELD_DECL,
9618 or return 0 if we are unable to determine what that offset is, either
9619 because the argument turns out to be a pointer to an ERROR_MARK node, or
9620 because the offset is actually variable. (We can't handle the latter case
9623 static HOST_WIDE_INT
9624 field_byte_offset (tree decl)
9626 unsigned int type_align_in_bits;
9627 unsigned int decl_align_in_bits;
9628 unsigned HOST_WIDE_INT type_size_in_bits;
9629 HOST_WIDE_INT object_offset_in_bits;
9631 tree field_size_tree;
9632 HOST_WIDE_INT bitpos_int;
9633 HOST_WIDE_INT deepest_bitpos;
9634 unsigned HOST_WIDE_INT field_size_in_bits;
9636 if (TREE_CODE (decl) == ERROR_MARK)
9639 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9641 type = field_type (decl);
9642 field_size_tree = DECL_SIZE (decl);
9644 /* The size could be unspecified if there was an error, or for
9645 a flexible array member. */
9646 if (! field_size_tree)
9647 field_size_tree = bitsize_zero_node;
9649 /* We cannot yet cope with fields whose positions are variable, so
9650 for now, when we see such things, we simply return 0. Someday, we may
9651 be able to handle such cases, but it will be damn difficult. */
9652 if (! host_integerp (bit_position (decl), 0))
9655 bitpos_int = int_bit_position (decl);
9657 /* If we don't know the size of the field, pretend it's a full word. */
9658 if (host_integerp (field_size_tree, 1))
9659 field_size_in_bits = tree_low_cst (field_size_tree, 1);
9661 field_size_in_bits = BITS_PER_WORD;
9663 type_size_in_bits = simple_type_size_in_bits (type);
9664 type_align_in_bits = simple_type_align_in_bits (type);
9665 decl_align_in_bits = simple_decl_align_in_bits (decl);
9667 /* The GCC front-end doesn't make any attempt to keep track of the starting
9668 bit offset (relative to the start of the containing structure type) of the
9669 hypothetical "containing object" for a bit-field. Thus, when computing
9670 the byte offset value for the start of the "containing object" of a
9671 bit-field, we must deduce this information on our own. This can be rather
9672 tricky to do in some cases. For example, handling the following structure
9673 type definition when compiling for an i386/i486 target (which only aligns
9674 long long's to 32-bit boundaries) can be very tricky:
9676 struct S { int field1; long long field2:31; };
9678 Fortunately, there is a simple rule-of-thumb which can be used in such
9679 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
9680 structure shown above. It decides to do this based upon one simple rule
9681 for bit-field allocation. GCC allocates each "containing object" for each
9682 bit-field at the first (i.e. lowest addressed) legitimate alignment
9683 boundary (based upon the required minimum alignment for the declared type
9684 of the field) which it can possibly use, subject to the condition that
9685 there is still enough available space remaining in the containing object
9686 (when allocated at the selected point) to fully accommodate all of the
9687 bits of the bit-field itself.
9689 This simple rule makes it obvious why GCC allocates 8 bytes for each
9690 object of the structure type shown above. When looking for a place to
9691 allocate the "containing object" for `field2', the compiler simply tries
9692 to allocate a 64-bit "containing object" at each successive 32-bit
9693 boundary (starting at zero) until it finds a place to allocate that 64-
9694 bit field such that at least 31 contiguous (and previously unallocated)
9695 bits remain within that selected 64 bit field. (As it turns out, for the
9696 example above, the compiler finds it is OK to allocate the "containing
9697 object" 64-bit field at bit-offset zero within the structure type.)
9699 Here we attempt to work backwards from the limited set of facts we're
9700 given, and we try to deduce from those facts, where GCC must have believed
9701 that the containing object started (within the structure type). The value
9702 we deduce is then used (by the callers of this routine) to generate
9703 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9704 and, in the case of DW_AT_location, regular fields as well). */
9706 /* Figure out the bit-distance from the start of the structure to the
9707 "deepest" bit of the bit-field. */
9708 deepest_bitpos = bitpos_int + field_size_in_bits;
9710 /* This is the tricky part. Use some fancy footwork to deduce where the
9711 lowest addressed bit of the containing object must be. */
9712 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9714 /* Round up to type_align by default. This works best for bitfields. */
9715 object_offset_in_bits += type_align_in_bits - 1;
9716 object_offset_in_bits /= type_align_in_bits;
9717 object_offset_in_bits *= type_align_in_bits;
9719 if (object_offset_in_bits > bitpos_int)
9721 /* Sigh, the decl must be packed. */
9722 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9724 /* Round up to decl_align instead. */
9725 object_offset_in_bits += decl_align_in_bits - 1;
9726 object_offset_in_bits /= decl_align_in_bits;
9727 object_offset_in_bits *= decl_align_in_bits;
9730 return object_offset_in_bits / BITS_PER_UNIT;
9733 /* The following routines define various Dwarf attributes and any data
9734 associated with them. */
9736 /* Add a location description attribute value to a DIE.
9738 This emits location attributes suitable for whole variables and
9739 whole parameters. Note that the location attributes for struct fields are
9740 generated by the routine `data_member_location_attribute' below. */
9743 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9744 dw_loc_descr_ref descr)
9747 add_AT_loc (die, attr_kind, descr);
9750 /* Attach the specialized form of location attribute used for data members of
9751 struct and union types. In the special case of a FIELD_DECL node which
9752 represents a bit-field, the "offset" part of this special location
9753 descriptor must indicate the distance in bytes from the lowest-addressed
9754 byte of the containing struct or union type to the lowest-addressed byte of
9755 the "containing object" for the bit-field. (See the `field_byte_offset'
9758 For any given bit-field, the "containing object" is a hypothetical object
9759 (of some integral or enum type) within which the given bit-field lives. The
9760 type of this hypothetical "containing object" is always the same as the
9761 declared type of the individual bit-field itself (for GCC anyway... the
9762 DWARF spec doesn't actually mandate this). Note that it is the size (in
9763 bytes) of the hypothetical "containing object" which will be given in the
9764 DW_AT_byte_size attribute for this bit-field. (See the
9765 `byte_size_attribute' function below.) It is also used when calculating the
9766 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9770 add_data_member_location_attribute (dw_die_ref die, tree decl)
9772 HOST_WIDE_INT offset;
9773 dw_loc_descr_ref loc_descr = 0;
9775 if (TREE_CODE (decl) == TREE_BINFO)
9777 /* We're working on the TAG_inheritance for a base class. */
9778 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9780 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9781 aren't at a fixed offset from all (sub)objects of the same
9782 type. We need to extract the appropriate offset from our
9783 vtable. The following dwarf expression means
9785 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9787 This is specific to the V3 ABI, of course. */
9789 dw_loc_descr_ref tmp;
9791 /* Make a copy of the object address. */
9792 tmp = new_loc_descr (DW_OP_dup, 0, 0);
9793 add_loc_descr (&loc_descr, tmp);
9795 /* Extract the vtable address. */
9796 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9797 add_loc_descr (&loc_descr, tmp);
9799 /* Calculate the address of the offset. */
9800 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9801 gcc_assert (offset < 0);
9803 tmp = int_loc_descriptor (-offset);
9804 add_loc_descr (&loc_descr, tmp);
9805 tmp = new_loc_descr (DW_OP_minus, 0, 0);
9806 add_loc_descr (&loc_descr, tmp);
9808 /* Extract the offset. */
9809 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9810 add_loc_descr (&loc_descr, tmp);
9812 /* Add it to the object address. */
9813 tmp = new_loc_descr (DW_OP_plus, 0, 0);
9814 add_loc_descr (&loc_descr, tmp);
9817 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9820 offset = field_byte_offset (decl);
9824 enum dwarf_location_atom op;
9826 /* The DWARF2 standard says that we should assume that the structure
9827 address is already on the stack, so we can specify a structure field
9828 address by using DW_OP_plus_uconst. */
9830 #ifdef MIPS_DEBUGGING_INFO
9831 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9832 operator correctly. It works only if we leave the offset on the
9836 op = DW_OP_plus_uconst;
9839 loc_descr = new_loc_descr (op, offset, 0);
9842 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9845 /* Writes integer values to dw_vec_const array. */
9848 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9852 *dest++ = val & 0xff;
9858 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
9860 static HOST_WIDE_INT
9861 extract_int (const unsigned char *src, unsigned int size)
9863 HOST_WIDE_INT val = 0;
9869 val |= *--src & 0xff;
9875 /* Writes floating point values to dw_vec_const array. */
9878 insert_float (rtx rtl, unsigned char *array)
9884 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9885 real_to_target (val, &rv, GET_MODE (rtl));
9887 /* real_to_target puts 32-bit pieces in each long. Pack them. */
9888 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9890 insert_int (val[i], 4, array);
9895 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9896 does not have a "location" either in memory or in a register. These
9897 things can arise in GNU C when a constant is passed as an actual parameter
9898 to an inlined function. They can also arise in C++ where declared
9899 constants do not necessarily get memory "homes". */
9902 add_const_value_attribute (dw_die_ref die, rtx rtl)
9904 switch (GET_CODE (rtl))
9908 HOST_WIDE_INT val = INTVAL (rtl);
9911 add_AT_int (die, DW_AT_const_value, val);
9913 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9918 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9919 floating-point constant. A CONST_DOUBLE is used whenever the
9920 constant requires more than one word in order to be adequately
9921 represented. We output CONST_DOUBLEs as blocks. */
9923 enum machine_mode mode = GET_MODE (rtl);
9925 if (SCALAR_FLOAT_MODE_P (mode))
9927 unsigned int length = GET_MODE_SIZE (mode);
9928 unsigned char *array = ggc_alloc (length);
9930 insert_float (rtl, array);
9931 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9935 /* ??? We really should be using HOST_WIDE_INT throughout. */
9936 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9938 add_AT_long_long (die, DW_AT_const_value,
9939 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9946 enum machine_mode mode = GET_MODE (rtl);
9947 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9948 unsigned int length = CONST_VECTOR_NUNITS (rtl);
9949 unsigned char *array = ggc_alloc (length * elt_size);
9953 switch (GET_MODE_CLASS (mode))
9955 case MODE_VECTOR_INT:
9956 for (i = 0, p = array; i < length; i++, p += elt_size)
9958 rtx elt = CONST_VECTOR_ELT (rtl, i);
9959 HOST_WIDE_INT lo, hi;
9961 switch (GET_CODE (elt))
9969 lo = CONST_DOUBLE_LOW (elt);
9970 hi = CONST_DOUBLE_HIGH (elt);
9977 if (elt_size <= sizeof (HOST_WIDE_INT))
9978 insert_int (lo, elt_size, p);
9981 unsigned char *p0 = p;
9982 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9984 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9985 if (WORDS_BIG_ENDIAN)
9990 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9991 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9996 case MODE_VECTOR_FLOAT:
9997 for (i = 0, p = array; i < length; i++, p += elt_size)
9999 rtx elt = CONST_VECTOR_ELT (rtl, i);
10000 insert_float (elt, p);
10005 gcc_unreachable ();
10008 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
10013 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
10019 add_AT_addr (die, DW_AT_const_value, rtl);
10020 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10024 /* In cases where an inlined instance of an inline function is passed
10025 the address of an `auto' variable (which is local to the caller) we
10026 can get a situation where the DECL_RTL of the artificial local
10027 variable (for the inlining) which acts as a stand-in for the
10028 corresponding formal parameter (of the inline function) will look
10029 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
10030 exactly a compile-time constant expression, but it isn't the address
10031 of the (artificial) local variable either. Rather, it represents the
10032 *value* which the artificial local variable always has during its
10033 lifetime. We currently have no way to represent such quasi-constant
10034 values in Dwarf, so for now we just punt and generate nothing. */
10038 /* No other kinds of rtx should be possible here. */
10039 gcc_unreachable ();
10044 /* Determine whether the evaluation of EXPR references any variables
10045 or functions which aren't otherwise used (and therefore may not be
10048 reference_to_unused (tree * tp, int * walk_subtrees,
10049 void * data ATTRIBUTE_UNUSED)
10051 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
10052 *walk_subtrees = 0;
10054 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
10055 && ! TREE_ASM_WRITTEN (*tp))
10057 else if (!flag_unit_at_a_time)
10059 else if (!cgraph_global_info_ready
10060 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
10062 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
10064 struct cgraph_varpool_node *node = cgraph_varpool_node (*tp);
10068 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
10069 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
10071 struct cgraph_node *node = cgraph_node (*tp);
10079 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
10080 for use in a later add_const_value_attribute call. */
10083 rtl_for_decl_init (tree init, tree type)
10085 rtx rtl = NULL_RTX;
10087 /* If a variable is initialized with a string constant without embedded
10088 zeros, build CONST_STRING. */
10089 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
10091 tree enttype = TREE_TYPE (type);
10092 tree domain = TYPE_DOMAIN (type);
10093 enum machine_mode mode = TYPE_MODE (enttype);
10095 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
10097 && integer_zerop (TYPE_MIN_VALUE (domain))
10098 && compare_tree_int (TYPE_MAX_VALUE (domain),
10099 TREE_STRING_LENGTH (init) - 1) == 0
10100 && ((size_t) TREE_STRING_LENGTH (init)
10101 == strlen (TREE_STRING_POINTER (init)) + 1))
10102 rtl = gen_rtx_CONST_STRING (VOIDmode,
10103 ggc_strdup (TREE_STRING_POINTER (init)));
10105 /* Other aggregates, and complex values, could be represented using
10107 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
10109 /* Vectors only work if their mode is supported by the target.
10110 FIXME: generic vectors ought to work too. */
10111 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
10113 /* If the initializer is something that we know will expand into an
10114 immediate RTL constant, expand it now. We must be careful not to
10115 reference variables which won't be output. */
10116 else if (initializer_constant_valid_p (init, type)
10117 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
10119 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
10121 if (TREE_CODE (type) == VECTOR_TYPE)
10122 switch (TREE_CODE (init))
10127 if (TREE_CONSTANT (init))
10129 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
10130 bool constant_p = true;
10132 unsigned HOST_WIDE_INT ix;
10134 /* Even when ctor is constant, it might contain non-*_CST
10135 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
10136 belong into VECTOR_CST nodes. */
10137 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
10138 if (!CONSTANT_CLASS_P (value))
10140 constant_p = false;
10146 init = build_vector_from_ctor (type, elts);
10156 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
10158 /* If expand_expr returns a MEM, it wasn't immediate. */
10159 gcc_assert (!rtl || !MEM_P (rtl));
10165 /* Generate RTL for the variable DECL to represent its location. */
10168 rtl_for_decl_location (tree decl)
10172 /* Here we have to decide where we are going to say the parameter "lives"
10173 (as far as the debugger is concerned). We only have a couple of
10174 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
10176 DECL_RTL normally indicates where the parameter lives during most of the
10177 activation of the function. If optimization is enabled however, this
10178 could be either NULL or else a pseudo-reg. Both of those cases indicate
10179 that the parameter doesn't really live anywhere (as far as the code
10180 generation parts of GCC are concerned) during most of the function's
10181 activation. That will happen (for example) if the parameter is never
10182 referenced within the function.
10184 We could just generate a location descriptor here for all non-NULL
10185 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
10186 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
10187 where DECL_RTL is NULL or is a pseudo-reg.
10189 Note however that we can only get away with using DECL_INCOMING_RTL as
10190 a backup substitute for DECL_RTL in certain limited cases. In cases
10191 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
10192 we can be sure that the parameter was passed using the same type as it is
10193 declared to have within the function, and that its DECL_INCOMING_RTL
10194 points us to a place where a value of that type is passed.
10196 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
10197 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
10198 because in these cases DECL_INCOMING_RTL points us to a value of some
10199 type which is *different* from the type of the parameter itself. Thus,
10200 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10201 such cases, the debugger would end up (for example) trying to fetch a
10202 `float' from a place which actually contains the first part of a
10203 `double'. That would lead to really incorrect and confusing
10204 output at debug-time.
10206 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10207 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
10208 are a couple of exceptions however. On little-endian machines we can
10209 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10210 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10211 an integral type that is smaller than TREE_TYPE (decl). These cases arise
10212 when (on a little-endian machine) a non-prototyped function has a
10213 parameter declared to be of type `short' or `char'. In such cases,
10214 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10215 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10216 passed `int' value. If the debugger then uses that address to fetch
10217 a `short' or a `char' (on a little-endian machine) the result will be
10218 the correct data, so we allow for such exceptional cases below.
10220 Note that our goal here is to describe the place where the given formal
10221 parameter lives during most of the function's activation (i.e. between the
10222 end of the prologue and the start of the epilogue). We'll do that as best
10223 as we can. Note however that if the given formal parameter is modified
10224 sometime during the execution of the function, then a stack backtrace (at
10225 debug-time) will show the function as having been called with the *new*
10226 value rather than the value which was originally passed in. This happens
10227 rarely enough that it is not a major problem, but it *is* a problem, and
10228 I'd like to fix it.
10230 A future version of dwarf2out.c may generate two additional attributes for
10231 any given DW_TAG_formal_parameter DIE which will describe the "passed
10232 type" and the "passed location" for the given formal parameter in addition
10233 to the attributes we now generate to indicate the "declared type" and the
10234 "active location" for each parameter. This additional set of attributes
10235 could be used by debuggers for stack backtraces. Separately, note that
10236 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10237 This happens (for example) for inlined-instances of inline function formal
10238 parameters which are never referenced. This really shouldn't be
10239 happening. All PARM_DECL nodes should get valid non-NULL
10240 DECL_INCOMING_RTL values. FIXME. */
10242 /* Use DECL_RTL as the "location" unless we find something better. */
10243 rtl = DECL_RTL_IF_SET (decl);
10245 /* When generating abstract instances, ignore everything except
10246 constants, symbols living in memory, and symbols living in
10247 fixed registers. */
10248 if (! reload_completed)
10251 && (CONSTANT_P (rtl)
10253 && CONSTANT_P (XEXP (rtl, 0)))
10255 && TREE_CODE (decl) == VAR_DECL
10256 && TREE_STATIC (decl))))
10258 rtl = targetm.delegitimize_address (rtl);
10263 else if (TREE_CODE (decl) == PARM_DECL)
10265 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10267 tree declared_type = TREE_TYPE (decl);
10268 tree passed_type = DECL_ARG_TYPE (decl);
10269 enum machine_mode dmode = TYPE_MODE (declared_type);
10270 enum machine_mode pmode = TYPE_MODE (passed_type);
10272 /* This decl represents a formal parameter which was optimized out.
10273 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10274 all cases where (rtl == NULL_RTX) just below. */
10275 if (dmode == pmode)
10276 rtl = DECL_INCOMING_RTL (decl);
10277 else if (SCALAR_INT_MODE_P (dmode)
10278 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10279 && DECL_INCOMING_RTL (decl))
10281 rtx inc = DECL_INCOMING_RTL (decl);
10284 else if (MEM_P (inc))
10286 if (BYTES_BIG_ENDIAN)
10287 rtl = adjust_address_nv (inc, dmode,
10288 GET_MODE_SIZE (pmode)
10289 - GET_MODE_SIZE (dmode));
10296 /* If the parm was passed in registers, but lives on the stack, then
10297 make a big endian correction if the mode of the type of the
10298 parameter is not the same as the mode of the rtl. */
10299 /* ??? This is the same series of checks that are made in dbxout.c before
10300 we reach the big endian correction code there. It isn't clear if all
10301 of these checks are necessary here, but keeping them all is the safe
10303 else if (MEM_P (rtl)
10304 && XEXP (rtl, 0) != const0_rtx
10305 && ! CONSTANT_P (XEXP (rtl, 0))
10306 /* Not passed in memory. */
10307 && !MEM_P (DECL_INCOMING_RTL (decl))
10308 /* Not passed by invisible reference. */
10309 && (!REG_P (XEXP (rtl, 0))
10310 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10311 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10312 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10313 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10316 /* Big endian correction check. */
10317 && BYTES_BIG_ENDIAN
10318 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10319 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10322 int offset = (UNITS_PER_WORD
10323 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10325 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10326 plus_constant (XEXP (rtl, 0), offset));
10329 else if (TREE_CODE (decl) == VAR_DECL
10332 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10333 && BYTES_BIG_ENDIAN)
10335 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10336 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10338 /* If a variable is declared "register" yet is smaller than
10339 a register, then if we store the variable to memory, it
10340 looks like we're storing a register-sized value, when in
10341 fact we are not. We need to adjust the offset of the
10342 storage location to reflect the actual value's bytes,
10343 else gdb will not be able to display it. */
10345 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10346 plus_constant (XEXP (rtl, 0), rsize-dsize));
10349 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10350 and will have been substituted directly into all expressions that use it.
10351 C does not have such a concept, but C++ and other languages do. */
10352 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10353 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10356 rtl = targetm.delegitimize_address (rtl);
10358 /* If we don't look past the constant pool, we risk emitting a
10359 reference to a constant pool entry that isn't referenced from
10360 code, and thus is not emitted. */
10362 rtl = avoid_constant_pool_reference (rtl);
10367 /* We need to figure out what section we should use as the base for the
10368 address ranges where a given location is valid.
10369 1. If this particular DECL has a section associated with it, use that.
10370 2. If this function has a section associated with it, use that.
10371 3. Otherwise, use the text section.
10372 XXX: If you split a variable across multiple sections, we won't notice. */
10374 static const char *
10375 secname_for_decl (tree decl)
10377 const char *secname;
10379 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10381 tree sectree = DECL_SECTION_NAME (decl);
10382 secname = TREE_STRING_POINTER (sectree);
10384 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10386 tree sectree = DECL_SECTION_NAME (current_function_decl);
10387 secname = TREE_STRING_POINTER (sectree);
10389 else if (cfun && in_cold_section_p)
10390 secname = cfun->cold_section_label;
10392 secname = text_section_label;
10397 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10398 data attribute for a variable or a parameter. We generate the
10399 DW_AT_const_value attribute only in those cases where the given variable
10400 or parameter does not have a true "location" either in memory or in a
10401 register. This can happen (for example) when a constant is passed as an
10402 actual argument in a call to an inline function. (It's possible that
10403 these things can crop up in other ways also.) Note that one type of
10404 constant value which can be passed into an inlined function is a constant
10405 pointer. This can happen for example if an actual argument in an inlined
10406 function call evaluates to a compile-time constant address. */
10409 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10410 enum dwarf_attribute attr)
10413 dw_loc_descr_ref descr;
10414 var_loc_list *loc_list;
10415 struct var_loc_node *node;
10416 if (TREE_CODE (decl) == ERROR_MARK)
10419 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10420 || TREE_CODE (decl) == RESULT_DECL);
10422 /* See if we possibly have multiple locations for this variable. */
10423 loc_list = lookup_decl_loc (decl);
10425 /* If it truly has multiple locations, the first and last node will
10427 if (loc_list && loc_list->first != loc_list->last)
10429 const char *endname, *secname;
10430 dw_loc_list_ref list;
10433 /* Now that we know what section we are using for a base,
10434 actually construct the list of locations.
10435 The first location information is what is passed to the
10436 function that creates the location list, and the remaining
10437 locations just get added on to that list.
10438 Note that we only know the start address for a location
10439 (IE location changes), so to build the range, we use
10440 the range [current location start, next location start].
10441 This means we have to special case the last node, and generate
10442 a range of [last location start, end of function label]. */
10444 node = loc_list->first;
10445 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10446 secname = secname_for_decl (decl);
10448 list = new_loc_list (loc_descriptor (varloc),
10449 node->label, node->next->label, secname, 1);
10452 for (; node->next; node = node->next)
10453 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10455 /* The variable has a location between NODE->LABEL and
10456 NODE->NEXT->LABEL. */
10457 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10458 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10459 node->label, node->next->label, secname);
10462 /* If the variable has a location at the last label
10463 it keeps its location until the end of function. */
10464 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10466 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10468 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10469 if (!current_function_decl)
10470 endname = text_end_label;
10473 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10474 current_function_funcdef_no);
10475 endname = ggc_strdup (label_id);
10477 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10478 node->label, endname, secname);
10481 /* Finally, add the location list to the DIE, and we are done. */
10482 add_AT_loc_list (die, attr, list);
10486 /* Try to get some constant RTL for this decl, and use that as the value of
10489 rtl = rtl_for_decl_location (decl);
10490 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10492 add_const_value_attribute (die, rtl);
10496 /* If we have tried to generate the location otherwise, and it
10497 didn't work out (we wouldn't be here if we did), and we have a one entry
10498 location list, try generating a location from that. */
10499 if (loc_list && loc_list->first)
10501 node = loc_list->first;
10502 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10505 add_AT_location_description (die, attr, descr);
10510 /* We couldn't get any rtl, so try directly generating the location
10511 description from the tree. */
10512 descr = loc_descriptor_from_tree (decl);
10515 add_AT_location_description (die, attr, descr);
10518 /* None of that worked, so it must not really have a location;
10519 try adding a constant value attribute from the DECL_INITIAL. */
10520 tree_add_const_value_attribute (die, decl);
10523 /* If we don't have a copy of this variable in memory for some reason (such
10524 as a C++ member constant that doesn't have an out-of-line definition),
10525 we should tell the debugger about the constant value. */
10528 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10530 tree init = DECL_INITIAL (decl);
10531 tree type = TREE_TYPE (decl);
10534 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10539 rtl = rtl_for_decl_init (init, type);
10541 add_const_value_attribute (var_die, rtl);
10544 /* Convert the CFI instructions for the current function into a
10545 location list. This is used for DW_AT_frame_base when we targeting
10546 a dwarf2 consumer that does not support the dwarf3
10547 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
10550 static dw_loc_list_ref
10551 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10554 dw_loc_list_ref list, *list_tail;
10556 dw_cfa_location last_cfa, next_cfa;
10557 const char *start_label, *last_label, *section;
10559 fde = &fde_table[fde_table_in_use - 1];
10561 section = secname_for_decl (current_function_decl);
10565 next_cfa.reg = INVALID_REGNUM;
10566 next_cfa.offset = 0;
10567 next_cfa.indirect = 0;
10568 next_cfa.base_offset = 0;
10570 start_label = fde->dw_fde_begin;
10572 /* ??? Bald assumption that the CIE opcode list does not contain
10573 advance opcodes. */
10574 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10575 lookup_cfa_1 (cfi, &next_cfa);
10577 last_cfa = next_cfa;
10578 last_label = start_label;
10580 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10581 switch (cfi->dw_cfi_opc)
10583 case DW_CFA_set_loc:
10584 case DW_CFA_advance_loc1:
10585 case DW_CFA_advance_loc2:
10586 case DW_CFA_advance_loc4:
10587 if (!cfa_equal_p (&last_cfa, &next_cfa))
10589 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10590 start_label, last_label, section,
10593 list_tail = &(*list_tail)->dw_loc_next;
10594 last_cfa = next_cfa;
10595 start_label = last_label;
10597 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10600 case DW_CFA_advance_loc:
10601 /* The encoding is complex enough that we should never emit this. */
10602 case DW_CFA_remember_state:
10603 case DW_CFA_restore_state:
10604 /* We don't handle these two in this function. It would be possible
10605 if it were to be required. */
10606 gcc_unreachable ();
10609 lookup_cfa_1 (cfi, &next_cfa);
10613 if (!cfa_equal_p (&last_cfa, &next_cfa))
10615 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10616 start_label, last_label, section,
10618 list_tail = &(*list_tail)->dw_loc_next;
10619 start_label = last_label;
10621 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10622 start_label, fde->dw_fde_end, section,
10628 /* Compute a displacement from the "steady-state frame pointer" to the
10629 frame base (often the same as the CFA), and store it in
10630 frame_pointer_fb_offset. OFFSET is added to the displacement
10631 before the latter is negated. */
10634 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10638 #ifdef FRAME_POINTER_CFA_OFFSET
10639 reg = frame_pointer_rtx;
10640 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10642 reg = arg_pointer_rtx;
10643 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10646 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10647 if (GET_CODE (elim) == PLUS)
10649 offset += INTVAL (XEXP (elim, 1));
10650 elim = XEXP (elim, 0);
10652 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10653 : stack_pointer_rtx));
10655 frame_pointer_fb_offset = -offset;
10658 /* Generate a DW_AT_name attribute given some string value to be included as
10659 the value of the attribute. */
10662 add_name_attribute (dw_die_ref die, const char *name_string)
10664 if (name_string != NULL && *name_string != 0)
10666 if (demangle_name_func)
10667 name_string = (*demangle_name_func) (name_string);
10669 add_AT_string (die, DW_AT_name, name_string);
10673 /* Generate a DW_AT_comp_dir attribute for DIE. */
10676 add_comp_dir_attribute (dw_die_ref die)
10678 const char *wd = get_src_pwd ();
10680 add_AT_string (die, DW_AT_comp_dir, wd);
10683 /* Given a tree node describing an array bound (either lower or upper) output
10684 a representation for that bound. */
10687 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10689 switch (TREE_CODE (bound))
10694 /* All fixed-bounds are represented by INTEGER_CST nodes. */
10696 if (! host_integerp (bound, 0)
10697 || (bound_attr == DW_AT_lower_bound
10698 && (((is_c_family () || is_java ()) && integer_zerop (bound))
10699 || (is_fortran () && integer_onep (bound)))))
10700 /* Use the default. */
10703 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10708 case NON_LVALUE_EXPR:
10709 case VIEW_CONVERT_EXPR:
10710 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10720 dw_die_ref decl_die = lookup_decl_die (bound);
10722 /* ??? Can this happen, or should the variable have been bound
10723 first? Probably it can, since I imagine that we try to create
10724 the types of parameters in the order in which they exist in
10725 the list, and won't have created a forward reference to a
10726 later parameter. */
10727 if (decl_die != NULL)
10728 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10734 /* Otherwise try to create a stack operation procedure to
10735 evaluate the value of the array bound. */
10737 dw_die_ref ctx, decl_die;
10738 dw_loc_descr_ref loc;
10740 loc = loc_descriptor_from_tree (bound);
10744 if (current_function_decl == 0)
10745 ctx = comp_unit_die;
10747 ctx = lookup_decl_die (current_function_decl);
10749 decl_die = new_die (DW_TAG_variable, ctx, bound);
10750 add_AT_flag (decl_die, DW_AT_artificial, 1);
10751 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10752 add_AT_loc (decl_die, DW_AT_location, loc);
10754 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10760 /* Note that the block of subscript information for an array type also
10761 includes information about the element type of type given array type. */
10764 add_subscript_info (dw_die_ref type_die, tree type)
10766 #ifndef MIPS_DEBUGGING_INFO
10767 unsigned dimension_number;
10770 dw_die_ref subrange_die;
10772 /* The GNU compilers represent multidimensional array types as sequences of
10773 one dimensional array types whose element types are themselves array
10774 types. Here we squish that down, so that each multidimensional array
10775 type gets only one array_type DIE in the Dwarf debugging info. The draft
10776 Dwarf specification say that we are allowed to do this kind of
10777 compression in C (because there is no difference between an array or
10778 arrays and a multidimensional array in C) but for other source languages
10779 (e.g. Ada) we probably shouldn't do this. */
10781 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10782 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10783 We work around this by disabling this feature. See also
10784 gen_array_type_die. */
10785 #ifndef MIPS_DEBUGGING_INFO
10786 for (dimension_number = 0;
10787 TREE_CODE (type) == ARRAY_TYPE;
10788 type = TREE_TYPE (type), dimension_number++)
10791 tree domain = TYPE_DOMAIN (type);
10793 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10794 and (in GNU C only) variable bounds. Handle all three forms
10796 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10799 /* We have an array type with specified bounds. */
10800 lower = TYPE_MIN_VALUE (domain);
10801 upper = TYPE_MAX_VALUE (domain);
10803 /* Define the index type. */
10804 if (TREE_TYPE (domain))
10806 /* ??? This is probably an Ada unnamed subrange type. Ignore the
10807 TREE_TYPE field. We can't emit debug info for this
10808 because it is an unnamed integral type. */
10809 if (TREE_CODE (domain) == INTEGER_TYPE
10810 && TYPE_NAME (domain) == NULL_TREE
10811 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10812 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10815 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10819 /* ??? If upper is NULL, the array has unspecified length,
10820 but it does have a lower bound. This happens with Fortran
10822 Since the debugger is definitely going to need to know N
10823 to produce useful results, go ahead and output the lower
10824 bound solo, and hope the debugger can cope. */
10826 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10828 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10831 /* Otherwise we have an array type with an unspecified length. The
10832 DWARF-2 spec does not say how to handle this; let's just leave out the
10838 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10842 switch (TREE_CODE (tree_node))
10847 case ENUMERAL_TYPE:
10850 case QUAL_UNION_TYPE:
10851 size = int_size_in_bytes (tree_node);
10854 /* For a data member of a struct or union, the DW_AT_byte_size is
10855 generally given as the number of bytes normally allocated for an
10856 object of the *declared* type of the member itself. This is true
10857 even for bit-fields. */
10858 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10861 gcc_unreachable ();
10864 /* Note that `size' might be -1 when we get to this point. If it is, that
10865 indicates that the byte size of the entity in question is variable. We
10866 have no good way of expressing this fact in Dwarf at the present time.
10867 GCC/35998: Avoid passing negative sizes to Dtrace and gdb. */
10868 add_AT_unsigned (die, DW_AT_byte_size, (size != (unsigned)-1 ? size : 0));
10871 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10872 which specifies the distance in bits from the highest order bit of the
10873 "containing object" for the bit-field to the highest order bit of the
10876 For any given bit-field, the "containing object" is a hypothetical object
10877 (of some integral or enum type) within which the given bit-field lives. The
10878 type of this hypothetical "containing object" is always the same as the
10879 declared type of the individual bit-field itself. The determination of the
10880 exact location of the "containing object" for a bit-field is rather
10881 complicated. It's handled by the `field_byte_offset' function (above).
10883 Note that it is the size (in bytes) of the hypothetical "containing object"
10884 which will be given in the DW_AT_byte_size attribute for this bit-field.
10885 (See `byte_size_attribute' above). */
10888 add_bit_offset_attribute (dw_die_ref die, tree decl)
10890 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10891 tree type = DECL_BIT_FIELD_TYPE (decl);
10892 HOST_WIDE_INT bitpos_int;
10893 HOST_WIDE_INT highest_order_object_bit_offset;
10894 HOST_WIDE_INT highest_order_field_bit_offset;
10895 HOST_WIDE_INT unsigned bit_offset;
10897 /* Must be a field and a bit field. */
10898 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10900 /* We can't yet handle bit-fields whose offsets are variable, so if we
10901 encounter such things, just return without generating any attribute
10902 whatsoever. Likewise for variable or too large size. */
10903 if (! host_integerp (bit_position (decl), 0)
10904 || ! host_integerp (DECL_SIZE (decl), 1))
10907 bitpos_int = int_bit_position (decl);
10909 /* Note that the bit offset is always the distance (in bits) from the
10910 highest-order bit of the "containing object" to the highest-order bit of
10911 the bit-field itself. Since the "high-order end" of any object or field
10912 is different on big-endian and little-endian machines, the computation
10913 below must take account of these differences. */
10914 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10915 highest_order_field_bit_offset = bitpos_int;
10917 if (! BYTES_BIG_ENDIAN)
10919 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10920 highest_order_object_bit_offset += simple_type_size_in_bits (type);
10924 = (! BYTES_BIG_ENDIAN
10925 ? highest_order_object_bit_offset - highest_order_field_bit_offset
10926 : highest_order_field_bit_offset - highest_order_object_bit_offset);
10928 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10931 /* For a FIELD_DECL node which represents a bit field, output an attribute
10932 which specifies the length in bits of the given field. */
10935 add_bit_size_attribute (dw_die_ref die, tree decl)
10937 /* Must be a field and a bit field. */
10938 gcc_assert (TREE_CODE (decl) == FIELD_DECL
10939 && DECL_BIT_FIELD_TYPE (decl));
10941 if (host_integerp (DECL_SIZE (decl), 1))
10942 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10945 /* If the compiled language is ANSI C, then add a 'prototyped'
10946 attribute, if arg types are given for the parameters of a function. */
10949 add_prototyped_attribute (dw_die_ref die, tree func_type)
10951 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10952 && TYPE_ARG_TYPES (func_type) != NULL)
10953 add_AT_flag (die, DW_AT_prototyped, 1);
10956 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
10957 by looking in either the type declaration or object declaration
10961 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10963 dw_die_ref origin_die = NULL;
10965 if (TREE_CODE (origin) != FUNCTION_DECL)
10967 /* We may have gotten separated from the block for the inlined
10968 function, if we're in an exception handler or some such; make
10969 sure that the abstract function has been written out.
10971 Doing this for nested functions is wrong, however; functions are
10972 distinct units, and our context might not even be inline. */
10976 fn = TYPE_STUB_DECL (fn);
10978 fn = decl_function_context (fn);
10980 dwarf2out_abstract_function (fn);
10983 if (DECL_P (origin))
10984 origin_die = lookup_decl_die (origin);
10985 else if (TYPE_P (origin))
10986 origin_die = lookup_type_die (origin);
10988 /* XXX: Functions that are never lowered don't always have correct block
10989 trees (in the case of java, they simply have no block tree, in some other
10990 languages). For these functions, there is nothing we can really do to
10991 output correct debug info for inlined functions in all cases. Rather
10992 than die, we'll just produce deficient debug info now, in that we will
10993 have variables without a proper abstract origin. In the future, when all
10994 functions are lowered, we should re-add a gcc_assert (origin_die)
10998 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
11001 /* We do not currently support the pure_virtual attribute. */
11004 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
11006 if (DECL_VINDEX (func_decl))
11008 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
11010 if (host_integerp (DECL_VINDEX (func_decl), 0))
11011 add_AT_loc (die, DW_AT_vtable_elem_location,
11012 new_loc_descr (DW_OP_constu,
11013 tree_low_cst (DECL_VINDEX (func_decl), 0),
11016 /* GNU extension: Record what type this method came from originally. */
11017 if (debug_info_level > DINFO_LEVEL_TERSE)
11018 add_AT_die_ref (die, DW_AT_containing_type,
11019 lookup_type_die (DECL_CONTEXT (func_decl)));
11023 /* Add source coordinate attributes for the given decl. */
11026 add_src_coords_attributes (dw_die_ref die, tree decl)
11028 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11030 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
11031 add_AT_unsigned (die, DW_AT_decl_line, s.line);
11034 /* Add a DW_AT_name attribute and source coordinate attribute for the
11035 given decl, but only if it actually has a name. */
11038 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
11042 decl_name = DECL_NAME (decl);
11043 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
11045 add_name_attribute (die, dwarf2_name (decl, 0));
11046 if (! DECL_ARTIFICIAL (decl))
11047 add_src_coords_attributes (die, decl);
11049 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
11050 && TREE_PUBLIC (decl)
11051 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
11052 && !DECL_ABSTRACT (decl)
11053 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
11054 add_AT_string (die, DW_AT_MIPS_linkage_name,
11055 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
11058 #ifdef VMS_DEBUGGING_INFO
11059 /* Get the function's name, as described by its RTL. This may be different
11060 from the DECL_NAME name used in the source file. */
11061 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
11063 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
11064 XEXP (DECL_RTL (decl), 0));
11065 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
11070 /* Push a new declaration scope. */
11073 push_decl_scope (tree scope)
11075 VEC_safe_push (tree, gc, decl_scope_table, scope);
11078 /* Pop a declaration scope. */
11081 pop_decl_scope (void)
11083 VEC_pop (tree, decl_scope_table);
11086 /* Return the DIE for the scope that immediately contains this type.
11087 Non-named types get global scope. Named types nested in other
11088 types get their containing scope if it's open, or global scope
11089 otherwise. All other types (i.e. function-local named types) get
11090 the current active scope. */
11093 scope_die_for (tree t, dw_die_ref context_die)
11095 dw_die_ref scope_die = NULL;
11096 tree containing_scope;
11099 /* Non-types always go in the current scope. */
11100 gcc_assert (TYPE_P (t));
11102 containing_scope = TYPE_CONTEXT (t);
11104 /* Use the containing namespace if it was passed in (for a declaration). */
11105 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
11107 if (context_die == lookup_decl_die (containing_scope))
11110 containing_scope = NULL_TREE;
11113 /* Ignore function type "scopes" from the C frontend. They mean that
11114 a tagged type is local to a parmlist of a function declarator, but
11115 that isn't useful to DWARF. */
11116 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
11117 containing_scope = NULL_TREE;
11119 if (containing_scope == NULL_TREE)
11120 scope_die = comp_unit_die;
11121 else if (TYPE_P (containing_scope))
11123 /* For types, we can just look up the appropriate DIE. But
11124 first we check to see if we're in the middle of emitting it
11125 so we know where the new DIE should go. */
11126 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
11127 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
11132 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
11133 || TREE_ASM_WRITTEN (containing_scope));
11135 /* If none of the current dies are suitable, we get file scope. */
11136 scope_die = comp_unit_die;
11139 scope_die = lookup_type_die (containing_scope);
11142 scope_die = context_die;
11147 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
11150 local_scope_p (dw_die_ref context_die)
11152 for (; context_die; context_die = context_die->die_parent)
11153 if (context_die->die_tag == DW_TAG_inlined_subroutine
11154 || context_die->die_tag == DW_TAG_subprogram)
11160 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
11161 whether or not to treat a DIE in this context as a declaration. */
11164 class_or_namespace_scope_p (dw_die_ref context_die)
11166 return (context_die
11167 && (context_die->die_tag == DW_TAG_structure_type
11168 || context_die->die_tag == DW_TAG_union_type
11169 || context_die->die_tag == DW_TAG_namespace));
11172 /* Many forms of DIEs require a "type description" attribute. This
11173 routine locates the proper "type descriptor" die for the type given
11174 by 'type', and adds a DW_AT_type attribute below the given die. */
11177 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
11178 int decl_volatile, dw_die_ref context_die)
11180 enum tree_code code = TREE_CODE (type);
11181 dw_die_ref type_die = NULL;
11183 /* APPLE LOCAL begin radar 5847213 */
11184 /* APPLE LOCAL begin radar 5811943 - Fix type of pointers to blocks */
11185 /* APPLE LOCAL - radar 6113240 */
11186 /* APPLE LOCAL begin radar 6300081 */
11187 if (code == BLOCK_POINTER_TYPE && generic_block_literal_struct_type)
11189 type = build_pointer_type (generic_block_literal_struct_type);
11190 code = TREE_CODE (type);
11192 /* APPLE LOCAL end radar 6300081 */
11193 /* APPLE LOCAL end radar 5811943 - Fix type of pointers to Blocks */
11194 /* APPLE LOCAL end radar 5847213 */
11196 /* ??? If this type is an unnamed subrange type of an integral or
11197 floating-point type, use the inner type. This is because we have no
11198 support for unnamed types in base_type_die. This can happen if this is
11199 an Ada subrange type. Correct solution is emit a subrange type die. */
11200 if ((code == INTEGER_TYPE || code == REAL_TYPE)
11201 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
11202 type = TREE_TYPE (type), code = TREE_CODE (type);
11204 if (code == ERROR_MARK
11205 /* Handle a special case. For functions whose return type is void, we
11206 generate *no* type attribute. (Note that no object may have type
11207 `void', so this only applies to function return types). */
11208 || code == VOID_TYPE)
11211 type_die = modified_type_die (type,
11212 decl_const || TYPE_READONLY (type),
11213 decl_volatile || TYPE_VOLATILE (type),
11216 if (type_die != NULL)
11217 add_AT_die_ref (object_die, DW_AT_type, type_die);
11220 /* Given an object die, add the calling convention attribute for the
11221 function call type. */
11223 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11225 enum dwarf_calling_convention value = DW_CC_normal;
11227 value = targetm.dwarf_calling_convention (type);
11229 /* Only add the attribute if the backend requests it, and
11230 is not DW_CC_normal. */
11231 if (value && (value != DW_CC_normal))
11232 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11235 /* Given a tree pointer to a struct, class, union, or enum type node, return
11236 a pointer to the (string) tag name for the given type, or zero if the type
11237 was declared without a tag. */
11239 static const char *
11240 type_tag (tree type)
11242 const char *name = 0;
11244 if (TYPE_NAME (type) != 0)
11248 /* Find the IDENTIFIER_NODE for the type name. */
11249 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11250 t = TYPE_NAME (type);
11252 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11253 a TYPE_DECL node, regardless of whether or not a `typedef' was
11255 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11256 && ! DECL_IGNORED_P (TYPE_NAME (type)))
11257 t = DECL_NAME (TYPE_NAME (type));
11259 /* Now get the name as a string, or invent one. */
11261 name = IDENTIFIER_POINTER (t);
11264 return (name == 0 || *name == '\0') ? 0 : name;
11267 /* Return the type associated with a data member, make a special check
11268 for bit field types. */
11271 member_declared_type (tree member)
11273 return (DECL_BIT_FIELD_TYPE (member)
11274 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11277 /* Get the decl's label, as described by its RTL. This may be different
11278 from the DECL_NAME name used in the source file. */
11281 static const char *
11282 decl_start_label (tree decl)
11285 const char *fnname;
11287 x = DECL_RTL (decl);
11288 gcc_assert (MEM_P (x));
11291 gcc_assert (GET_CODE (x) == SYMBOL_REF);
11293 fnname = XSTR (x, 0);
11298 /* These routines generate the internal representation of the DIE's for
11299 the compilation unit. Debugging information is collected by walking
11300 the declaration trees passed in from dwarf2out_decl(). */
11303 gen_array_type_die (tree type, dw_die_ref context_die)
11305 dw_die_ref scope_die = scope_die_for (type, context_die);
11306 dw_die_ref array_die;
11309 /* ??? The SGI dwarf reader fails for array of array of enum types unless
11310 the inner array type comes before the outer array type. Thus we must
11311 call gen_type_die before we call new_die. See below also. */
11312 #ifdef MIPS_DEBUGGING_INFO
11313 gen_type_die (TREE_TYPE (type), context_die);
11316 array_die = new_die (DW_TAG_array_type, scope_die, type);
11317 add_name_attribute (array_die, type_tag (type));
11318 equate_type_number_to_die (type, array_die);
11320 if (TREE_CODE (type) == VECTOR_TYPE)
11322 /* The frontend feeds us a representation for the vector as a struct
11323 containing an array. Pull out the array type. */
11324 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11325 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11329 /* We default the array ordering. SDB will probably do
11330 the right things even if DW_AT_ordering is not present. It's not even
11331 an issue until we start to get into multidimensional arrays anyway. If
11332 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11333 then we'll have to put the DW_AT_ordering attribute back in. (But if
11334 and when we find out that we need to put these in, we will only do so
11335 for multidimensional arrays. */
11336 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11339 #ifdef MIPS_DEBUGGING_INFO
11340 /* The SGI compilers handle arrays of unknown bound by setting
11341 AT_declaration and not emitting any subrange DIEs. */
11342 if (! TYPE_DOMAIN (type))
11343 add_AT_flag (array_die, DW_AT_declaration, 1);
11346 add_subscript_info (array_die, type);
11348 /* Add representation of the type of the elements of this array type. */
11349 element_type = TREE_TYPE (type);
11351 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11352 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
11353 We work around this by disabling this feature. See also
11354 add_subscript_info. */
11355 #ifndef MIPS_DEBUGGING_INFO
11356 while (TREE_CODE (element_type) == ARRAY_TYPE)
11357 element_type = TREE_TYPE (element_type);
11359 gen_type_die (element_type, context_die);
11362 add_type_attribute (array_die, element_type, 0, 0, context_die);
11364 if (get_AT (array_die, DW_AT_name))
11365 add_pubtype (type, array_die);
11370 gen_entry_point_die (tree decl, dw_die_ref context_die)
11372 tree origin = decl_ultimate_origin (decl);
11373 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11375 if (origin != NULL)
11376 add_abstract_origin_attribute (decl_die, origin);
11379 add_name_and_src_coords_attributes (decl_die, decl);
11380 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11381 0, 0, context_die);
11384 if (DECL_ABSTRACT (decl))
11385 equate_decl_number_to_die (decl, decl_die);
11387 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11391 /* Walk through the list of incomplete types again, trying once more to
11392 emit full debugging info for them. */
11395 retry_incomplete_types (void)
11399 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11400 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11403 /* Generate a DIE to represent an inlined instance of an enumeration type. */
11406 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11408 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11410 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11411 be incomplete and such types are not marked. */
11412 add_abstract_origin_attribute (type_die, type);
11415 /* Generate a DIE to represent an inlined instance of a structure type. */
11418 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11420 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11422 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11423 be incomplete and such types are not marked. */
11424 add_abstract_origin_attribute (type_die, type);
11427 /* Generate a DIE to represent an inlined instance of a union type. */
11430 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11432 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11434 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11435 be incomplete and such types are not marked. */
11436 add_abstract_origin_attribute (type_die, type);
11439 /* Generate a DIE to represent an enumeration type. Note that these DIEs
11440 include all of the information about the enumeration values also. Each
11441 enumerated type name/value is listed as a child of the enumerated type
11445 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11447 dw_die_ref type_die = lookup_type_die (type);
11449 if (type_die == NULL)
11451 type_die = new_die (DW_TAG_enumeration_type,
11452 scope_die_for (type, context_die), type);
11453 equate_type_number_to_die (type, type_die);
11454 add_name_attribute (type_die, type_tag (type));
11456 else if (! TYPE_SIZE (type))
11459 remove_AT (type_die, DW_AT_declaration);
11461 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
11462 given enum type is incomplete, do not generate the DW_AT_byte_size
11463 attribute or the DW_AT_element_list attribute. */
11464 if (TYPE_SIZE (type))
11468 TREE_ASM_WRITTEN (type) = 1;
11469 add_byte_size_attribute (type_die, type);
11470 if (TYPE_STUB_DECL (type) != NULL_TREE)
11471 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11473 /* If the first reference to this type was as the return type of an
11474 inline function, then it may not have a parent. Fix this now. */
11475 if (type_die->die_parent == NULL)
11476 add_child_die (scope_die_for (type, context_die), type_die);
11478 for (link = TYPE_VALUES (type);
11479 link != NULL; link = TREE_CHAIN (link))
11481 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11482 tree value = TREE_VALUE (link);
11484 add_name_attribute (enum_die,
11485 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11487 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11488 /* DWARF2 does not provide a way of indicating whether or
11489 not enumeration constants are signed or unsigned. GDB
11490 always assumes the values are signed, so we output all
11491 values as if they were signed. That means that
11492 enumeration constants with very large unsigned values
11493 will appear to have negative values in the debugger. */
11494 add_AT_int (enum_die, DW_AT_const_value,
11495 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11499 add_AT_flag (type_die, DW_AT_declaration, 1);
11501 if (get_AT (type_die, DW_AT_name))
11502 add_pubtype (type, type_die);
11507 /* Generate a DIE to represent either a real live formal parameter decl or to
11508 represent just the type of some formal parameter position in some function
11511 Note that this routine is a bit unusual because its argument may be a
11512 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11513 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11514 node. If it's the former then this function is being called to output a
11515 DIE to represent a formal parameter object (or some inlining thereof). If
11516 it's the latter, then this function is only being called to output a
11517 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11518 argument type of some subprogram type. */
11521 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11523 dw_die_ref parm_die
11524 = new_die (DW_TAG_formal_parameter, context_die, node);
11527 switch (TREE_CODE_CLASS (TREE_CODE (node)))
11529 case tcc_declaration:
11530 origin = decl_ultimate_origin (node);
11531 if (origin != NULL)
11532 add_abstract_origin_attribute (parm_die, origin);
11535 add_name_and_src_coords_attributes (parm_die, node);
11536 add_type_attribute (parm_die, TREE_TYPE (node),
11537 TREE_READONLY (node),
11538 TREE_THIS_VOLATILE (node),
11540 if (DECL_ARTIFICIAL (node))
11541 add_AT_flag (parm_die, DW_AT_artificial, 1);
11544 equate_decl_number_to_die (node, parm_die);
11545 if (! DECL_ABSTRACT (node))
11546 add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11551 /* We were called with some kind of a ..._TYPE node. */
11552 add_type_attribute (parm_die, node, 0, 0, context_die);
11556 gcc_unreachable ();
11562 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11563 at the end of an (ANSI prototyped) formal parameters list. */
11566 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11568 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11571 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11572 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11573 parameters as specified in some function type specification (except for
11574 those which appear as part of a function *definition*). */
11577 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11580 tree formal_type = NULL;
11581 tree first_parm_type;
11584 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11586 arg = DECL_ARGUMENTS (function_or_method_type);
11587 function_or_method_type = TREE_TYPE (function_or_method_type);
11592 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11594 /* Make our first pass over the list of formal parameter types and output a
11595 DW_TAG_formal_parameter DIE for each one. */
11596 for (link = first_parm_type; link; )
11598 dw_die_ref parm_die;
11600 formal_type = TREE_VALUE (link);
11601 if (formal_type == void_type_node)
11604 /* Output a (nameless) DIE to represent the formal parameter itself. */
11605 parm_die = gen_formal_parameter_die (formal_type, context_die);
11606 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11607 && link == first_parm_type)
11608 || (arg && DECL_ARTIFICIAL (arg)))
11609 add_AT_flag (parm_die, DW_AT_artificial, 1);
11611 link = TREE_CHAIN (link);
11613 arg = TREE_CHAIN (arg);
11616 /* If this function type has an ellipsis, add a
11617 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
11618 if (formal_type != void_type_node)
11619 gen_unspecified_parameters_die (function_or_method_type, context_die);
11621 /* Make our second (and final) pass over the list of formal parameter types
11622 and output DIEs to represent those types (as necessary). */
11623 for (link = TYPE_ARG_TYPES (function_or_method_type);
11624 link && TREE_VALUE (link);
11625 link = TREE_CHAIN (link))
11626 gen_type_die (TREE_VALUE (link), context_die);
11629 /* We want to generate the DIE for TYPE so that we can generate the
11630 die for MEMBER, which has been defined; we will need to refer back
11631 to the member declaration nested within TYPE. If we're trying to
11632 generate minimal debug info for TYPE, processing TYPE won't do the
11633 trick; we need to attach the member declaration by hand. */
11636 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11638 gen_type_die (type, context_die);
11640 /* If we're trying to avoid duplicate debug info, we may not have
11641 emitted the member decl for this function. Emit it now. */
11642 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11643 && ! lookup_decl_die (member))
11645 dw_die_ref type_die;
11646 gcc_assert (!decl_ultimate_origin (member));
11648 push_decl_scope (type);
11649 type_die = lookup_type_die (type);
11650 if (TREE_CODE (member) == FUNCTION_DECL)
11651 gen_subprogram_die (member, type_die);
11652 else if (TREE_CODE (member) == FIELD_DECL)
11654 /* Ignore the nameless fields that are used to skip bits but handle
11655 C++ anonymous unions and structs. */
11656 if (DECL_NAME (member) != NULL_TREE
11657 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11658 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11660 gen_type_die (member_declared_type (member), type_die);
11661 gen_field_die (member, type_die);
11665 gen_variable_die (member, type_die);
11671 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11672 may later generate inlined and/or out-of-line instances of. */
11675 dwarf2out_abstract_function (tree decl)
11677 dw_die_ref old_die;
11679 struct function *save_cfun;
11681 int was_abstract = DECL_ABSTRACT (decl);
11683 /* Make sure we have the actual abstract inline, not a clone. */
11684 decl = DECL_ORIGIN (decl);
11686 old_die = lookup_decl_die (decl);
11687 if (old_die && get_AT (old_die, DW_AT_inline))
11688 /* We've already generated the abstract instance. */
11691 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11692 we don't get confused by DECL_ABSTRACT. */
11693 if (debug_info_level > DINFO_LEVEL_TERSE)
11695 context = decl_class_context (decl);
11697 gen_type_die_for_member
11698 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11701 /* Pretend we've just finished compiling this function. */
11702 save_fn = current_function_decl;
11704 current_function_decl = decl;
11705 cfun = DECL_STRUCT_FUNCTION (decl);
11707 set_decl_abstract_flags (decl, 1);
11708 dwarf2out_decl (decl);
11709 if (! was_abstract)
11710 set_decl_abstract_flags (decl, 0);
11712 current_function_decl = save_fn;
11716 /* Helper function of premark_used_types() which gets called through
11717 htab_traverse_resize().
11719 Marks the DIE of a given type in *SLOT as perennial, so it never gets
11720 marked as unused by prune_unused_types. */
11722 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
11728 die = lookup_type_die (type);
11730 die->die_perennial_p = 1;
11734 /* Mark all members of used_types_hash as perennial. */
11736 premark_used_types (void)
11738 if (cfun && cfun->used_types_hash)
11739 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
11742 /* Generate a DIE to represent a declared function (either file-scope or
11746 gen_subprogram_die (tree decl, dw_die_ref context_die)
11748 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11749 tree origin = decl_ultimate_origin (decl);
11750 dw_die_ref subr_die;
11753 dw_die_ref old_die = lookup_decl_die (decl);
11754 int declaration = (current_function_decl != decl
11755 || class_or_namespace_scope_p (context_die));
11757 premark_used_types ();
11759 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11760 started to generate the abstract instance of an inline, decided to output
11761 its containing class, and proceeded to emit the declaration of the inline
11762 from the member list for the class. If so, DECLARATION takes priority;
11763 we'll get back to the abstract instance when done with the class. */
11765 /* The class-scope declaration DIE must be the primary DIE. */
11766 if (origin && declaration && class_or_namespace_scope_p (context_die))
11769 gcc_assert (!old_die);
11772 /* Now that the C++ front end lazily declares artificial member fns, we
11773 might need to retrofit the declaration into its class. */
11774 if (!declaration && !origin && !old_die
11775 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11776 && !class_or_namespace_scope_p (context_die)
11777 && debug_info_level > DINFO_LEVEL_TERSE)
11778 old_die = force_decl_die (decl);
11780 if (origin != NULL)
11782 gcc_assert (!declaration || local_scope_p (context_die));
11784 /* Fixup die_parent for the abstract instance of a nested
11785 inline function. */
11786 if (old_die && old_die->die_parent == NULL)
11787 add_child_die (context_die, old_die);
11789 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11790 add_abstract_origin_attribute (subr_die, origin);
11794 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11795 struct dwarf_file_data * file_index = lookup_filename (s.file);
11797 if (!get_AT_flag (old_die, DW_AT_declaration)
11798 /* We can have a normal definition following an inline one in the
11799 case of redefinition of GNU C extern inlines.
11800 It seems reasonable to use AT_specification in this case. */
11801 && !get_AT (old_die, DW_AT_inline))
11803 /* Detect and ignore this case, where we are trying to output
11804 something we have already output. */
11808 /* If the definition comes from the same place as the declaration,
11809 maybe use the old DIE. We always want the DIE for this function
11810 that has the *_pc attributes to be under comp_unit_die so the
11811 debugger can find it. We also need to do this for abstract
11812 instances of inlines, since the spec requires the out-of-line copy
11813 to have the same parent. For local class methods, this doesn't
11814 apply; we just use the old DIE. */
11815 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11816 && (DECL_ARTIFICIAL (decl)
11817 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
11818 && (get_AT_unsigned (old_die, DW_AT_decl_line)
11819 == (unsigned) s.line))))
11821 subr_die = old_die;
11823 /* Clear out the declaration attribute and the formal parameters.
11824 Do not remove all children, because it is possible that this
11825 declaration die was forced using force_decl_die(). In such
11826 cases die that forced declaration die (e.g. TAG_imported_module)
11827 is one of the children that we do not want to remove. */
11828 remove_AT (subr_die, DW_AT_declaration);
11829 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11833 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11834 add_AT_specification (subr_die, old_die);
11835 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
11836 add_AT_file (subr_die, DW_AT_decl_file, file_index);
11837 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
11838 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
11843 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11845 if (TREE_PUBLIC (decl))
11846 add_AT_flag (subr_die, DW_AT_external, 1);
11848 add_name_and_src_coords_attributes (subr_die, decl);
11849 if (debug_info_level > DINFO_LEVEL_TERSE)
11851 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11852 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11853 0, 0, context_die);
11856 add_pure_or_virtual_attribute (subr_die, decl);
11857 if (DECL_ARTIFICIAL (decl))
11858 add_AT_flag (subr_die, DW_AT_artificial, 1);
11860 if (TREE_PROTECTED (decl))
11861 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11862 else if (TREE_PRIVATE (decl))
11863 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11868 if (!old_die || !get_AT (old_die, DW_AT_inline))
11870 add_AT_flag (subr_die, DW_AT_declaration, 1);
11872 /* The first time we see a member function, it is in the context of
11873 the class to which it belongs. We make sure of this by emitting
11874 the class first. The next time is the definition, which is
11875 handled above. The two may come from the same source text.
11877 Note that force_decl_die() forces function declaration die. It is
11878 later reused to represent definition. */
11879 equate_decl_number_to_die (decl, subr_die);
11882 else if (DECL_ABSTRACT (decl))
11884 if (DECL_DECLARED_INLINE_P (decl))
11886 if (cgraph_function_possibly_inlined_p (decl))
11887 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11889 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11893 if (cgraph_function_possibly_inlined_p (decl))
11894 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11896 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11899 equate_decl_number_to_die (decl, subr_die);
11901 else if (!DECL_EXTERNAL (decl))
11903 HOST_WIDE_INT cfa_fb_offset;
11905 if (!old_die || !get_AT (old_die, DW_AT_inline))
11906 equate_decl_number_to_die (decl, subr_die);
11908 if (!flag_reorder_blocks_and_partition)
11910 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11911 current_function_funcdef_no);
11912 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11913 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11914 current_function_funcdef_no);
11915 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11917 add_pubname (decl, subr_die);
11918 add_arange (decl, subr_die);
11921 { /* Do nothing for now; maybe need to duplicate die, one for
11922 hot section and ond for cold section, then use the hot/cold
11923 section begin/end labels to generate the aranges... */
11925 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11926 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11927 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11928 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11930 add_pubname (decl, subr_die);
11931 add_arange (decl, subr_die);
11932 add_arange (decl, subr_die);
11936 #ifdef MIPS_DEBUGGING_INFO
11937 /* Add a reference to the FDE for this routine. */
11938 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11941 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
11943 /* We define the "frame base" as the function's CFA. This is more
11944 convenient for several reasons: (1) It's stable across the prologue
11945 and epilogue, which makes it better than just a frame pointer,
11946 (2) With dwarf3, there exists a one-byte encoding that allows us
11947 to reference the .debug_frame data by proxy, but failing that,
11948 (3) We can at least reuse the code inspection and interpretation
11949 code that determines the CFA position at various points in the
11951 /* ??? Use some command-line or configury switch to enable the use
11952 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
11953 consumers that understand it; fall back to "pure" dwarf2 and
11954 convert the CFA data into a location list. */
11956 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
11957 if (list->dw_loc_next)
11958 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11960 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11963 /* Compute a displacement from the "steady-state frame pointer" to
11964 the CFA. The former is what all stack slots and argument slots
11965 will reference in the rtl; the later is what we've told the
11966 debugger about. We'll need to adjust all frame_base references
11967 by this displacement. */
11968 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
11970 if (cfun->static_chain_decl)
11971 add_AT_location_description (subr_die, DW_AT_static_link,
11972 loc_descriptor_from_tree (cfun->static_chain_decl));
11975 /* Now output descriptions of the arguments for this function. This gets
11976 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11977 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11978 `...' at the end of the formal parameter list. In order to find out if
11979 there was a trailing ellipsis or not, we must instead look at the type
11980 associated with the FUNCTION_DECL. This will be a node of type
11981 FUNCTION_TYPE. If the chain of type nodes hanging off of this
11982 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11983 an ellipsis at the end. */
11985 /* In the case where we are describing a mere function declaration, all we
11986 need to do here (and all we *can* do here) is to describe the *types* of
11987 its formal parameters. */
11988 if (debug_info_level <= DINFO_LEVEL_TERSE)
11990 else if (declaration)
11991 gen_formal_types_die (decl, subr_die);
11994 /* Generate DIEs to represent all known formal parameters. */
11995 tree arg_decls = DECL_ARGUMENTS (decl);
11998 /* When generating DIEs, generate the unspecified_parameters DIE
11999 instead if we come across the arg "__builtin_va_alist" */
12000 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
12001 if (TREE_CODE (parm) == PARM_DECL)
12003 if (DECL_NAME (parm)
12004 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
12005 "__builtin_va_alist"))
12006 gen_unspecified_parameters_die (parm, subr_die);
12008 gen_decl_die (parm, subr_die);
12011 /* Decide whether we need an unspecified_parameters DIE at the end.
12012 There are 2 more cases to do this for: 1) the ansi ... declaration -
12013 this is detectable when the end of the arg list is not a
12014 void_type_node 2) an unprototyped function declaration (not a
12015 definition). This just means that we have no info about the
12016 parameters at all. */
12017 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
12018 if (fn_arg_types != NULL)
12020 /* This is the prototyped case, check for.... */
12021 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
12022 gen_unspecified_parameters_die (decl, subr_die);
12024 else if (DECL_INITIAL (decl) == NULL_TREE)
12025 gen_unspecified_parameters_die (decl, subr_die);
12028 /* Output Dwarf info for all of the stuff within the body of the function
12029 (if it has one - it may be just a declaration). */
12030 outer_scope = DECL_INITIAL (decl);
12032 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
12033 a function. This BLOCK actually represents the outermost binding contour
12034 for the function, i.e. the contour in which the function's formal
12035 parameters and labels get declared. Curiously, it appears that the front
12036 end doesn't actually put the PARM_DECL nodes for the current function onto
12037 the BLOCK_VARS list for this outer scope, but are strung off of the
12038 DECL_ARGUMENTS list for the function instead.
12040 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
12041 the LABEL_DECL nodes for the function however, and we output DWARF info
12042 for those in decls_for_scope. Just within the `outer_scope' there will be
12043 a BLOCK node representing the function's outermost pair of curly braces,
12044 and any blocks used for the base and member initializers of a C++
12045 constructor function. */
12046 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
12048 /* Emit a DW_TAG_variable DIE for a named return value. */
12049 if (DECL_NAME (DECL_RESULT (decl)))
12050 gen_decl_die (DECL_RESULT (decl), subr_die);
12052 current_function_has_inlines = 0;
12053 decls_for_scope (outer_scope, subr_die, 0);
12055 #if 0 && defined (MIPS_DEBUGGING_INFO)
12056 if (current_function_has_inlines)
12058 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
12059 if (! comp_unit_has_inlines)
12061 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
12062 comp_unit_has_inlines = 1;
12067 /* Add the calling convention attribute if requested. */
12068 add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
12072 /* Generate a DIE to represent a declared data object. */
12075 gen_variable_die (tree decl, dw_die_ref context_die)
12077 tree origin = decl_ultimate_origin (decl);
12078 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
12080 dw_die_ref old_die = lookup_decl_die (decl);
12081 int declaration = (DECL_EXTERNAL (decl)
12082 /* If DECL is COMDAT and has not actually been
12083 emitted, we cannot take its address; there
12084 might end up being no definition anywhere in
12085 the program. For example, consider the C++
12089 struct S { static const int i = 7; };
12094 int f() { return S<int>::i; }
12096 Here, S<int>::i is not DECL_EXTERNAL, but no
12097 definition is required, so the compiler will
12098 not emit a definition. */
12099 || (TREE_CODE (decl) == VAR_DECL
12100 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
12101 || class_or_namespace_scope_p (context_die));
12103 if (origin != NULL)
12104 add_abstract_origin_attribute (var_die, origin);
12106 /* Loop unrolling can create multiple blocks that refer to the same
12107 static variable, so we must test for the DW_AT_declaration flag.
12109 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
12110 copy decls and set the DECL_ABSTRACT flag on them instead of
12113 ??? Duplicated blocks have been rewritten to use .debug_ranges.
12115 ??? The declare_in_namespace support causes us to get two DIEs for one
12116 variable, both of which are declarations. We want to avoid considering
12117 one to be a specification, so we must test that this DIE is not a
12119 else if (old_die && TREE_STATIC (decl) && ! declaration
12120 && get_AT_flag (old_die, DW_AT_declaration) == 1)
12122 /* This is a definition of a C++ class level static. */
12123 add_AT_specification (var_die, old_die);
12124 if (DECL_NAME (decl))
12126 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12127 struct dwarf_file_data * file_index = lookup_filename (s.file);
12129 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
12130 add_AT_file (var_die, DW_AT_decl_file, file_index);
12132 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
12134 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
12139 add_name_and_src_coords_attributes (var_die, decl);
12140 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
12141 TREE_THIS_VOLATILE (decl), context_die);
12143 if (TREE_PUBLIC (decl))
12144 add_AT_flag (var_die, DW_AT_external, 1);
12146 if (DECL_ARTIFICIAL (decl))
12147 add_AT_flag (var_die, DW_AT_artificial, 1);
12149 if (TREE_PROTECTED (decl))
12150 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
12151 else if (TREE_PRIVATE (decl))
12152 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
12156 add_AT_flag (var_die, DW_AT_declaration, 1);
12158 if (DECL_ABSTRACT (decl) || declaration)
12159 equate_decl_number_to_die (decl, var_die);
12161 if (! declaration && ! DECL_ABSTRACT (decl))
12163 add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
12164 add_pubname (decl, var_die);
12167 tree_add_const_value_attribute (var_die, decl);
12170 /* Generate a DIE to represent a label identifier. */
12173 gen_label_die (tree decl, dw_die_ref context_die)
12175 tree origin = decl_ultimate_origin (decl);
12176 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
12178 char label[MAX_ARTIFICIAL_LABEL_BYTES];
12180 if (origin != NULL)
12181 add_abstract_origin_attribute (lbl_die, origin);
12183 add_name_and_src_coords_attributes (lbl_die, decl);
12185 if (DECL_ABSTRACT (decl))
12186 equate_decl_number_to_die (decl, lbl_die);
12189 insn = DECL_RTL_IF_SET (decl);
12191 /* Deleted labels are programmer specified labels which have been
12192 eliminated because of various optimizations. We still emit them
12193 here so that it is possible to put breakpoints on them. */
12197 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
12199 /* When optimization is enabled (via -O) some parts of the compiler
12200 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
12201 represent source-level labels which were explicitly declared by
12202 the user. This really shouldn't be happening though, so catch
12203 it if it ever does happen. */
12204 gcc_assert (!INSN_DELETED_P (insn));
12206 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
12207 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
12212 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
12213 attributes to the DIE for a block STMT, to describe where the inlined
12214 function was called from. This is similar to add_src_coords_attributes. */
12217 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
12219 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
12221 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
12222 add_AT_unsigned (die, DW_AT_call_line, s.line);
12225 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
12226 Add low_pc and high_pc attributes to the DIE for a block STMT. */
12229 add_high_low_attributes (tree stmt, dw_die_ref die)
12231 char label[MAX_ARTIFICIAL_LABEL_BYTES];
12233 if (BLOCK_FRAGMENT_CHAIN (stmt))
12237 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
12239 chain = BLOCK_FRAGMENT_CHAIN (stmt);
12242 add_ranges (chain);
12243 chain = BLOCK_FRAGMENT_CHAIN (chain);
12250 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12251 BLOCK_NUMBER (stmt));
12252 add_AT_lbl_id (die, DW_AT_low_pc, label);
12253 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
12254 BLOCK_NUMBER (stmt));
12255 add_AT_lbl_id (die, DW_AT_high_pc, label);
12259 /* Generate a DIE for a lexical block. */
12262 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12264 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12266 if (! BLOCK_ABSTRACT (stmt))
12267 add_high_low_attributes (stmt, stmt_die);
12269 decls_for_scope (stmt, stmt_die, depth);
12272 /* Generate a DIE for an inlined subprogram. */
12275 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12277 tree decl = block_ultimate_origin (stmt);
12279 /* Emit info for the abstract instance first, if we haven't yet. We
12280 must emit this even if the block is abstract, otherwise when we
12281 emit the block below (or elsewhere), we may end up trying to emit
12282 a die whose origin die hasn't been emitted, and crashing. */
12283 dwarf2out_abstract_function (decl);
12285 if (! BLOCK_ABSTRACT (stmt))
12287 dw_die_ref subr_die
12288 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12290 add_abstract_origin_attribute (subr_die, decl);
12291 add_high_low_attributes (stmt, subr_die);
12292 add_call_src_coords_attributes (stmt, subr_die);
12294 decls_for_scope (stmt, subr_die, depth);
12295 current_function_has_inlines = 1;
12298 /* We may get here if we're the outer block of function A that was
12299 inlined into function B that was inlined into function C. When
12300 generating debugging info for C, dwarf2out_abstract_function(B)
12301 would mark all inlined blocks as abstract, including this one.
12302 So, we wouldn't (and shouldn't) expect labels to be generated
12303 for this one. Instead, just emit debugging info for
12304 declarations within the block. This is particularly important
12305 in the case of initializers of arguments passed from B to us:
12306 if they're statement expressions containing declarations, we
12307 wouldn't generate dies for their abstract variables, and then,
12308 when generating dies for the real variables, we'd die (pun
12310 gen_lexical_block_die (stmt, context_die, depth);
12313 /* Generate a DIE for a field in a record, or structure. */
12316 gen_field_die (tree decl, dw_die_ref context_die)
12318 dw_die_ref decl_die;
12320 if (TREE_TYPE (decl) == error_mark_node)
12323 decl_die = new_die (DW_TAG_member, context_die, decl);
12324 add_name_and_src_coords_attributes (decl_die, decl);
12325 add_type_attribute (decl_die, member_declared_type (decl),
12326 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12329 if (DECL_BIT_FIELD_TYPE (decl))
12331 add_byte_size_attribute (decl_die, decl);
12332 add_bit_size_attribute (decl_die, decl);
12333 add_bit_offset_attribute (decl_die, decl);
12336 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12337 add_data_member_location_attribute (decl_die, decl);
12339 if (DECL_ARTIFICIAL (decl))
12340 add_AT_flag (decl_die, DW_AT_artificial, 1);
12342 if (TREE_PROTECTED (decl))
12343 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12344 else if (TREE_PRIVATE (decl))
12345 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12347 /* Equate decl number to die, so that we can look up this decl later on. */
12348 equate_decl_number_to_die (decl, decl_die);
12352 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12353 Use modified_type_die instead.
12354 We keep this code here just in case these types of DIEs may be needed to
12355 represent certain things in other languages (e.g. Pascal) someday. */
12358 gen_pointer_type_die (tree type, dw_die_ref context_die)
12361 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12363 equate_type_number_to_die (type, ptr_die);
12364 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12365 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12368 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12369 Use modified_type_die instead.
12370 We keep this code here just in case these types of DIEs may be needed to
12371 represent certain things in other languages (e.g. Pascal) someday. */
12374 gen_reference_type_die (tree type, dw_die_ref context_die)
12377 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12379 equate_type_number_to_die (type, ref_die);
12380 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12381 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12385 /* Generate a DIE for a pointer to a member type. */
12388 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12391 = new_die (DW_TAG_ptr_to_member_type,
12392 scope_die_for (type, context_die), type);
12394 equate_type_number_to_die (type, ptr_die);
12395 add_AT_die_ref (ptr_die, DW_AT_containing_type,
12396 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12397 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12400 /* Generate the DIE for the compilation unit. */
12403 gen_compile_unit_die (const char *filename)
12406 char producer[250];
12407 const char *language_string = lang_hooks.name;
12410 die = new_die (DW_TAG_compile_unit, NULL, NULL);
12414 add_name_attribute (die, filename);
12415 /* Don't add cwd for <built-in>. */
12416 if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12417 add_comp_dir_attribute (die);
12420 sprintf (producer, "%s %s", language_string, version_string);
12422 #ifdef MIPS_DEBUGGING_INFO
12423 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12424 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12425 not appear in the producer string, the debugger reaches the conclusion
12426 that the object file is stripped and has no debugging information.
12427 To get the MIPS/SGI debugger to believe that there is debugging
12428 information in the object file, we add a -g to the producer string. */
12429 if (debug_info_level > DINFO_LEVEL_TERSE)
12430 strcat (producer, " -g");
12433 add_AT_string (die, DW_AT_producer, producer);
12435 if (strcmp (language_string, "GNU C++") == 0)
12436 language = DW_LANG_C_plus_plus;
12437 else if (strcmp (language_string, "GNU Ada") == 0)
12438 language = DW_LANG_Ada95;
12439 else if (strcmp (language_string, "GNU F77") == 0)
12440 language = DW_LANG_Fortran77;
12441 else if (strcmp (language_string, "GNU F95") == 0)
12442 language = DW_LANG_Fortran95;
12443 else if (strcmp (language_string, "GNU Pascal") == 0)
12444 language = DW_LANG_Pascal83;
12445 else if (strcmp (language_string, "GNU Java") == 0)
12446 language = DW_LANG_Java;
12447 else if (strcmp (language_string, "GNU Objective-C") == 0)
12448 language = DW_LANG_ObjC;
12449 else if (strcmp (language_string, "GNU Objective-C++") == 0)
12450 language = DW_LANG_ObjC_plus_plus;
12452 language = DW_LANG_C89;
12454 add_AT_unsigned (die, DW_AT_language, language);
12458 /* Generate the DIE for a base class. */
12461 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12463 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12465 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12466 add_data_member_location_attribute (die, binfo);
12468 if (BINFO_VIRTUAL_P (binfo))
12469 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12471 if (access == access_public_node)
12472 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12473 else if (access == access_protected_node)
12474 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12477 /* Generate a DIE for a class member. */
12480 gen_member_die (tree type, dw_die_ref context_die)
12483 tree binfo = TYPE_BINFO (type);
12486 /* If this is not an incomplete type, output descriptions of each of its
12487 members. Note that as we output the DIEs necessary to represent the
12488 members of this record or union type, we will also be trying to output
12489 DIEs to represent the *types* of those members. However the `type'
12490 function (above) will specifically avoid generating type DIEs for member
12491 types *within* the list of member DIEs for this (containing) type except
12492 for those types (of members) which are explicitly marked as also being
12493 members of this (containing) type themselves. The g++ front- end can
12494 force any given type to be treated as a member of some other (containing)
12495 type by setting the TYPE_CONTEXT of the given (member) type to point to
12496 the TREE node representing the appropriate (containing) type. */
12498 /* First output info about the base classes. */
12501 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12505 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12506 gen_inheritance_die (base,
12507 (accesses ? VEC_index (tree, accesses, i)
12508 : access_public_node), context_die);
12511 /* Now output info about the data members and type members. */
12512 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12514 /* If we thought we were generating minimal debug info for TYPE
12515 and then changed our minds, some of the member declarations
12516 may have already been defined. Don't define them again, but
12517 do put them in the right order. */
12519 child = lookup_decl_die (member);
12521 splice_child_die (context_die, child);
12523 gen_decl_die (member, context_die);
12526 /* Now output info about the function members (if any). */
12527 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12529 /* Don't include clones in the member list. */
12530 if (DECL_ABSTRACT_ORIGIN (member))
12533 child = lookup_decl_die (member);
12535 splice_child_die (context_die, child);
12537 gen_decl_die (member, context_die);
12541 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
12542 is set, we pretend that the type was never defined, so we only get the
12543 member DIEs needed by later specification DIEs. */
12546 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
12547 enum debug_info_usage usage)
12549 dw_die_ref type_die = lookup_type_die (type);
12550 dw_die_ref scope_die = 0;
12552 int complete = (TYPE_SIZE (type)
12553 && (! TYPE_STUB_DECL (type)
12554 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12555 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12556 complete = complete && should_emit_struct_debug (type, usage);
12558 if (type_die && ! complete)
12561 if (TYPE_CONTEXT (type) != NULL_TREE
12562 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12563 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12566 scope_die = scope_die_for (type, context_die);
12568 if (! type_die || (nested && scope_die == comp_unit_die))
12569 /* First occurrence of type or toplevel definition of nested class. */
12571 dw_die_ref old_die = type_die;
12573 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12574 ? DW_TAG_structure_type : DW_TAG_union_type,
12576 equate_type_number_to_die (type, type_die);
12578 add_AT_specification (type_die, old_die);
12580 add_name_attribute (type_die, type_tag (type));
12581 /* APPLE LOCAL begin radar 5811943 - Fix type of pointers to Blocks */
12582 if (TYPE_BLOCK_IMPL_STRUCT (type))
12583 add_AT_flag (type_die, DW_AT_APPLE_block, 1);
12584 /* APPLE LOCAL end radar 5811943 - Fix type of pointers to Blocks */
12587 remove_AT (type_die, DW_AT_declaration);
12589 /* If this type has been completed, then give it a byte_size attribute and
12590 then give a list of members. */
12591 if (complete && !ns_decl)
12593 /* Prevent infinite recursion in cases where the type of some member of
12594 this type is expressed in terms of this type itself. */
12595 TREE_ASM_WRITTEN (type) = 1;
12596 add_byte_size_attribute (type_die, type);
12597 if (TYPE_STUB_DECL (type) != NULL_TREE)
12598 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12600 /* If the first reference to this type was as the return type of an
12601 inline function, then it may not have a parent. Fix this now. */
12602 if (type_die->die_parent == NULL)
12603 add_child_die (scope_die, type_die);
12605 push_decl_scope (type);
12606 gen_member_die (type, type_die);
12609 /* GNU extension: Record what type our vtable lives in. */
12610 if (TYPE_VFIELD (type))
12612 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12614 gen_type_die (vtype, context_die);
12615 add_AT_die_ref (type_die, DW_AT_containing_type,
12616 lookup_type_die (vtype));
12621 add_AT_flag (type_die, DW_AT_declaration, 1);
12623 /* We don't need to do this for function-local types. */
12624 if (TYPE_STUB_DECL (type)
12625 && ! decl_function_context (TYPE_STUB_DECL (type)))
12626 VEC_safe_push (tree, gc, incomplete_types, type);
12629 if (get_AT (type_die, DW_AT_name))
12630 add_pubtype (type, type_die);
12633 /* Generate a DIE for a subroutine _type_. */
12636 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12638 tree return_type = TREE_TYPE (type);
12639 dw_die_ref subr_die
12640 = new_die (DW_TAG_subroutine_type,
12641 scope_die_for (type, context_die), type);
12643 equate_type_number_to_die (type, subr_die);
12644 add_prototyped_attribute (subr_die, type);
12645 add_type_attribute (subr_die, return_type, 0, 0, context_die);
12646 gen_formal_types_die (type, subr_die);
12648 if (get_AT (subr_die, DW_AT_name))
12649 add_pubtype (type, subr_die);
12652 /* Generate a DIE for a type definition. */
12655 gen_typedef_die (tree decl, dw_die_ref context_die)
12657 dw_die_ref type_die;
12660 if (TREE_ASM_WRITTEN (decl))
12663 TREE_ASM_WRITTEN (decl) = 1;
12664 type_die = new_die (DW_TAG_typedef, context_die, decl);
12665 origin = decl_ultimate_origin (decl);
12666 if (origin != NULL)
12667 add_abstract_origin_attribute (type_die, origin);
12672 add_name_and_src_coords_attributes (type_die, decl);
12673 if (DECL_ORIGINAL_TYPE (decl))
12675 type = DECL_ORIGINAL_TYPE (decl);
12677 gcc_assert (type != TREE_TYPE (decl));
12678 equate_type_number_to_die (TREE_TYPE (decl), type_die);
12681 type = TREE_TYPE (decl);
12683 add_type_attribute (type_die, type, TREE_READONLY (decl),
12684 TREE_THIS_VOLATILE (decl), context_die);
12687 if (DECL_ABSTRACT (decl))
12688 equate_decl_number_to_die (decl, type_die);
12690 if (get_AT (type_die, DW_AT_name))
12691 add_pubtype (decl, type_die);
12694 /* Generate a type description DIE. */
12697 gen_type_die_with_usage (tree type, dw_die_ref context_die,
12698 enum debug_info_usage usage)
12702 if (type == NULL_TREE || type == error_mark_node)
12705 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12706 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12708 if (TREE_ASM_WRITTEN (type))
12711 /* Prevent broken recursion; we can't hand off to the same type. */
12712 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12714 TREE_ASM_WRITTEN (type) = 1;
12715 gen_decl_die (TYPE_NAME (type), context_die);
12719 /* We are going to output a DIE to represent the unqualified version
12720 of this type (i.e. without any const or volatile qualifiers) so
12721 get the main variant (i.e. the unqualified version) of this type
12722 now. (Vectors are special because the debugging info is in the
12723 cloned type itself). */
12724 if (TREE_CODE (type) != VECTOR_TYPE)
12725 type = type_main_variant (type);
12727 if (TREE_ASM_WRITTEN (type))
12730 switch (TREE_CODE (type))
12734 /* APPLE LOCAL radar 5732232 - blocks */
12735 case BLOCK_POINTER_TYPE:
12737 case REFERENCE_TYPE:
12738 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
12739 ensures that the gen_type_die recursion will terminate even if the
12740 type is recursive. Recursive types are possible in Ada. */
12741 /* ??? We could perhaps do this for all types before the switch
12743 TREE_ASM_WRITTEN (type) = 1;
12745 /* For these types, all that is required is that we output a DIE (or a
12746 set of DIEs) to represent the "basis" type. */
12747 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12748 DINFO_USAGE_IND_USE);
12752 /* This code is used for C++ pointer-to-data-member types.
12753 Output a description of the relevant class type. */
12754 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
12755 DINFO_USAGE_IND_USE);
12757 /* Output a description of the type of the object pointed to. */
12758 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12759 DINFO_USAGE_IND_USE);
12761 /* Now output a DIE to represent this pointer-to-data-member type
12763 gen_ptr_to_mbr_type_die (type, context_die);
12766 case FUNCTION_TYPE:
12767 /* Force out return type (in case it wasn't forced out already). */
12768 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12769 DINFO_USAGE_DIR_USE);
12770 gen_subroutine_type_die (type, context_die);
12774 /* Force out return type (in case it wasn't forced out already). */
12775 gen_type_die_with_usage (TREE_TYPE (type), context_die,
12776 DINFO_USAGE_DIR_USE);
12777 gen_subroutine_type_die (type, context_die);
12781 gen_array_type_die (type, context_die);
12785 gen_array_type_die (type, context_die);
12788 case ENUMERAL_TYPE:
12791 case QUAL_UNION_TYPE:
12792 /* If this is a nested type whose containing class hasn't been written
12793 out yet, writing it out will cover this one, too. This does not apply
12794 to instantiations of member class templates; they need to be added to
12795 the containing class as they are generated. FIXME: This hurts the
12796 idea of combining type decls from multiple TUs, since we can't predict
12797 what set of template instantiations we'll get. */
12798 if (TYPE_CONTEXT (type)
12799 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12800 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12802 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
12804 if (TREE_ASM_WRITTEN (type))
12807 /* If that failed, attach ourselves to the stub. */
12808 push_decl_scope (TYPE_CONTEXT (type));
12809 context_die = lookup_type_die (TYPE_CONTEXT (type));
12814 declare_in_namespace (type, context_die);
12818 if (TREE_CODE (type) == ENUMERAL_TYPE)
12820 /* This might have been written out by the call to
12821 declare_in_namespace. */
12822 if (!TREE_ASM_WRITTEN (type))
12823 gen_enumeration_type_die (type, context_die);
12826 gen_struct_or_union_type_die (type, context_die, usage);
12831 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12832 it up if it is ever completed. gen_*_type_die will set it for us
12833 when appropriate. */
12841 /* No DIEs needed for fundamental types. */
12845 /* No Dwarf representation currently defined. */
12849 gcc_unreachable ();
12852 TREE_ASM_WRITTEN (type) = 1;
12856 gen_type_die (tree type, dw_die_ref context_die)
12858 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
12861 /* Generate a DIE for a tagged type instantiation. */
12864 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12866 if (type == NULL_TREE || type == error_mark_node)
12869 /* We are going to output a DIE to represent the unqualified version of
12870 this type (i.e. without any const or volatile qualifiers) so make sure
12871 that we have the main variant (i.e. the unqualified version) of this
12873 gcc_assert (type == type_main_variant (type));
12875 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12876 an instance of an unresolved type. */
12878 switch (TREE_CODE (type))
12883 case ENUMERAL_TYPE:
12884 gen_inlined_enumeration_type_die (type, context_die);
12888 gen_inlined_structure_type_die (type, context_die);
12892 case QUAL_UNION_TYPE:
12893 gen_inlined_union_type_die (type, context_die);
12897 gcc_unreachable ();
12901 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12902 things which are local to the given block. */
12905 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12907 int must_output_die = 0;
12910 enum tree_code origin_code;
12912 /* Ignore blocks that are NULL. */
12913 if (stmt == NULL_TREE)
12916 /* If the block is one fragment of a non-contiguous block, do not
12917 process the variables, since they will have been done by the
12918 origin block. Do process subblocks. */
12919 if (BLOCK_FRAGMENT_ORIGIN (stmt))
12923 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12924 gen_block_die (sub, context_die, depth + 1);
12929 /* Determine the "ultimate origin" of this block. This block may be an
12930 inlined instance of an inlined instance of inline function, so we have
12931 to trace all of the way back through the origin chain to find out what
12932 sort of node actually served as the original seed for the creation of
12933 the current block. */
12934 origin = block_ultimate_origin (stmt);
12935 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12937 /* Determine if we need to output any Dwarf DIEs at all to represent this
12939 if (origin_code == FUNCTION_DECL)
12940 /* The outer scopes for inlinings *must* always be represented. We
12941 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
12942 must_output_die = 1;
12945 /* In the case where the current block represents an inlining of the
12946 "body block" of an inline function, we must *NOT* output any DIE for
12947 this block because we have already output a DIE to represent the whole
12948 inlined function scope and the "body block" of any function doesn't
12949 really represent a different scope according to ANSI C rules. So we
12950 check here to make sure that this block does not represent a "body
12951 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
12952 if (! is_body_block (origin ? origin : stmt))
12954 /* Determine if this block directly contains any "significant"
12955 local declarations which we will need to output DIEs for. */
12956 if (debug_info_level > DINFO_LEVEL_TERSE)
12957 /* We are not in terse mode so *any* local declaration counts
12958 as being a "significant" one. */
12959 must_output_die = (BLOCK_VARS (stmt) != NULL
12960 && (TREE_USED (stmt)
12961 || TREE_ASM_WRITTEN (stmt)
12962 || BLOCK_ABSTRACT (stmt)));
12964 /* We are in terse mode, so only local (nested) function
12965 definitions count as "significant" local declarations. */
12966 for (decl = BLOCK_VARS (stmt);
12967 decl != NULL; decl = TREE_CHAIN (decl))
12968 if (TREE_CODE (decl) == FUNCTION_DECL
12969 && DECL_INITIAL (decl))
12971 must_output_die = 1;
12977 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12978 DIE for any block which contains no significant local declarations at
12979 all. Rather, in such cases we just call `decls_for_scope' so that any
12980 needed Dwarf info for any sub-blocks will get properly generated. Note
12981 that in terse mode, our definition of what constitutes a "significant"
12982 local declaration gets restricted to include only inlined function
12983 instances and local (nested) function definitions. */
12984 if (must_output_die)
12986 if (origin_code == FUNCTION_DECL)
12987 gen_inlined_subroutine_die (stmt, context_die, depth);
12989 gen_lexical_block_die (stmt, context_die, depth);
12992 decls_for_scope (stmt, context_die, depth);
12995 /* Generate all of the decls declared within a given scope and (recursively)
12996 all of its sub-blocks. */
12999 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
13004 /* Ignore NULL blocks. */
13005 if (stmt == NULL_TREE)
13008 if (TREE_USED (stmt))
13010 /* Output the DIEs to represent all of the data objects and typedefs
13011 declared directly within this block but not within any nested
13012 sub-blocks. Also, nested function and tag DIEs have been
13013 generated with a parent of NULL; fix that up now. */
13014 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
13018 if (TREE_CODE (decl) == FUNCTION_DECL)
13019 die = lookup_decl_die (decl);
13020 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
13021 die = lookup_type_die (TREE_TYPE (decl));
13025 if (die != NULL && die->die_parent == NULL)
13026 add_child_die (context_die, die);
13027 /* Do not produce debug information for static variables since
13028 these might be optimized out. We are called for these later
13029 in cgraph_varpool_analyze_pending_decls. */
13030 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
13033 gen_decl_die (decl, context_die);
13037 /* If we're at -g1, we're not interested in subblocks. */
13038 if (debug_info_level <= DINFO_LEVEL_TERSE)
13041 /* Output the DIEs to represent all sub-blocks (and the items declared
13042 therein) of this block. */
13043 for (subblocks = BLOCK_SUBBLOCKS (stmt);
13045 subblocks = BLOCK_CHAIN (subblocks))
13046 gen_block_die (subblocks, context_die, depth + 1);
13049 /* Is this a typedef we can avoid emitting? */
13052 is_redundant_typedef (tree decl)
13054 if (TYPE_DECL_IS_STUB (decl))
13057 if (DECL_ARTIFICIAL (decl)
13058 && DECL_CONTEXT (decl)
13059 && is_tagged_type (DECL_CONTEXT (decl))
13060 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
13061 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
13062 /* Also ignore the artificial member typedef for the class name. */
13068 /* Returns the DIE for decl. A DIE will always be returned. */
13071 force_decl_die (tree decl)
13073 dw_die_ref decl_die;
13074 unsigned saved_external_flag;
13075 tree save_fn = NULL_TREE;
13076 decl_die = lookup_decl_die (decl);
13079 dw_die_ref context_die;
13080 tree decl_context = DECL_CONTEXT (decl);
13083 /* Find die that represents this context. */
13084 if (TYPE_P (decl_context))
13085 context_die = force_type_die (decl_context);
13087 context_die = force_decl_die (decl_context);
13090 context_die = comp_unit_die;
13092 decl_die = lookup_decl_die (decl);
13096 switch (TREE_CODE (decl))
13098 case FUNCTION_DECL:
13099 /* Clear current_function_decl, so that gen_subprogram_die thinks
13100 that this is a declaration. At this point, we just want to force
13101 declaration die. */
13102 save_fn = current_function_decl;
13103 current_function_decl = NULL_TREE;
13104 gen_subprogram_die (decl, context_die);
13105 current_function_decl = save_fn;
13109 /* Set external flag to force declaration die. Restore it after
13110 gen_decl_die() call. */
13111 saved_external_flag = DECL_EXTERNAL (decl);
13112 DECL_EXTERNAL (decl) = 1;
13113 gen_decl_die (decl, context_die);
13114 DECL_EXTERNAL (decl) = saved_external_flag;
13117 case NAMESPACE_DECL:
13118 dwarf2out_decl (decl);
13122 gcc_unreachable ();
13125 /* We should be able to find the DIE now. */
13127 decl_die = lookup_decl_die (decl);
13128 gcc_assert (decl_die);
13134 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
13135 always returned. */
13138 force_type_die (tree type)
13140 dw_die_ref type_die;
13142 type_die = lookup_type_die (type);
13145 dw_die_ref context_die;
13146 if (TYPE_CONTEXT (type))
13148 if (TYPE_P (TYPE_CONTEXT (type)))
13149 context_die = force_type_die (TYPE_CONTEXT (type));
13151 context_die = force_decl_die (TYPE_CONTEXT (type));
13154 context_die = comp_unit_die;
13156 type_die = lookup_type_die (type);
13159 gen_type_die (type, context_die);
13160 type_die = lookup_type_die (type);
13161 gcc_assert (type_die);
13166 /* Force out any required namespaces to be able to output DECL,
13167 and return the new context_die for it, if it's changed. */
13170 setup_namespace_context (tree thing, dw_die_ref context_die)
13172 tree context = (DECL_P (thing)
13173 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
13174 if (context && TREE_CODE (context) == NAMESPACE_DECL)
13175 /* Force out the namespace. */
13176 context_die = force_decl_die (context);
13178 return context_die;
13181 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
13182 type) within its namespace, if appropriate.
13184 For compatibility with older debuggers, namespace DIEs only contain
13185 declarations; all definitions are emitted at CU scope. */
13188 declare_in_namespace (tree thing, dw_die_ref context_die)
13190 dw_die_ref ns_context;
13192 if (debug_info_level <= DINFO_LEVEL_TERSE)
13195 /* If this decl is from an inlined function, then don't try to emit it in its
13196 namespace, as we will get confused. It would have already been emitted
13197 when the abstract instance of the inline function was emitted anyways. */
13198 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
13201 ns_context = setup_namespace_context (thing, context_die);
13203 if (ns_context != context_die)
13205 if (DECL_P (thing))
13206 gen_decl_die (thing, ns_context);
13208 gen_type_die (thing, ns_context);
13212 /* Generate a DIE for a namespace or namespace alias. */
13215 gen_namespace_die (tree decl)
13217 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
13219 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
13220 they are an alias of. */
13221 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
13223 /* Output a real namespace. */
13224 dw_die_ref namespace_die
13225 = new_die (DW_TAG_namespace, context_die, decl);
13226 add_name_and_src_coords_attributes (namespace_die, decl);
13227 equate_decl_number_to_die (decl, namespace_die);
13231 /* Output a namespace alias. */
13233 /* Force out the namespace we are an alias of, if necessary. */
13234 dw_die_ref origin_die
13235 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
13237 /* Now create the namespace alias DIE. */
13238 dw_die_ref namespace_die
13239 = new_die (DW_TAG_imported_declaration, context_die, decl);
13240 add_name_and_src_coords_attributes (namespace_die, decl);
13241 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
13242 equate_decl_number_to_die (decl, namespace_die);
13246 /* Generate Dwarf debug information for a decl described by DECL. */
13249 gen_decl_die (tree decl, dw_die_ref context_die)
13253 if (DECL_P (decl) && DECL_IGNORED_P (decl))
13256 switch (TREE_CODE (decl))
13262 /* The individual enumerators of an enum type get output when we output
13263 the Dwarf representation of the relevant enum type itself. */
13266 case FUNCTION_DECL:
13267 /* Don't output any DIEs to represent mere function declarations,
13268 unless they are class members or explicit block externs. */
13269 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13270 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13275 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13276 on local redeclarations of global functions. That seems broken. */
13277 if (current_function_decl != decl)
13278 /* This is only a declaration. */;
13281 /* If we're emitting a clone, emit info for the abstract instance. */
13282 if (DECL_ORIGIN (decl) != decl)
13283 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13285 /* If we're emitting an out-of-line copy of an inline function,
13286 emit info for the abstract instance and set up to refer to it. */
13287 else if (cgraph_function_possibly_inlined_p (decl)
13288 && ! DECL_ABSTRACT (decl)
13289 && ! class_or_namespace_scope_p (context_die)
13290 /* dwarf2out_abstract_function won't emit a die if this is just
13291 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
13292 that case, because that works only if we have a die. */
13293 && DECL_INITIAL (decl) != NULL_TREE)
13295 dwarf2out_abstract_function (decl);
13296 set_decl_origin_self (decl);
13299 /* Otherwise we're emitting the primary DIE for this decl. */
13300 else if (debug_info_level > DINFO_LEVEL_TERSE)
13302 /* Before we describe the FUNCTION_DECL itself, make sure that we
13303 have described its return type. */
13304 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13306 /* And its virtual context. */
13307 if (DECL_VINDEX (decl) != NULL_TREE)
13308 gen_type_die (DECL_CONTEXT (decl), context_die);
13310 /* And its containing type. */
13311 origin = decl_class_context (decl);
13312 if (origin != NULL_TREE)
13313 gen_type_die_for_member (origin, decl, context_die);
13315 /* And its containing namespace. */
13316 declare_in_namespace (decl, context_die);
13319 /* Now output a DIE to represent the function itself. */
13320 gen_subprogram_die (decl, context_die);
13324 /* If we are in terse mode, don't generate any DIEs to represent any
13325 actual typedefs. */
13326 if (debug_info_level <= DINFO_LEVEL_TERSE)
13329 /* In the special case of a TYPE_DECL node representing the declaration
13330 of some type tag, if the given TYPE_DECL is marked as having been
13331 instantiated from some other (original) TYPE_DECL node (e.g. one which
13332 was generated within the original definition of an inline function) we
13333 have to generate a special (abbreviated) DW_TAG_structure_type,
13334 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
13335 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE
13336 && is_tagged_type (TREE_TYPE (decl)))
13338 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13342 if (is_redundant_typedef (decl))
13343 gen_type_die (TREE_TYPE (decl), context_die);
13345 /* Output a DIE to represent the typedef itself. */
13346 gen_typedef_die (decl, context_die);
13350 if (debug_info_level >= DINFO_LEVEL_NORMAL)
13351 gen_label_die (decl, context_die);
13356 /* If we are in terse mode, don't generate any DIEs to represent any
13357 variable declarations or definitions. */
13358 if (debug_info_level <= DINFO_LEVEL_TERSE)
13361 /* Output any DIEs that are needed to specify the type of this data
13363 gen_type_die (TREE_TYPE (decl), context_die);
13365 /* And its containing type. */
13366 origin = decl_class_context (decl);
13367 if (origin != NULL_TREE)
13368 gen_type_die_for_member (origin, decl, context_die);
13370 /* And its containing namespace. */
13371 declare_in_namespace (decl, context_die);
13373 /* Now output the DIE to represent the data object itself. This gets
13374 complicated because of the possibility that the VAR_DECL really
13375 represents an inlined instance of a formal parameter for an inline
13377 origin = decl_ultimate_origin (decl);
13378 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13379 gen_formal_parameter_die (decl, context_die);
13381 gen_variable_die (decl, context_die);
13385 /* Ignore the nameless fields that are used to skip bits but handle C++
13386 anonymous unions and structs. */
13387 if (DECL_NAME (decl) != NULL_TREE
13388 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13389 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13391 gen_type_die (member_declared_type (decl), context_die);
13392 gen_field_die (decl, context_die);
13397 gen_type_die (TREE_TYPE (decl), context_die);
13398 gen_formal_parameter_die (decl, context_die);
13401 case NAMESPACE_DECL:
13402 gen_namespace_die (decl);
13406 /* Probably some frontend-internal decl. Assume we don't care. */
13407 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13412 /* Output debug information for global decl DECL. Called from toplev.c after
13413 compilation proper has finished. */
13416 dwarf2out_global_decl (tree decl)
13418 /* Output DWARF2 information for file-scope tentative data object
13419 declarations, file-scope (extern) function declarations (which had no
13420 corresponding body) and file-scope tagged type declarations and
13421 definitions which have not yet been forced out. */
13422 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13423 dwarf2out_decl (decl);
13426 /* Output debug information for type decl DECL. Called from toplev.c
13427 and from language front ends (to record built-in types). */
13429 dwarf2out_type_decl (tree decl, int local)
13432 dwarf2out_decl (decl);
13435 /* Output debug information for imported module or decl. */
13438 dwarf2out_imported_module_or_decl (tree decl, tree context)
13440 dw_die_ref imported_die, at_import_die;
13441 dw_die_ref scope_die;
13442 expanded_location xloc;
13444 if (debug_info_level <= DINFO_LEVEL_TERSE)
13449 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13450 We need decl DIE for reference and scope die. First, get DIE for the decl
13453 /* Get the scope die for decl context. Use comp_unit_die for global module
13454 or decl. If die is not found for non globals, force new die. */
13456 scope_die = comp_unit_die;
13457 else if (TYPE_P (context))
13459 if (!should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
13461 scope_die = force_type_die (context);
13464 scope_die = force_decl_die (context);
13466 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */
13467 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13469 if (is_base_type (TREE_TYPE (decl)))
13470 at_import_die = base_type_die (TREE_TYPE (decl));
13472 at_import_die = force_type_die (TREE_TYPE (decl));
13476 at_import_die = lookup_decl_die (decl);
13477 if (!at_import_die)
13479 /* If we're trying to avoid duplicate debug info, we may not have
13480 emitted the member decl for this field. Emit it now. */
13481 if (TREE_CODE (decl) == FIELD_DECL)
13483 tree type = DECL_CONTEXT (decl);
13484 dw_die_ref type_context_die;
13486 if (TYPE_CONTEXT (type))
13487 if (TYPE_P (TYPE_CONTEXT (type)))
13489 if (!should_emit_struct_debug (TYPE_CONTEXT (type),
13490 DINFO_USAGE_DIR_USE))
13492 type_context_die = force_type_die (TYPE_CONTEXT (type));
13495 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13497 type_context_die = comp_unit_die;
13498 gen_type_die_for_member (type, decl, type_context_die);
13500 at_import_die = force_decl_die (decl);
13504 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
13505 if (TREE_CODE (decl) == NAMESPACE_DECL)
13506 imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13508 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13510 xloc = expand_location (input_location);
13511 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
13512 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13513 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13516 /* Write the debugging output for DECL. */
13519 dwarf2out_decl (tree decl)
13521 dw_die_ref context_die = comp_unit_die;
13523 switch (TREE_CODE (decl))
13528 case FUNCTION_DECL:
13529 /* What we would really like to do here is to filter out all mere
13530 file-scope declarations of file-scope functions which are never
13531 referenced later within this translation unit (and keep all of ones
13532 that *are* referenced later on) but we aren't clairvoyant, so we have
13533 no idea which functions will be referenced in the future (i.e. later
13534 on within the current translation unit). So here we just ignore all
13535 file-scope function declarations which are not also definitions. If
13536 and when the debugger needs to know something about these functions,
13537 it will have to hunt around and find the DWARF information associated
13538 with the definition of the function.
13540 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13541 nodes represent definitions and which ones represent mere
13542 declarations. We have to check DECL_INITIAL instead. That's because
13543 the C front-end supports some weird semantics for "extern inline"
13544 function definitions. These can get inlined within the current
13545 translation unit (and thus, we need to generate Dwarf info for their
13546 abstract instances so that the Dwarf info for the concrete inlined
13547 instances can have something to refer to) but the compiler never
13548 generates any out-of-lines instances of such things (despite the fact
13549 that they *are* definitions).
13551 The important point is that the C front-end marks these "extern
13552 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13553 them anyway. Note that the C++ front-end also plays some similar games
13554 for inline function definitions appearing within include files which
13555 also contain `#pragma interface' pragmas. */
13556 if (DECL_INITIAL (decl) == NULL_TREE)
13559 /* If we're a nested function, initially use a parent of NULL; if we're
13560 a plain function, this will be fixed up in decls_for_scope. If
13561 we're a method, it will be ignored, since we already have a DIE. */
13562 if (decl_function_context (decl)
13563 /* But if we're in terse mode, we don't care about scope. */
13564 && debug_info_level > DINFO_LEVEL_TERSE)
13565 context_die = NULL;
13569 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13570 declaration and if the declaration was never even referenced from
13571 within this entire compilation unit. We suppress these DIEs in
13572 order to save space in the .debug section (by eliminating entries
13573 which are probably useless). Note that we must not suppress
13574 block-local extern declarations (whether used or not) because that
13575 would screw-up the debugger's name lookup mechanism and cause it to
13576 miss things which really ought to be in scope at a given point. */
13577 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13580 /* For local statics lookup proper context die. */
13581 if (TREE_STATIC (decl) && decl_function_context (decl))
13582 context_die = lookup_decl_die (DECL_CONTEXT (decl));
13584 /* If we are in terse mode, don't generate any DIEs to represent any
13585 variable declarations or definitions. */
13586 if (debug_info_level <= DINFO_LEVEL_TERSE)
13590 case NAMESPACE_DECL:
13591 if (debug_info_level <= DINFO_LEVEL_TERSE)
13593 if (lookup_decl_die (decl) != NULL)
13598 /* Don't emit stubs for types unless they are needed by other DIEs. */
13599 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13602 /* Don't bother trying to generate any DIEs to represent any of the
13603 normal built-in types for the language we are compiling. */
13604 if (DECL_IS_BUILTIN (decl))
13606 /* OK, we need to generate one for `bool' so GDB knows what type
13607 comparisons have. */
13609 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13610 && ! DECL_IGNORED_P (decl))
13611 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13616 /* If we are in terse mode, don't generate any DIEs for types. */
13617 if (debug_info_level <= DINFO_LEVEL_TERSE)
13620 /* If we're a function-scope tag, initially use a parent of NULL;
13621 this will be fixed up in decls_for_scope. */
13622 if (decl_function_context (decl))
13623 context_die = NULL;
13631 gen_decl_die (decl, context_die);
13634 /* Output a marker (i.e. a label) for the beginning of the generated code for
13635 a lexical block. */
13638 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13639 unsigned int blocknum)
13641 switch_to_section (current_function_section ());
13642 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13645 /* Output a marker (i.e. a label) for the end of the generated code for a
13649 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13651 switch_to_section (current_function_section ());
13652 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13655 /* Returns nonzero if it is appropriate not to emit any debugging
13656 information for BLOCK, because it doesn't contain any instructions.
13658 Don't allow this for blocks with nested functions or local classes
13659 as we would end up with orphans, and in the presence of scheduling
13660 we may end up calling them anyway. */
13663 dwarf2out_ignore_block (tree block)
13667 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13668 if (TREE_CODE (decl) == FUNCTION_DECL
13669 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13675 /* Hash table routines for file_hash. */
13678 file_table_eq (const void *p1_p, const void *p2_p)
13680 const struct dwarf_file_data * p1 = p1_p;
13681 const char * p2 = p2_p;
13682 return strcmp (p1->filename, p2) == 0;
13686 file_table_hash (const void *p_p)
13688 const struct dwarf_file_data * p = p_p;
13689 return htab_hash_string (p->filename);
13692 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13693 dwarf2out.c) and return its "index". The index of each (known) filename is
13694 just a unique number which is associated with only that one filename. We
13695 need such numbers for the sake of generating labels (in the .debug_sfnames
13696 section) and references to those files numbers (in the .debug_srcinfo
13697 and.debug_macinfo sections). If the filename given as an argument is not
13698 found in our current list, add it to the list and assign it the next
13699 available unique index number. In order to speed up searches, we remember
13700 the index of the filename was looked up last. This handles the majority of
13703 static struct dwarf_file_data *
13704 lookup_filename (const char *file_name)
13707 struct dwarf_file_data * created;
13709 /* Check to see if the file name that was searched on the previous
13710 call matches this file name. If so, return the index. */
13711 if (file_table_last_lookup
13712 && (file_name == file_table_last_lookup->filename
13713 || strcmp (file_table_last_lookup->filename, file_name) == 0))
13714 return file_table_last_lookup;
13716 /* Didn't match the previous lookup, search the table. */
13717 slot = htab_find_slot_with_hash (file_table, file_name,
13718 htab_hash_string (file_name), INSERT);
13722 created = ggc_alloc (sizeof (struct dwarf_file_data));
13723 created->filename = file_name;
13724 created->emitted_number = 0;
13729 /* If the assembler will construct the file table, then translate the compiler
13730 internal file table number into the assembler file table number, and emit
13731 a .file directive if we haven't already emitted one yet. The file table
13732 numbers are different because we prune debug info for unused variables and
13733 types, which may include filenames. */
13736 maybe_emit_file (struct dwarf_file_data * fd)
13738 if (! fd->emitted_number)
13740 if (last_emitted_file)
13741 fd->emitted_number = last_emitted_file->emitted_number + 1;
13743 fd->emitted_number = 1;
13744 last_emitted_file = fd;
13746 if (DWARF2_ASM_LINE_DEBUG_INFO)
13748 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
13749 output_quoted_string (asm_out_file, fd->filename);
13750 fputc ('\n', asm_out_file);
13754 return fd->emitted_number;
13757 /* Called by the final INSN scan whenever we see a var location. We
13758 use it to drop labels in the right places, and throw the location in
13759 our lookup table. */
13762 dwarf2out_var_location (rtx loc_note)
13764 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13765 struct var_loc_node *newloc;
13767 static rtx last_insn;
13768 static const char *last_label;
13771 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13773 prev_insn = PREV_INSN (loc_note);
13775 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13776 /* If the insn we processed last time is the previous insn
13777 and it is also a var location note, use the label we emitted
13779 if (last_insn != NULL_RTX
13780 && last_insn == prev_insn
13781 && NOTE_P (prev_insn)
13782 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13784 newloc->label = last_label;
13788 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13789 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13791 newloc->label = ggc_strdup (loclabel);
13793 newloc->var_loc_note = loc_note;
13794 newloc->next = NULL;
13796 if (cfun && in_cold_section_p)
13797 newloc->section_label = cfun->cold_section_label;
13799 newloc->section_label = text_section_label;
13801 last_insn = loc_note;
13802 last_label = newloc->label;
13803 decl = NOTE_VAR_LOCATION_DECL (loc_note);
13804 add_var_loc_to_decl (decl, newloc);
13807 /* We need to reset the locations at the beginning of each
13808 function. We can't do this in the end_function hook, because the
13809 declarations that use the locations won't have been output when
13810 that hook is called. Also compute have_multiple_function_sections here. */
13813 dwarf2out_begin_function (tree fun)
13815 htab_empty (decl_loc_table);
13817 if (function_section (fun) != text_section)
13818 have_multiple_function_sections = true;
13821 /* Output a label to mark the beginning of a source code line entry
13822 and record information relating to this source line, in
13823 'line_info_table' for later output of the .debug_line section. */
13826 dwarf2out_source_line (unsigned int line, const char *filename)
13828 if (debug_info_level >= DINFO_LEVEL_NORMAL
13831 int file_num = maybe_emit_file (lookup_filename (filename));
13833 switch_to_section (current_function_section ());
13835 /* If requested, emit something human-readable. */
13836 if (flag_debug_asm)
13837 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13840 if (DWARF2_ASM_LINE_DEBUG_INFO)
13842 /* Emit the .loc directive understood by GNU as. */
13843 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13845 /* Indicate that line number info exists. */
13846 line_info_table_in_use++;
13848 else if (function_section (current_function_decl) != text_section)
13850 dw_separate_line_info_ref line_info;
13851 targetm.asm_out.internal_label (asm_out_file,
13852 SEPARATE_LINE_CODE_LABEL,
13853 separate_line_info_table_in_use);
13855 /* Expand the line info table if necessary. */
13856 if (separate_line_info_table_in_use
13857 == separate_line_info_table_allocated)
13859 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13860 separate_line_info_table
13861 = ggc_realloc (separate_line_info_table,
13862 separate_line_info_table_allocated
13863 * sizeof (dw_separate_line_info_entry));
13864 memset (separate_line_info_table
13865 + separate_line_info_table_in_use,
13867 (LINE_INFO_TABLE_INCREMENT
13868 * sizeof (dw_separate_line_info_entry)));
13871 /* Add the new entry at the end of the line_info_table. */
13873 = &separate_line_info_table[separate_line_info_table_in_use++];
13874 line_info->dw_file_num = file_num;
13875 line_info->dw_line_num = line;
13876 line_info->function = current_function_funcdef_no;
13880 dw_line_info_ref line_info;
13882 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13883 line_info_table_in_use);
13885 /* Expand the line info table if necessary. */
13886 if (line_info_table_in_use == line_info_table_allocated)
13888 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13890 = ggc_realloc (line_info_table,
13891 (line_info_table_allocated
13892 * sizeof (dw_line_info_entry)));
13893 memset (line_info_table + line_info_table_in_use, 0,
13894 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13897 /* Add the new entry at the end of the line_info_table. */
13898 line_info = &line_info_table[line_info_table_in_use++];
13899 line_info->dw_file_num = file_num;
13900 line_info->dw_line_num = line;
13905 /* Record the beginning of a new source file. */
13908 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13910 if (flag_eliminate_dwarf2_dups)
13912 /* Record the beginning of the file for break_out_includes. */
13913 dw_die_ref bincl_die;
13915 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13916 add_AT_string (bincl_die, DW_AT_name, filename);
13919 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13921 int file_num = maybe_emit_file (lookup_filename (filename));
13923 switch_to_section (debug_macinfo_section);
13924 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13925 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13928 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
13932 /* Record the end of a source file. */
13935 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13937 if (flag_eliminate_dwarf2_dups)
13938 /* Record the end of the file for break_out_includes. */
13939 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13941 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13943 switch_to_section (debug_macinfo_section);
13944 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13948 /* Called from debug_define in toplev.c. The `buffer' parameter contains
13949 the tail part of the directive line, i.e. the part which is past the
13950 initial whitespace, #, whitespace, directive-name, whitespace part. */
13953 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13954 const char *buffer ATTRIBUTE_UNUSED)
13956 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13958 switch_to_section (debug_macinfo_section);
13959 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13960 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13961 dw2_asm_output_nstring (buffer, -1, "The macro");
13965 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
13966 the tail part of the directive line, i.e. the part which is past the
13967 initial whitespace, #, whitespace, directive-name, whitespace part. */
13970 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13971 const char *buffer ATTRIBUTE_UNUSED)
13973 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13975 switch_to_section (debug_macinfo_section);
13976 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13977 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13978 dw2_asm_output_nstring (buffer, -1, "The macro");
13982 /* Set up for Dwarf output at the start of compilation. */
13985 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13987 /* Allocate the file_table. */
13988 file_table = htab_create_ggc (50, file_table_hash,
13989 file_table_eq, NULL);
13991 /* Allocate the decl_die_table. */
13992 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13993 decl_die_table_eq, NULL);
13995 /* Allocate the decl_loc_table. */
13996 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13997 decl_loc_table_eq, NULL);
13999 /* Allocate the initial hunk of the decl_scope_table. */
14000 decl_scope_table = VEC_alloc (tree, gc, 256);
14002 /* Allocate the initial hunk of the abbrev_die_table. */
14003 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
14004 * sizeof (dw_die_ref));
14005 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
14006 /* Zero-th entry is allocated, but unused. */
14007 abbrev_die_table_in_use = 1;
14009 /* Allocate the initial hunk of the line_info_table. */
14010 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
14011 * sizeof (dw_line_info_entry));
14012 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
14014 /* Zero-th entry is allocated, but unused. */
14015 line_info_table_in_use = 1;
14017 /* Allocate the pubtypes and pubnames vectors. */
14018 pubname_table = VEC_alloc (pubname_entry, gc, 32);
14019 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
14021 /* Generate the initial DIE for the .debug section. Note that the (string)
14022 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
14023 will (typically) be a relative pathname and that this pathname should be
14024 taken as being relative to the directory from which the compiler was
14025 invoked when the given (base) source file was compiled. We will fill
14026 in this value in dwarf2out_finish. */
14027 comp_unit_die = gen_compile_unit_die (NULL);
14029 incomplete_types = VEC_alloc (tree, gc, 64);
14031 used_rtx_array = VEC_alloc (rtx, gc, 32);
14033 debug_info_section = get_section (DEBUG_INFO_SECTION,
14034 SECTION_DEBUG, NULL);
14035 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
14036 SECTION_DEBUG, NULL);
14037 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
14038 SECTION_DEBUG, NULL);
14039 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
14040 SECTION_DEBUG, NULL);
14041 debug_line_section = get_section (DEBUG_LINE_SECTION,
14042 SECTION_DEBUG, NULL);
14043 debug_loc_section = get_section (DEBUG_LOC_SECTION,
14044 SECTION_DEBUG, NULL);
14045 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
14046 SECTION_DEBUG, NULL);
14047 #ifdef DEBUG_PUBTYPES_SECTION
14048 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
14049 SECTION_DEBUG, NULL);
14051 debug_str_section = get_section (DEBUG_STR_SECTION,
14052 DEBUG_STR_SECTION_FLAGS, NULL);
14053 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
14054 SECTION_DEBUG, NULL);
14055 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
14056 SECTION_DEBUG, NULL);
14058 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
14059 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
14060 DEBUG_ABBREV_SECTION_LABEL, 0);
14061 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
14062 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
14063 COLD_TEXT_SECTION_LABEL, 0);
14064 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
14066 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
14067 DEBUG_INFO_SECTION_LABEL, 0);
14068 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
14069 DEBUG_LINE_SECTION_LABEL, 0);
14070 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
14071 DEBUG_RANGES_SECTION_LABEL, 0);
14072 switch_to_section (debug_abbrev_section);
14073 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
14074 switch_to_section (debug_info_section);
14075 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
14076 switch_to_section (debug_line_section);
14077 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
14079 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14081 switch_to_section (debug_macinfo_section);
14082 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
14083 DEBUG_MACINFO_SECTION_LABEL, 0);
14084 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
14087 switch_to_section (text_section);
14088 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
14089 if (flag_reorder_blocks_and_partition)
14091 switch_to_section (unlikely_text_section ());
14092 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
14096 /* A helper function for dwarf2out_finish called through
14097 ht_forall. Emit one queued .debug_str string. */
14100 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
14102 struct indirect_string_node *node = (struct indirect_string_node *) *h;
14104 if (node->form == DW_FORM_strp)
14106 switch_to_section (debug_str_section);
14107 ASM_OUTPUT_LABEL (asm_out_file, node->label);
14108 assemble_string (node->str, strlen (node->str) + 1);
14114 #if ENABLE_ASSERT_CHECKING
14115 /* Verify that all marks are clear. */
14118 verify_marks_clear (dw_die_ref die)
14122 gcc_assert (! die->die_mark);
14123 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
14125 #endif /* ENABLE_ASSERT_CHECKING */
14127 /* Clear the marks for a die and its children.
14128 Be cool if the mark isn't set. */
14131 prune_unmark_dies (dw_die_ref die)
14137 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
14140 /* Given DIE that we're marking as used, find any other dies
14141 it references as attributes and mark them as used. */
14144 prune_unused_types_walk_attribs (dw_die_ref die)
14149 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14151 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
14153 /* A reference to another DIE.
14154 Make sure that it will get emitted. */
14155 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
14157 /* Set the string's refcount to 0 so that prune_unused_types_mark
14158 accounts properly for it. */
14159 if (AT_class (a) == dw_val_class_str)
14160 a->dw_attr_val.v.val_str->refcount = 0;
14165 /* Mark DIE as being used. If DOKIDS is true, then walk down
14166 to DIE's children. */
14169 prune_unused_types_mark (dw_die_ref die, int dokids)
14173 if (die->die_mark == 0)
14175 /* We haven't done this node yet. Mark it as used. */
14178 /* We also have to mark its parents as used.
14179 (But we don't want to mark our parents' kids due to this.) */
14180 if (die->die_parent)
14181 prune_unused_types_mark (die->die_parent, 0);
14183 /* Mark any referenced nodes. */
14184 prune_unused_types_walk_attribs (die);
14186 /* If this node is a specification,
14187 also mark the definition, if it exists. */
14188 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
14189 prune_unused_types_mark (die->die_definition, 1);
14192 if (dokids && die->die_mark != 2)
14194 /* We need to walk the children, but haven't done so yet.
14195 Remember that we've walked the kids. */
14198 /* If this is an array type, we need to make sure our
14199 kids get marked, even if they're types. */
14200 if (die->die_tag == DW_TAG_array_type)
14201 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
14203 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14208 /* Walk the tree DIE and mark types that we actually use. */
14211 prune_unused_types_walk (dw_die_ref die)
14215 /* Don't do anything if this node is already marked. */
14219 switch (die->die_tag) {
14220 case DW_TAG_const_type:
14221 case DW_TAG_packed_type:
14222 case DW_TAG_pointer_type:
14223 case DW_TAG_reference_type:
14224 case DW_TAG_volatile_type:
14225 case DW_TAG_typedef:
14226 case DW_TAG_array_type:
14227 case DW_TAG_structure_type:
14228 case DW_TAG_union_type:
14229 case DW_TAG_class_type:
14230 case DW_TAG_friend:
14231 case DW_TAG_variant_part:
14232 case DW_TAG_enumeration_type:
14233 case DW_TAG_subroutine_type:
14234 case DW_TAG_string_type:
14235 case DW_TAG_set_type:
14236 case DW_TAG_subrange_type:
14237 case DW_TAG_ptr_to_member_type:
14238 case DW_TAG_file_type:
14239 if (die->die_perennial_p)
14242 /* It's a type node --- don't mark it. */
14246 /* Mark everything else. */
14252 /* Now, mark any dies referenced from here. */
14253 prune_unused_types_walk_attribs (die);
14255 /* Mark children. */
14256 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
14259 /* Increment the string counts on strings referred to from DIE's
14263 prune_unused_types_update_strings (dw_die_ref die)
14268 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
14269 if (AT_class (a) == dw_val_class_str)
14271 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
14273 /* Avoid unnecessarily putting strings that are used less than
14274 twice in the hash table. */
14276 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
14279 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
14280 htab_hash_string (s->str),
14282 gcc_assert (*slot == NULL);
14288 /* Remove from the tree DIE any dies that aren't marked. */
14291 prune_unused_types_prune (dw_die_ref die)
14295 gcc_assert (die->die_mark);
14296 prune_unused_types_update_strings (die);
14298 if (! die->die_child)
14301 c = die->die_child;
14303 dw_die_ref prev = c;
14304 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
14305 if (c == die->die_child)
14307 /* No marked children between 'prev' and the end of the list. */
14309 /* No marked children at all. */
14310 die->die_child = NULL;
14313 prev->die_sib = c->die_sib;
14314 die->die_child = prev;
14319 if (c != prev->die_sib)
14321 prune_unused_types_prune (c);
14322 } while (c != die->die_child);
14326 /* Remove dies representing declarations that we never use. */
14329 prune_unused_types (void)
14332 limbo_die_node *node;
14335 #if ENABLE_ASSERT_CHECKING
14336 /* All the marks should already be clear. */
14337 verify_marks_clear (comp_unit_die);
14338 for (node = limbo_die_list; node; node = node->next)
14339 verify_marks_clear (node->die);
14340 #endif /* ENABLE_ASSERT_CHECKING */
14342 /* Set the mark on nodes that are actually used. */
14343 prune_unused_types_walk (comp_unit_die);
14344 for (node = limbo_die_list; node; node = node->next)
14345 prune_unused_types_walk (node->die);
14347 /* Also set the mark on nodes referenced from the
14348 pubname_table or arange_table. */
14349 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
14350 prune_unused_types_mark (pub->die, 1);
14351 for (i = 0; i < arange_table_in_use; i++)
14352 prune_unused_types_mark (arange_table[i], 1);
14354 /* Get rid of nodes that aren't marked; and update the string counts. */
14355 if (debug_str_hash)
14356 htab_empty (debug_str_hash);
14357 prune_unused_types_prune (comp_unit_die);
14358 for (node = limbo_die_list; node; node = node->next)
14359 prune_unused_types_prune (node->die);
14361 /* Leave the marks clear. */
14362 prune_unmark_dies (comp_unit_die);
14363 for (node = limbo_die_list; node; node = node->next)
14364 prune_unmark_dies (node->die);
14367 /* Set the parameter to true if there are any relative pathnames in
14370 file_table_relative_p (void ** slot, void *param)
14373 struct dwarf_file_data *d = *slot;
14374 if (d->emitted_number && d->filename[0] != DIR_SEPARATOR)
14382 /* Output stuff that dwarf requires at the end of every file,
14383 and generate the DWARF-2 debugging info. */
14386 dwarf2out_finish (const char *filename)
14388 limbo_die_node *node, *next_node;
14389 dw_die_ref die = 0;
14391 /* Add the name for the main input file now. We delayed this from
14392 dwarf2out_init to avoid complications with PCH. */
14393 add_name_attribute (comp_unit_die, filename);
14394 if (filename[0] != DIR_SEPARATOR)
14395 add_comp_dir_attribute (comp_unit_die);
14396 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14399 htab_traverse (file_table, file_table_relative_p, &p);
14401 add_comp_dir_attribute (comp_unit_die);
14404 /* Traverse the limbo die list, and add parent/child links. The only
14405 dies without parents that should be here are concrete instances of
14406 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
14407 For concrete instances, we can get the parent die from the abstract
14409 for (node = limbo_die_list; node; node = next_node)
14411 next_node = node->next;
14414 if (die->die_parent == NULL)
14416 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14419 add_child_die (origin->die_parent, die);
14420 else if (die == comp_unit_die)
14422 else if (errorcount > 0 || sorrycount > 0)
14423 /* It's OK to be confused by errors in the input. */
14424 add_child_die (comp_unit_die, die);
14427 /* In certain situations, the lexical block containing a
14428 nested function can be optimized away, which results
14429 in the nested function die being orphaned. Likewise
14430 with the return type of that nested function. Force
14431 this to be a child of the containing function.
14433 It may happen that even the containing function got fully
14434 inlined and optimized out. In that case we are lost and
14435 assign the empty child. This should not be big issue as
14436 the function is likely unreachable too. */
14437 tree context = NULL_TREE;
14439 gcc_assert (node->created_for);
14441 if (DECL_P (node->created_for))
14442 context = DECL_CONTEXT (node->created_for);
14443 else if (TYPE_P (node->created_for))
14444 context = TYPE_CONTEXT (node->created_for);
14446 gcc_assert (context
14447 && (TREE_CODE (context) == FUNCTION_DECL
14448 || TREE_CODE (context) == NAMESPACE_DECL));
14450 origin = lookup_decl_die (context);
14452 add_child_die (origin, die);
14454 add_child_die (comp_unit_die, die);
14459 limbo_die_list = NULL;
14461 /* Walk through the list of incomplete types again, trying once more to
14462 emit full debugging info for them. */
14463 retry_incomplete_types ();
14465 if (flag_eliminate_unused_debug_types)
14466 prune_unused_types ();
14468 /* Generate separate CUs for each of the include files we've seen.
14469 They will go into limbo_die_list. */
14470 if (flag_eliminate_dwarf2_dups)
14471 break_out_includes (comp_unit_die);
14473 /* Traverse the DIE's and add add sibling attributes to those DIE's
14474 that have children. */
14475 add_sibling_attributes (comp_unit_die);
14476 for (node = limbo_die_list; node; node = node->next)
14477 add_sibling_attributes (node->die);
14479 /* Output a terminator label for the .text section. */
14480 switch_to_section (text_section);
14481 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14482 if (flag_reorder_blocks_and_partition)
14484 switch_to_section (unlikely_text_section ());
14485 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14488 /* We can only use the low/high_pc attributes if all of the code was
14490 if (!have_multiple_function_sections)
14492 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14493 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14496 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14497 "base address". Use zero so that these addresses become absolute. */
14498 else if (have_location_lists || ranges_table_in_use)
14499 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14501 /* Output location list section if necessary. */
14502 if (have_location_lists)
14504 /* Output the location lists info. */
14505 switch_to_section (debug_loc_section);
14506 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14507 DEBUG_LOC_SECTION_LABEL, 0);
14508 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14509 output_location_lists (die);
14512 if (debug_info_level >= DINFO_LEVEL_NORMAL)
14513 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
14514 debug_line_section_label);
14516 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14517 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14519 /* Output all of the compilation units. We put the main one last so that
14520 the offsets are available to output_pubnames. */
14521 for (node = limbo_die_list; node; node = node->next)
14522 output_comp_unit (node->die, 0);
14524 output_comp_unit (comp_unit_die, 0);
14526 /* Output the abbreviation table. */
14527 switch_to_section (debug_abbrev_section);
14528 output_abbrev_section ();
14530 /* Output public names table if necessary. */
14531 if (!VEC_empty (pubname_entry, pubname_table))
14533 switch_to_section (debug_pubnames_section);
14534 output_pubnames (pubname_table);
14537 #ifdef DEBUG_PUBTYPES_SECTION
14538 /* Output public types table if necessary. */
14539 if (!VEC_empty (pubname_entry, pubtype_table))
14541 switch_to_section (debug_pubtypes_section);
14542 output_pubnames (pubtype_table);
14546 /* Output the address range information. We only put functions in the arange
14547 table, so don't write it out if we don't have any. */
14548 if (fde_table_in_use)
14550 switch_to_section (debug_aranges_section);
14554 /* Output ranges section if necessary. */
14555 if (ranges_table_in_use)
14557 switch_to_section (debug_ranges_section);
14558 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14562 /* Output the source line correspondence table. We must do this
14563 even if there is no line information. Otherwise, on an empty
14564 translation unit, we will generate a present, but empty,
14565 .debug_info section. IRIX 6.5 `nm' will then complain when
14566 examining the file. This is done late so that any filenames
14567 used by the debug_info section are marked as 'used'. */
14568 if (! DWARF2_ASM_LINE_DEBUG_INFO)
14570 switch_to_section (debug_line_section);
14571 output_line_info ();
14574 /* Have to end the macro section. */
14575 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14577 switch_to_section (debug_macinfo_section);
14578 dw2_asm_output_data (1, 0, "End compilation unit");
14581 /* If we emitted any DW_FORM_strp form attribute, output the string
14583 if (debug_str_hash)
14584 htab_traverse (debug_str_hash, output_indirect_string, NULL);
14588 /* This should never be used, but its address is needed for comparisons. */
14589 const struct gcc_debug_hooks dwarf2_debug_hooks;
14591 #endif /* DWARF2_DEBUGGING_INFO */
14593 #include "gt-dwarf2out.h"