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_str_section;
160 static GTY(()) section *debug_ranges_section;
161 static GTY(()) section *debug_frame_section;
163 /* How to start an assembler comment. */
164 #ifndef ASM_COMMENT_START
165 #define ASM_COMMENT_START ";#"
168 typedef struct dw_cfi_struct *dw_cfi_ref;
169 typedef struct dw_fde_struct *dw_fde_ref;
170 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
172 /* Call frames are described using a sequence of Call Frame
173 Information instructions. The register number, offset
174 and address fields are provided as possible operands;
175 their use is selected by the opcode field. */
177 enum dw_cfi_oprnd_type {
179 dw_cfi_oprnd_reg_num,
185 typedef union dw_cfi_oprnd_struct GTY(())
187 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
188 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
189 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
190 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
194 typedef struct dw_cfi_struct GTY(())
196 dw_cfi_ref dw_cfi_next;
197 enum dwarf_call_frame_info dw_cfi_opc;
198 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
200 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
205 /* This is how we define the location of the CFA. We use to handle it
206 as REG + OFFSET all the time, but now it can be more complex.
207 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
208 Instead of passing around REG and OFFSET, we pass a copy
209 of this structure. */
210 typedef struct cfa_loc GTY(())
212 HOST_WIDE_INT offset;
213 HOST_WIDE_INT base_offset;
215 int indirect; /* 1 if CFA is accessed via a dereference. */
218 /* All call frame descriptions (FDE's) in the GCC generated DWARF
219 refer to a single Common Information Entry (CIE), defined at
220 the beginning of the .debug_frame section. This use of a single
221 CIE obviates the need to keep track of multiple CIE's
222 in the DWARF generation routines below. */
224 typedef struct dw_fde_struct GTY(())
227 const char *dw_fde_begin;
228 const char *dw_fde_current_label;
229 const char *dw_fde_end;
230 const char *dw_fde_hot_section_label;
231 const char *dw_fde_hot_section_end_label;
232 const char *dw_fde_unlikely_section_label;
233 const char *dw_fde_unlikely_section_end_label;
234 bool dw_fde_switched_sections;
235 dw_cfi_ref dw_fde_cfi;
236 unsigned funcdef_number;
237 unsigned all_throwers_are_sibcalls : 1;
238 unsigned nothrow : 1;
239 unsigned uses_eh_lsda : 1;
243 /* Maximum size (in bytes) of an artificially generated label. */
244 #define MAX_ARTIFICIAL_LABEL_BYTES 30
246 /* The size of addresses as they appear in the Dwarf 2 data.
247 Some architectures use word addresses to refer to code locations,
248 but Dwarf 2 info always uses byte addresses. On such machines,
249 Dwarf 2 addresses need to be larger than the architecture's
251 #ifndef DWARF2_ADDR_SIZE
252 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
255 /* The size in bytes of a DWARF field indicating an offset or length
256 relative to a debug info section, specified to be 4 bytes in the
257 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
260 #ifndef DWARF_OFFSET_SIZE
261 #define DWARF_OFFSET_SIZE 4
264 /* According to the (draft) DWARF 3 specification, the initial length
265 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
266 bytes are 0xffffffff, followed by the length stored in the next 8
269 However, the SGI/MIPS ABI uses an initial length which is equal to
270 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
272 #ifndef DWARF_INITIAL_LENGTH_SIZE
273 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
276 #define DWARF_VERSION 2
278 /* Round SIZE up to the nearest BOUNDARY. */
279 #define DWARF_ROUND(SIZE,BOUNDARY) \
280 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
282 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
283 #ifndef DWARF_CIE_DATA_ALIGNMENT
284 #ifdef STACK_GROWS_DOWNWARD
285 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
287 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
291 /* A pointer to the base of a table that contains frame description
292 information for each routine. */
293 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
295 /* Number of elements currently allocated for fde_table. */
296 static GTY(()) unsigned fde_table_allocated;
298 /* Number of elements in fde_table currently in use. */
299 static GTY(()) unsigned fde_table_in_use;
301 /* Size (in elements) of increments by which we may expand the
303 #define FDE_TABLE_INCREMENT 256
305 /* A list of call frame insns for the CIE. */
306 static GTY(()) dw_cfi_ref cie_cfi_head;
308 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
309 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
310 attribute that accelerates the lookup of the FDE associated
311 with the subprogram. This variable holds the table index of the FDE
312 associated with the current function (body) definition. */
313 static unsigned current_funcdef_fde;
316 struct indirect_string_node GTY(())
319 unsigned int refcount;
324 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
326 static GTY(()) int dw2_string_counter;
327 static GTY(()) unsigned long dwarf2out_cfi_label_num;
329 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
331 /* Forward declarations for functions defined in this file. */
333 static char *stripattributes (const char *);
334 static const char *dwarf_cfi_name (unsigned);
335 static dw_cfi_ref new_cfi (void);
336 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
337 static void add_fde_cfi (const char *, dw_cfi_ref);
338 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
339 static void lookup_cfa (dw_cfa_location *);
340 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
341 static void initial_return_save (rtx);
342 static HOST_WIDE_INT stack_adjust_offset (rtx);
343 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
344 static void output_call_frame_info (int);
345 static void dwarf2out_stack_adjust (rtx, bool);
346 static void flush_queued_reg_saves (void);
347 static bool clobbers_queued_reg_save (rtx);
348 static void dwarf2out_frame_debug_expr (rtx, const char *);
350 /* Support for complex CFA locations. */
351 static void output_cfa_loc (dw_cfi_ref);
352 static void get_cfa_from_loc_descr (dw_cfa_location *,
353 struct dw_loc_descr_struct *);
354 static struct dw_loc_descr_struct *build_cfa_loc
355 (dw_cfa_location *, HOST_WIDE_INT);
356 static void def_cfa_1 (const char *, dw_cfa_location *);
358 /* How to start an assembler comment. */
359 #ifndef ASM_COMMENT_START
360 #define ASM_COMMENT_START ";#"
363 /* Data and reference forms for relocatable data. */
364 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
365 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
367 #ifndef DEBUG_FRAME_SECTION
368 #define DEBUG_FRAME_SECTION ".debug_frame"
371 #ifndef FUNC_BEGIN_LABEL
372 #define FUNC_BEGIN_LABEL "LFB"
375 #ifndef FUNC_END_LABEL
376 #define FUNC_END_LABEL "LFE"
379 #ifndef FRAME_BEGIN_LABEL
380 #define FRAME_BEGIN_LABEL "Lframe"
382 #define CIE_AFTER_SIZE_LABEL "LSCIE"
383 #define CIE_END_LABEL "LECIE"
384 #define FDE_LABEL "LSFDE"
385 #define FDE_AFTER_SIZE_LABEL "LASFDE"
386 #define FDE_END_LABEL "LEFDE"
387 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
388 #define LINE_NUMBER_END_LABEL "LELT"
389 #define LN_PROLOG_AS_LABEL "LASLTP"
390 #define LN_PROLOG_END_LABEL "LELTP"
391 #define DIE_LABEL_PREFIX "DW"
393 /* The DWARF 2 CFA column which tracks the return address. Normally this
394 is the column for PC, or the first column after all of the hard
396 #ifndef DWARF_FRAME_RETURN_COLUMN
398 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
400 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
404 /* The mapping from gcc register number to DWARF 2 CFA column number. By
405 default, we just provide columns for all registers. */
406 #ifndef DWARF_FRAME_REGNUM
407 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
410 /* Hook used by __throw. */
413 expand_builtin_dwarf_sp_column (void)
415 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
416 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
419 /* Return a pointer to a copy of the section string name S with all
420 attributes stripped off, and an asterisk prepended (for assemble_name). */
423 stripattributes (const char *s)
425 char *stripped = XNEWVEC (char, strlen (s) + 2);
430 while (*s && *s != ',')
437 /* Generate code to initialize the register size table. */
440 expand_builtin_init_dwarf_reg_sizes (tree address)
443 enum machine_mode mode = TYPE_MODE (char_type_node);
444 rtx addr = expand_normal (address);
445 rtx mem = gen_rtx_MEM (BLKmode, addr);
446 bool wrote_return_column = false;
448 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
450 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
452 if (rnum < DWARF_FRAME_REGISTERS)
454 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
455 enum machine_mode save_mode = reg_raw_mode[i];
458 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
459 save_mode = choose_hard_reg_mode (i, 1, true);
460 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
462 if (save_mode == VOIDmode)
464 wrote_return_column = true;
466 size = GET_MODE_SIZE (save_mode);
470 emit_move_insn (adjust_address (mem, mode, offset),
471 gen_int_mode (size, mode));
475 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
476 gcc_assert (wrote_return_column);
477 i = DWARF_ALT_FRAME_RETURN_COLUMN;
478 wrote_return_column = false;
480 i = DWARF_FRAME_RETURN_COLUMN;
483 if (! wrote_return_column)
485 enum machine_mode save_mode = Pmode;
486 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
487 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
488 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
492 /* Convert a DWARF call frame info. operation to its string name */
495 dwarf_cfi_name (unsigned int cfi_opc)
499 case DW_CFA_advance_loc:
500 return "DW_CFA_advance_loc";
502 return "DW_CFA_offset";
504 return "DW_CFA_restore";
508 return "DW_CFA_set_loc";
509 case DW_CFA_advance_loc1:
510 return "DW_CFA_advance_loc1";
511 case DW_CFA_advance_loc2:
512 return "DW_CFA_advance_loc2";
513 case DW_CFA_advance_loc4:
514 return "DW_CFA_advance_loc4";
515 case DW_CFA_offset_extended:
516 return "DW_CFA_offset_extended";
517 case DW_CFA_restore_extended:
518 return "DW_CFA_restore_extended";
519 case DW_CFA_undefined:
520 return "DW_CFA_undefined";
521 case DW_CFA_same_value:
522 return "DW_CFA_same_value";
523 case DW_CFA_register:
524 return "DW_CFA_register";
525 case DW_CFA_remember_state:
526 return "DW_CFA_remember_state";
527 case DW_CFA_restore_state:
528 return "DW_CFA_restore_state";
530 return "DW_CFA_def_cfa";
531 case DW_CFA_def_cfa_register:
532 return "DW_CFA_def_cfa_register";
533 case DW_CFA_def_cfa_offset:
534 return "DW_CFA_def_cfa_offset";
537 case DW_CFA_def_cfa_expression:
538 return "DW_CFA_def_cfa_expression";
539 case DW_CFA_expression:
540 return "DW_CFA_expression";
541 case DW_CFA_offset_extended_sf:
542 return "DW_CFA_offset_extended_sf";
543 case DW_CFA_def_cfa_sf:
544 return "DW_CFA_def_cfa_sf";
545 case DW_CFA_def_cfa_offset_sf:
546 return "DW_CFA_def_cfa_offset_sf";
548 /* SGI/MIPS specific */
549 case DW_CFA_MIPS_advance_loc8:
550 return "DW_CFA_MIPS_advance_loc8";
553 case DW_CFA_GNU_window_save:
554 return "DW_CFA_GNU_window_save";
555 case DW_CFA_GNU_args_size:
556 return "DW_CFA_GNU_args_size";
557 case DW_CFA_GNU_negative_offset_extended:
558 return "DW_CFA_GNU_negative_offset_extended";
561 return "DW_CFA_<unknown>";
565 /* Return a pointer to a newly allocated Call Frame Instruction. */
567 static inline dw_cfi_ref
570 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
572 cfi->dw_cfi_next = NULL;
573 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
574 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
579 /* Add a Call Frame Instruction to list of instructions. */
582 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
586 /* Find the end of the chain. */
587 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
593 /* Generate a new label for the CFI info to refer to. */
596 dwarf2out_cfi_label (void)
598 static char label[20];
600 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
601 ASM_OUTPUT_LABEL (asm_out_file, label);
605 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
606 or to the CIE if LABEL is NULL. */
609 add_fde_cfi (const char *label, dw_cfi_ref cfi)
613 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
616 label = dwarf2out_cfi_label ();
618 if (fde->dw_fde_current_label == NULL
619 || strcmp (label, fde->dw_fde_current_label) != 0)
623 fde->dw_fde_current_label = label = xstrdup (label);
625 /* Set the location counter to the new label. */
627 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
628 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
629 add_cfi (&fde->dw_fde_cfi, xcfi);
632 add_cfi (&fde->dw_fde_cfi, cfi);
636 add_cfi (&cie_cfi_head, cfi);
639 /* Subroutine of lookup_cfa. */
642 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
644 switch (cfi->dw_cfi_opc)
646 case DW_CFA_def_cfa_offset:
647 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
649 case DW_CFA_def_cfa_offset_sf:
651 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
653 case DW_CFA_def_cfa_register:
654 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
657 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
658 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
660 case DW_CFA_def_cfa_sf:
661 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
663 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
665 case DW_CFA_def_cfa_expression:
666 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
673 /* Find the previous value for the CFA. */
676 lookup_cfa (dw_cfa_location *loc)
680 loc->reg = INVALID_REGNUM;
683 loc->base_offset = 0;
685 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
686 lookup_cfa_1 (cfi, loc);
688 if (fde_table_in_use)
690 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
691 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
692 lookup_cfa_1 (cfi, loc);
696 /* The current rule for calculating the DWARF2 canonical frame address. */
697 static dw_cfa_location cfa;
699 /* The register used for saving registers to the stack, and its offset
701 static dw_cfa_location cfa_store;
703 /* The running total of the size of arguments pushed onto the stack. */
704 static HOST_WIDE_INT args_size;
706 /* The last args_size we actually output. */
707 static HOST_WIDE_INT old_args_size;
709 /* Entry point to update the canonical frame address (CFA).
710 LABEL is passed to add_fde_cfi. The value of CFA is now to be
711 calculated from REG+OFFSET. */
714 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
721 def_cfa_1 (label, &loc);
724 /* Determine if two dw_cfa_location structures define the same data. */
727 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
729 return (loc1->reg == loc2->reg
730 && loc1->offset == loc2->offset
731 && loc1->indirect == loc2->indirect
732 && (loc1->indirect == 0
733 || loc1->base_offset == loc2->base_offset));
736 /* This routine does the actual work. The CFA is now calculated from
737 the dw_cfa_location structure. */
740 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
743 dw_cfa_location old_cfa, loc;
748 if (cfa_store.reg == loc.reg && loc.indirect == 0)
749 cfa_store.offset = loc.offset;
751 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
752 lookup_cfa (&old_cfa);
754 /* If nothing changed, no need to issue any call frame instructions. */
755 if (cfa_equal_p (&loc, &old_cfa))
760 if (loc.reg == old_cfa.reg && !loc.indirect)
762 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
763 the CFA register did not change but the offset did. */
766 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
767 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
769 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
770 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
774 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
775 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
779 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
780 else if (loc.offset == old_cfa.offset
781 && old_cfa.reg != INVALID_REGNUM
784 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
785 indicating the CFA register has changed to <register> but the
786 offset has not changed. */
787 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
788 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
792 else if (loc.indirect == 0)
794 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
795 indicating the CFA register has changed to <register> with
796 the specified offset. */
799 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
800 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
802 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
803 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
804 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
808 cfi->dw_cfi_opc = DW_CFA_def_cfa;
809 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
810 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
815 /* Construct a DW_CFA_def_cfa_expression instruction to
816 calculate the CFA using a full location expression since no
817 register-offset pair is available. */
818 struct dw_loc_descr_struct *loc_list;
820 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
821 loc_list = build_cfa_loc (&loc, 0);
822 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
825 add_fde_cfi (label, cfi);
828 /* Add the CFI for saving a register. REG is the CFA column number.
829 LABEL is passed to add_fde_cfi.
830 If SREG is -1, the register is saved at OFFSET from the CFA;
831 otherwise it is saved in SREG. */
834 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
836 dw_cfi_ref cfi = new_cfi ();
838 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
840 if (sreg == INVALID_REGNUM)
843 /* The register number won't fit in 6 bits, so we have to use
845 cfi->dw_cfi_opc = DW_CFA_offset_extended;
847 cfi->dw_cfi_opc = DW_CFA_offset;
849 #ifdef ENABLE_CHECKING
851 /* If we get an offset that is not a multiple of
852 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
853 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
855 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
857 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
860 offset /= DWARF_CIE_DATA_ALIGNMENT;
862 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
864 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
866 else if (sreg == reg)
867 cfi->dw_cfi_opc = DW_CFA_same_value;
870 cfi->dw_cfi_opc = DW_CFA_register;
871 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
874 add_fde_cfi (label, cfi);
877 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
878 This CFI tells the unwinder that it needs to restore the window registers
879 from the previous frame's window save area.
881 ??? Perhaps we should note in the CIE where windows are saved (instead of
882 assuming 0(cfa)) and what registers are in the window. */
885 dwarf2out_window_save (const char *label)
887 dw_cfi_ref cfi = new_cfi ();
889 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
890 add_fde_cfi (label, cfi);
893 /* Add a CFI to update the running total of the size of arguments
894 pushed onto the stack. */
897 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
901 if (size == old_args_size)
904 old_args_size = size;
907 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
908 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
909 add_fde_cfi (label, cfi);
912 /* Entry point for saving a register to the stack. REG is the GCC register
913 number. LABEL and OFFSET are passed to reg_save. */
916 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
918 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
921 /* Entry point for saving the return address in the stack.
922 LABEL and OFFSET are passed to reg_save. */
925 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
927 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
930 /* Entry point for saving the return address in a register.
931 LABEL and SREG are passed to reg_save. */
934 dwarf2out_return_reg (const char *label, unsigned int sreg)
936 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
939 /* Record the initial position of the return address. RTL is
940 INCOMING_RETURN_ADDR_RTX. */
943 initial_return_save (rtx rtl)
945 unsigned int reg = INVALID_REGNUM;
946 HOST_WIDE_INT offset = 0;
948 switch (GET_CODE (rtl))
951 /* RA is in a register. */
952 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
956 /* RA is on the stack. */
958 switch (GET_CODE (rtl))
961 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
966 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
967 offset = INTVAL (XEXP (rtl, 1));
971 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
972 offset = -INTVAL (XEXP (rtl, 1));
982 /* The return address is at some offset from any value we can
983 actually load. For instance, on the SPARC it is in %i7+8. Just
984 ignore the offset for now; it doesn't matter for unwinding frames. */
985 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
986 initial_return_save (XEXP (rtl, 0));
993 if (reg != DWARF_FRAME_RETURN_COLUMN)
994 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
997 /* Given a SET, calculate the amount of stack adjustment it
1000 static HOST_WIDE_INT
1001 stack_adjust_offset (rtx pattern)
1003 rtx src = SET_SRC (pattern);
1004 rtx dest = SET_DEST (pattern);
1005 HOST_WIDE_INT offset = 0;
1008 if (dest == stack_pointer_rtx)
1010 /* (set (reg sp) (plus (reg sp) (const_int))) */
1011 code = GET_CODE (src);
1012 if (! (code == PLUS || code == MINUS)
1013 || XEXP (src, 0) != stack_pointer_rtx
1014 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1017 offset = INTVAL (XEXP (src, 1));
1021 else if (MEM_P (dest))
1023 /* (set (mem (pre_dec (reg sp))) (foo)) */
1024 src = XEXP (dest, 0);
1025 code = GET_CODE (src);
1031 if (XEXP (src, 0) == stack_pointer_rtx)
1033 rtx val = XEXP (XEXP (src, 1), 1);
1034 /* We handle only adjustments by constant amount. */
1035 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1036 && GET_CODE (val) == CONST_INT);
1037 offset = -INTVAL (val);
1044 if (XEXP (src, 0) == stack_pointer_rtx)
1046 offset = GET_MODE_SIZE (GET_MODE (dest));
1053 if (XEXP (src, 0) == stack_pointer_rtx)
1055 offset = -GET_MODE_SIZE (GET_MODE (dest));
1070 /* Check INSN to see if it looks like a push or a stack adjustment, and
1071 make a note of it if it does. EH uses this information to find out how
1072 much extra space it needs to pop off the stack. */
1075 dwarf2out_stack_adjust (rtx insn, bool after_p ATTRIBUTE_UNUSED)
1077 HOST_WIDE_INT offset;
1081 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1082 with this function. Proper support would require all frame-related
1083 insns to be marked, and to be able to handle saving state around
1084 epilogues textually in the middle of the function. */
1085 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1088 if (BARRIER_P (insn))
1090 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1091 the compiler will have already emitted a stack adjustment, but
1092 doesn't bother for calls to noreturn functions. */
1093 #ifdef STACK_GROWS_DOWNWARD
1094 offset = -args_size;
1099 else if (GET_CODE (PATTERN (insn)) == SET)
1100 offset = stack_adjust_offset (PATTERN (insn));
1101 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1102 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1104 /* There may be stack adjustments inside compound insns. Search
1106 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1107 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1108 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1110 else if (GET_CODE (insn) == CALL_INSN)
1115 /* We handle this separately because we want stack adjustments in a
1116 CALL_INSN to be handled. */;
1117 if (GET_CODE (insn) == CALL_INSN)
1119 /* If only calls can throw, adjust args_size only at call sites. */
1120 if (!flag_asynchronous_unwind_tables)
1121 dwarf2out_args_size ("", args_size);
1127 if (cfa.reg == STACK_POINTER_REGNUM)
1128 cfa.offset += offset;
1130 #ifndef STACK_GROWS_DOWNWARD
1134 args_size += offset;
1138 /* If only calls can throw and we have a frame pointer, we'll save
1139 up adjustments until we see the CALL_INSN. We used to return
1140 early and derive args_size from NARGS in the CALL_INSN itself,
1141 but that doesn't compute the right value if we have nested call
1142 expansions, e.g., stack adjustments for a call have already been
1143 emitted, and then we issue another call to compute an argument
1144 for the enclosing call (i.e., bar (foo ())). */
1145 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1148 label = dwarf2out_cfi_label ();
1149 def_cfa_1 (label, &cfa);
1150 if (flag_asynchronous_unwind_tables)
1151 dwarf2out_args_size (label, args_size);
1156 /* We delay emitting a register save until either (a) we reach the end
1157 of the prologue or (b) the register is clobbered. This clusters
1158 register saves so that there are fewer pc advances. */
1160 struct queued_reg_save GTY(())
1162 struct queued_reg_save *next;
1164 HOST_WIDE_INT cfa_offset;
1168 static GTY(()) struct queued_reg_save *queued_reg_saves;
1170 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1171 struct reg_saved_in_data GTY(()) {
1176 /* A list of registers saved in other registers.
1177 The list intentionally has a small maximum capacity of 4; if your
1178 port needs more than that, you might consider implementing a
1179 more efficient data structure. */
1180 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1181 static GTY(()) size_t num_regs_saved_in_regs;
1183 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1184 static const char *last_reg_save_label;
1186 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1187 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1190 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1192 struct queued_reg_save *q;
1194 /* Duplicates waste space, but it's also necessary to remove them
1195 for correctness, since the queue gets output in reverse
1197 for (q = queued_reg_saves; q != NULL; q = q->next)
1198 if (REGNO (q->reg) == REGNO (reg))
1203 q = ggc_alloc (sizeof (*q));
1204 q->next = queued_reg_saves;
1205 queued_reg_saves = q;
1209 q->cfa_offset = offset;
1210 q->saved_reg = sreg;
1212 last_reg_save_label = label;
1215 /* Output all the entries in QUEUED_REG_SAVES. */
1218 flush_queued_reg_saves (void)
1220 struct queued_reg_save *q;
1222 for (q = queued_reg_saves; q; q = q->next)
1225 unsigned int reg, sreg;
1227 for (i = 0; i < num_regs_saved_in_regs; i++)
1228 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1230 if (q->saved_reg && i == num_regs_saved_in_regs)
1232 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1233 num_regs_saved_in_regs++;
1235 if (i != num_regs_saved_in_regs)
1237 regs_saved_in_regs[i].orig_reg = q->reg;
1238 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1241 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1243 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1245 sreg = INVALID_REGNUM;
1246 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1249 queued_reg_saves = NULL;
1250 last_reg_save_label = NULL;
1253 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1254 location for? Or, does it clobber a register which we've previously
1255 said that some other register is saved in, and for which we now
1256 have a new location for? */
1259 clobbers_queued_reg_save (rtx insn)
1261 struct queued_reg_save *q;
1263 for (q = queued_reg_saves; q; q = q->next)
1266 if (modified_in_p (q->reg, insn))
1268 for (i = 0; i < num_regs_saved_in_regs; i++)
1269 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1270 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1277 /* Entry point for saving the first register into the second. */
1280 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1283 unsigned int regno, sregno;
1285 for (i = 0; i < num_regs_saved_in_regs; i++)
1286 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1288 if (i == num_regs_saved_in_regs)
1290 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1291 num_regs_saved_in_regs++;
1293 regs_saved_in_regs[i].orig_reg = reg;
1294 regs_saved_in_regs[i].saved_in_reg = sreg;
1296 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1297 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1298 reg_save (label, regno, sregno, 0);
1301 /* What register, if any, is currently saved in REG? */
1304 reg_saved_in (rtx reg)
1306 unsigned int regn = REGNO (reg);
1308 struct queued_reg_save *q;
1310 for (q = queued_reg_saves; q; q = q->next)
1311 if (q->saved_reg && regn == REGNO (q->saved_reg))
1314 for (i = 0; i < num_regs_saved_in_regs; i++)
1315 if (regs_saved_in_regs[i].saved_in_reg
1316 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1317 return regs_saved_in_regs[i].orig_reg;
1323 /* A temporary register holding an integral value used in adjusting SP
1324 or setting up the store_reg. The "offset" field holds the integer
1325 value, not an offset. */
1326 static dw_cfa_location cfa_temp;
1328 /* Record call frame debugging information for an expression EXPR,
1329 which either sets SP or FP (adjusting how we calculate the frame
1330 address) or saves a register to the stack or another register.
1331 LABEL indicates the address of EXPR.
1333 This function encodes a state machine mapping rtxes to actions on
1334 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1335 users need not read the source code.
1337 The High-Level Picture
1339 Changes in the register we use to calculate the CFA: Currently we
1340 assume that if you copy the CFA register into another register, we
1341 should take the other one as the new CFA register; this seems to
1342 work pretty well. If it's wrong for some target, it's simple
1343 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1345 Changes in the register we use for saving registers to the stack:
1346 This is usually SP, but not always. Again, we deduce that if you
1347 copy SP into another register (and SP is not the CFA register),
1348 then the new register is the one we will be using for register
1349 saves. This also seems to work.
1351 Register saves: There's not much guesswork about this one; if
1352 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1353 register save, and the register used to calculate the destination
1354 had better be the one we think we're using for this purpose.
1355 It's also assumed that a copy from a call-saved register to another
1356 register is saving that register if RTX_FRAME_RELATED_P is set on
1357 that instruction. If the copy is from a call-saved register to
1358 the *same* register, that means that the register is now the same
1359 value as in the caller.
1361 Except: If the register being saved is the CFA register, and the
1362 offset is nonzero, we are saving the CFA, so we assume we have to
1363 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1364 the intent is to save the value of SP from the previous frame.
1366 In addition, if a register has previously been saved to a different
1369 Invariants / Summaries of Rules
1371 cfa current rule for calculating the CFA. It usually
1372 consists of a register and an offset.
1373 cfa_store register used by prologue code to save things to the stack
1374 cfa_store.offset is the offset from the value of
1375 cfa_store.reg to the actual CFA
1376 cfa_temp register holding an integral value. cfa_temp.offset
1377 stores the value, which will be used to adjust the
1378 stack pointer. cfa_temp is also used like cfa_store,
1379 to track stores to the stack via fp or a temp reg.
1381 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1382 with cfa.reg as the first operand changes the cfa.reg and its
1383 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1386 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1387 expression yielding a constant. This sets cfa_temp.reg
1388 and cfa_temp.offset.
1390 Rule 5: Create a new register cfa_store used to save items to the
1393 Rules 10-14: Save a register to the stack. Define offset as the
1394 difference of the original location and cfa_store's
1395 location (or cfa_temp's location if cfa_temp is used).
1399 "{a,b}" indicates a choice of a xor b.
1400 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1403 (set <reg1> <reg2>:cfa.reg)
1404 effects: cfa.reg = <reg1>
1405 cfa.offset unchanged
1406 cfa_temp.reg = <reg1>
1407 cfa_temp.offset = cfa.offset
1410 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1411 {<const_int>,<reg>:cfa_temp.reg}))
1412 effects: cfa.reg = sp if fp used
1413 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1414 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1415 if cfa_store.reg==sp
1418 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1419 effects: cfa.reg = fp
1420 cfa_offset += +/- <const_int>
1423 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1424 constraints: <reg1> != fp
1426 effects: cfa.reg = <reg1>
1427 cfa_temp.reg = <reg1>
1428 cfa_temp.offset = cfa.offset
1431 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1432 constraints: <reg1> != fp
1434 effects: cfa_store.reg = <reg1>
1435 cfa_store.offset = cfa.offset - cfa_temp.offset
1438 (set <reg> <const_int>)
1439 effects: cfa_temp.reg = <reg>
1440 cfa_temp.offset = <const_int>
1443 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1444 effects: cfa_temp.reg = <reg1>
1445 cfa_temp.offset |= <const_int>
1448 (set <reg> (high <exp>))
1452 (set <reg> (lo_sum <exp> <const_int>))
1453 effects: cfa_temp.reg = <reg>
1454 cfa_temp.offset = <const_int>
1457 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1458 effects: cfa_store.offset -= <const_int>
1459 cfa.offset = cfa_store.offset if cfa.reg == sp
1461 cfa.base_offset = -cfa_store.offset
1464 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1465 effects: cfa_store.offset += -/+ mode_size(mem)
1466 cfa.offset = cfa_store.offset if cfa.reg == sp
1468 cfa.base_offset = -cfa_store.offset
1471 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1474 effects: cfa.reg = <reg1>
1475 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1478 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1479 effects: cfa.reg = <reg1>
1480 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1483 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1484 effects: cfa.reg = <reg1>
1485 cfa.base_offset = -cfa_temp.offset
1486 cfa_temp.offset -= mode_size(mem)
1489 Â (set <reg> {unspec, unspec_volatile})
1490 Â effects: target-dependent */
1493 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1496 HOST_WIDE_INT offset;
1498 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1499 the PARALLEL independently. The first element is always processed if
1500 it is a SET. This is for backward compatibility. Other elements
1501 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1502 flag is set in them. */
1503 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1506 int limit = XVECLEN (expr, 0);
1508 for (par_index = 0; par_index < limit; par_index++)
1509 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1510 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1512 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1517 gcc_assert (GET_CODE (expr) == SET);
1519 src = SET_SRC (expr);
1520 dest = SET_DEST (expr);
1524 rtx rsi = reg_saved_in (src);
1529 switch (GET_CODE (dest))
1532 switch (GET_CODE (src))
1534 /* Setting FP from SP. */
1536 if (cfa.reg == (unsigned) REGNO (src))
1539 /* Update the CFA rule wrt SP or FP. Make sure src is
1540 relative to the current CFA register.
1542 We used to require that dest be either SP or FP, but the
1543 ARM copies SP to a temporary register, and from there to
1544 FP. So we just rely on the backends to only set
1545 RTX_FRAME_RELATED_P on appropriate insns. */
1546 cfa.reg = REGNO (dest);
1547 cfa_temp.reg = cfa.reg;
1548 cfa_temp.offset = cfa.offset;
1552 /* Saving a register in a register. */
1553 gcc_assert (!fixed_regs [REGNO (dest)]
1554 /* For the SPARC and its register window. */
1555 || (DWARF_FRAME_REGNUM (REGNO (src))
1556 == DWARF_FRAME_RETURN_COLUMN));
1557 queue_reg_save (label, src, dest, 0);
1564 if (dest == stack_pointer_rtx)
1568 switch (GET_CODE (XEXP (src, 1)))
1571 offset = INTVAL (XEXP (src, 1));
1574 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1576 offset = cfa_temp.offset;
1582 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1584 /* Restoring SP from FP in the epilogue. */
1585 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1586 cfa.reg = STACK_POINTER_REGNUM;
1588 else if (GET_CODE (src) == LO_SUM)
1589 /* Assume we've set the source reg of the LO_SUM from sp. */
1592 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1594 if (GET_CODE (src) != MINUS)
1596 if (cfa.reg == STACK_POINTER_REGNUM)
1597 cfa.offset += offset;
1598 if (cfa_store.reg == STACK_POINTER_REGNUM)
1599 cfa_store.offset += offset;
1601 else if (dest == hard_frame_pointer_rtx)
1604 /* Either setting the FP from an offset of the SP,
1605 or adjusting the FP */
1606 gcc_assert (frame_pointer_needed);
1608 gcc_assert (REG_P (XEXP (src, 0))
1609 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1610 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1611 offset = INTVAL (XEXP (src, 1));
1612 if (GET_CODE (src) != MINUS)
1614 cfa.offset += offset;
1615 cfa.reg = HARD_FRAME_POINTER_REGNUM;
1619 gcc_assert (GET_CODE (src) != MINUS);
1622 if (REG_P (XEXP (src, 0))
1623 && REGNO (XEXP (src, 0)) == cfa.reg
1624 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1626 /* Setting a temporary CFA register that will be copied
1627 into the FP later on. */
1628 offset = - INTVAL (XEXP (src, 1));
1629 cfa.offset += offset;
1630 cfa.reg = REGNO (dest);
1631 /* Or used to save regs to the stack. */
1632 cfa_temp.reg = cfa.reg;
1633 cfa_temp.offset = cfa.offset;
1637 else if (REG_P (XEXP (src, 0))
1638 && REGNO (XEXP (src, 0)) == cfa_temp.reg
1639 && XEXP (src, 1) == stack_pointer_rtx)
1641 /* Setting a scratch register that we will use instead
1642 of SP for saving registers to the stack. */
1643 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1644 cfa_store.reg = REGNO (dest);
1645 cfa_store.offset = cfa.offset - cfa_temp.offset;
1649 else if (GET_CODE (src) == LO_SUM
1650 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1652 cfa_temp.reg = REGNO (dest);
1653 cfa_temp.offset = INTVAL (XEXP (src, 1));
1662 cfa_temp.reg = REGNO (dest);
1663 cfa_temp.offset = INTVAL (src);
1668 gcc_assert (REG_P (XEXP (src, 0))
1669 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1670 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1672 if ((unsigned) REGNO (dest) != cfa_temp.reg)
1673 cfa_temp.reg = REGNO (dest);
1674 cfa_temp.offset |= INTVAL (XEXP (src, 1));
1677 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1678 which will fill in all of the bits. */
1685 case UNSPEC_VOLATILE:
1686 gcc_assert (targetm.dwarf_handle_frame_unspec);
1687 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1694 def_cfa_1 (label, &cfa);
1698 gcc_assert (REG_P (src));
1700 /* Saving a register to the stack. Make sure dest is relative to the
1702 switch (GET_CODE (XEXP (dest, 0)))
1707 /* We can't handle variable size modifications. */
1708 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1710 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1712 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1713 && cfa_store.reg == STACK_POINTER_REGNUM);
1715 cfa_store.offset += offset;
1716 if (cfa.reg == STACK_POINTER_REGNUM)
1717 cfa.offset = cfa_store.offset;
1719 offset = -cfa_store.offset;
1725 offset = GET_MODE_SIZE (GET_MODE (dest));
1726 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1729 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1730 && cfa_store.reg == STACK_POINTER_REGNUM);
1732 cfa_store.offset += offset;
1733 if (cfa.reg == STACK_POINTER_REGNUM)
1734 cfa.offset = cfa_store.offset;
1736 offset = -cfa_store.offset;
1740 /* With an offset. */
1747 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
1748 && REG_P (XEXP (XEXP (dest, 0), 0)));
1749 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1750 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1753 regno = REGNO (XEXP (XEXP (dest, 0), 0));
1755 if (cfa_store.reg == (unsigned) regno)
1756 offset -= cfa_store.offset;
1759 gcc_assert (cfa_temp.reg == (unsigned) regno);
1760 offset -= cfa_temp.offset;
1766 /* Without an offset. */
1769 int regno = REGNO (XEXP (dest, 0));
1771 if (cfa_store.reg == (unsigned) regno)
1772 offset = -cfa_store.offset;
1775 gcc_assert (cfa_temp.reg == (unsigned) regno);
1776 offset = -cfa_temp.offset;
1783 gcc_assert (cfa_temp.reg
1784 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1785 offset = -cfa_temp.offset;
1786 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1793 if (REGNO (src) != STACK_POINTER_REGNUM
1794 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1795 && (unsigned) REGNO (src) == cfa.reg)
1797 /* We're storing the current CFA reg into the stack. */
1799 if (cfa.offset == 0)
1801 /* If the source register is exactly the CFA, assume
1802 we're saving SP like any other register; this happens
1804 def_cfa_1 (label, &cfa);
1805 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1810 /* Otherwise, we'll need to look in the stack to
1811 calculate the CFA. */
1812 rtx x = XEXP (dest, 0);
1816 gcc_assert (REG_P (x));
1818 cfa.reg = REGNO (x);
1819 cfa.base_offset = offset;
1821 def_cfa_1 (label, &cfa);
1826 def_cfa_1 (label, &cfa);
1827 queue_reg_save (label, src, NULL_RTX, offset);
1835 /* Record call frame debugging information for INSN, which either
1836 sets SP or FP (adjusting how we calculate the frame address) or saves a
1837 register to the stack. If INSN is NULL_RTX, initialize our state.
1839 If AFTER_P is false, we're being called before the insn is emitted,
1840 otherwise after. Call instructions get invoked twice. */
1843 dwarf2out_frame_debug (rtx insn, bool after_p)
1848 if (insn == NULL_RTX)
1852 /* Flush any queued register saves. */
1853 flush_queued_reg_saves ();
1855 /* Set up state for generating call frame debug info. */
1858 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1860 cfa.reg = STACK_POINTER_REGNUM;
1863 cfa_temp.offset = 0;
1865 for (i = 0; i < num_regs_saved_in_regs; i++)
1867 regs_saved_in_regs[i].orig_reg = NULL_RTX;
1868 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1870 num_regs_saved_in_regs = 0;
1874 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1875 flush_queued_reg_saves ();
1877 if (! RTX_FRAME_RELATED_P (insn))
1879 if (!ACCUMULATE_OUTGOING_ARGS)
1880 dwarf2out_stack_adjust (insn, after_p);
1884 label = dwarf2out_cfi_label ();
1885 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1887 insn = XEXP (src, 0);
1889 insn = PATTERN (insn);
1891 dwarf2out_frame_debug_expr (insn, label);
1896 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
1897 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1898 (enum dwarf_call_frame_info cfi);
1900 static enum dw_cfi_oprnd_type
1901 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1906 case DW_CFA_GNU_window_save:
1907 return dw_cfi_oprnd_unused;
1909 case DW_CFA_set_loc:
1910 case DW_CFA_advance_loc1:
1911 case DW_CFA_advance_loc2:
1912 case DW_CFA_advance_loc4:
1913 case DW_CFA_MIPS_advance_loc8:
1914 return dw_cfi_oprnd_addr;
1917 case DW_CFA_offset_extended:
1918 case DW_CFA_def_cfa:
1919 case DW_CFA_offset_extended_sf:
1920 case DW_CFA_def_cfa_sf:
1921 case DW_CFA_restore_extended:
1922 case DW_CFA_undefined:
1923 case DW_CFA_same_value:
1924 case DW_CFA_def_cfa_register:
1925 case DW_CFA_register:
1926 return dw_cfi_oprnd_reg_num;
1928 case DW_CFA_def_cfa_offset:
1929 case DW_CFA_GNU_args_size:
1930 case DW_CFA_def_cfa_offset_sf:
1931 return dw_cfi_oprnd_offset;
1933 case DW_CFA_def_cfa_expression:
1934 case DW_CFA_expression:
1935 return dw_cfi_oprnd_loc;
1942 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
1943 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1944 (enum dwarf_call_frame_info cfi);
1946 static enum dw_cfi_oprnd_type
1947 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1951 case DW_CFA_def_cfa:
1952 case DW_CFA_def_cfa_sf:
1954 case DW_CFA_offset_extended_sf:
1955 case DW_CFA_offset_extended:
1956 return dw_cfi_oprnd_offset;
1958 case DW_CFA_register:
1959 return dw_cfi_oprnd_reg_num;
1962 return dw_cfi_oprnd_unused;
1966 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1968 /* Switch to eh_frame_section. If we don't have an eh_frame_section,
1969 switch to the data section instead, and write out a synthetic label
1973 switch_to_eh_frame_section (void)
1977 #ifdef EH_FRAME_SECTION_NAME
1978 if (eh_frame_section == 0)
1982 if (EH_TABLES_CAN_BE_READ_ONLY)
1988 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
1990 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
1992 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
1994 flags = ((! flag_pic
1995 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
1996 && (fde_encoding & 0x70) != DW_EH_PE_aligned
1997 && (per_encoding & 0x70) != DW_EH_PE_absptr
1998 && (per_encoding & 0x70) != DW_EH_PE_aligned
1999 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2000 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2001 ? 0 : SECTION_WRITE);
2004 flags = SECTION_WRITE;
2005 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2009 if (eh_frame_section)
2010 switch_to_section (eh_frame_section);
2013 /* We have no special eh_frame section. Put the information in
2014 the data section and emit special labels to guide collect2. */
2015 switch_to_section (data_section);
2016 label = get_file_function_name ('F');
2017 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2018 targetm.asm_out.globalize_label (asm_out_file,
2019 IDENTIFIER_POINTER (label));
2020 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2024 /* Output a Call Frame Information opcode and its operand(s). */
2027 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2030 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2031 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2032 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2033 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2034 cfi->dw_cfi_oprnd1.dw_cfi_offset);
2035 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2037 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2038 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2039 "DW_CFA_offset, column 0x%lx", r);
2040 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2042 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2044 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2045 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2046 "DW_CFA_restore, column 0x%lx", r);
2050 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2051 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2053 switch (cfi->dw_cfi_opc)
2055 case DW_CFA_set_loc:
2057 dw2_asm_output_encoded_addr_rtx (
2058 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2059 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2062 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2063 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2066 case DW_CFA_advance_loc1:
2067 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2068 fde->dw_fde_current_label, NULL);
2069 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2072 case DW_CFA_advance_loc2:
2073 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2074 fde->dw_fde_current_label, NULL);
2075 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2078 case DW_CFA_advance_loc4:
2079 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2080 fde->dw_fde_current_label, NULL);
2081 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2084 case DW_CFA_MIPS_advance_loc8:
2085 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2086 fde->dw_fde_current_label, NULL);
2087 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2090 case DW_CFA_offset_extended:
2091 case DW_CFA_def_cfa:
2092 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2093 dw2_asm_output_data_uleb128 (r, NULL);
2094 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2097 case DW_CFA_offset_extended_sf:
2098 case DW_CFA_def_cfa_sf:
2099 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2100 dw2_asm_output_data_uleb128 (r, NULL);
2101 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2104 case DW_CFA_restore_extended:
2105 case DW_CFA_undefined:
2106 case DW_CFA_same_value:
2107 case DW_CFA_def_cfa_register:
2108 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2109 dw2_asm_output_data_uleb128 (r, NULL);
2112 case DW_CFA_register:
2113 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2114 dw2_asm_output_data_uleb128 (r, NULL);
2115 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2116 dw2_asm_output_data_uleb128 (r, NULL);
2119 case DW_CFA_def_cfa_offset:
2120 case DW_CFA_GNU_args_size:
2121 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2124 case DW_CFA_def_cfa_offset_sf:
2125 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2128 case DW_CFA_GNU_window_save:
2131 case DW_CFA_def_cfa_expression:
2132 case DW_CFA_expression:
2133 output_cfa_loc (cfi);
2136 case DW_CFA_GNU_negative_offset_extended:
2137 /* Obsoleted by DW_CFA_offset_extended_sf. */
2146 /* Output the call frame information used to record information
2147 that relates to calculating the frame pointer, and records the
2148 location of saved registers. */
2151 output_call_frame_info (int for_eh)
2156 char l1[20], l2[20], section_start_label[20];
2157 bool any_lsda_needed = false;
2158 char augmentation[6];
2159 int augmentation_size;
2160 int fde_encoding = DW_EH_PE_absptr;
2161 int per_encoding = DW_EH_PE_absptr;
2162 int lsda_encoding = DW_EH_PE_absptr;
2165 /* Don't emit a CIE if there won't be any FDEs. */
2166 if (fde_table_in_use == 0)
2169 /* If we make FDEs linkonce, we may have to emit an empty label for
2170 an FDE that wouldn't otherwise be emitted. We want to avoid
2171 having an FDE kept around when the function it refers to is
2172 discarded. Example where this matters: a primary function
2173 template in C++ requires EH information, but an explicit
2174 specialization doesn't. */
2175 if (TARGET_USES_WEAK_UNWIND_INFO
2176 && ! flag_asynchronous_unwind_tables
2178 for (i = 0; i < fde_table_in_use; i++)
2179 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2180 && !fde_table[i].uses_eh_lsda
2181 && ! DECL_WEAK (fde_table[i].decl))
2182 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2183 for_eh, /* empty */ 1);
2185 /* If we don't have any functions we'll want to unwind out of, don't
2186 emit any EH unwind information. Note that if exceptions aren't
2187 enabled, we won't have collected nothrow information, and if we
2188 asked for asynchronous tables, we always want this info. */
2191 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2193 for (i = 0; i < fde_table_in_use; i++)
2194 if (fde_table[i].uses_eh_lsda)
2195 any_eh_needed = any_lsda_needed = true;
2196 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2197 any_eh_needed = true;
2198 else if (! fde_table[i].nothrow
2199 && ! fde_table[i].all_throwers_are_sibcalls)
2200 any_eh_needed = true;
2202 if (! any_eh_needed)
2206 /* We're going to be generating comments, so turn on app. */
2211 switch_to_eh_frame_section ();
2213 switch_to_section (debug_frame_section);
2215 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2216 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2218 /* Output the CIE. */
2219 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2220 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2221 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2222 "Length of Common Information Entry");
2223 ASM_OUTPUT_LABEL (asm_out_file, l1);
2225 /* Now that the CIE pointer is PC-relative for EH,
2226 use 0 to identify the CIE. */
2227 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2228 (for_eh ? 0 : DW_CIE_ID),
2229 "CIE Identifier Tag");
2231 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2233 augmentation[0] = 0;
2234 augmentation_size = 0;
2240 z Indicates that a uleb128 is present to size the
2241 augmentation section.
2242 L Indicates the encoding (and thus presence) of
2243 an LSDA pointer in the FDE augmentation.
2244 R Indicates a non-default pointer encoding for
2246 P Indicates the presence of an encoding + language
2247 personality routine in the CIE augmentation. */
2249 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2250 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2251 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2253 p = augmentation + 1;
2254 if (eh_personality_libfunc)
2257 augmentation_size += 1 + size_of_encoded_value (per_encoding);
2259 if (any_lsda_needed)
2262 augmentation_size += 1;
2264 if (fde_encoding != DW_EH_PE_absptr)
2267 augmentation_size += 1;
2269 if (p > augmentation + 1)
2271 augmentation[0] = 'z';
2275 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2276 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2278 int offset = ( 4 /* Length */
2280 + 1 /* CIE version */
2281 + strlen (augmentation) + 1 /* Augmentation */
2282 + size_of_uleb128 (1) /* Code alignment */
2283 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2285 + 1 /* Augmentation size */
2286 + 1 /* Personality encoding */ );
2287 int pad = -offset & (PTR_SIZE - 1);
2289 augmentation_size += pad;
2291 /* Augmentations should be small, so there's scarce need to
2292 iterate for a solution. Die if we exceed one uleb128 byte. */
2293 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2297 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2298 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2299 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2300 "CIE Data Alignment Factor");
2302 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2303 if (DW_CIE_VERSION == 1)
2304 dw2_asm_output_data (1, return_reg, "CIE RA Column");
2306 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2308 if (augmentation[0])
2310 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2311 if (eh_personality_libfunc)
2313 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2314 eh_data_format_name (per_encoding));
2315 dw2_asm_output_encoded_addr_rtx (per_encoding,
2316 eh_personality_libfunc,
2320 if (any_lsda_needed)
2321 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2322 eh_data_format_name (lsda_encoding));
2324 if (fde_encoding != DW_EH_PE_absptr)
2325 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2326 eh_data_format_name (fde_encoding));
2329 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2330 output_cfi (cfi, NULL, for_eh);
2332 /* Pad the CIE out to an address sized boundary. */
2333 ASM_OUTPUT_ALIGN (asm_out_file,
2334 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2335 ASM_OUTPUT_LABEL (asm_out_file, l2);
2337 /* Loop through all of the FDE's. */
2338 for (i = 0; i < fde_table_in_use; i++)
2340 fde = &fde_table[i];
2342 /* Don't emit EH unwind info for leaf functions that don't need it. */
2343 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2344 && (fde->nothrow || fde->all_throwers_are_sibcalls)
2345 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2346 && !fde->uses_eh_lsda)
2349 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2350 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2351 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2352 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2353 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2355 ASM_OUTPUT_LABEL (asm_out_file, l1);
2358 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2360 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2361 debug_frame_section, "FDE CIE offset");
2365 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2366 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2367 dw2_asm_output_encoded_addr_rtx (fde_encoding,
2370 "FDE initial location");
2371 if (fde->dw_fde_switched_sections)
2373 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2374 fde->dw_fde_unlikely_section_label);
2375 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2376 fde->dw_fde_hot_section_label);
2377 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2378 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2379 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
2380 "FDE initial location");
2381 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2382 fde->dw_fde_hot_section_end_label,
2383 fde->dw_fde_hot_section_label,
2384 "FDE address range");
2385 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
2386 "FDE initial location");
2387 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2388 fde->dw_fde_unlikely_section_end_label,
2389 fde->dw_fde_unlikely_section_label,
2390 "FDE address range");
2393 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2394 fde->dw_fde_end, fde->dw_fde_begin,
2395 "FDE address range");
2399 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2400 "FDE initial location");
2401 if (fde->dw_fde_switched_sections)
2403 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2404 fde->dw_fde_hot_section_label,
2405 "FDE initial location");
2406 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2407 fde->dw_fde_hot_section_end_label,
2408 fde->dw_fde_hot_section_label,
2409 "FDE address range");
2410 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2411 fde->dw_fde_unlikely_section_label,
2412 "FDE initial location");
2413 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2414 fde->dw_fde_unlikely_section_end_label,
2415 fde->dw_fde_unlikely_section_label,
2416 "FDE address range");
2419 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2420 fde->dw_fde_end, fde->dw_fde_begin,
2421 "FDE address range");
2424 if (augmentation[0])
2426 if (any_lsda_needed)
2428 int size = size_of_encoded_value (lsda_encoding);
2430 if (lsda_encoding == DW_EH_PE_aligned)
2432 int offset = ( 4 /* Length */
2433 + 4 /* CIE offset */
2434 + 2 * size_of_encoded_value (fde_encoding)
2435 + 1 /* Augmentation size */ );
2436 int pad = -offset & (PTR_SIZE - 1);
2439 gcc_assert (size_of_uleb128 (size) == 1);
2442 dw2_asm_output_data_uleb128 (size, "Augmentation size");
2444 if (fde->uses_eh_lsda)
2446 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2447 fde->funcdef_number);
2448 dw2_asm_output_encoded_addr_rtx (
2449 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2450 false, "Language Specific Data Area");
2454 if (lsda_encoding == DW_EH_PE_aligned)
2455 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2457 (size_of_encoded_value (lsda_encoding), 0,
2458 "Language Specific Data Area (none)");
2462 dw2_asm_output_data_uleb128 (0, "Augmentation size");
2465 /* Loop through the Call Frame Instructions associated with
2467 fde->dw_fde_current_label = fde->dw_fde_begin;
2468 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2469 output_cfi (cfi, fde, for_eh);
2471 /* Pad the FDE out to an address sized boundary. */
2472 ASM_OUTPUT_ALIGN (asm_out_file,
2473 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2474 ASM_OUTPUT_LABEL (asm_out_file, l2);
2477 if (for_eh && targetm.terminate_dw2_eh_frame_info)
2478 dw2_asm_output_data (4, 0, "End of Table");
2479 #ifdef MIPS_DEBUGGING_INFO
2480 /* Work around Irix 6 assembler bug whereby labels at the end of a section
2481 get a value of 0. Putting .align 0 after the label fixes it. */
2482 ASM_OUTPUT_ALIGN (asm_out_file, 0);
2485 /* Turn off app to make assembly quicker. */
2490 /* Output a marker (i.e. a label) for the beginning of a function, before
2494 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2495 const char *file ATTRIBUTE_UNUSED)
2497 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2501 current_function_func_begin_label = NULL;
2503 #ifdef TARGET_UNWIND_INFO
2504 /* ??? current_function_func_begin_label is also used by except.c
2505 for call-site information. We must emit this label if it might
2507 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2508 && ! dwarf2out_do_frame ())
2511 if (! dwarf2out_do_frame ())
2515 switch_to_section (function_section (current_function_decl));
2516 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2517 current_function_funcdef_no);
2518 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2519 current_function_funcdef_no);
2520 dup_label = xstrdup (label);
2521 current_function_func_begin_label = dup_label;
2523 #ifdef TARGET_UNWIND_INFO
2524 /* We can elide the fde allocation if we're not emitting debug info. */
2525 if (! dwarf2out_do_frame ())
2529 /* Expand the fde table if necessary. */
2530 if (fde_table_in_use == fde_table_allocated)
2532 fde_table_allocated += FDE_TABLE_INCREMENT;
2533 fde_table = ggc_realloc (fde_table,
2534 fde_table_allocated * sizeof (dw_fde_node));
2535 memset (fde_table + fde_table_in_use, 0,
2536 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2539 /* Record the FDE associated with this function. */
2540 current_funcdef_fde = fde_table_in_use;
2542 /* Add the new FDE at the end of the fde_table. */
2543 fde = &fde_table[fde_table_in_use++];
2544 fde->decl = current_function_decl;
2545 fde->dw_fde_begin = dup_label;
2546 fde->dw_fde_current_label = NULL;
2547 fde->dw_fde_hot_section_label = NULL;
2548 fde->dw_fde_hot_section_end_label = NULL;
2549 fde->dw_fde_unlikely_section_label = NULL;
2550 fde->dw_fde_unlikely_section_end_label = NULL;
2551 fde->dw_fde_switched_sections = false;
2552 fde->dw_fde_end = NULL;
2553 fde->dw_fde_cfi = NULL;
2554 fde->funcdef_number = current_function_funcdef_no;
2555 fde->nothrow = TREE_NOTHROW (current_function_decl);
2556 fde->uses_eh_lsda = cfun->uses_eh_lsda;
2557 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2559 args_size = old_args_size = 0;
2561 /* We only want to output line number information for the genuine dwarf2
2562 prologue case, not the eh frame case. */
2563 #ifdef DWARF2_DEBUGGING_INFO
2565 dwarf2out_source_line (line, file);
2569 /* Output a marker (i.e. a label) for the absolute end of the generated code
2570 for a function definition. This gets called *after* the epilogue code has
2574 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2575 const char *file ATTRIBUTE_UNUSED)
2578 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2580 /* Output a label to mark the endpoint of the code generated for this
2582 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2583 current_function_funcdef_no);
2584 ASM_OUTPUT_LABEL (asm_out_file, label);
2585 fde = &fde_table[fde_table_in_use - 1];
2586 fde->dw_fde_end = xstrdup (label);
2590 dwarf2out_frame_init (void)
2592 /* Allocate the initial hunk of the fde_table. */
2593 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2594 fde_table_allocated = FDE_TABLE_INCREMENT;
2595 fde_table_in_use = 0;
2597 /* Generate the CFA instructions common to all FDE's. Do it now for the
2598 sake of lookup_cfa. */
2600 /* On entry, the Canonical Frame Address is at SP. */
2601 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2603 #ifdef DWARF2_UNWIND_INFO
2604 if (DWARF2_UNWIND_INFO)
2605 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2610 dwarf2out_frame_finish (void)
2612 /* Output call frame information. */
2613 if (DWARF2_FRAME_INFO)
2614 output_call_frame_info (0);
2616 #ifndef TARGET_UNWIND_INFO
2617 /* Output another copy for the unwinder. */
2618 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2619 output_call_frame_info (1);
2624 /* And now, the subset of the debugging information support code necessary
2625 for emitting location expressions. */
2627 /* We need some way to distinguish DW_OP_addr with a direct symbol
2628 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
2629 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
2632 typedef struct dw_val_struct *dw_val_ref;
2633 typedef struct die_struct *dw_die_ref;
2634 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2635 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2637 /* Each DIE may have a series of attribute/value pairs. Values
2638 can take on several forms. The forms that are used in this
2639 implementation are listed below. */
2644 dw_val_class_offset,
2646 dw_val_class_loc_list,
2647 dw_val_class_range_list,
2649 dw_val_class_unsigned_const,
2650 dw_val_class_long_long,
2653 dw_val_class_die_ref,
2654 dw_val_class_fde_ref,
2655 dw_val_class_lbl_id,
2656 dw_val_class_lineptr,
2661 /* Describe a double word constant value. */
2662 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
2664 typedef struct dw_long_long_struct GTY(())
2671 /* Describe a floating point constant value, or a vector constant value. */
2673 typedef struct dw_vec_struct GTY(())
2675 unsigned char * GTY((length ("%h.length"))) array;
2681 /* The dw_val_node describes an attribute's value, as it is
2682 represented internally. */
2684 typedef struct dw_val_struct GTY(())
2686 enum dw_val_class val_class;
2687 union dw_val_struct_union
2689 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2690 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2691 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2692 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2693 HOST_WIDE_INT GTY ((default)) val_int;
2694 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2695 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2696 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2697 struct dw_val_die_union
2701 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2702 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2703 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2704 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2705 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2707 GTY ((desc ("%1.val_class"))) v;
2711 /* Locations in memory are described using a sequence of stack machine
2714 typedef struct dw_loc_descr_struct GTY(())
2716 dw_loc_descr_ref dw_loc_next;
2717 enum dwarf_location_atom dw_loc_opc;
2718 dw_val_node dw_loc_oprnd1;
2719 dw_val_node dw_loc_oprnd2;
2724 /* Location lists are ranges + location descriptions for that range,
2725 so you can track variables that are in different places over
2726 their entire life. */
2727 typedef struct dw_loc_list_struct GTY(())
2729 dw_loc_list_ref dw_loc_next;
2730 const char *begin; /* Label for begin address of range */
2731 const char *end; /* Label for end address of range */
2732 char *ll_symbol; /* Label for beginning of location list.
2733 Only on head of list */
2734 const char *section; /* Section this loclist is relative to */
2735 dw_loc_descr_ref expr;
2738 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2740 static const char *dwarf_stack_op_name (unsigned);
2741 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2742 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2743 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2744 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2745 static unsigned long size_of_locs (dw_loc_descr_ref);
2746 static void output_loc_operands (dw_loc_descr_ref);
2747 static void output_loc_sequence (dw_loc_descr_ref);
2749 /* Convert a DWARF stack opcode into its string name. */
2752 dwarf_stack_op_name (unsigned int op)
2757 case INTERNAL_DW_OP_tls_addr:
2758 return "DW_OP_addr";
2760 return "DW_OP_deref";
2762 return "DW_OP_const1u";
2764 return "DW_OP_const1s";
2766 return "DW_OP_const2u";
2768 return "DW_OP_const2s";
2770 return "DW_OP_const4u";
2772 return "DW_OP_const4s";
2774 return "DW_OP_const8u";
2776 return "DW_OP_const8s";
2778 return "DW_OP_constu";
2780 return "DW_OP_consts";
2784 return "DW_OP_drop";
2786 return "DW_OP_over";
2788 return "DW_OP_pick";
2790 return "DW_OP_swap";
2794 return "DW_OP_xderef";
2802 return "DW_OP_minus";
2814 return "DW_OP_plus";
2815 case DW_OP_plus_uconst:
2816 return "DW_OP_plus_uconst";
2822 return "DW_OP_shra";
2840 return "DW_OP_skip";
2842 return "DW_OP_lit0";
2844 return "DW_OP_lit1";
2846 return "DW_OP_lit2";
2848 return "DW_OP_lit3";
2850 return "DW_OP_lit4";
2852 return "DW_OP_lit5";
2854 return "DW_OP_lit6";
2856 return "DW_OP_lit7";
2858 return "DW_OP_lit8";
2860 return "DW_OP_lit9";
2862 return "DW_OP_lit10";
2864 return "DW_OP_lit11";
2866 return "DW_OP_lit12";
2868 return "DW_OP_lit13";
2870 return "DW_OP_lit14";
2872 return "DW_OP_lit15";
2874 return "DW_OP_lit16";
2876 return "DW_OP_lit17";
2878 return "DW_OP_lit18";
2880 return "DW_OP_lit19";
2882 return "DW_OP_lit20";
2884 return "DW_OP_lit21";
2886 return "DW_OP_lit22";
2888 return "DW_OP_lit23";
2890 return "DW_OP_lit24";
2892 return "DW_OP_lit25";
2894 return "DW_OP_lit26";
2896 return "DW_OP_lit27";
2898 return "DW_OP_lit28";
2900 return "DW_OP_lit29";
2902 return "DW_OP_lit30";
2904 return "DW_OP_lit31";
2906 return "DW_OP_reg0";
2908 return "DW_OP_reg1";
2910 return "DW_OP_reg2";
2912 return "DW_OP_reg3";
2914 return "DW_OP_reg4";
2916 return "DW_OP_reg5";
2918 return "DW_OP_reg6";
2920 return "DW_OP_reg7";
2922 return "DW_OP_reg8";
2924 return "DW_OP_reg9";
2926 return "DW_OP_reg10";
2928 return "DW_OP_reg11";
2930 return "DW_OP_reg12";
2932 return "DW_OP_reg13";
2934 return "DW_OP_reg14";
2936 return "DW_OP_reg15";
2938 return "DW_OP_reg16";
2940 return "DW_OP_reg17";
2942 return "DW_OP_reg18";
2944 return "DW_OP_reg19";
2946 return "DW_OP_reg20";
2948 return "DW_OP_reg21";
2950 return "DW_OP_reg22";
2952 return "DW_OP_reg23";
2954 return "DW_OP_reg24";
2956 return "DW_OP_reg25";
2958 return "DW_OP_reg26";
2960 return "DW_OP_reg27";
2962 return "DW_OP_reg28";
2964 return "DW_OP_reg29";
2966 return "DW_OP_reg30";
2968 return "DW_OP_reg31";
2970 return "DW_OP_breg0";
2972 return "DW_OP_breg1";
2974 return "DW_OP_breg2";
2976 return "DW_OP_breg3";
2978 return "DW_OP_breg4";
2980 return "DW_OP_breg5";
2982 return "DW_OP_breg6";
2984 return "DW_OP_breg7";
2986 return "DW_OP_breg8";
2988 return "DW_OP_breg9";
2990 return "DW_OP_breg10";
2992 return "DW_OP_breg11";
2994 return "DW_OP_breg12";
2996 return "DW_OP_breg13";
2998 return "DW_OP_breg14";
3000 return "DW_OP_breg15";
3002 return "DW_OP_breg16";
3004 return "DW_OP_breg17";
3006 return "DW_OP_breg18";
3008 return "DW_OP_breg19";
3010 return "DW_OP_breg20";
3012 return "DW_OP_breg21";
3014 return "DW_OP_breg22";
3016 return "DW_OP_breg23";
3018 return "DW_OP_breg24";
3020 return "DW_OP_breg25";
3022 return "DW_OP_breg26";
3024 return "DW_OP_breg27";
3026 return "DW_OP_breg28";
3028 return "DW_OP_breg29";
3030 return "DW_OP_breg30";
3032 return "DW_OP_breg31";
3034 return "DW_OP_regx";
3036 return "DW_OP_fbreg";
3038 return "DW_OP_bregx";
3040 return "DW_OP_piece";
3041 case DW_OP_deref_size:
3042 return "DW_OP_deref_size";
3043 case DW_OP_xderef_size:
3044 return "DW_OP_xderef_size";
3047 case DW_OP_push_object_address:
3048 return "DW_OP_push_object_address";
3050 return "DW_OP_call2";
3052 return "DW_OP_call4";
3053 case DW_OP_call_ref:
3054 return "DW_OP_call_ref";
3055 case DW_OP_GNU_push_tls_address:
3056 return "DW_OP_GNU_push_tls_address";
3058 return "OP_<unknown>";
3062 /* Return a pointer to a newly allocated location description. Location
3063 descriptions are simple expression terms that can be strung
3064 together to form more complicated location (address) descriptions. */
3066 static inline dw_loc_descr_ref
3067 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3068 unsigned HOST_WIDE_INT oprnd2)
3070 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
3072 descr->dw_loc_opc = op;
3073 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3074 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3075 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3076 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3081 /* Add a location description term to a location description expression. */
3084 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3086 dw_loc_descr_ref *d;
3088 /* Find the end of the chain. */
3089 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3095 /* Return the size of a location descriptor. */
3097 static unsigned long
3098 size_of_loc_descr (dw_loc_descr_ref loc)
3100 unsigned long size = 1;
3102 switch (loc->dw_loc_opc)
3105 case INTERNAL_DW_OP_tls_addr:
3106 size += DWARF2_ADDR_SIZE;
3125 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3128 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3133 case DW_OP_plus_uconst:
3134 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3172 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3175 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3178 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3181 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3182 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3185 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3187 case DW_OP_deref_size:
3188 case DW_OP_xderef_size:
3197 case DW_OP_call_ref:
3198 size += DWARF2_ADDR_SIZE;
3207 /* Return the size of a series of location descriptors. */
3209 static unsigned long
3210 size_of_locs (dw_loc_descr_ref loc)
3214 for (size = 0; loc != NULL; loc = loc->dw_loc_next)
3216 loc->dw_loc_addr = size;
3217 size += size_of_loc_descr (loc);
3223 /* Output location description stack opcode's operands (if any). */
3226 output_loc_operands (dw_loc_descr_ref loc)
3228 dw_val_ref val1 = &loc->dw_loc_oprnd1;
3229 dw_val_ref val2 = &loc->dw_loc_oprnd2;
3231 switch (loc->dw_loc_opc)
3233 #ifdef DWARF2_DEBUGGING_INFO
3235 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3239 dw2_asm_output_data (2, val1->v.val_int, NULL);
3243 dw2_asm_output_data (4, val1->v.val_int, NULL);
3247 gcc_assert (HOST_BITS_PER_LONG >= 64);
3248 dw2_asm_output_data (8, val1->v.val_int, NULL);
3255 gcc_assert (val1->val_class == dw_val_class_loc);
3256 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3258 dw2_asm_output_data (2, offset, NULL);
3271 /* We currently don't make any attempt to make sure these are
3272 aligned properly like we do for the main unwind info, so
3273 don't support emitting things larger than a byte if we're
3274 only doing unwinding. */
3279 dw2_asm_output_data (1, val1->v.val_int, NULL);
3282 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3285 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3288 dw2_asm_output_data (1, val1->v.val_int, NULL);
3290 case DW_OP_plus_uconst:
3291 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3325 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3328 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3331 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3334 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3335 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3338 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3340 case DW_OP_deref_size:
3341 case DW_OP_xderef_size:
3342 dw2_asm_output_data (1, val1->v.val_int, NULL);
3345 case INTERNAL_DW_OP_tls_addr:
3346 if (targetm.asm_out.output_dwarf_dtprel)
3348 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3351 fputc ('\n', asm_out_file);
3358 /* Other codes have no operands. */
3363 /* Output a sequence of location operations. */
3366 output_loc_sequence (dw_loc_descr_ref loc)
3368 for (; loc != NULL; loc = loc->dw_loc_next)
3370 /* Output the opcode. */
3371 dw2_asm_output_data (1, loc->dw_loc_opc,
3372 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3374 /* Output the operand(s) (if any). */
3375 output_loc_operands (loc);
3379 /* This routine will generate the correct assembly data for a location
3380 description based on a cfi entry with a complex address. */
3383 output_cfa_loc (dw_cfi_ref cfi)
3385 dw_loc_descr_ref loc;
3388 /* Output the size of the block. */
3389 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3390 size = size_of_locs (loc);
3391 dw2_asm_output_data_uleb128 (size, NULL);
3393 /* Now output the operations themselves. */
3394 output_loc_sequence (loc);
3397 /* This function builds a dwarf location descriptor sequence from a
3398 dw_cfa_location, adding the given OFFSET to the result of the
3401 static struct dw_loc_descr_struct *
3402 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
3404 struct dw_loc_descr_struct *head, *tmp;
3406 offset += cfa->offset;
3410 if (cfa->base_offset)
3413 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3415 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3417 else if (cfa->reg <= 31)
3418 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3420 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3422 head->dw_loc_oprnd1.val_class = dw_val_class_const;
3423 tmp = new_loc_descr (DW_OP_deref, 0, 0);
3424 add_loc_descr (&head, tmp);
3427 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
3428 add_loc_descr (&head, tmp);
3435 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3437 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3438 else if (cfa->reg <= 31)
3439 head = new_loc_descr (DW_OP_breg0 + cfa->reg, offset, 0);
3441 head = new_loc_descr (DW_OP_bregx, cfa->reg, offset);
3447 /* This function fills in aa dw_cfa_location structure from a dwarf location
3448 descriptor sequence. */
3451 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3453 struct dw_loc_descr_struct *ptr;
3455 cfa->base_offset = 0;
3459 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3461 enum dwarf_location_atom op = ptr->dw_loc_opc;
3497 cfa->reg = op - DW_OP_reg0;
3500 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3534 cfa->reg = op - DW_OP_breg0;
3535 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3538 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3539 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3544 case DW_OP_plus_uconst:
3545 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3548 internal_error ("DW_LOC_OP %s not implemented",
3549 dwarf_stack_op_name (ptr->dw_loc_opc));
3553 #endif /* .debug_frame support */
3555 /* And now, the support for symbolic debugging information. */
3556 #ifdef DWARF2_DEBUGGING_INFO
3558 /* .debug_str support. */
3559 static int output_indirect_string (void **, void *);
3561 static void dwarf2out_init (const char *);
3562 static void dwarf2out_finish (const char *);
3563 static void dwarf2out_define (unsigned int, const char *);
3564 static void dwarf2out_undef (unsigned int, const char *);
3565 static void dwarf2out_start_source_file (unsigned, const char *);
3566 static void dwarf2out_end_source_file (unsigned);
3567 static void dwarf2out_begin_block (unsigned, unsigned);
3568 static void dwarf2out_end_block (unsigned, unsigned);
3569 static bool dwarf2out_ignore_block (tree);
3570 static void dwarf2out_global_decl (tree);
3571 static void dwarf2out_type_decl (tree, int);
3572 static void dwarf2out_imported_module_or_decl (tree, tree);
3573 static void dwarf2out_abstract_function (tree);
3574 static void dwarf2out_var_location (rtx);
3575 static void dwarf2out_begin_function (tree);
3576 static void dwarf2out_switch_text_section (void);
3578 /* The debug hooks structure. */
3580 const struct gcc_debug_hooks dwarf2_debug_hooks =
3586 dwarf2out_start_source_file,
3587 dwarf2out_end_source_file,
3588 dwarf2out_begin_block,
3589 dwarf2out_end_block,
3590 dwarf2out_ignore_block,
3591 dwarf2out_source_line,
3592 dwarf2out_begin_prologue,
3593 debug_nothing_int_charstar, /* end_prologue */
3594 dwarf2out_end_epilogue,
3595 dwarf2out_begin_function,
3596 debug_nothing_int, /* end_function */
3597 dwarf2out_decl, /* function_decl */
3598 dwarf2out_global_decl,
3599 dwarf2out_type_decl, /* type_decl */
3600 dwarf2out_imported_module_or_decl,
3601 debug_nothing_tree, /* deferred_inline_function */
3602 /* The DWARF 2 backend tries to reduce debugging bloat by not
3603 emitting the abstract description of inline functions until
3604 something tries to reference them. */
3605 dwarf2out_abstract_function, /* outlining_inline_function */
3606 debug_nothing_rtx, /* label */
3607 debug_nothing_int, /* handle_pch */
3608 dwarf2out_var_location,
3609 dwarf2out_switch_text_section,
3610 1 /* start_end_main_source_file */
3614 /* NOTE: In the comments in this file, many references are made to
3615 "Debugging Information Entries". This term is abbreviated as `DIE'
3616 throughout the remainder of this file. */
3618 /* An internal representation of the DWARF output is built, and then
3619 walked to generate the DWARF debugging info. The walk of the internal
3620 representation is done after the entire program has been compiled.
3621 The types below are used to describe the internal representation. */
3623 /* Various DIE's use offsets relative to the beginning of the
3624 .debug_info section to refer to each other. */
3626 typedef long int dw_offset;
3628 /* Define typedefs here to avoid circular dependencies. */
3630 typedef struct dw_attr_struct *dw_attr_ref;
3631 typedef struct dw_line_info_struct *dw_line_info_ref;
3632 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3633 typedef struct pubname_struct *pubname_ref;
3634 typedef struct dw_ranges_struct *dw_ranges_ref;
3636 /* Each entry in the line_info_table maintains the file and
3637 line number associated with the label generated for that
3638 entry. The label gives the PC value associated with
3639 the line number entry. */
3641 typedef struct dw_line_info_struct GTY(())
3643 unsigned long dw_file_num;
3644 unsigned long dw_line_num;
3648 /* Line information for functions in separate sections; each one gets its
3650 typedef struct dw_separate_line_info_struct GTY(())
3652 unsigned long dw_file_num;
3653 unsigned long dw_line_num;
3654 unsigned long function;
3656 dw_separate_line_info_entry;
3658 /* Each DIE attribute has a field specifying the attribute kind,
3659 a link to the next attribute in the chain, and an attribute value.
3660 Attributes are typically linked below the DIE they modify. */
3662 typedef struct dw_attr_struct GTY(())
3664 enum dwarf_attribute dw_attr;
3665 dw_attr_ref dw_attr_next;
3666 dw_val_node dw_attr_val;
3670 /* The Debugging Information Entry (DIE) structure */
3672 typedef struct die_struct GTY(())
3674 enum dwarf_tag die_tag;
3676 dw_attr_ref die_attr;
3677 dw_die_ref die_parent;
3678 dw_die_ref die_child;
3680 dw_die_ref die_definition; /* ref from a specification to its definition */
3681 dw_offset die_offset;
3682 unsigned long die_abbrev;
3684 unsigned int decl_id;
3688 /* The pubname structure */
3690 typedef struct pubname_struct GTY(())
3697 struct dw_ranges_struct GTY(())
3702 /* The limbo die list structure. */
3703 typedef struct limbo_die_struct GTY(())
3707 struct limbo_die_struct *next;
3711 /* How to start an assembler comment. */
3712 #ifndef ASM_COMMENT_START
3713 #define ASM_COMMENT_START ";#"
3716 /* Define a macro which returns nonzero for a TYPE_DECL which was
3717 implicitly generated for a tagged type.
3719 Note that unlike the gcc front end (which generates a NULL named
3720 TYPE_DECL node for each complete tagged type, each array type, and
3721 each function type node created) the g++ front end generates a
3722 _named_ TYPE_DECL node for each tagged type node created.
3723 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3724 generate a DW_TAG_typedef DIE for them. */
3726 #define TYPE_DECL_IS_STUB(decl) \
3727 (DECL_NAME (decl) == NULL_TREE \
3728 || (DECL_ARTIFICIAL (decl) \
3729 && is_tagged_type (TREE_TYPE (decl)) \
3730 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3731 /* This is necessary for stub decls that \
3732 appear in nested inline functions. */ \
3733 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3734 && (decl_ultimate_origin (decl) \
3735 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3737 /* Information concerning the compilation unit's programming
3738 language, and compiler version. */
3740 /* Fixed size portion of the DWARF compilation unit header. */
3741 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3742 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3744 /* Fixed size portion of public names info. */
3745 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3747 /* Fixed size portion of the address range info. */
3748 #define DWARF_ARANGES_HEADER_SIZE \
3749 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3750 DWARF2_ADDR_SIZE * 2) \
3751 - DWARF_INITIAL_LENGTH_SIZE)
3753 /* Size of padding portion in the address range info. It must be
3754 aligned to twice the pointer size. */
3755 #define DWARF_ARANGES_PAD_SIZE \
3756 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3757 DWARF2_ADDR_SIZE * 2) \
3758 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3760 /* Use assembler line directives if available. */
3761 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3762 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3763 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3765 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3769 /* Minimum line offset in a special line info. opcode.
3770 This value was chosen to give a reasonable range of values. */
3771 #define DWARF_LINE_BASE -10
3773 /* First special line opcode - leave room for the standard opcodes. */
3774 #define DWARF_LINE_OPCODE_BASE 10
3776 /* Range of line offsets in a special line info. opcode. */
3777 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3779 /* Flag that indicates the initial value of the is_stmt_start flag.
3780 In the present implementation, we do not mark any lines as
3781 the beginning of a source statement, because that information
3782 is not made available by the GCC front-end. */
3783 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3785 #ifdef DWARF2_DEBUGGING_INFO
3786 /* This location is used by calc_die_sizes() to keep track
3787 the offset of each DIE within the .debug_info section. */
3788 static unsigned long next_die_offset;
3791 /* Record the root of the DIE's built for the current compilation unit. */
3792 static GTY(()) dw_die_ref comp_unit_die;
3794 /* A list of DIEs with a NULL parent waiting to be relocated. */
3795 static GTY(()) limbo_die_node *limbo_die_list;
3797 /* Filenames referenced by this compilation unit. */
3798 static GTY(()) varray_type file_table;
3799 static GTY(()) varray_type file_table_emitted;
3800 static GTY(()) size_t file_table_last_lookup_index;
3802 /* A hash table of references to DIE's that describe declarations.
3803 The key is a DECL_UID() which is a unique number identifying each decl. */
3804 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3806 /* Node of the variable location list. */
3807 struct var_loc_node GTY ((chain_next ("%h.next")))
3809 rtx GTY (()) var_loc_note;
3810 const char * GTY (()) label;
3811 const char * GTY (()) section_label;
3812 struct var_loc_node * GTY (()) next;
3815 /* Variable location list. */
3816 struct var_loc_list_def GTY (())
3818 struct var_loc_node * GTY (()) first;
3820 /* Do not mark the last element of the chained list because
3821 it is marked through the chain. */
3822 struct var_loc_node * GTY ((skip ("%h"))) last;
3824 /* DECL_UID of the variable decl. */
3825 unsigned int decl_id;
3827 typedef struct var_loc_list_def var_loc_list;
3830 /* Table of decl location linked lists. */
3831 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3833 /* A pointer to the base of a list of references to DIE's that
3834 are uniquely identified by their tag, presence/absence of
3835 children DIE's, and list of attribute/value pairs. */
3836 static GTY((length ("abbrev_die_table_allocated")))
3837 dw_die_ref *abbrev_die_table;
3839 /* Number of elements currently allocated for abbrev_die_table. */
3840 static GTY(()) unsigned abbrev_die_table_allocated;
3842 /* Number of elements in type_die_table currently in use. */
3843 static GTY(()) unsigned abbrev_die_table_in_use;
3845 /* Size (in elements) of increments by which we may expand the
3846 abbrev_die_table. */
3847 #define ABBREV_DIE_TABLE_INCREMENT 256
3849 /* A pointer to the base of a table that contains line information
3850 for each source code line in .text in the compilation unit. */
3851 static GTY((length ("line_info_table_allocated")))
3852 dw_line_info_ref line_info_table;
3854 /* Number of elements currently allocated for line_info_table. */
3855 static GTY(()) unsigned line_info_table_allocated;
3857 /* Number of elements in line_info_table currently in use. */
3858 static GTY(()) unsigned line_info_table_in_use;
3860 /* True if the compilation unit places functions in more than one section. */
3861 static GTY(()) bool have_multiple_function_sections = false;
3863 /* A pointer to the base of a table that contains line information
3864 for each source code line outside of .text in the compilation unit. */
3865 static GTY ((length ("separate_line_info_table_allocated")))
3866 dw_separate_line_info_ref separate_line_info_table;
3868 /* Number of elements currently allocated for separate_line_info_table. */
3869 static GTY(()) unsigned separate_line_info_table_allocated;
3871 /* Number of elements in separate_line_info_table currently in use. */
3872 static GTY(()) unsigned separate_line_info_table_in_use;
3874 /* Size (in elements) of increments by which we may expand the
3876 #define LINE_INFO_TABLE_INCREMENT 1024
3878 /* A pointer to the base of a table that contains a list of publicly
3879 accessible names. */
3880 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3882 /* Number of elements currently allocated for pubname_table. */
3883 static GTY(()) unsigned pubname_table_allocated;
3885 /* Number of elements in pubname_table currently in use. */
3886 static GTY(()) unsigned pubname_table_in_use;
3888 /* Size (in elements) of increments by which we may expand the
3890 #define PUBNAME_TABLE_INCREMENT 64
3892 /* Array of dies for which we should generate .debug_arange info. */
3893 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3895 /* Number of elements currently allocated for arange_table. */
3896 static GTY(()) unsigned arange_table_allocated;
3898 /* Number of elements in arange_table currently in use. */
3899 static GTY(()) unsigned arange_table_in_use;
3901 /* Size (in elements) of increments by which we may expand the
3903 #define ARANGE_TABLE_INCREMENT 64
3905 /* Array of dies for which we should generate .debug_ranges info. */
3906 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3908 /* Number of elements currently allocated for ranges_table. */
3909 static GTY(()) unsigned ranges_table_allocated;
3911 /* Number of elements in ranges_table currently in use. */
3912 static GTY(()) unsigned ranges_table_in_use;
3914 /* Size (in elements) of increments by which we may expand the
3916 #define RANGES_TABLE_INCREMENT 64
3918 /* Whether we have location lists that need outputting */
3919 static GTY(()) bool have_location_lists;
3921 /* Unique label counter. */
3922 static GTY(()) unsigned int loclabel_num;
3924 #ifdef DWARF2_DEBUGGING_INFO
3925 /* Record whether the function being analyzed contains inlined functions. */
3926 static int current_function_has_inlines;
3928 #if 0 && defined (MIPS_DEBUGGING_INFO)
3929 static int comp_unit_has_inlines;
3932 /* Number of file tables emitted in maybe_emit_file(). */
3933 static GTY(()) int emitcount = 0;
3935 /* Number of internal labels generated by gen_internal_sym(). */
3936 static GTY(()) int label_num;
3938 #ifdef DWARF2_DEBUGGING_INFO
3940 /* Offset from the "steady-state frame pointer" to the frame base,
3941 within the current function. */
3942 static HOST_WIDE_INT frame_pointer_fb_offset;
3944 /* Forward declarations for functions defined in this file. */
3946 static int is_pseudo_reg (rtx);
3947 static tree type_main_variant (tree);
3948 static int is_tagged_type (tree);
3949 static const char *dwarf_tag_name (unsigned);
3950 static const char *dwarf_attr_name (unsigned);
3951 static const char *dwarf_form_name (unsigned);
3952 static tree decl_ultimate_origin (tree);
3953 static tree block_ultimate_origin (tree);
3954 static tree decl_class_context (tree);
3955 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3956 static inline enum dw_val_class AT_class (dw_attr_ref);
3957 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3958 static inline unsigned AT_flag (dw_attr_ref);
3959 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3960 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3961 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3962 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3963 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
3965 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3966 unsigned int, unsigned char *);
3967 static hashval_t debug_str_do_hash (const void *);
3968 static int debug_str_eq (const void *, const void *);
3969 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3970 static inline const char *AT_string (dw_attr_ref);
3971 static int AT_string_form (dw_attr_ref);
3972 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3973 static void add_AT_specification (dw_die_ref, dw_die_ref);
3974 static inline dw_die_ref AT_ref (dw_attr_ref);
3975 static inline int AT_ref_external (dw_attr_ref);
3976 static inline void set_AT_ref_external (dw_attr_ref, int);
3977 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3978 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3979 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3980 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3982 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3983 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3984 static inline rtx AT_addr (dw_attr_ref);
3985 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3986 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3987 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3988 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3989 unsigned HOST_WIDE_INT);
3990 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3992 static inline const char *AT_lbl (dw_attr_ref);
3993 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3994 static const char *get_AT_low_pc (dw_die_ref);
3995 static const char *get_AT_hi_pc (dw_die_ref);
3996 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3997 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3998 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3999 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
4000 static bool is_c_family (void);
4001 static bool is_cxx (void);
4002 static bool is_java (void);
4003 static bool is_fortran (void);
4004 static bool is_ada (void);
4005 static void remove_AT (dw_die_ref, enum dwarf_attribute);
4006 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4007 static inline void free_die (dw_die_ref);
4008 static void remove_children (dw_die_ref);
4009 static void add_child_die (dw_die_ref, dw_die_ref);
4010 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4011 static dw_die_ref lookup_type_die (tree);
4012 static void equate_type_number_to_die (tree, dw_die_ref);
4013 static hashval_t decl_die_table_hash (const void *);
4014 static int decl_die_table_eq (const void *, const void *);
4015 static dw_die_ref lookup_decl_die (tree);
4016 static hashval_t decl_loc_table_hash (const void *);
4017 static int decl_loc_table_eq (const void *, const void *);
4018 static var_loc_list *lookup_decl_loc (tree);
4019 static void equate_decl_number_to_die (tree, dw_die_ref);
4020 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4021 static void print_spaces (FILE *);
4022 static void print_die (dw_die_ref, FILE *);
4023 static void print_dwarf_line_table (FILE *);
4024 static void reverse_die_lists (dw_die_ref);
4025 static void reverse_all_dies (dw_die_ref);
4026 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4027 static dw_die_ref pop_compile_unit (dw_die_ref);
4028 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4029 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4030 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4031 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4032 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4033 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4034 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4035 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4036 static void compute_section_prefix (dw_die_ref);
4037 static int is_type_die (dw_die_ref);
4038 static int is_comdat_die (dw_die_ref);
4039 static int is_symbol_die (dw_die_ref);
4040 static void assign_symbol_names (dw_die_ref);
4041 static void break_out_includes (dw_die_ref);
4042 static hashval_t htab_cu_hash (const void *);
4043 static int htab_cu_eq (const void *, const void *);
4044 static void htab_cu_del (void *);
4045 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4046 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4047 static void add_sibling_attributes (dw_die_ref);
4048 static void build_abbrev_table (dw_die_ref);
4049 static void output_location_lists (dw_die_ref);
4050 static int constant_size (long unsigned);
4051 static unsigned long size_of_die (dw_die_ref);
4052 static void calc_die_sizes (dw_die_ref);
4053 static void mark_dies (dw_die_ref);
4054 static void unmark_dies (dw_die_ref);
4055 static void unmark_all_dies (dw_die_ref);
4056 static unsigned long size_of_pubnames (void);
4057 static unsigned long size_of_aranges (void);
4058 static enum dwarf_form value_format (dw_attr_ref);
4059 static void output_value_format (dw_attr_ref);
4060 static void output_abbrev_section (void);
4061 static void output_die_symbol (dw_die_ref);
4062 static void output_die (dw_die_ref);
4063 static void output_compilation_unit_header (void);
4064 static void output_comp_unit (dw_die_ref, int);
4065 static const char *dwarf2_name (tree, int);
4066 static void add_pubname (tree, dw_die_ref);
4067 static void output_pubnames (void);
4068 static void add_arange (tree, dw_die_ref);
4069 static void output_aranges (void);
4070 static unsigned int add_ranges (tree);
4071 static void output_ranges (void);
4072 static void output_line_info (void);
4073 static void output_file_names (void);
4074 static dw_die_ref base_type_die (tree);
4075 static tree root_type (tree);
4076 static int is_base_type (tree);
4077 static bool is_subrange_type (tree);
4078 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4079 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4080 static int type_is_enum (tree);
4081 static unsigned int dbx_reg_number (rtx);
4082 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4083 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4084 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4085 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4086 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4087 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4088 static int is_based_loc (rtx);
4089 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4090 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4091 static dw_loc_descr_ref loc_descriptor (rtx);
4092 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4093 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4094 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4095 static tree field_type (tree);
4096 static unsigned int simple_type_align_in_bits (tree);
4097 static unsigned int simple_decl_align_in_bits (tree);
4098 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4099 static HOST_WIDE_INT field_byte_offset (tree);
4100 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4102 static void add_data_member_location_attribute (dw_die_ref, tree);
4103 static void add_const_value_attribute (dw_die_ref, rtx);
4104 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4105 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4106 static void insert_float (rtx, unsigned char *);
4107 static rtx rtl_for_decl_location (tree);
4108 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4109 enum dwarf_attribute);
4110 static void tree_add_const_value_attribute (dw_die_ref, tree);
4111 static void add_name_attribute (dw_die_ref, const char *);
4112 static void add_comp_dir_attribute (dw_die_ref);
4113 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4114 static void add_subscript_info (dw_die_ref, tree);
4115 static void add_byte_size_attribute (dw_die_ref, tree);
4116 static void add_bit_offset_attribute (dw_die_ref, tree);
4117 static void add_bit_size_attribute (dw_die_ref, tree);
4118 static void add_prototyped_attribute (dw_die_ref, tree);
4119 static void add_abstract_origin_attribute (dw_die_ref, tree);
4120 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4121 static void add_src_coords_attributes (dw_die_ref, tree);
4122 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4123 static void push_decl_scope (tree);
4124 static void pop_decl_scope (void);
4125 static dw_die_ref scope_die_for (tree, dw_die_ref);
4126 static inline int local_scope_p (dw_die_ref);
4127 static inline int class_or_namespace_scope_p (dw_die_ref);
4128 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4129 static void add_calling_convention_attribute (dw_die_ref, tree);
4130 static const char *type_tag (tree);
4131 static tree member_declared_type (tree);
4133 static const char *decl_start_label (tree);
4135 static void gen_array_type_die (tree, dw_die_ref);
4137 static void gen_entry_point_die (tree, dw_die_ref);
4139 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4140 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4141 static void gen_inlined_union_type_die (tree, dw_die_ref);
4142 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4143 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4144 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4145 static void gen_formal_types_die (tree, dw_die_ref);
4146 static void gen_subprogram_die (tree, dw_die_ref);
4147 static void gen_variable_die (tree, dw_die_ref);
4148 static void gen_label_die (tree, dw_die_ref);
4149 static void gen_lexical_block_die (tree, dw_die_ref, int);
4150 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4151 static void gen_field_die (tree, dw_die_ref);
4152 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4153 static dw_die_ref gen_compile_unit_die (const char *);
4154 static void gen_inheritance_die (tree, tree, dw_die_ref);
4155 static void gen_member_die (tree, dw_die_ref);
4156 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4157 static void gen_subroutine_type_die (tree, dw_die_ref);
4158 static void gen_typedef_die (tree, dw_die_ref);
4159 static void gen_type_die (tree, dw_die_ref);
4160 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4161 static void gen_block_die (tree, dw_die_ref, int);
4162 static void decls_for_scope (tree, dw_die_ref, int);
4163 static int is_redundant_typedef (tree);
4164 static void gen_namespace_die (tree);
4165 static void gen_decl_die (tree, dw_die_ref);
4166 static dw_die_ref force_decl_die (tree);
4167 static dw_die_ref force_type_die (tree);
4168 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4169 static void declare_in_namespace (tree, dw_die_ref);
4170 static unsigned lookup_filename (const char *);
4171 static void init_file_table (void);
4172 static void retry_incomplete_types (void);
4173 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4174 static void splice_child_die (dw_die_ref, dw_die_ref);
4175 static int file_info_cmp (const void *, const void *);
4176 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4177 const char *, const char *, unsigned);
4178 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4179 const char *, const char *,
4181 static void output_loc_list (dw_loc_list_ref);
4182 static char *gen_internal_sym (const char *);
4184 static void prune_unmark_dies (dw_die_ref);
4185 static void prune_unused_types_mark (dw_die_ref, int);
4186 static void prune_unused_types_walk (dw_die_ref);
4187 static void prune_unused_types_walk_attribs (dw_die_ref);
4188 static void prune_unused_types_prune (dw_die_ref);
4189 static void prune_unused_types (void);
4190 static int maybe_emit_file (int);
4192 /* Section names used to hold DWARF debugging information. */
4193 #ifndef DEBUG_INFO_SECTION
4194 #define DEBUG_INFO_SECTION ".debug_info"
4196 #ifndef DEBUG_ABBREV_SECTION
4197 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
4199 #ifndef DEBUG_ARANGES_SECTION
4200 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4202 #ifndef DEBUG_MACINFO_SECTION
4203 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4205 #ifndef DEBUG_LINE_SECTION
4206 #define DEBUG_LINE_SECTION ".debug_line"
4208 #ifndef DEBUG_LOC_SECTION
4209 #define DEBUG_LOC_SECTION ".debug_loc"
4211 #ifndef DEBUG_PUBNAMES_SECTION
4212 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
4214 #ifndef DEBUG_STR_SECTION
4215 #define DEBUG_STR_SECTION ".debug_str"
4217 #ifndef DEBUG_RANGES_SECTION
4218 #define DEBUG_RANGES_SECTION ".debug_ranges"
4221 /* Standard ELF section names for compiled code and data. */
4222 #ifndef TEXT_SECTION_NAME
4223 #define TEXT_SECTION_NAME ".text"
4226 /* Section flags for .debug_str section. */
4227 #define DEBUG_STR_SECTION_FLAGS \
4228 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
4229 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4232 /* Labels we insert at beginning sections we can reference instead of
4233 the section names themselves. */
4235 #ifndef TEXT_SECTION_LABEL
4236 #define TEXT_SECTION_LABEL "Ltext"
4238 #ifndef COLD_TEXT_SECTION_LABEL
4239 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4241 #ifndef DEBUG_LINE_SECTION_LABEL
4242 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4244 #ifndef DEBUG_INFO_SECTION_LABEL
4245 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4247 #ifndef DEBUG_ABBREV_SECTION_LABEL
4248 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4250 #ifndef DEBUG_LOC_SECTION_LABEL
4251 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4253 #ifndef DEBUG_RANGES_SECTION_LABEL
4254 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4256 #ifndef DEBUG_MACINFO_SECTION_LABEL
4257 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4260 /* Definitions of defaults for formats and names of various special
4261 (artificial) labels which may be generated within this file (when the -g
4262 options is used and DWARF2_DEBUGGING_INFO is in effect.
4263 If necessary, these may be overridden from within the tm.h file, but
4264 typically, overriding these defaults is unnecessary. */
4266 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4267 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4268 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4269 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4270 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4271 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4272 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4273 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4274 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4275 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4277 #ifndef TEXT_END_LABEL
4278 #define TEXT_END_LABEL "Letext"
4280 #ifndef COLD_END_LABEL
4281 #define COLD_END_LABEL "Letext_cold"
4283 #ifndef BLOCK_BEGIN_LABEL
4284 #define BLOCK_BEGIN_LABEL "LBB"
4286 #ifndef BLOCK_END_LABEL
4287 #define BLOCK_END_LABEL "LBE"
4289 #ifndef LINE_CODE_LABEL
4290 #define LINE_CODE_LABEL "LM"
4292 #ifndef SEPARATE_LINE_CODE_LABEL
4293 #define SEPARATE_LINE_CODE_LABEL "LSM"
4296 /* We allow a language front-end to designate a function that is to be
4297 called to "demangle" any name before it is put into a DIE. */
4299 static const char *(*demangle_name_func) (const char *);
4302 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4304 demangle_name_func = func;
4307 /* Test if rtl node points to a pseudo register. */
4310 is_pseudo_reg (rtx rtl)
4312 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4313 || (GET_CODE (rtl) == SUBREG
4314 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4317 /* Return a reference to a type, with its const and volatile qualifiers
4321 type_main_variant (tree type)
4323 type = TYPE_MAIN_VARIANT (type);
4325 /* ??? There really should be only one main variant among any group of
4326 variants of a given type (and all of the MAIN_VARIANT values for all
4327 members of the group should point to that one type) but sometimes the C
4328 front-end messes this up for array types, so we work around that bug
4330 if (TREE_CODE (type) == ARRAY_TYPE)
4331 while (type != TYPE_MAIN_VARIANT (type))
4332 type = TYPE_MAIN_VARIANT (type);
4337 /* Return nonzero if the given type node represents a tagged type. */
4340 is_tagged_type (tree type)
4342 enum tree_code code = TREE_CODE (type);
4344 return (code == RECORD_TYPE || code == UNION_TYPE
4345 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4348 /* Convert a DIE tag into its string name. */
4351 dwarf_tag_name (unsigned int tag)
4355 case DW_TAG_padding:
4356 return "DW_TAG_padding";
4357 case DW_TAG_array_type:
4358 return "DW_TAG_array_type";
4359 case DW_TAG_class_type:
4360 return "DW_TAG_class_type";
4361 case DW_TAG_entry_point:
4362 return "DW_TAG_entry_point";
4363 case DW_TAG_enumeration_type:
4364 return "DW_TAG_enumeration_type";
4365 case DW_TAG_formal_parameter:
4366 return "DW_TAG_formal_parameter";
4367 case DW_TAG_imported_declaration:
4368 return "DW_TAG_imported_declaration";
4370 return "DW_TAG_label";
4371 case DW_TAG_lexical_block:
4372 return "DW_TAG_lexical_block";
4374 return "DW_TAG_member";
4375 case DW_TAG_pointer_type:
4376 return "DW_TAG_pointer_type";
4377 case DW_TAG_reference_type:
4378 return "DW_TAG_reference_type";
4379 case DW_TAG_compile_unit:
4380 return "DW_TAG_compile_unit";
4381 case DW_TAG_string_type:
4382 return "DW_TAG_string_type";
4383 case DW_TAG_structure_type:
4384 return "DW_TAG_structure_type";
4385 case DW_TAG_subroutine_type:
4386 return "DW_TAG_subroutine_type";
4387 case DW_TAG_typedef:
4388 return "DW_TAG_typedef";
4389 case DW_TAG_union_type:
4390 return "DW_TAG_union_type";
4391 case DW_TAG_unspecified_parameters:
4392 return "DW_TAG_unspecified_parameters";
4393 case DW_TAG_variant:
4394 return "DW_TAG_variant";
4395 case DW_TAG_common_block:
4396 return "DW_TAG_common_block";
4397 case DW_TAG_common_inclusion:
4398 return "DW_TAG_common_inclusion";
4399 case DW_TAG_inheritance:
4400 return "DW_TAG_inheritance";
4401 case DW_TAG_inlined_subroutine:
4402 return "DW_TAG_inlined_subroutine";
4404 return "DW_TAG_module";
4405 case DW_TAG_ptr_to_member_type:
4406 return "DW_TAG_ptr_to_member_type";
4407 case DW_TAG_set_type:
4408 return "DW_TAG_set_type";
4409 case DW_TAG_subrange_type:
4410 return "DW_TAG_subrange_type";
4411 case DW_TAG_with_stmt:
4412 return "DW_TAG_with_stmt";
4413 case DW_TAG_access_declaration:
4414 return "DW_TAG_access_declaration";
4415 case DW_TAG_base_type:
4416 return "DW_TAG_base_type";
4417 case DW_TAG_catch_block:
4418 return "DW_TAG_catch_block";
4419 case DW_TAG_const_type:
4420 return "DW_TAG_const_type";
4421 case DW_TAG_constant:
4422 return "DW_TAG_constant";
4423 case DW_TAG_enumerator:
4424 return "DW_TAG_enumerator";
4425 case DW_TAG_file_type:
4426 return "DW_TAG_file_type";
4428 return "DW_TAG_friend";
4429 case DW_TAG_namelist:
4430 return "DW_TAG_namelist";
4431 case DW_TAG_namelist_item:
4432 return "DW_TAG_namelist_item";
4433 case DW_TAG_namespace:
4434 return "DW_TAG_namespace";
4435 case DW_TAG_packed_type:
4436 return "DW_TAG_packed_type";
4437 case DW_TAG_subprogram:
4438 return "DW_TAG_subprogram";
4439 case DW_TAG_template_type_param:
4440 return "DW_TAG_template_type_param";
4441 case DW_TAG_template_value_param:
4442 return "DW_TAG_template_value_param";
4443 case DW_TAG_thrown_type:
4444 return "DW_TAG_thrown_type";
4445 case DW_TAG_try_block:
4446 return "DW_TAG_try_block";
4447 case DW_TAG_variant_part:
4448 return "DW_TAG_variant_part";
4449 case DW_TAG_variable:
4450 return "DW_TAG_variable";
4451 case DW_TAG_volatile_type:
4452 return "DW_TAG_volatile_type";
4453 case DW_TAG_imported_module:
4454 return "DW_TAG_imported_module";
4455 case DW_TAG_MIPS_loop:
4456 return "DW_TAG_MIPS_loop";
4457 case DW_TAG_format_label:
4458 return "DW_TAG_format_label";
4459 case DW_TAG_function_template:
4460 return "DW_TAG_function_template";
4461 case DW_TAG_class_template:
4462 return "DW_TAG_class_template";
4463 case DW_TAG_GNU_BINCL:
4464 return "DW_TAG_GNU_BINCL";
4465 case DW_TAG_GNU_EINCL:
4466 return "DW_TAG_GNU_EINCL";
4468 return "DW_TAG_<unknown>";
4472 /* Convert a DWARF attribute code into its string name. */
4475 dwarf_attr_name (unsigned int attr)
4480 return "DW_AT_sibling";
4481 case DW_AT_location:
4482 return "DW_AT_location";
4484 return "DW_AT_name";
4485 case DW_AT_ordering:
4486 return "DW_AT_ordering";
4487 case DW_AT_subscr_data:
4488 return "DW_AT_subscr_data";
4489 case DW_AT_byte_size:
4490 return "DW_AT_byte_size";
4491 case DW_AT_bit_offset:
4492 return "DW_AT_bit_offset";
4493 case DW_AT_bit_size:
4494 return "DW_AT_bit_size";
4495 case DW_AT_element_list:
4496 return "DW_AT_element_list";
4497 case DW_AT_stmt_list:
4498 return "DW_AT_stmt_list";
4500 return "DW_AT_low_pc";
4502 return "DW_AT_high_pc";
4503 case DW_AT_language:
4504 return "DW_AT_language";
4506 return "DW_AT_member";
4508 return "DW_AT_discr";
4509 case DW_AT_discr_value:
4510 return "DW_AT_discr_value";
4511 case DW_AT_visibility:
4512 return "DW_AT_visibility";
4514 return "DW_AT_import";
4515 case DW_AT_string_length:
4516 return "DW_AT_string_length";
4517 case DW_AT_common_reference:
4518 return "DW_AT_common_reference";
4519 case DW_AT_comp_dir:
4520 return "DW_AT_comp_dir";
4521 case DW_AT_const_value:
4522 return "DW_AT_const_value";
4523 case DW_AT_containing_type:
4524 return "DW_AT_containing_type";
4525 case DW_AT_default_value:
4526 return "DW_AT_default_value";
4528 return "DW_AT_inline";
4529 case DW_AT_is_optional:
4530 return "DW_AT_is_optional";
4531 case DW_AT_lower_bound:
4532 return "DW_AT_lower_bound";
4533 case DW_AT_producer:
4534 return "DW_AT_producer";
4535 case DW_AT_prototyped:
4536 return "DW_AT_prototyped";
4537 case DW_AT_return_addr:
4538 return "DW_AT_return_addr";
4539 case DW_AT_start_scope:
4540 return "DW_AT_start_scope";
4541 case DW_AT_stride_size:
4542 return "DW_AT_stride_size";
4543 case DW_AT_upper_bound:
4544 return "DW_AT_upper_bound";
4545 case DW_AT_abstract_origin:
4546 return "DW_AT_abstract_origin";
4547 case DW_AT_accessibility:
4548 return "DW_AT_accessibility";
4549 case DW_AT_address_class:
4550 return "DW_AT_address_class";
4551 case DW_AT_artificial:
4552 return "DW_AT_artificial";
4553 case DW_AT_base_types:
4554 return "DW_AT_base_types";
4555 case DW_AT_calling_convention:
4556 return "DW_AT_calling_convention";
4558 return "DW_AT_count";
4559 case DW_AT_data_member_location:
4560 return "DW_AT_data_member_location";
4561 case DW_AT_decl_column:
4562 return "DW_AT_decl_column";
4563 case DW_AT_decl_file:
4564 return "DW_AT_decl_file";
4565 case DW_AT_decl_line:
4566 return "DW_AT_decl_line";
4567 case DW_AT_declaration:
4568 return "DW_AT_declaration";
4569 case DW_AT_discr_list:
4570 return "DW_AT_discr_list";
4571 case DW_AT_encoding:
4572 return "DW_AT_encoding";
4573 case DW_AT_external:
4574 return "DW_AT_external";
4575 case DW_AT_frame_base:
4576 return "DW_AT_frame_base";
4578 return "DW_AT_friend";
4579 case DW_AT_identifier_case:
4580 return "DW_AT_identifier_case";
4581 case DW_AT_macro_info:
4582 return "DW_AT_macro_info";
4583 case DW_AT_namelist_items:
4584 return "DW_AT_namelist_items";
4585 case DW_AT_priority:
4586 return "DW_AT_priority";
4588 return "DW_AT_segment";
4589 case DW_AT_specification:
4590 return "DW_AT_specification";
4591 case DW_AT_static_link:
4592 return "DW_AT_static_link";
4594 return "DW_AT_type";
4595 case DW_AT_use_location:
4596 return "DW_AT_use_location";
4597 case DW_AT_variable_parameter:
4598 return "DW_AT_variable_parameter";
4599 case DW_AT_virtuality:
4600 return "DW_AT_virtuality";
4601 case DW_AT_vtable_elem_location:
4602 return "DW_AT_vtable_elem_location";
4604 case DW_AT_allocated:
4605 return "DW_AT_allocated";
4606 case DW_AT_associated:
4607 return "DW_AT_associated";
4608 case DW_AT_data_location:
4609 return "DW_AT_data_location";
4611 return "DW_AT_stride";
4612 case DW_AT_entry_pc:
4613 return "DW_AT_entry_pc";
4614 case DW_AT_use_UTF8:
4615 return "DW_AT_use_UTF8";
4616 case DW_AT_extension:
4617 return "DW_AT_extension";
4619 return "DW_AT_ranges";
4620 case DW_AT_trampoline:
4621 return "DW_AT_trampoline";
4622 case DW_AT_call_column:
4623 return "DW_AT_call_column";
4624 case DW_AT_call_file:
4625 return "DW_AT_call_file";
4626 case DW_AT_call_line:
4627 return "DW_AT_call_line";
4629 case DW_AT_MIPS_fde:
4630 return "DW_AT_MIPS_fde";
4631 case DW_AT_MIPS_loop_begin:
4632 return "DW_AT_MIPS_loop_begin";
4633 case DW_AT_MIPS_tail_loop_begin:
4634 return "DW_AT_MIPS_tail_loop_begin";
4635 case DW_AT_MIPS_epilog_begin:
4636 return "DW_AT_MIPS_epilog_begin";
4637 case DW_AT_MIPS_loop_unroll_factor:
4638 return "DW_AT_MIPS_loop_unroll_factor";
4639 case DW_AT_MIPS_software_pipeline_depth:
4640 return "DW_AT_MIPS_software_pipeline_depth";
4641 case DW_AT_MIPS_linkage_name:
4642 return "DW_AT_MIPS_linkage_name";
4643 case DW_AT_MIPS_stride:
4644 return "DW_AT_MIPS_stride";
4645 case DW_AT_MIPS_abstract_name:
4646 return "DW_AT_MIPS_abstract_name";
4647 case DW_AT_MIPS_clone_origin:
4648 return "DW_AT_MIPS_clone_origin";
4649 case DW_AT_MIPS_has_inlines:
4650 return "DW_AT_MIPS_has_inlines";
4652 case DW_AT_sf_names:
4653 return "DW_AT_sf_names";
4654 case DW_AT_src_info:
4655 return "DW_AT_src_info";
4656 case DW_AT_mac_info:
4657 return "DW_AT_mac_info";
4658 case DW_AT_src_coords:
4659 return "DW_AT_src_coords";
4660 case DW_AT_body_begin:
4661 return "DW_AT_body_begin";
4662 case DW_AT_body_end:
4663 return "DW_AT_body_end";
4664 case DW_AT_GNU_vector:
4665 return "DW_AT_GNU_vector";
4667 case DW_AT_VMS_rtnbeg_pd_address:
4668 return "DW_AT_VMS_rtnbeg_pd_address";
4671 return "DW_AT_<unknown>";
4675 /* Convert a DWARF value form code into its string name. */
4678 dwarf_form_name (unsigned int form)
4683 return "DW_FORM_addr";
4684 case DW_FORM_block2:
4685 return "DW_FORM_block2";
4686 case DW_FORM_block4:
4687 return "DW_FORM_block4";
4689 return "DW_FORM_data2";
4691 return "DW_FORM_data4";
4693 return "DW_FORM_data8";
4694 case DW_FORM_string:
4695 return "DW_FORM_string";
4697 return "DW_FORM_block";
4698 case DW_FORM_block1:
4699 return "DW_FORM_block1";
4701 return "DW_FORM_data1";
4703 return "DW_FORM_flag";
4705 return "DW_FORM_sdata";
4707 return "DW_FORM_strp";
4709 return "DW_FORM_udata";
4710 case DW_FORM_ref_addr:
4711 return "DW_FORM_ref_addr";
4713 return "DW_FORM_ref1";
4715 return "DW_FORM_ref2";
4717 return "DW_FORM_ref4";
4719 return "DW_FORM_ref8";
4720 case DW_FORM_ref_udata:
4721 return "DW_FORM_ref_udata";
4722 case DW_FORM_indirect:
4723 return "DW_FORM_indirect";
4725 return "DW_FORM_<unknown>";
4729 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4730 instance of an inlined instance of a decl which is local to an inline
4731 function, so we have to trace all of the way back through the origin chain
4732 to find out what sort of node actually served as the original seed for the
4736 decl_ultimate_origin (tree decl)
4738 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4741 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4742 nodes in the function to point to themselves; ignore that if
4743 we're trying to output the abstract instance of this function. */
4744 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4747 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4748 most distant ancestor, this should never happen. */
4749 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4751 return DECL_ABSTRACT_ORIGIN (decl);
4754 /* Determine the "ultimate origin" of a block. The block may be an inlined
4755 instance of an inlined instance of a block which is local to an inline
4756 function, so we have to trace all of the way back through the origin chain
4757 to find out what sort of node actually served as the original seed for the
4761 block_ultimate_origin (tree block)
4763 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4765 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4766 nodes in the function to point to themselves; ignore that if
4767 we're trying to output the abstract instance of this function. */
4768 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4771 if (immediate_origin == NULL_TREE)
4776 tree lookahead = immediate_origin;
4780 ret_val = lookahead;
4781 lookahead = (TREE_CODE (ret_val) == BLOCK
4782 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4784 while (lookahead != NULL && lookahead != ret_val);
4786 /* The block's abstract origin chain may not be the *ultimate* origin of
4787 the block. It could lead to a DECL that has an abstract origin set.
4788 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4789 will give us if it has one). Note that DECL's abstract origins are
4790 supposed to be the most distant ancestor (or so decl_ultimate_origin
4791 claims), so we don't need to loop following the DECL origins. */
4792 if (DECL_P (ret_val))
4793 return DECL_ORIGIN (ret_val);
4799 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4800 of a virtual function may refer to a base class, so we check the 'this'
4804 decl_class_context (tree decl)
4806 tree context = NULL_TREE;
4808 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4809 context = DECL_CONTEXT (decl);
4811 context = TYPE_MAIN_VARIANT
4812 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4814 if (context && !TYPE_P (context))
4815 context = NULL_TREE;
4820 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
4821 addition order, and correct that in reverse_all_dies. */
4824 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4826 if (die != NULL && attr != NULL)
4828 attr->dw_attr_next = die->die_attr;
4829 die->die_attr = attr;
4833 static inline enum dw_val_class
4834 AT_class (dw_attr_ref a)
4836 return a->dw_attr_val.val_class;
4839 /* Add a flag value attribute to a DIE. */
4842 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4844 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4846 attr->dw_attr_next = NULL;
4847 attr->dw_attr = attr_kind;
4848 attr->dw_attr_val.val_class = dw_val_class_flag;
4849 attr->dw_attr_val.v.val_flag = flag;
4850 add_dwarf_attr (die, attr);
4853 static inline unsigned
4854 AT_flag (dw_attr_ref a)
4856 gcc_assert (a && AT_class (a) == dw_val_class_flag);
4857 return a->dw_attr_val.v.val_flag;
4860 /* Add a signed integer attribute value to a DIE. */
4863 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4865 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4867 attr->dw_attr_next = NULL;
4868 attr->dw_attr = attr_kind;
4869 attr->dw_attr_val.val_class = dw_val_class_const;
4870 attr->dw_attr_val.v.val_int = int_val;
4871 add_dwarf_attr (die, attr);
4874 static inline HOST_WIDE_INT
4875 AT_int (dw_attr_ref a)
4877 gcc_assert (a && AT_class (a) == dw_val_class_const);
4878 return a->dw_attr_val.v.val_int;
4881 /* Add an unsigned integer attribute value to a DIE. */
4884 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4885 unsigned HOST_WIDE_INT unsigned_val)
4887 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4889 attr->dw_attr_next = NULL;
4890 attr->dw_attr = attr_kind;
4891 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
4892 attr->dw_attr_val.v.val_unsigned = unsigned_val;
4893 add_dwarf_attr (die, attr);
4896 static inline unsigned HOST_WIDE_INT
4897 AT_unsigned (dw_attr_ref a)
4899 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4900 return a->dw_attr_val.v.val_unsigned;
4903 /* Add an unsigned double integer attribute value to a DIE. */
4906 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4907 long unsigned int val_hi, long unsigned int val_low)
4909 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4911 attr->dw_attr_next = NULL;
4912 attr->dw_attr = attr_kind;
4913 attr->dw_attr_val.val_class = dw_val_class_long_long;
4914 attr->dw_attr_val.v.val_long_long.hi = val_hi;
4915 attr->dw_attr_val.v.val_long_long.low = val_low;
4916 add_dwarf_attr (die, attr);
4919 /* Add a floating point attribute value to a DIE and return it. */
4922 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4923 unsigned int length, unsigned int elt_size, unsigned char *array)
4925 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4927 attr->dw_attr_next = NULL;
4928 attr->dw_attr = attr_kind;
4929 attr->dw_attr_val.val_class = dw_val_class_vec;
4930 attr->dw_attr_val.v.val_vec.length = length;
4931 attr->dw_attr_val.v.val_vec.elt_size = elt_size;
4932 attr->dw_attr_val.v.val_vec.array = array;
4933 add_dwarf_attr (die, attr);
4936 /* Hash and equality functions for debug_str_hash. */
4939 debug_str_do_hash (const void *x)
4941 return htab_hash_string (((const struct indirect_string_node *)x)->str);
4945 debug_str_eq (const void *x1, const void *x2)
4947 return strcmp ((((const struct indirect_string_node *)x1)->str),
4948 (const char *)x2) == 0;
4951 /* Add a string attribute value to a DIE. */
4954 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4956 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4957 struct indirect_string_node *node;
4960 if (! debug_str_hash)
4961 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4962 debug_str_eq, NULL);
4964 slot = htab_find_slot_with_hash (debug_str_hash, str,
4965 htab_hash_string (str), INSERT);
4967 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
4968 node = (struct indirect_string_node *) *slot;
4969 node->str = ggc_strdup (str);
4972 attr->dw_attr_next = NULL;
4973 attr->dw_attr = attr_kind;
4974 attr->dw_attr_val.val_class = dw_val_class_str;
4975 attr->dw_attr_val.v.val_str = node;
4976 add_dwarf_attr (die, attr);
4979 static inline const char *
4980 AT_string (dw_attr_ref a)
4982 gcc_assert (a && AT_class (a) == dw_val_class_str);
4983 return a->dw_attr_val.v.val_str->str;
4986 /* Find out whether a string should be output inline in DIE
4987 or out-of-line in .debug_str section. */
4990 AT_string_form (dw_attr_ref a)
4992 struct indirect_string_node *node;
4996 gcc_assert (a && AT_class (a) == dw_val_class_str);
4998 node = a->dw_attr_val.v.val_str;
5002 len = strlen (node->str) + 1;
5004 /* If the string is shorter or equal to the size of the reference, it is
5005 always better to put it inline. */
5006 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5007 return node->form = DW_FORM_string;
5009 /* If we cannot expect the linker to merge strings in .debug_str
5010 section, only put it into .debug_str if it is worth even in this
5012 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5013 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5014 return node->form = DW_FORM_string;
5016 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5017 ++dw2_string_counter;
5018 node->label = xstrdup (label);
5020 return node->form = DW_FORM_strp;
5023 /* Add a DIE reference attribute value to a DIE. */
5026 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5028 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5030 attr->dw_attr_next = NULL;
5031 attr->dw_attr = attr_kind;
5032 attr->dw_attr_val.val_class = dw_val_class_die_ref;
5033 attr->dw_attr_val.v.val_die_ref.die = targ_die;
5034 attr->dw_attr_val.v.val_die_ref.external = 0;
5035 add_dwarf_attr (die, attr);
5038 /* Add an AT_specification attribute to a DIE, and also make the back
5039 pointer from the specification to the definition. */
5042 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5044 add_AT_die_ref (die, DW_AT_specification, targ_die);
5045 gcc_assert (!targ_die->die_definition);
5046 targ_die->die_definition = die;
5049 static inline dw_die_ref
5050 AT_ref (dw_attr_ref a)
5052 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5053 return a->dw_attr_val.v.val_die_ref.die;
5057 AT_ref_external (dw_attr_ref a)
5059 if (a && AT_class (a) == dw_val_class_die_ref)
5060 return a->dw_attr_val.v.val_die_ref.external;
5066 set_AT_ref_external (dw_attr_ref a, int i)
5068 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5069 a->dw_attr_val.v.val_die_ref.external = i;
5072 /* Add an FDE reference attribute value to a DIE. */
5075 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5077 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5079 attr->dw_attr_next = NULL;
5080 attr->dw_attr = attr_kind;
5081 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
5082 attr->dw_attr_val.v.val_fde_index = targ_fde;
5083 add_dwarf_attr (die, attr);
5086 /* Add a location description attribute value to a DIE. */
5089 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5091 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5093 attr->dw_attr_next = NULL;
5094 attr->dw_attr = attr_kind;
5095 attr->dw_attr_val.val_class = dw_val_class_loc;
5096 attr->dw_attr_val.v.val_loc = loc;
5097 add_dwarf_attr (die, attr);
5100 static inline dw_loc_descr_ref
5101 AT_loc (dw_attr_ref a)
5103 gcc_assert (a && AT_class (a) == dw_val_class_loc);
5104 return a->dw_attr_val.v.val_loc;
5108 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5110 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5112 attr->dw_attr_next = NULL;
5113 attr->dw_attr = attr_kind;
5114 attr->dw_attr_val.val_class = dw_val_class_loc_list;
5115 attr->dw_attr_val.v.val_loc_list = loc_list;
5116 add_dwarf_attr (die, attr);
5117 have_location_lists = true;
5120 static inline dw_loc_list_ref
5121 AT_loc_list (dw_attr_ref a)
5123 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5124 return a->dw_attr_val.v.val_loc_list;
5127 /* Add an address constant attribute value to a DIE. */
5130 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5132 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5134 attr->dw_attr_next = NULL;
5135 attr->dw_attr = attr_kind;
5136 attr->dw_attr_val.val_class = dw_val_class_addr;
5137 attr->dw_attr_val.v.val_addr = addr;
5138 add_dwarf_attr (die, attr);
5142 AT_addr (dw_attr_ref a)
5144 gcc_assert (a && AT_class (a) == dw_val_class_addr);
5145 return a->dw_attr_val.v.val_addr;
5148 /* Add a label identifier attribute value to a DIE. */
5151 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5153 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5155 attr->dw_attr_next = NULL;
5156 attr->dw_attr = attr_kind;
5157 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
5158 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5159 add_dwarf_attr (die, attr);
5162 /* Add a section offset attribute value to a DIE, an offset into the
5163 debug_line section. */
5166 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5169 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5171 attr->dw_attr_next = NULL;
5172 attr->dw_attr = attr_kind;
5173 attr->dw_attr_val.val_class = dw_val_class_lineptr;
5174 attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
5175 add_dwarf_attr (die, attr);
5178 /* Add a section offset attribute value to a DIE, an offset into the
5179 debug_macinfo section. */
5182 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5185 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5187 attr->dw_attr_next = NULL;
5188 attr->dw_attr = attr_kind;
5189 attr->dw_attr_val.val_class = dw_val_class_macptr;
5190 attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
5191 add_dwarf_attr (die, attr);
5194 /* Add an offset attribute value to a DIE. */
5197 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5198 unsigned HOST_WIDE_INT offset)
5200 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5202 attr->dw_attr_next = NULL;
5203 attr->dw_attr = attr_kind;
5204 attr->dw_attr_val.val_class = dw_val_class_offset;
5205 attr->dw_attr_val.v.val_offset = offset;
5206 add_dwarf_attr (die, attr);
5209 /* Add an range_list attribute value to a DIE. */
5212 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5213 long unsigned int offset)
5215 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5217 attr->dw_attr_next = NULL;
5218 attr->dw_attr = attr_kind;
5219 attr->dw_attr_val.val_class = dw_val_class_range_list;
5220 attr->dw_attr_val.v.val_offset = offset;
5221 add_dwarf_attr (die, attr);
5224 static inline const char *
5225 AT_lbl (dw_attr_ref a)
5227 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5228 || AT_class (a) == dw_val_class_lineptr
5229 || AT_class (a) == dw_val_class_macptr));
5230 return a->dw_attr_val.v.val_lbl_id;
5233 /* Get the attribute of type attr_kind. */
5236 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5239 dw_die_ref spec = NULL;
5243 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5244 if (a->dw_attr == attr_kind)
5246 else if (a->dw_attr == DW_AT_specification
5247 || a->dw_attr == DW_AT_abstract_origin)
5251 return get_AT (spec, attr_kind);
5257 /* Return the "low pc" attribute value, typically associated with a subprogram
5258 DIE. Return null if the "low pc" attribute is either not present, or if it
5259 cannot be represented as an assembler label identifier. */
5261 static inline const char *
5262 get_AT_low_pc (dw_die_ref die)
5264 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5266 return a ? AT_lbl (a) : NULL;
5269 /* Return the "high pc" attribute value, typically associated with a subprogram
5270 DIE. Return null if the "high pc" attribute is either not present, or if it
5271 cannot be represented as an assembler label identifier. */
5273 static inline const char *
5274 get_AT_hi_pc (dw_die_ref die)
5276 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5278 return a ? AT_lbl (a) : NULL;
5281 /* Return the value of the string attribute designated by ATTR_KIND, or
5282 NULL if it is not present. */
5284 static inline const char *
5285 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5287 dw_attr_ref a = get_AT (die, attr_kind);
5289 return a ? AT_string (a) : NULL;
5292 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5293 if it is not present. */
5296 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5298 dw_attr_ref a = get_AT (die, attr_kind);
5300 return a ? AT_flag (a) : 0;
5303 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5304 if it is not present. */
5306 static inline unsigned
5307 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5309 dw_attr_ref a = get_AT (die, attr_kind);
5311 return a ? AT_unsigned (a) : 0;
5314 static inline dw_die_ref
5315 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5317 dw_attr_ref a = get_AT (die, attr_kind);
5319 return a ? AT_ref (a) : NULL;
5322 /* Return TRUE if the language is C or C++. */
5327 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5329 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
5330 || lang == DW_LANG_C99
5331 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
5334 /* Return TRUE if the language is C++. */
5339 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5341 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
5344 /* Return TRUE if the language is Fortran. */
5349 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5351 return (lang == DW_LANG_Fortran77
5352 || lang == DW_LANG_Fortran90
5353 || lang == DW_LANG_Fortran95);
5356 /* Return TRUE if the language is Java. */
5361 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5363 return lang == DW_LANG_Java;
5366 /* Return TRUE if the language is Ada. */
5371 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5373 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5376 /* Free up the memory used by A. */
5378 static inline void free_AT (dw_attr_ref);
5380 free_AT (dw_attr_ref a)
5382 if (AT_class (a) == dw_val_class_str)
5383 if (a->dw_attr_val.v.val_str->refcount)
5384 a->dw_attr_val.v.val_str->refcount--;
5387 /* Remove the specified attribute if present. */
5390 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5393 dw_attr_ref removed = NULL;
5397 for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5398 if ((*p)->dw_attr == attr_kind)
5401 *p = (*p)->dw_attr_next;
5410 /* Remove child die whose die_tag is specified tag. */
5413 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5415 dw_die_ref current, prev, next;
5416 current = die->die_child;
5418 while (current != NULL)
5420 if (current->die_tag == tag)
5422 next = current->die_sib;
5424 die->die_child = next;
5426 prev->die_sib = next;
5433 current = current->die_sib;
5438 /* Free up the memory used by DIE. */
5441 free_die (dw_die_ref die)
5443 remove_children (die);
5446 /* Discard the children of this DIE. */
5449 remove_children (dw_die_ref die)
5451 dw_die_ref child_die = die->die_child;
5453 die->die_child = NULL;
5455 while (child_die != NULL)
5457 dw_die_ref tmp_die = child_die;
5460 child_die = child_die->die_sib;
5462 for (a = tmp_die->die_attr; a != NULL;)
5464 dw_attr_ref tmp_a = a;
5466 a = a->dw_attr_next;
5474 /* Add a child DIE below its parent. We build the lists up in reverse
5475 addition order, and correct that in reverse_all_dies. */
5478 add_child_die (dw_die_ref die, dw_die_ref child_die)
5480 if (die != NULL && child_die != NULL)
5482 gcc_assert (die != child_die);
5484 child_die->die_parent = die;
5485 child_die->die_sib = die->die_child;
5486 die->die_child = child_die;
5490 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5491 is the specification, to the front of PARENT's list of children. */
5494 splice_child_die (dw_die_ref parent, dw_die_ref child)
5498 /* We want the declaration DIE from inside the class, not the
5499 specification DIE at toplevel. */
5500 if (child->die_parent != parent)
5502 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5508 gcc_assert (child->die_parent == parent
5509 || (child->die_parent
5510 == get_AT_ref (parent, DW_AT_specification)));
5512 for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5515 *p = child->die_sib;
5519 child->die_parent = parent;
5520 child->die_sib = parent->die_child;
5521 parent->die_child = child;
5524 /* Return a pointer to a newly created DIE node. */
5526 static inline dw_die_ref
5527 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5529 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5531 die->die_tag = tag_value;
5533 if (parent_die != NULL)
5534 add_child_die (parent_die, die);
5537 limbo_die_node *limbo_node;
5539 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5540 limbo_node->die = die;
5541 limbo_node->created_for = t;
5542 limbo_node->next = limbo_die_list;
5543 limbo_die_list = limbo_node;
5549 /* Return the DIE associated with the given type specifier. */
5551 static inline dw_die_ref
5552 lookup_type_die (tree type)
5554 return TYPE_SYMTAB_DIE (type);
5557 /* Equate a DIE to a given type specifier. */
5560 equate_type_number_to_die (tree type, dw_die_ref type_die)
5562 TYPE_SYMTAB_DIE (type) = type_die;
5565 /* Returns a hash value for X (which really is a die_struct). */
5568 decl_die_table_hash (const void *x)
5570 return (hashval_t) ((const dw_die_ref) x)->decl_id;
5573 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5576 decl_die_table_eq (const void *x, const void *y)
5578 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5581 /* Return the DIE associated with a given declaration. */
5583 static inline dw_die_ref
5584 lookup_decl_die (tree decl)
5586 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5589 /* Returns a hash value for X (which really is a var_loc_list). */
5592 decl_loc_table_hash (const void *x)
5594 return (hashval_t) ((const var_loc_list *) x)->decl_id;
5597 /* Return nonzero if decl_id of var_loc_list X is the same as
5601 decl_loc_table_eq (const void *x, const void *y)
5603 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5606 /* Return the var_loc list associated with a given declaration. */
5608 static inline var_loc_list *
5609 lookup_decl_loc (tree decl)
5611 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5614 /* Equate a DIE to a particular declaration. */
5617 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5619 unsigned int decl_id = DECL_UID (decl);
5622 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5624 decl_die->decl_id = decl_id;
5627 /* Add a variable location node to the linked list for DECL. */
5630 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5632 unsigned int decl_id = DECL_UID (decl);
5636 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5639 temp = ggc_alloc_cleared (sizeof (var_loc_list));
5640 temp->decl_id = decl_id;
5648 /* If the current location is the same as the end of the list,
5649 we have nothing to do. */
5650 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5651 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5653 /* Add LOC to the end of list and update LAST. */
5654 temp->last->next = loc;
5658 /* Do not add empty location to the beginning of the list. */
5659 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5666 /* Keep track of the number of spaces used to indent the
5667 output of the debugging routines that print the structure of
5668 the DIE internal representation. */
5669 static int print_indent;
5671 /* Indent the line the number of spaces given by print_indent. */
5674 print_spaces (FILE *outfile)
5676 fprintf (outfile, "%*s", print_indent, "");
5679 /* Print the information associated with a given DIE, and its children.
5680 This routine is a debugging aid only. */
5683 print_die (dw_die_ref die, FILE *outfile)
5688 print_spaces (outfile);
5689 fprintf (outfile, "DIE %4lu: %s\n",
5690 die->die_offset, dwarf_tag_name (die->die_tag));
5691 print_spaces (outfile);
5692 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5693 fprintf (outfile, " offset: %lu\n", die->die_offset);
5695 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5697 print_spaces (outfile);
5698 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5700 switch (AT_class (a))
5702 case dw_val_class_addr:
5703 fprintf (outfile, "address");
5705 case dw_val_class_offset:
5706 fprintf (outfile, "offset");
5708 case dw_val_class_loc:
5709 fprintf (outfile, "location descriptor");
5711 case dw_val_class_loc_list:
5712 fprintf (outfile, "location list -> label:%s",
5713 AT_loc_list (a)->ll_symbol);
5715 case dw_val_class_range_list:
5716 fprintf (outfile, "range list");
5718 case dw_val_class_const:
5719 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5721 case dw_val_class_unsigned_const:
5722 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5724 case dw_val_class_long_long:
5725 fprintf (outfile, "constant (%lu,%lu)",
5726 a->dw_attr_val.v.val_long_long.hi,
5727 a->dw_attr_val.v.val_long_long.low);
5729 case dw_val_class_vec:
5730 fprintf (outfile, "floating-point or vector constant");
5732 case dw_val_class_flag:
5733 fprintf (outfile, "%u", AT_flag (a));
5735 case dw_val_class_die_ref:
5736 if (AT_ref (a) != NULL)
5738 if (AT_ref (a)->die_symbol)
5739 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5741 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5744 fprintf (outfile, "die -> <null>");
5746 case dw_val_class_lbl_id:
5747 case dw_val_class_lineptr:
5748 case dw_val_class_macptr:
5749 fprintf (outfile, "label: %s", AT_lbl (a));
5751 case dw_val_class_str:
5752 if (AT_string (a) != NULL)
5753 fprintf (outfile, "\"%s\"", AT_string (a));
5755 fprintf (outfile, "<null>");
5761 fprintf (outfile, "\n");
5764 if (die->die_child != NULL)
5767 for (c = die->die_child; c != NULL; c = c->die_sib)
5768 print_die (c, outfile);
5772 if (print_indent == 0)
5773 fprintf (outfile, "\n");
5776 /* Print the contents of the source code line number correspondence table.
5777 This routine is a debugging aid only. */
5780 print_dwarf_line_table (FILE *outfile)
5783 dw_line_info_ref line_info;
5785 fprintf (outfile, "\n\nDWARF source line information\n");
5786 for (i = 1; i < line_info_table_in_use; i++)
5788 line_info = &line_info_table[i];
5789 fprintf (outfile, "%5d: ", i);
5790 fprintf (outfile, "%-20s",
5791 VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5792 fprintf (outfile, "%6ld", line_info->dw_line_num);
5793 fprintf (outfile, "\n");
5796 fprintf (outfile, "\n\n");
5799 /* Print the information collected for a given DIE. */
5802 debug_dwarf_die (dw_die_ref die)
5804 print_die (die, stderr);
5807 /* Print all DWARF information collected for the compilation unit.
5808 This routine is a debugging aid only. */
5814 print_die (comp_unit_die, stderr);
5815 if (! DWARF2_ASM_LINE_DEBUG_INFO)
5816 print_dwarf_line_table (stderr);
5819 /* We build up the lists of children and attributes by pushing new ones
5820 onto the beginning of the list. Reverse the lists for DIE so that
5821 they are in order of addition. */
5824 reverse_die_lists (dw_die_ref die)
5826 dw_die_ref c, cp, cn;
5827 dw_attr_ref a, ap, an;
5829 for (a = die->die_attr, ap = 0; a; a = an)
5831 an = a->dw_attr_next;
5832 a->dw_attr_next = ap;
5838 for (c = die->die_child, cp = 0; c; c = cn)
5845 die->die_child = cp;
5848 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5849 reverse all dies in add_sibling_attributes, which runs through all the dies,
5850 it would reverse all the dies. Now, however, since we don't call
5851 reverse_die_lists in add_sibling_attributes, we need a routine to
5852 recursively reverse all the dies. This is that routine. */
5855 reverse_all_dies (dw_die_ref die)
5859 reverse_die_lists (die);
5861 for (c = die->die_child; c; c = c->die_sib)
5862 reverse_all_dies (c);
5865 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5866 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5867 DIE that marks the start of the DIEs for this include file. */
5870 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5872 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5873 dw_die_ref new_unit = gen_compile_unit_die (filename);
5875 new_unit->die_sib = old_unit;
5879 /* Close an include-file CU and reopen the enclosing one. */
5882 pop_compile_unit (dw_die_ref old_unit)
5884 dw_die_ref new_unit = old_unit->die_sib;
5886 old_unit->die_sib = NULL;
5890 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5891 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5893 /* Calculate the checksum of a location expression. */
5896 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5898 CHECKSUM (loc->dw_loc_opc);
5899 CHECKSUM (loc->dw_loc_oprnd1);
5900 CHECKSUM (loc->dw_loc_oprnd2);
5903 /* Calculate the checksum of an attribute. */
5906 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5908 dw_loc_descr_ref loc;
5911 CHECKSUM (at->dw_attr);
5913 /* We don't care about differences in file numbering. */
5914 if (at->dw_attr == DW_AT_decl_file
5915 /* Or that this was compiled with a different compiler snapshot; if
5916 the output is the same, that's what matters. */
5917 || at->dw_attr == DW_AT_producer)
5920 switch (AT_class (at))
5922 case dw_val_class_const:
5923 CHECKSUM (at->dw_attr_val.v.val_int);
5925 case dw_val_class_unsigned_const:
5926 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5928 case dw_val_class_long_long:
5929 CHECKSUM (at->dw_attr_val.v.val_long_long);
5931 case dw_val_class_vec:
5932 CHECKSUM (at->dw_attr_val.v.val_vec);
5934 case dw_val_class_flag:
5935 CHECKSUM (at->dw_attr_val.v.val_flag);
5937 case dw_val_class_str:
5938 CHECKSUM_STRING (AT_string (at));
5941 case dw_val_class_addr:
5943 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5944 CHECKSUM_STRING (XSTR (r, 0));
5947 case dw_val_class_offset:
5948 CHECKSUM (at->dw_attr_val.v.val_offset);
5951 case dw_val_class_loc:
5952 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5953 loc_checksum (loc, ctx);
5956 case dw_val_class_die_ref:
5957 die_checksum (AT_ref (at), ctx, mark);
5960 case dw_val_class_fde_ref:
5961 case dw_val_class_lbl_id:
5962 case dw_val_class_lineptr:
5963 case dw_val_class_macptr:
5971 /* Calculate the checksum of a DIE. */
5974 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5979 /* To avoid infinite recursion. */
5982 CHECKSUM (die->die_mark);
5985 die->die_mark = ++(*mark);
5987 CHECKSUM (die->die_tag);
5989 for (a = die->die_attr; a; a = a->dw_attr_next)
5990 attr_checksum (a, ctx, mark);
5992 for (c = die->die_child; c; c = c->die_sib)
5993 die_checksum (c, ctx, mark);
5997 #undef CHECKSUM_STRING
5999 /* Do the location expressions look same? */
6001 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6003 return loc1->dw_loc_opc == loc2->dw_loc_opc
6004 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6005 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6008 /* Do the values look the same? */
6010 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
6012 dw_loc_descr_ref loc1, loc2;
6015 if (v1->val_class != v2->val_class)
6018 switch (v1->val_class)
6020 case dw_val_class_const:
6021 return v1->v.val_int == v2->v.val_int;
6022 case dw_val_class_unsigned_const:
6023 return v1->v.val_unsigned == v2->v.val_unsigned;
6024 case dw_val_class_long_long:
6025 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6026 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6027 case dw_val_class_vec:
6028 if (v1->v.val_vec.length != v2->v.val_vec.length
6029 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6031 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6032 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6035 case dw_val_class_flag:
6036 return v1->v.val_flag == v2->v.val_flag;
6037 case dw_val_class_str:
6038 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6040 case dw_val_class_addr:
6041 r1 = v1->v.val_addr;
6042 r2 = v2->v.val_addr;
6043 if (GET_CODE (r1) != GET_CODE (r2))
6045 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6046 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6048 case dw_val_class_offset:
6049 return v1->v.val_offset == v2->v.val_offset;
6051 case dw_val_class_loc:
6052 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6054 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6055 if (!same_loc_p (loc1, loc2, mark))
6057 return !loc1 && !loc2;
6059 case dw_val_class_die_ref:
6060 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6062 case dw_val_class_fde_ref:
6063 case dw_val_class_lbl_id:
6064 case dw_val_class_lineptr:
6065 case dw_val_class_macptr:
6073 /* Do the attributes look the same? */
6076 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6078 if (at1->dw_attr != at2->dw_attr)
6081 /* We don't care about differences in file numbering. */
6082 if (at1->dw_attr == DW_AT_decl_file
6083 /* Or that this was compiled with a different compiler snapshot; if
6084 the output is the same, that's what matters. */
6085 || at1->dw_attr == DW_AT_producer)
6088 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6091 /* Do the dies look the same? */
6094 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6099 /* To avoid infinite recursion. */
6101 return die1->die_mark == die2->die_mark;
6102 die1->die_mark = die2->die_mark = ++(*mark);
6104 if (die1->die_tag != die2->die_tag)
6107 for (a1 = die1->die_attr, a2 = die2->die_attr;
6109 a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
6110 if (!same_attr_p (a1, a2, mark))
6115 for (c1 = die1->die_child, c2 = die2->die_child;
6117 c1 = c1->die_sib, c2 = c2->die_sib)
6118 if (!same_die_p (c1, c2, mark))
6126 /* Do the dies look the same? Wrapper around same_die_p. */
6129 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6132 int ret = same_die_p (die1, die2, &mark);
6134 unmark_all_dies (die1);
6135 unmark_all_dies (die2);
6140 /* The prefix to attach to symbols on DIEs in the current comdat debug
6142 static char *comdat_symbol_id;
6144 /* The index of the current symbol within the current comdat CU. */
6145 static unsigned int comdat_symbol_number;
6147 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6148 children, and set comdat_symbol_id accordingly. */
6151 compute_section_prefix (dw_die_ref unit_die)
6153 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6154 const char *base = die_name ? lbasename (die_name) : "anonymous";
6155 char *name = alloca (strlen (base) + 64);
6158 unsigned char checksum[16];
6161 /* Compute the checksum of the DIE, then append part of it as hex digits to
6162 the name filename of the unit. */
6164 md5_init_ctx (&ctx);
6166 die_checksum (unit_die, &ctx, &mark);
6167 unmark_all_dies (unit_die);
6168 md5_finish_ctx (&ctx, checksum);
6170 sprintf (name, "%s.", base);
6171 clean_symbol_name (name);
6173 p = name + strlen (name);
6174 for (i = 0; i < 4; i++)
6176 sprintf (p, "%.2x", checksum[i]);
6180 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6181 comdat_symbol_number = 0;
6184 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6187 is_type_die (dw_die_ref die)
6189 switch (die->die_tag)
6191 case DW_TAG_array_type:
6192 case DW_TAG_class_type:
6193 case DW_TAG_enumeration_type:
6194 case DW_TAG_pointer_type:
6195 case DW_TAG_reference_type:
6196 case DW_TAG_string_type:
6197 case DW_TAG_structure_type:
6198 case DW_TAG_subroutine_type:
6199 case DW_TAG_union_type:
6200 case DW_TAG_ptr_to_member_type:
6201 case DW_TAG_set_type:
6202 case DW_TAG_subrange_type:
6203 case DW_TAG_base_type:
6204 case DW_TAG_const_type:
6205 case DW_TAG_file_type:
6206 case DW_TAG_packed_type:
6207 case DW_TAG_volatile_type:
6208 case DW_TAG_typedef:
6215 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6216 Basically, we want to choose the bits that are likely to be shared between
6217 compilations (types) and leave out the bits that are specific to individual
6218 compilations (functions). */
6221 is_comdat_die (dw_die_ref c)
6223 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6224 we do for stabs. The advantage is a greater likelihood of sharing between
6225 objects that don't include headers in the same order (and therefore would
6226 put the base types in a different comdat). jason 8/28/00 */
6228 if (c->die_tag == DW_TAG_base_type)
6231 if (c->die_tag == DW_TAG_pointer_type
6232 || c->die_tag == DW_TAG_reference_type
6233 || c->die_tag == DW_TAG_const_type
6234 || c->die_tag == DW_TAG_volatile_type)
6236 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6238 return t ? is_comdat_die (t) : 0;
6241 return is_type_die (c);
6244 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6245 compilation unit. */
6248 is_symbol_die (dw_die_ref c)
6250 return (is_type_die (c)
6251 || (get_AT (c, DW_AT_declaration)
6252 && !get_AT (c, DW_AT_specification)));
6256 gen_internal_sym (const char *prefix)
6260 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6261 return xstrdup (buf);
6264 /* Assign symbols to all worthy DIEs under DIE. */
6267 assign_symbol_names (dw_die_ref die)
6271 if (is_symbol_die (die))
6273 if (comdat_symbol_id)
6275 char *p = alloca (strlen (comdat_symbol_id) + 64);
6277 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6278 comdat_symbol_id, comdat_symbol_number++);
6279 die->die_symbol = xstrdup (p);
6282 die->die_symbol = gen_internal_sym ("LDIE");
6285 for (c = die->die_child; c != NULL; c = c->die_sib)
6286 assign_symbol_names (c);
6289 struct cu_hash_table_entry
6292 unsigned min_comdat_num, max_comdat_num;
6293 struct cu_hash_table_entry *next;
6296 /* Routines to manipulate hash table of CUs. */
6298 htab_cu_hash (const void *of)
6300 const struct cu_hash_table_entry *entry = of;
6302 return htab_hash_string (entry->cu->die_symbol);
6306 htab_cu_eq (const void *of1, const void *of2)
6308 const struct cu_hash_table_entry *entry1 = of1;
6309 const struct die_struct *entry2 = of2;
6311 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6315 htab_cu_del (void *what)
6317 struct cu_hash_table_entry *next, *entry = what;
6327 /* Check whether we have already seen this CU and set up SYM_NUM
6330 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6332 struct cu_hash_table_entry dummy;
6333 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6335 dummy.max_comdat_num = 0;
6337 slot = (struct cu_hash_table_entry **)
6338 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6342 for (; entry; last = entry, entry = entry->next)
6344 if (same_die_p_wrap (cu, entry->cu))
6350 *sym_num = entry->min_comdat_num;
6354 entry = XCNEW (struct cu_hash_table_entry);
6356 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6357 entry->next = *slot;
6363 /* Record SYM_NUM to record of CU in HTABLE. */
6365 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6367 struct cu_hash_table_entry **slot, *entry;
6369 slot = (struct cu_hash_table_entry **)
6370 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6374 entry->max_comdat_num = sym_num;
6377 /* Traverse the DIE (which is always comp_unit_die), and set up
6378 additional compilation units for each of the include files we see
6379 bracketed by BINCL/EINCL. */
6382 break_out_includes (dw_die_ref die)
6385 dw_die_ref unit = NULL;
6386 limbo_die_node *node, **pnode;
6387 htab_t cu_hash_table;
6389 for (ptr = &(die->die_child); *ptr;)
6391 dw_die_ref c = *ptr;
6393 if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6394 || (unit && is_comdat_die (c)))
6396 /* This DIE is for a secondary CU; remove it from the main one. */
6399 if (c->die_tag == DW_TAG_GNU_BINCL)
6401 unit = push_new_compile_unit (unit, c);
6404 else if (c->die_tag == DW_TAG_GNU_EINCL)
6406 unit = pop_compile_unit (unit);
6410 add_child_die (unit, c);
6414 /* Leave this DIE in the main CU. */
6415 ptr = &(c->die_sib);
6421 /* We can only use this in debugging, since the frontend doesn't check
6422 to make sure that we leave every include file we enter. */
6426 assign_symbol_names (die);
6427 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6428 for (node = limbo_die_list, pnode = &limbo_die_list;
6434 compute_section_prefix (node->die);
6435 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6436 &comdat_symbol_number);
6437 assign_symbol_names (node->die);
6439 *pnode = node->next;
6442 pnode = &node->next;
6443 record_comdat_symbol_number (node->die, cu_hash_table,
6444 comdat_symbol_number);
6447 htab_delete (cu_hash_table);
6450 /* Traverse the DIE and add a sibling attribute if it may have the
6451 effect of speeding up access to siblings. To save some space,
6452 avoid generating sibling attributes for DIE's without children. */
6455 add_sibling_attributes (dw_die_ref die)
6459 if (die->die_tag != DW_TAG_compile_unit
6460 && die->die_sib && die->die_child != NULL)
6461 /* Add the sibling link to the front of the attribute list. */
6462 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6464 for (c = die->die_child; c != NULL; c = c->die_sib)
6465 add_sibling_attributes (c);
6468 /* Output all location lists for the DIE and its children. */
6471 output_location_lists (dw_die_ref die)
6476 for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6477 if (AT_class (d_attr) == dw_val_class_loc_list)
6478 output_loc_list (AT_loc_list (d_attr));
6480 for (c = die->die_child; c != NULL; c = c->die_sib)
6481 output_location_lists (c);
6485 /* The format of each DIE (and its attribute value pairs) is encoded in an
6486 abbreviation table. This routine builds the abbreviation table and assigns
6487 a unique abbreviation id for each abbreviation entry. The children of each
6488 die are visited recursively. */
6491 build_abbrev_table (dw_die_ref die)
6493 unsigned long abbrev_id;
6494 unsigned int n_alloc;
6496 dw_attr_ref d_attr, a_attr;
6498 /* Scan the DIE references, and mark as external any that refer to
6499 DIEs from other CUs (i.e. those which are not marked). */
6500 for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6501 if (AT_class (d_attr) == dw_val_class_die_ref
6502 && AT_ref (d_attr)->die_mark == 0)
6504 gcc_assert (AT_ref (d_attr)->die_symbol);
6506 set_AT_ref_external (d_attr, 1);
6509 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6511 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6513 if (abbrev->die_tag == die->die_tag)
6515 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6517 a_attr = abbrev->die_attr;
6518 d_attr = die->die_attr;
6520 while (a_attr != NULL && d_attr != NULL)
6522 if ((a_attr->dw_attr != d_attr->dw_attr)
6523 || (value_format (a_attr) != value_format (d_attr)))
6526 a_attr = a_attr->dw_attr_next;
6527 d_attr = d_attr->dw_attr_next;
6530 if (a_attr == NULL && d_attr == NULL)
6536 if (abbrev_id >= abbrev_die_table_in_use)
6538 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6540 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6541 abbrev_die_table = ggc_realloc (abbrev_die_table,
6542 sizeof (dw_die_ref) * n_alloc);
6544 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6545 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6546 abbrev_die_table_allocated = n_alloc;
6549 ++abbrev_die_table_in_use;
6550 abbrev_die_table[abbrev_id] = die;
6553 die->die_abbrev = abbrev_id;
6554 for (c = die->die_child; c != NULL; c = c->die_sib)
6555 build_abbrev_table (c);
6558 /* Return the power-of-two number of bytes necessary to represent VALUE. */
6561 constant_size (long unsigned int value)
6568 log = floor_log2 (value);
6571 log = 1 << (floor_log2 (log) + 1);
6576 /* Return the size of a DIE as it is represented in the
6577 .debug_info section. */
6579 static unsigned long
6580 size_of_die (dw_die_ref die)
6582 unsigned long size = 0;
6585 size += size_of_uleb128 (die->die_abbrev);
6586 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6588 switch (AT_class (a))
6590 case dw_val_class_addr:
6591 size += DWARF2_ADDR_SIZE;
6593 case dw_val_class_offset:
6594 size += DWARF_OFFSET_SIZE;
6596 case dw_val_class_loc:
6598 unsigned long lsize = size_of_locs (AT_loc (a));
6601 size += constant_size (lsize);
6605 case dw_val_class_loc_list:
6606 size += DWARF_OFFSET_SIZE;
6608 case dw_val_class_range_list:
6609 size += DWARF_OFFSET_SIZE;
6611 case dw_val_class_const:
6612 size += size_of_sleb128 (AT_int (a));
6614 case dw_val_class_unsigned_const:
6615 size += constant_size (AT_unsigned (a));
6617 case dw_val_class_long_long:
6618 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6620 case dw_val_class_vec:
6621 size += 1 + (a->dw_attr_val.v.val_vec.length
6622 * a->dw_attr_val.v.val_vec.elt_size); /* block */
6624 case dw_val_class_flag:
6627 case dw_val_class_die_ref:
6628 if (AT_ref_external (a))
6629 size += DWARF2_ADDR_SIZE;
6631 size += DWARF_OFFSET_SIZE;
6633 case dw_val_class_fde_ref:
6634 size += DWARF_OFFSET_SIZE;
6636 case dw_val_class_lbl_id:
6637 size += DWARF2_ADDR_SIZE;
6639 case dw_val_class_lineptr:
6640 case dw_val_class_macptr:
6641 size += DWARF_OFFSET_SIZE;
6643 case dw_val_class_str:
6644 if (AT_string_form (a) == DW_FORM_strp)
6645 size += DWARF_OFFSET_SIZE;
6647 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6657 /* Size the debugging information associated with a given DIE. Visits the
6658 DIE's children recursively. Updates the global variable next_die_offset, on
6659 each time through. Uses the current value of next_die_offset to update the
6660 die_offset field in each DIE. */
6663 calc_die_sizes (dw_die_ref die)
6667 die->die_offset = next_die_offset;
6668 next_die_offset += size_of_die (die);
6670 for (c = die->die_child; c != NULL; c = c->die_sib)
6673 if (die->die_child != NULL)
6674 /* Count the null byte used to terminate sibling lists. */
6675 next_die_offset += 1;
6678 /* Set the marks for a die and its children. We do this so
6679 that we know whether or not a reference needs to use FORM_ref_addr; only
6680 DIEs in the same CU will be marked. We used to clear out the offset
6681 and use that as the flag, but ran into ordering problems. */
6684 mark_dies (dw_die_ref die)
6688 gcc_assert (!die->die_mark);
6691 for (c = die->die_child; c; c = c->die_sib)
6695 /* Clear the marks for a die and its children. */
6698 unmark_dies (dw_die_ref die)
6702 gcc_assert (die->die_mark);
6705 for (c = die->die_child; c; c = c->die_sib)
6709 /* Clear the marks for a die, its children and referred dies. */
6712 unmark_all_dies (dw_die_ref die)
6721 for (c = die->die_child; c; c = c->die_sib)
6722 unmark_all_dies (c);
6724 for (a = die->die_attr; a; a = a->dw_attr_next)
6725 if (AT_class (a) == dw_val_class_die_ref)
6726 unmark_all_dies (AT_ref (a));
6729 /* Return the size of the .debug_pubnames table generated for the
6730 compilation unit. */
6732 static unsigned long
6733 size_of_pubnames (void)
6738 size = DWARF_PUBNAMES_HEADER_SIZE;
6739 for (i = 0; i < pubname_table_in_use; i++)
6741 pubname_ref p = &pubname_table[i];
6742 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6745 size += DWARF_OFFSET_SIZE;
6749 /* Return the size of the information in the .debug_aranges section. */
6751 static unsigned long
6752 size_of_aranges (void)
6756 size = DWARF_ARANGES_HEADER_SIZE;
6758 /* Count the address/length pair for this compilation unit. */
6759 size += 2 * DWARF2_ADDR_SIZE;
6760 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6762 /* Count the two zero words used to terminated the address range table. */
6763 size += 2 * DWARF2_ADDR_SIZE;
6767 /* Select the encoding of an attribute value. */
6769 static enum dwarf_form
6770 value_format (dw_attr_ref a)
6772 switch (a->dw_attr_val.val_class)
6774 case dw_val_class_addr:
6775 return DW_FORM_addr;
6776 case dw_val_class_range_list:
6777 case dw_val_class_offset:
6778 switch (DWARF_OFFSET_SIZE)
6781 return DW_FORM_data4;
6783 return DW_FORM_data8;
6787 case dw_val_class_loc_list:
6788 /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6789 .debug_loc section */
6790 return DW_FORM_data4;
6791 case dw_val_class_loc:
6792 switch (constant_size (size_of_locs (AT_loc (a))))
6795 return DW_FORM_block1;
6797 return DW_FORM_block2;
6801 case dw_val_class_const:
6802 return DW_FORM_sdata;
6803 case dw_val_class_unsigned_const:
6804 switch (constant_size (AT_unsigned (a)))
6807 return DW_FORM_data1;
6809 return DW_FORM_data2;
6811 return DW_FORM_data4;
6813 return DW_FORM_data8;
6817 case dw_val_class_long_long:
6818 return DW_FORM_block1;
6819 case dw_val_class_vec:
6820 return DW_FORM_block1;
6821 case dw_val_class_flag:
6822 return DW_FORM_flag;
6823 case dw_val_class_die_ref:
6824 if (AT_ref_external (a))
6825 return DW_FORM_ref_addr;
6828 case dw_val_class_fde_ref:
6829 return DW_FORM_data;
6830 case dw_val_class_lbl_id:
6831 return DW_FORM_addr;
6832 case dw_val_class_lineptr:
6833 case dw_val_class_macptr:
6834 return DW_FORM_data;
6835 case dw_val_class_str:
6836 return AT_string_form (a);
6843 /* Output the encoding of an attribute value. */
6846 output_value_format (dw_attr_ref a)
6848 enum dwarf_form form = value_format (a);
6850 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6853 /* Output the .debug_abbrev section which defines the DIE abbreviation
6857 output_abbrev_section (void)
6859 unsigned long abbrev_id;
6863 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6865 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6867 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6868 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6869 dwarf_tag_name (abbrev->die_tag));
6871 if (abbrev->die_child != NULL)
6872 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6874 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6876 for (a_attr = abbrev->die_attr; a_attr != NULL;
6877 a_attr = a_attr->dw_attr_next)
6879 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6880 dwarf_attr_name (a_attr->dw_attr));
6881 output_value_format (a_attr);
6884 dw2_asm_output_data (1, 0, NULL);
6885 dw2_asm_output_data (1, 0, NULL);
6888 /* Terminate the table. */
6889 dw2_asm_output_data (1, 0, NULL);
6892 /* Output a symbol we can use to refer to this DIE from another CU. */
6895 output_die_symbol (dw_die_ref die)
6897 char *sym = die->die_symbol;
6902 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6903 /* We make these global, not weak; if the target doesn't support
6904 .linkonce, it doesn't support combining the sections, so debugging
6906 targetm.asm_out.globalize_label (asm_out_file, sym);
6908 ASM_OUTPUT_LABEL (asm_out_file, sym);
6911 /* Return a new location list, given the begin and end range, and the
6912 expression. gensym tells us whether to generate a new internal symbol for
6913 this location list node, which is done for the head of the list only. */
6915 static inline dw_loc_list_ref
6916 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6917 const char *section, unsigned int gensym)
6919 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6921 retlist->begin = begin;
6923 retlist->expr = expr;
6924 retlist->section = section;
6926 retlist->ll_symbol = gen_internal_sym ("LLST");
6931 /* Add a location description expression to a location list. */
6934 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6935 const char *begin, const char *end,
6936 const char *section)
6940 /* Find the end of the chain. */
6941 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6944 /* Add a new location list node to the list. */
6945 *d = new_loc_list (descr, begin, end, section, 0);
6949 dwarf2out_switch_text_section (void)
6955 fde = &fde_table[fde_table_in_use - 1];
6956 fde->dw_fde_switched_sections = true;
6957 fde->dw_fde_hot_section_label = cfun->hot_section_label;
6958 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
6959 fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
6960 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
6961 have_multiple_function_sections = true;
6964 /* Output the location list given to us. */
6967 output_loc_list (dw_loc_list_ref list_head)
6969 dw_loc_list_ref curr = list_head;
6971 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6973 /* Walk the location list, and output each range + expression. */
6974 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6977 if (!have_multiple_function_sections)
6979 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6980 "Location list begin address (%s)",
6981 list_head->ll_symbol);
6982 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6983 "Location list end address (%s)",
6984 list_head->ll_symbol);
6988 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
6989 "Location list begin address (%s)",
6990 list_head->ll_symbol);
6991 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
6992 "Location list end address (%s)",
6993 list_head->ll_symbol);
6995 size = size_of_locs (curr->expr);
6997 /* Output the block length for this list of location operations. */
6998 gcc_assert (size <= 0xffff);
6999 dw2_asm_output_data (2, size, "%s", "Location expression size");
7001 output_loc_sequence (curr->expr);
7004 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7005 "Location list terminator begin (%s)",
7006 list_head->ll_symbol);
7007 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7008 "Location list terminator end (%s)",
7009 list_head->ll_symbol);
7012 /* Output the DIE and its attributes. Called recursively to generate
7013 the definitions of each child DIE. */
7016 output_die (dw_die_ref die)
7022 /* If someone in another CU might refer to us, set up a symbol for
7023 them to point to. */
7024 if (die->die_symbol)
7025 output_die_symbol (die);
7027 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
7028 die->die_offset, dwarf_tag_name (die->die_tag));
7030 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
7032 const char *name = dwarf_attr_name (a->dw_attr);
7034 switch (AT_class (a))
7036 case dw_val_class_addr:
7037 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7040 case dw_val_class_offset:
7041 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7045 case dw_val_class_range_list:
7047 char *p = strchr (ranges_section_label, '\0');
7049 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7050 a->dw_attr_val.v.val_offset);
7051 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7052 debug_ranges_section, "%s", name);
7057 case dw_val_class_loc:
7058 size = size_of_locs (AT_loc (a));
7060 /* Output the block length for this list of location operations. */
7061 dw2_asm_output_data (constant_size (size), size, "%s", name);
7063 output_loc_sequence (AT_loc (a));
7066 case dw_val_class_const:
7067 /* ??? It would be slightly more efficient to use a scheme like is
7068 used for unsigned constants below, but gdb 4.x does not sign
7069 extend. Gdb 5.x does sign extend. */
7070 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7073 case dw_val_class_unsigned_const:
7074 dw2_asm_output_data (constant_size (AT_unsigned (a)),
7075 AT_unsigned (a), "%s", name);
7078 case dw_val_class_long_long:
7080 unsigned HOST_WIDE_INT first, second;
7082 dw2_asm_output_data (1,
7083 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7086 if (WORDS_BIG_ENDIAN)
7088 first = a->dw_attr_val.v.val_long_long.hi;
7089 second = a->dw_attr_val.v.val_long_long.low;
7093 first = a->dw_attr_val.v.val_long_long.low;
7094 second = a->dw_attr_val.v.val_long_long.hi;
7097 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7098 first, "long long constant");
7099 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7104 case dw_val_class_vec:
7106 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7107 unsigned int len = a->dw_attr_val.v.val_vec.length;
7111 dw2_asm_output_data (1, len * elt_size, "%s", name);
7112 if (elt_size > sizeof (HOST_WIDE_INT))
7117 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7120 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7121 "fp or vector constant word %u", i);
7125 case dw_val_class_flag:
7126 dw2_asm_output_data (1, AT_flag (a), "%s", name);
7129 case dw_val_class_loc_list:
7131 char *sym = AT_loc_list (a)->ll_symbol;
7134 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
7139 case dw_val_class_die_ref:
7140 if (AT_ref_external (a))
7142 char *sym = AT_ref (a)->die_symbol;
7145 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
7150 gcc_assert (AT_ref (a)->die_offset);
7151 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7156 case dw_val_class_fde_ref:
7160 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7161 a->dw_attr_val.v.val_fde_index * 2);
7162 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
7167 case dw_val_class_lbl_id:
7168 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7171 case dw_val_class_lineptr:
7172 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7173 debug_line_section, "%s", name);
7176 case dw_val_class_macptr:
7177 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
7178 debug_macinfo_section, "%s", name);
7181 case dw_val_class_str:
7182 if (AT_string_form (a) == DW_FORM_strp)
7183 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7184 a->dw_attr_val.v.val_str->label,
7186 "%s: \"%s\"", name, AT_string (a));
7188 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7196 for (c = die->die_child; c != NULL; c = c->die_sib)
7199 /* Add null byte to terminate sibling list. */
7200 if (die->die_child != NULL)
7201 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7205 /* Output the compilation unit that appears at the beginning of the
7206 .debug_info section, and precedes the DIE descriptions. */
7209 output_compilation_unit_header (void)
7211 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7212 dw2_asm_output_data (4, 0xffffffff,
7213 "Initial length escape value indicating 64-bit DWARF extension");
7214 dw2_asm_output_data (DWARF_OFFSET_SIZE,
7215 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7216 "Length of Compilation Unit Info");
7217 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7218 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7219 debug_abbrev_section,
7220 "Offset Into Abbrev. Section");
7221 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7224 /* Output the compilation unit DIE and its children. */
7227 output_comp_unit (dw_die_ref die, int output_if_empty)
7229 const char *secname;
7232 /* Unless we are outputting main CU, we may throw away empty ones. */
7233 if (!output_if_empty && die->die_child == NULL)
7236 /* Even if there are no children of this DIE, we must output the information
7237 about the compilation unit. Otherwise, on an empty translation unit, we
7238 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
7239 will then complain when examining the file. First mark all the DIEs in
7240 this CU so we know which get local refs. */
7243 build_abbrev_table (die);
7245 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
7246 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7247 calc_die_sizes (die);
7249 oldsym = die->die_symbol;
7252 tmp = alloca (strlen (oldsym) + 24);
7254 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7256 die->die_symbol = NULL;
7257 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
7260 switch_to_section (debug_info_section);
7262 /* Output debugging information. */
7263 output_compilation_unit_header ();
7266 /* Leave the marks on the main CU, so we can check them in
7271 die->die_symbol = oldsym;
7275 /* The DWARF2 pubname for a nested thingy looks like "A::f". The
7276 output of lang_hooks.decl_printable_name for C++ looks like
7277 "A::f(int)". Let's drop the argument list, and maybe the scope. */
7280 dwarf2_name (tree decl, int scope)
7282 return lang_hooks.decl_printable_name (decl, scope ? 1 : 0);
7285 /* Add a new entry to .debug_pubnames if appropriate. */
7288 add_pubname (tree decl, dw_die_ref die)
7292 if (! TREE_PUBLIC (decl))
7295 if (pubname_table_in_use == pubname_table_allocated)
7297 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7299 = ggc_realloc (pubname_table,
7300 (pubname_table_allocated * sizeof (pubname_entry)));
7301 memset (pubname_table + pubname_table_in_use, 0,
7302 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7305 p = &pubname_table[pubname_table_in_use++];
7307 p->name = xstrdup (dwarf2_name (decl, 1));
7310 /* Output the public names table used to speed up access to externally
7311 visible names. For now, only generate entries for externally
7312 visible procedures. */
7315 output_pubnames (void)
7318 unsigned long pubnames_length = size_of_pubnames ();
7320 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7321 dw2_asm_output_data (4, 0xffffffff,
7322 "Initial length escape value indicating 64-bit DWARF extension");
7323 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7324 "Length of Public Names Info");
7325 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7326 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7328 "Offset of Compilation Unit Info");
7329 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7330 "Compilation Unit Length");
7332 for (i = 0; i < pubname_table_in_use; i++)
7334 pubname_ref pub = &pubname_table[i];
7336 /* We shouldn't see pubnames for DIEs outside of the main CU. */
7337 gcc_assert (pub->die->die_mark);
7339 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7342 dw2_asm_output_nstring (pub->name, -1, "external name");
7345 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7348 /* Add a new entry to .debug_aranges if appropriate. */
7351 add_arange (tree decl, dw_die_ref die)
7353 if (! DECL_SECTION_NAME (decl))
7356 if (arange_table_in_use == arange_table_allocated)
7358 arange_table_allocated += ARANGE_TABLE_INCREMENT;
7359 arange_table = ggc_realloc (arange_table,
7360 (arange_table_allocated
7361 * sizeof (dw_die_ref)));
7362 memset (arange_table + arange_table_in_use, 0,
7363 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7366 arange_table[arange_table_in_use++] = die;
7369 /* Output the information that goes into the .debug_aranges table.
7370 Namely, define the beginning and ending address range of the
7371 text section generated for this compilation unit. */
7374 output_aranges (void)
7377 unsigned long aranges_length = size_of_aranges ();
7379 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7380 dw2_asm_output_data (4, 0xffffffff,
7381 "Initial length escape value indicating 64-bit DWARF extension");
7382 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7383 "Length of Address Ranges Info");
7384 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7385 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7387 "Offset of Compilation Unit Info");
7388 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7389 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7391 /* We need to align to twice the pointer size here. */
7392 if (DWARF_ARANGES_PAD_SIZE)
7394 /* Pad using a 2 byte words so that padding is correct for any
7396 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7397 2 * DWARF2_ADDR_SIZE);
7398 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7399 dw2_asm_output_data (2, 0, NULL);
7402 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7403 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7404 text_section_label, "Length");
7405 if (flag_reorder_blocks_and_partition)
7407 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7409 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7410 cold_text_section_label, "Length");
7413 for (i = 0; i < arange_table_in_use; i++)
7415 dw_die_ref die = arange_table[i];
7417 /* We shouldn't see aranges for DIEs outside of the main CU. */
7418 gcc_assert (die->die_mark);
7420 if (die->die_tag == DW_TAG_subprogram)
7422 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7424 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7425 get_AT_low_pc (die), "Length");
7429 /* A static variable; extract the symbol from DW_AT_location.
7430 Note that this code isn't currently hit, as we only emit
7431 aranges for functions (jason 9/23/99). */
7432 dw_attr_ref a = get_AT (die, DW_AT_location);
7433 dw_loc_descr_ref loc;
7435 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7438 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7440 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7441 loc->dw_loc_oprnd1.v.val_addr, "Address");
7442 dw2_asm_output_data (DWARF2_ADDR_SIZE,
7443 get_AT_unsigned (die, DW_AT_byte_size),
7448 /* Output the terminator words. */
7449 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7450 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7453 /* Add a new entry to .debug_ranges. Return the offset at which it
7457 add_ranges (tree block)
7459 unsigned int in_use = ranges_table_in_use;
7461 if (in_use == ranges_table_allocated)
7463 ranges_table_allocated += RANGES_TABLE_INCREMENT;
7465 = ggc_realloc (ranges_table, (ranges_table_allocated
7466 * sizeof (struct dw_ranges_struct)));
7467 memset (ranges_table + ranges_table_in_use, 0,
7468 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7471 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7472 ranges_table_in_use = in_use + 1;
7474 return in_use * 2 * DWARF2_ADDR_SIZE;
7478 output_ranges (void)
7481 static const char *const start_fmt = "Offset 0x%x";
7482 const char *fmt = start_fmt;
7484 for (i = 0; i < ranges_table_in_use; i++)
7486 int block_num = ranges_table[i].block_num;
7490 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7491 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7493 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7494 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7496 /* If all code is in the text section, then the compilation
7497 unit base address defaults to DW_AT_low_pc, which is the
7498 base of the text section. */
7499 if (!have_multiple_function_sections)
7501 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7503 fmt, i * 2 * DWARF2_ADDR_SIZE);
7504 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7505 text_section_label, NULL);
7508 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7509 compilation unit base address to zero, which allows us to
7510 use absolute addresses, and not worry about whether the
7511 target supports cross-section arithmetic. */
7514 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7515 fmt, i * 2 * DWARF2_ADDR_SIZE);
7516 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7523 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7524 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7530 /* Data structure containing information about input files. */
7533 char *path; /* Complete file name. */
7534 char *fname; /* File name part. */
7535 int length; /* Length of entire string. */
7536 int file_idx; /* Index in input file table. */
7537 int dir_idx; /* Index in directory table. */
7540 /* Data structure containing information about directories with source
7544 char *path; /* Path including directory name. */
7545 int length; /* Path length. */
7546 int prefix; /* Index of directory entry which is a prefix. */
7547 int count; /* Number of files in this directory. */
7548 int dir_idx; /* Index of directory used as base. */
7549 int used; /* Used in the end? */
7552 /* Callback function for file_info comparison. We sort by looking at
7553 the directories in the path. */
7556 file_info_cmp (const void *p1, const void *p2)
7558 const struct file_info *s1 = p1;
7559 const struct file_info *s2 = p2;
7563 /* Take care of file names without directories. We need to make sure that
7564 we return consistent values to qsort since some will get confused if
7565 we return the same value when identical operands are passed in opposite
7566 orders. So if neither has a directory, return 0 and otherwise return
7567 1 or -1 depending on which one has the directory. */
7568 if ((s1->path == s1->fname || s2->path == s2->fname))
7569 return (s2->path == s2->fname) - (s1->path == s1->fname);
7571 cp1 = (unsigned char *) s1->path;
7572 cp2 = (unsigned char *) s2->path;
7578 /* Reached the end of the first path? If so, handle like above. */
7579 if ((cp1 == (unsigned char *) s1->fname)
7580 || (cp2 == (unsigned char *) s2->fname))
7581 return ((cp2 == (unsigned char *) s2->fname)
7582 - (cp1 == (unsigned char *) s1->fname));
7584 /* Character of current path component the same? */
7585 else if (*cp1 != *cp2)
7590 /* Output the directory table and the file name table. We try to minimize
7591 the total amount of memory needed. A heuristic is used to avoid large
7592 slowdowns with many input files. */
7595 output_file_names (void)
7597 struct file_info *files;
7598 struct dir_info *dirs;
7607 /* Handle the case where file_table is empty. */
7608 if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7610 dw2_asm_output_data (1, 0, "End directory table");
7611 dw2_asm_output_data (1, 0, "End file name table");
7615 /* Allocate the various arrays we need. */
7616 files = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct file_info));
7617 dirs = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct dir_info));
7619 /* Sort the file names. */
7620 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7624 /* Skip all leading "./". */
7625 f = VARRAY_CHAR_PTR (file_table, i);
7626 while (f[0] == '.' && f[1] == '/')
7629 /* Create a new array entry. */
7631 files[i].length = strlen (f);
7632 files[i].file_idx = i;
7634 /* Search for the file name part. */
7635 f = strrchr (f, '/');
7636 files[i].fname = f == NULL ? files[i].path : f + 1;
7639 qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7640 sizeof (files[0]), file_info_cmp);
7642 /* Find all the different directories used. */
7643 dirs[0].path = files[1].path;
7644 dirs[0].length = files[1].fname - files[1].path;
7645 dirs[0].prefix = -1;
7647 dirs[0].dir_idx = 0;
7649 files[1].dir_idx = 0;
7652 for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7653 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7654 && memcmp (dirs[ndirs - 1].path, files[i].path,
7655 dirs[ndirs - 1].length) == 0)
7657 /* Same directory as last entry. */
7658 files[i].dir_idx = ndirs - 1;
7659 ++dirs[ndirs - 1].count;
7665 /* This is a new directory. */
7666 dirs[ndirs].path = files[i].path;
7667 dirs[ndirs].length = files[i].fname - files[i].path;
7668 dirs[ndirs].count = 1;
7669 dirs[ndirs].dir_idx = ndirs;
7670 dirs[ndirs].used = 0;
7671 files[i].dir_idx = ndirs;
7673 /* Search for a prefix. */
7674 dirs[ndirs].prefix = -1;
7675 for (j = 0; j < ndirs; j++)
7676 if (dirs[j].length < dirs[ndirs].length
7677 && dirs[j].length > 1
7678 && (dirs[ndirs].prefix == -1
7679 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7680 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7681 dirs[ndirs].prefix = j;
7686 /* Now to the actual work. We have to find a subset of the directories which
7687 allow expressing the file name using references to the directory table
7688 with the least amount of characters. We do not do an exhaustive search
7689 where we would have to check out every combination of every single
7690 possible prefix. Instead we use a heuristic which provides nearly optimal
7691 results in most cases and never is much off. */
7692 saved = alloca (ndirs * sizeof (int));
7693 savehere = alloca (ndirs * sizeof (int));
7695 memset (saved, '\0', ndirs * sizeof (saved[0]));
7696 for (i = 0; i < ndirs; i++)
7701 /* We can always save some space for the current directory. But this
7702 does not mean it will be enough to justify adding the directory. */
7703 savehere[i] = dirs[i].length;
7704 total = (savehere[i] - saved[i]) * dirs[i].count;
7706 for (j = i + 1; j < ndirs; j++)
7709 if (saved[j] < dirs[i].length)
7711 /* Determine whether the dirs[i] path is a prefix of the
7716 while (k != -1 && k != (int) i)
7721 /* Yes it is. We can possibly safe some memory but
7722 writing the filenames in dirs[j] relative to
7724 savehere[j] = dirs[i].length;
7725 total += (savehere[j] - saved[j]) * dirs[j].count;
7730 /* Check whether we can safe enough to justify adding the dirs[i]
7732 if (total > dirs[i].length + 1)
7734 /* It's worthwhile adding. */
7735 for (j = i; j < ndirs; j++)
7736 if (savehere[j] > 0)
7738 /* Remember how much we saved for this directory so far. */
7739 saved[j] = savehere[j];
7741 /* Remember the prefix directory. */
7742 dirs[j].dir_idx = i;
7747 /* We have to emit them in the order they appear in the file_table array
7748 since the index is used in the debug info generation. To do this
7749 efficiently we generate a back-mapping of the indices first. */
7750 backmap = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7751 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7753 backmap[files[i].file_idx] = i;
7755 /* Mark this directory as used. */
7756 dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7759 /* That was it. We are ready to emit the information. First emit the
7760 directory name table. We have to make sure the first actually emitted
7761 directory name has index one; zero is reserved for the current working
7762 directory. Make sure we do not confuse these indices with the one for the
7763 constructed table (even though most of the time they are identical). */
7765 idx_offset = dirs[0].length > 0 ? 1 : 0;
7766 for (i = 1 - idx_offset; i < ndirs; i++)
7767 if (dirs[i].used != 0)
7769 dirs[i].used = idx++;
7770 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7771 "Directory Entry: 0x%x", dirs[i].used);
7774 dw2_asm_output_data (1, 0, "End directory table");
7776 /* Correct the index for the current working directory entry if it
7778 if (idx_offset == 0)
7781 /* Now write all the file names. */
7782 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7784 int file_idx = backmap[i];
7785 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7787 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7788 "File Entry: 0x%lx", (unsigned long) i);
7790 /* Include directory index. */
7791 dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7793 /* Modification time. */
7794 dw2_asm_output_data_uleb128 (0, NULL);
7796 /* File length in bytes. */
7797 dw2_asm_output_data_uleb128 (0, NULL);
7800 dw2_asm_output_data (1, 0, "End file name table");
7804 /* Output the source line number correspondence information. This
7805 information goes into the .debug_line section. */
7808 output_line_info (void)
7810 char l1[20], l2[20], p1[20], p2[20];
7811 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7812 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7815 unsigned long lt_index;
7816 unsigned long current_line;
7819 unsigned long current_file;
7820 unsigned long function;
7822 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7823 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7824 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7825 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7827 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7828 dw2_asm_output_data (4, 0xffffffff,
7829 "Initial length escape value indicating 64-bit DWARF extension");
7830 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7831 "Length of Source Line Info");
7832 ASM_OUTPUT_LABEL (asm_out_file, l1);
7834 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7835 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7836 ASM_OUTPUT_LABEL (asm_out_file, p1);
7838 /* Define the architecture-dependent minimum instruction length (in
7839 bytes). In this implementation of DWARF, this field is used for
7840 information purposes only. Since GCC generates assembly language,
7841 we have no a priori knowledge of how many instruction bytes are
7842 generated for each source line, and therefore can use only the
7843 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7844 commands. Accordingly, we fix this as `1', which is "correct
7845 enough" for all architectures, and don't let the target override. */
7846 dw2_asm_output_data (1, 1,
7847 "Minimum Instruction Length");
7849 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7850 "Default is_stmt_start flag");
7851 dw2_asm_output_data (1, DWARF_LINE_BASE,
7852 "Line Base Value (Special Opcodes)");
7853 dw2_asm_output_data (1, DWARF_LINE_RANGE,
7854 "Line Range Value (Special Opcodes)");
7855 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7856 "Special Opcode Base");
7858 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7862 case DW_LNS_advance_pc:
7863 case DW_LNS_advance_line:
7864 case DW_LNS_set_file:
7865 case DW_LNS_set_column:
7866 case DW_LNS_fixed_advance_pc:
7874 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7878 /* Write out the information about the files we use. */
7879 output_file_names ();
7880 ASM_OUTPUT_LABEL (asm_out_file, p2);
7882 /* We used to set the address register to the first location in the text
7883 section here, but that didn't accomplish anything since we already
7884 have a line note for the opening brace of the first function. */
7886 /* Generate the line number to PC correspondence table, encoded as
7887 a series of state machine operations. */
7891 if (cfun && in_cold_section_p)
7892 strcpy (prev_line_label, cfun->cold_section_label);
7894 strcpy (prev_line_label, text_section_label);
7895 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7897 dw_line_info_ref line_info = &line_info_table[lt_index];
7900 /* Disable this optimization for now; GDB wants to see two line notes
7901 at the beginning of a function so it can find the end of the
7904 /* Don't emit anything for redundant notes. Just updating the
7905 address doesn't accomplish anything, because we already assume
7906 that anything after the last address is this line. */
7907 if (line_info->dw_line_num == current_line
7908 && line_info->dw_file_num == current_file)
7912 /* Emit debug info for the address of the current line.
7914 Unfortunately, we have little choice here currently, and must always
7915 use the most general form. GCC does not know the address delta
7916 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
7917 attributes which will give an upper bound on the address range. We
7918 could perhaps use length attributes to determine when it is safe to
7919 use DW_LNS_fixed_advance_pc. */
7921 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7924 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
7925 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7926 "DW_LNS_fixed_advance_pc");
7927 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7931 /* This can handle any delta. This takes
7932 4+DWARF2_ADDR_SIZE bytes. */
7933 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7934 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7935 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7936 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7939 strcpy (prev_line_label, line_label);
7941 /* Emit debug info for the source file of the current line, if
7942 different from the previous line. */
7943 if (line_info->dw_file_num != current_file)
7945 current_file = line_info->dw_file_num;
7946 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7947 dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7948 VARRAY_CHAR_PTR (file_table,
7952 /* Emit debug info for the current line number, choosing the encoding
7953 that uses the least amount of space. */
7954 if (line_info->dw_line_num != current_line)
7956 line_offset = line_info->dw_line_num - current_line;
7957 line_delta = line_offset - DWARF_LINE_BASE;
7958 current_line = line_info->dw_line_num;
7959 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7960 /* This can handle deltas from -10 to 234, using the current
7961 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
7963 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7964 "line %lu", current_line);
7967 /* This can handle any delta. This takes at least 4 bytes,
7968 depending on the value being encoded. */
7969 dw2_asm_output_data (1, DW_LNS_advance_line,
7970 "advance to line %lu", current_line);
7971 dw2_asm_output_data_sleb128 (line_offset, NULL);
7972 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7976 /* We still need to start a new row, so output a copy insn. */
7977 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7980 /* Emit debug info for the address of the end of the function. */
7983 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7984 "DW_LNS_fixed_advance_pc");
7985 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7989 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7990 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7991 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7992 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7995 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7996 dw2_asm_output_data_uleb128 (1, NULL);
7997 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8002 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
8004 dw_separate_line_info_ref line_info
8005 = &separate_line_info_table[lt_index];
8008 /* Don't emit anything for redundant notes. */
8009 if (line_info->dw_line_num == current_line
8010 && line_info->dw_file_num == current_file
8011 && line_info->function == function)
8015 /* Emit debug info for the address of the current line. If this is
8016 a new function, or the first line of a function, then we need
8017 to handle it differently. */
8018 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
8020 if (function != line_info->function)
8022 function = line_info->function;
8024 /* Set the address register to the first line in the function. */
8025 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8026 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8027 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8028 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8032 /* ??? See the DW_LNS_advance_pc comment above. */
8035 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8036 "DW_LNS_fixed_advance_pc");
8037 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8041 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8042 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8043 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8044 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8048 strcpy (prev_line_label, line_label);
8050 /* Emit debug info for the source file of the current line, if
8051 different from the previous line. */
8052 if (line_info->dw_file_num != current_file)
8054 current_file = line_info->dw_file_num;
8055 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8056 dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
8057 VARRAY_CHAR_PTR (file_table,
8061 /* Emit debug info for the current line number, choosing the encoding
8062 that uses the least amount of space. */
8063 if (line_info->dw_line_num != current_line)
8065 line_offset = line_info->dw_line_num - current_line;
8066 line_delta = line_offset - DWARF_LINE_BASE;
8067 current_line = line_info->dw_line_num;
8068 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8069 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8070 "line %lu", current_line);
8073 dw2_asm_output_data (1, DW_LNS_advance_line,
8074 "advance to line %lu", current_line);
8075 dw2_asm_output_data_sleb128 (line_offset, NULL);
8076 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8080 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8088 /* If we're done with a function, end its sequence. */
8089 if (lt_index == separate_line_info_table_in_use
8090 || separate_line_info_table[lt_index].function != function)
8095 /* Emit debug info for the address of the end of the function. */
8096 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8099 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8100 "DW_LNS_fixed_advance_pc");
8101 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8105 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8106 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8107 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8108 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8111 /* Output the marker for the end of this sequence. */
8112 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8113 dw2_asm_output_data_uleb128 (1, NULL);
8114 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8118 /* Output the marker for the end of the line number info. */
8119 ASM_OUTPUT_LABEL (asm_out_file, l2);
8122 /* Given a pointer to a tree node for some base type, return a pointer to
8123 a DIE that describes the given type.
8125 This routine must only be called for GCC type nodes that correspond to
8126 Dwarf base (fundamental) types. */
8129 base_type_die (tree type)
8131 dw_die_ref base_type_result;
8132 enum dwarf_type encoding;
8134 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8137 switch (TREE_CODE (type))
8140 if (TYPE_STRING_FLAG (type))
8142 if (TYPE_UNSIGNED (type))
8143 encoding = DW_ATE_unsigned_char;
8145 encoding = DW_ATE_signed_char;
8147 else if (TYPE_UNSIGNED (type))
8148 encoding = DW_ATE_unsigned;
8150 encoding = DW_ATE_signed;
8154 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
8155 encoding = DW_ATE_decimal_float;
8157 encoding = DW_ATE_float;
8160 /* Dwarf2 doesn't know anything about complex ints, so use
8161 a user defined type for it. */
8163 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8164 encoding = DW_ATE_complex_float;
8166 encoding = DW_ATE_lo_user;
8170 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
8171 encoding = DW_ATE_boolean;
8175 /* No other TREE_CODEs are Dwarf fundamental types. */
8179 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8181 /* This probably indicates a bug. */
8182 if (! TYPE_NAME (type))
8183 add_name_attribute (base_type_result, "__unknown__");
8185 add_AT_unsigned (base_type_result, DW_AT_byte_size,
8186 int_size_in_bytes (type));
8187 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8189 return base_type_result;
8192 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8193 the Dwarf "root" type for the given input type. The Dwarf "root" type of
8194 a given type is generally the same as the given type, except that if the
8195 given type is a pointer or reference type, then the root type of the given
8196 type is the root type of the "basis" type for the pointer or reference
8197 type. (This definition of the "root" type is recursive.) Also, the root
8198 type of a `const' qualified type or a `volatile' qualified type is the
8199 root type of the given type without the qualifiers. */
8202 root_type (tree type)
8204 if (TREE_CODE (type) == ERROR_MARK)
8205 return error_mark_node;
8207 switch (TREE_CODE (type))
8210 return error_mark_node;
8213 case REFERENCE_TYPE:
8214 return type_main_variant (root_type (TREE_TYPE (type)));
8217 return type_main_variant (type);
8221 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8222 given input type is a Dwarf "fundamental" type. Otherwise return null. */
8225 is_base_type (tree type)
8227 switch (TREE_CODE (type))
8240 case QUAL_UNION_TYPE:
8245 case REFERENCE_TYPE:
8258 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8259 node, return the size in bits for the type if it is a constant, or else
8260 return the alignment for the type if the type's size is not constant, or
8261 else return BITS_PER_WORD if the type actually turns out to be an
8264 static inline unsigned HOST_WIDE_INT
8265 simple_type_size_in_bits (tree type)
8267 if (TREE_CODE (type) == ERROR_MARK)
8268 return BITS_PER_WORD;
8269 else if (TYPE_SIZE (type) == NULL_TREE)
8271 else if (host_integerp (TYPE_SIZE (type), 1))
8272 return tree_low_cst (TYPE_SIZE (type), 1);
8274 return TYPE_ALIGN (type);
8277 /* Return true if the debug information for the given type should be
8278 emitted as a subrange type. */
8281 is_subrange_type (tree type)
8283 tree subtype = TREE_TYPE (type);
8285 /* Subrange types are identified by the fact that they are integer
8286 types, and that they have a subtype which is either an integer type
8287 or an enumeral type. */
8289 if (TREE_CODE (type) != INTEGER_TYPE
8290 || subtype == NULL_TREE)
8293 if (TREE_CODE (subtype) != INTEGER_TYPE
8294 && TREE_CODE (subtype) != ENUMERAL_TYPE)
8297 if (TREE_CODE (type) == TREE_CODE (subtype)
8298 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8299 && TYPE_MIN_VALUE (type) != NULL
8300 && TYPE_MIN_VALUE (subtype) != NULL
8301 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8302 && TYPE_MAX_VALUE (type) != NULL
8303 && TYPE_MAX_VALUE (subtype) != NULL
8304 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8306 /* The type and its subtype have the same representation. If in
8307 addition the two types also have the same name, then the given
8308 type is not a subrange type, but rather a plain base type. */
8309 /* FIXME: brobecker/2004-03-22:
8310 Sizetype INTEGER_CSTs nodes are canonicalized. It should
8311 therefore be sufficient to check the TYPE_SIZE node pointers
8312 rather than checking the actual size. Unfortunately, we have
8313 found some cases, such as in the Ada "integer" type, where
8314 this is not the case. Until this problem is solved, we need to
8315 keep checking the actual size. */
8316 tree type_name = TYPE_NAME (type);
8317 tree subtype_name = TYPE_NAME (subtype);
8319 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8320 type_name = DECL_NAME (type_name);
8322 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8323 subtype_name = DECL_NAME (subtype_name);
8325 if (type_name == subtype_name)
8332 /* Given a pointer to a tree node for a subrange type, return a pointer
8333 to a DIE that describes the given type. */
8336 subrange_type_die (tree type, dw_die_ref context_die)
8338 dw_die_ref subrange_die;
8339 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8341 if (context_die == NULL)
8342 context_die = comp_unit_die;
8344 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8346 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
8348 /* The size of the subrange type and its base type do not match,
8349 so we need to generate a size attribute for the subrange type. */
8350 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8353 if (TYPE_MIN_VALUE (type) != NULL)
8354 add_bound_info (subrange_die, DW_AT_lower_bound,
8355 TYPE_MIN_VALUE (type));
8356 if (TYPE_MAX_VALUE (type) != NULL)
8357 add_bound_info (subrange_die, DW_AT_upper_bound,
8358 TYPE_MAX_VALUE (type));
8360 return subrange_die;
8363 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8364 entry that chains various modifiers in front of the given type. */
8367 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8368 dw_die_ref context_die)
8370 enum tree_code code = TREE_CODE (type);
8371 dw_die_ref mod_type_die;
8372 dw_die_ref sub_die = NULL;
8373 tree item_type = NULL;
8374 tree qualified_type;
8377 if (code == ERROR_MARK)
8380 /* See if we already have the appropriately qualified variant of
8383 = get_qualified_type (type,
8384 ((is_const_type ? TYPE_QUAL_CONST : 0)
8385 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
8387 /* If we do, then we can just use its DIE, if it exists. */
8390 mod_type_die = lookup_type_die (qualified_type);
8392 return mod_type_die;
8395 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
8397 /* Handle C typedef types. */
8398 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
8400 tree dtype = TREE_TYPE (name);
8402 if (qualified_type == dtype)
8404 /* For a named type, use the typedef. */
8405 gen_type_die (qualified_type, context_die);
8406 return lookup_type_die (qualified_type);
8408 else if (DECL_ORIGINAL_TYPE (name)
8409 && (is_const_type < TYPE_READONLY (dtype)
8410 || is_volatile_type < TYPE_VOLATILE (dtype)))
8411 /* cv-unqualified version of named type. Just use the unnamed
8412 type to which it refers. */
8413 return modified_type_die (DECL_ORIGINAL_TYPE (name),
8414 is_const_type, is_volatile_type,
8416 /* Else cv-qualified version of named type; fall through. */
8421 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8422 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8424 else if (is_volatile_type)
8426 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8427 sub_die = modified_type_die (type, 0, 0, context_die);
8429 else if (code == POINTER_TYPE)
8431 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8432 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8433 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8434 item_type = TREE_TYPE (type);
8436 else if (code == REFERENCE_TYPE)
8438 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8439 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8440 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8441 item_type = TREE_TYPE (type);
8443 else if (is_subrange_type (type))
8445 mod_type_die = subrange_type_die (type, context_die);
8446 item_type = TREE_TYPE (type);
8448 else if (is_base_type (type))
8449 mod_type_die = base_type_die (type);
8452 gen_type_die (type, context_die);
8454 /* We have to get the type_main_variant here (and pass that to the
8455 `lookup_type_die' routine) because the ..._TYPE node we have
8456 might simply be a *copy* of some original type node (where the
8457 copy was created to help us keep track of typedef names) and
8458 that copy might have a different TYPE_UID from the original
8460 if (TREE_CODE (type) != VECTOR_TYPE)
8461 return lookup_type_die (type_main_variant (type));
8463 /* Vectors have the debugging information in the type,
8464 not the main variant. */
8465 return lookup_type_die (type);
8468 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
8469 don't output a DW_TAG_typedef, since there isn't one in the
8470 user's program; just attach a DW_AT_name to the type. */
8472 && (TREE_CODE (name) != TYPE_DECL || TREE_TYPE (name) == qualified_type))
8474 if (TREE_CODE (name) == TYPE_DECL)
8475 /* Could just call add_name_and_src_coords_attributes here,
8476 but since this is a builtin type it doesn't have any
8477 useful source coordinates anyway. */
8478 name = DECL_NAME (name);
8479 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
8483 equate_type_number_to_die (qualified_type, mod_type_die);
8486 /* We must do this after the equate_type_number_to_die call, in case
8487 this is a recursive type. This ensures that the modified_type_die
8488 recursion will terminate even if the type is recursive. Recursive
8489 types are possible in Ada. */
8490 sub_die = modified_type_die (item_type,
8491 TYPE_READONLY (item_type),
8492 TYPE_VOLATILE (item_type),
8495 if (sub_die != NULL)
8496 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8498 return mod_type_die;
8501 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8502 an enumerated type. */
8505 type_is_enum (tree type)
8507 return TREE_CODE (type) == ENUMERAL_TYPE;
8510 /* Return the DBX register number described by a given RTL node. */
8513 dbx_reg_number (rtx rtl)
8515 unsigned regno = REGNO (rtl);
8517 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8519 #ifdef LEAF_REG_REMAP
8520 regno = LEAF_REG_REMAP (regno);
8523 return DBX_REGISTER_NUMBER (regno);
8526 /* Optionally add a DW_OP_piece term to a location description expression.
8527 DW_OP_piece is only added if the location description expression already
8528 doesn't end with DW_OP_piece. */
8531 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8533 dw_loc_descr_ref loc;
8535 if (*list_head != NULL)
8537 /* Find the end of the chain. */
8538 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8541 if (loc->dw_loc_opc != DW_OP_piece)
8542 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8546 /* Return a location descriptor that designates a machine register or
8547 zero if there is none. */
8549 static dw_loc_descr_ref
8550 reg_loc_descriptor (rtx rtl)
8554 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8557 regs = targetm.dwarf_register_span (rtl);
8559 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8560 return multiple_reg_loc_descriptor (rtl, regs);
8562 return one_reg_loc_descriptor (dbx_reg_number (rtl));
8565 /* Return a location descriptor that designates a machine register for
8566 a given hard register number. */
8568 static dw_loc_descr_ref
8569 one_reg_loc_descriptor (unsigned int regno)
8572 return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8574 return new_loc_descr (DW_OP_regx, regno, 0);
8577 /* Given an RTL of a register, return a location descriptor that
8578 designates a value that spans more than one register. */
8580 static dw_loc_descr_ref
8581 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8585 dw_loc_descr_ref loc_result = NULL;
8588 #ifdef LEAF_REG_REMAP
8589 reg = LEAF_REG_REMAP (reg);
8591 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8592 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8594 /* Simple, contiguous registers. */
8595 if (regs == NULL_RTX)
8597 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8604 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8605 add_loc_descr (&loc_result, t);
8606 add_loc_descr_op_piece (&loc_result, size);
8612 /* Now onto stupid register sets in non contiguous locations. */
8614 gcc_assert (GET_CODE (regs) == PARALLEL);
8616 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8619 for (i = 0; i < XVECLEN (regs, 0); ++i)
8623 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8624 add_loc_descr (&loc_result, t);
8625 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8626 add_loc_descr_op_piece (&loc_result, size);
8631 /* Return a location descriptor that designates a constant. */
8633 static dw_loc_descr_ref
8634 int_loc_descriptor (HOST_WIDE_INT i)
8636 enum dwarf_location_atom op;
8638 /* Pick the smallest representation of a constant, rather than just
8639 defaulting to the LEB encoding. */
8643 op = DW_OP_lit0 + i;
8646 else if (i <= 0xffff)
8648 else if (HOST_BITS_PER_WIDE_INT == 32
8658 else if (i >= -0x8000)
8660 else if (HOST_BITS_PER_WIDE_INT == 32
8661 || i >= -0x80000000)
8667 return new_loc_descr (op, i, 0);
8670 /* Return a location descriptor that designates a base+offset location. */
8672 static dw_loc_descr_ref
8673 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8677 /* We only use "frame base" when we're sure we're talking about the
8678 post-prologue local stack frame. We do this by *not* running
8679 register elimination until this point, and recognizing the special
8680 argument pointer and soft frame pointer rtx's. */
8681 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8683 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8687 if (GET_CODE (elim) == PLUS)
8689 offset += INTVAL (XEXP (elim, 1));
8690 elim = XEXP (elim, 0);
8692 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8693 : stack_pointer_rtx));
8694 offset += frame_pointer_fb_offset;
8696 return new_loc_descr (DW_OP_fbreg, offset, 0);
8700 regno = dbx_reg_number (reg);
8702 return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8704 return new_loc_descr (DW_OP_bregx, regno, offset);
8707 /* Return true if this RTL expression describes a base+offset calculation. */
8710 is_based_loc (rtx rtl)
8712 return (GET_CODE (rtl) == PLUS
8713 && ((REG_P (XEXP (rtl, 0))
8714 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8715 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8718 /* The following routine converts the RTL for a variable or parameter
8719 (resident in memory) into an equivalent Dwarf representation of a
8720 mechanism for getting the address of that same variable onto the top of a
8721 hypothetical "address evaluation" stack.
8723 When creating memory location descriptors, we are effectively transforming
8724 the RTL for a memory-resident object into its Dwarf postfix expression
8725 equivalent. This routine recursively descends an RTL tree, turning
8726 it into Dwarf postfix code as it goes.
8728 MODE is the mode of the memory reference, needed to handle some
8729 autoincrement addressing modes.
8731 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8732 location list for RTL.
8734 Return 0 if we can't represent the location. */
8736 static dw_loc_descr_ref
8737 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8739 dw_loc_descr_ref mem_loc_result = NULL;
8740 enum dwarf_location_atom op;
8742 /* Note that for a dynamically sized array, the location we will generate a
8743 description of here will be the lowest numbered location which is
8744 actually within the array. That's *not* necessarily the same as the
8745 zeroth element of the array. */
8747 rtl = targetm.delegitimize_address (rtl);
8749 switch (GET_CODE (rtl))
8754 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8755 just fall into the SUBREG code. */
8757 /* ... fall through ... */
8760 /* The case of a subreg may arise when we have a local (register)
8761 variable or a formal (register) parameter which doesn't quite fill
8762 up an entire register. For now, just assume that it is
8763 legitimate to make the Dwarf info refer to the whole register which
8764 contains the given subreg. */
8765 rtl = XEXP (rtl, 0);
8767 /* ... fall through ... */
8770 /* Whenever a register number forms a part of the description of the
8771 method for calculating the (dynamic) address of a memory resident
8772 object, DWARF rules require the register number be referred to as
8773 a "base register". This distinction is not based in any way upon
8774 what category of register the hardware believes the given register
8775 belongs to. This is strictly DWARF terminology we're dealing with
8776 here. Note that in cases where the location of a memory-resident
8777 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8778 OP_CONST (0)) the actual DWARF location descriptor that we generate
8779 may just be OP_BASEREG (basereg). This may look deceptively like
8780 the object in question was allocated to a register (rather than in
8781 memory) so DWARF consumers need to be aware of the subtle
8782 distinction between OP_REG and OP_BASEREG. */
8783 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8784 mem_loc_result = based_loc_descr (rtl, 0);
8788 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8789 if (mem_loc_result != 0)
8790 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8794 rtl = XEXP (rtl, 1);
8796 /* ... fall through ... */
8799 /* Some ports can transform a symbol ref into a label ref, because
8800 the symbol ref is too far away and has to be dumped into a constant
8804 /* Alternatively, the symbol in the constant pool might be referenced
8805 by a different symbol. */
8806 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8809 rtx tmp = get_pool_constant_mark (rtl, &marked);
8811 if (GET_CODE (tmp) == SYMBOL_REF)
8814 if (CONSTANT_POOL_ADDRESS_P (tmp))
8815 get_pool_constant_mark (tmp, &marked);
8820 /* If all references to this pool constant were optimized away,
8821 it was not output and thus we can't represent it.
8822 FIXME: might try to use DW_OP_const_value here, though
8823 DW_OP_piece complicates it. */
8828 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8829 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8830 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8831 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8835 /* Extract the PLUS expression nested inside and fall into
8837 rtl = XEXP (rtl, 1);
8842 /* Turn these into a PLUS expression and fall into the PLUS code
8844 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8845 GEN_INT (GET_CODE (rtl) == PRE_INC
8846 ? GET_MODE_UNIT_SIZE (mode)
8847 : -GET_MODE_UNIT_SIZE (mode)));
8849 /* ... fall through ... */
8853 if (is_based_loc (rtl))
8854 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8855 INTVAL (XEXP (rtl, 1)));
8858 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8859 if (mem_loc_result == 0)
8862 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8863 && INTVAL (XEXP (rtl, 1)) >= 0)
8864 add_loc_descr (&mem_loc_result,
8865 new_loc_descr (DW_OP_plus_uconst,
8866 INTVAL (XEXP (rtl, 1)), 0));
8869 add_loc_descr (&mem_loc_result,
8870 mem_loc_descriptor (XEXP (rtl, 1), mode));
8871 add_loc_descr (&mem_loc_result,
8872 new_loc_descr (DW_OP_plus, 0, 0));
8877 /* If a pseudo-reg is optimized away, it is possible for it to
8878 be replaced with a MEM containing a multiply or shift. */
8897 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8898 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8900 if (op0 == 0 || op1 == 0)
8903 mem_loc_result = op0;
8904 add_loc_descr (&mem_loc_result, op1);
8905 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8910 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8917 return mem_loc_result;
8920 /* Return a descriptor that describes the concatenation of two locations.
8921 This is typically a complex variable. */
8923 static dw_loc_descr_ref
8924 concat_loc_descriptor (rtx x0, rtx x1)
8926 dw_loc_descr_ref cc_loc_result = NULL;
8927 dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8928 dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8930 if (x0_ref == 0 || x1_ref == 0)
8933 cc_loc_result = x0_ref;
8934 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
8936 add_loc_descr (&cc_loc_result, x1_ref);
8937 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
8939 return cc_loc_result;
8942 /* Output a proper Dwarf location descriptor for a variable or parameter
8943 which is either allocated in a register or in a memory location. For a
8944 register, we just generate an OP_REG and the register number. For a
8945 memory location we provide a Dwarf postfix expression describing how to
8946 generate the (dynamic) address of the object onto the address stack.
8948 If we don't know how to describe it, return 0. */
8950 static dw_loc_descr_ref
8951 loc_descriptor (rtx rtl)
8953 dw_loc_descr_ref loc_result = NULL;
8955 switch (GET_CODE (rtl))
8958 /* The case of a subreg may arise when we have a local (register)
8959 variable or a formal (register) parameter which doesn't quite fill
8960 up an entire register. For now, just assume that it is
8961 legitimate to make the Dwarf info refer to the whole register which
8962 contains the given subreg. */
8963 rtl = SUBREG_REG (rtl);
8965 /* ... fall through ... */
8968 loc_result = reg_loc_descriptor (rtl);
8972 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8976 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8981 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
8983 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
8987 rtl = XEXP (rtl, 1);
8992 rtvec par_elems = XVEC (rtl, 0);
8993 int num_elem = GET_NUM_ELEM (par_elems);
8994 enum machine_mode mode;
8997 /* Create the first one, so we have something to add to. */
8998 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
8999 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
9000 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9001 for (i = 1; i < num_elem; i++)
9003 dw_loc_descr_ref temp;
9005 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
9006 add_loc_descr (&loc_result, temp);
9007 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
9008 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9020 /* Similar, but generate the descriptor from trees instead of rtl. This comes
9021 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
9022 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9023 top-level invocation, and we require the address of LOC; is 0 if we require
9024 the value of LOC. */
9026 static dw_loc_descr_ref
9027 loc_descriptor_from_tree_1 (tree loc, int want_address)
9029 dw_loc_descr_ref ret, ret1;
9030 int have_address = 0;
9031 enum dwarf_location_atom op;
9033 /* ??? Most of the time we do not take proper care for sign/zero
9034 extending the values properly. Hopefully this won't be a real
9037 switch (TREE_CODE (loc))
9042 case PLACEHOLDER_EXPR:
9043 /* This case involves extracting fields from an object to determine the
9044 position of other fields. We don't try to encode this here. The
9045 only user of this is Ada, which encodes the needed information using
9046 the names of types. */
9052 case PREINCREMENT_EXPR:
9053 case PREDECREMENT_EXPR:
9054 case POSTINCREMENT_EXPR:
9055 case POSTDECREMENT_EXPR:
9056 /* There are no opcodes for these operations. */
9060 /* If we already want an address, there's nothing we can do. */
9064 /* Otherwise, process the argument and look for the address. */
9065 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9068 if (DECL_THREAD_LOCAL_P (loc))
9072 /* If this is not defined, we have no way to emit the data. */
9073 if (!targetm.asm_out.output_dwarf_dtprel)
9076 /* The way DW_OP_GNU_push_tls_address is specified, we can only
9077 look up addresses of objects in the current module. */
9078 if (DECL_EXTERNAL (loc))
9081 rtl = rtl_for_decl_location (loc);
9082 if (rtl == NULL_RTX)
9087 rtl = XEXP (rtl, 0);
9088 if (! CONSTANT_P (rtl))
9091 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9092 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9093 ret->dw_loc_oprnd1.v.val_addr = rtl;
9095 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9096 add_loc_descr (&ret, ret1);
9104 if (DECL_HAS_VALUE_EXPR_P (loc))
9105 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9111 rtx rtl = rtl_for_decl_location (loc);
9113 if (rtl == NULL_RTX)
9115 else if (GET_CODE (rtl) == CONST_INT)
9117 HOST_WIDE_INT val = INTVAL (rtl);
9118 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9119 val &= GET_MODE_MASK (DECL_MODE (loc));
9120 ret = int_loc_descriptor (val);
9122 else if (GET_CODE (rtl) == CONST_STRING)
9124 else if (CONSTANT_P (rtl))
9126 ret = new_loc_descr (DW_OP_addr, 0, 0);
9127 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9128 ret->dw_loc_oprnd1.v.val_addr = rtl;
9132 enum machine_mode mode;
9134 /* Certain constructs can only be represented at top-level. */
9135 if (want_address == 2)
9136 return loc_descriptor (rtl);
9138 mode = GET_MODE (rtl);
9141 rtl = XEXP (rtl, 0);
9144 ret = mem_loc_descriptor (rtl, mode);
9150 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9155 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9159 case NON_LVALUE_EXPR:
9160 case VIEW_CONVERT_EXPR:
9163 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9168 case ARRAY_RANGE_REF:
9171 HOST_WIDE_INT bitsize, bitpos, bytepos;
9172 enum machine_mode mode;
9174 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9176 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9177 &unsignedp, &volatilep, false);
9182 ret = loc_descriptor_from_tree_1 (obj, 1);
9184 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9187 if (offset != NULL_TREE)
9189 /* Variable offset. */
9190 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9191 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9194 bytepos = bitpos / BITS_PER_UNIT;
9196 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9197 else if (bytepos < 0)
9199 add_loc_descr (&ret, int_loc_descriptor (bytepos));
9200 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9208 if (host_integerp (loc, 0))
9209 ret = int_loc_descriptor (tree_low_cst (loc, 0));
9216 /* Get an RTL for this, if something has been emitted. */
9217 rtx rtl = lookup_constant_def (loc);
9218 enum machine_mode mode;
9220 if (!rtl || !MEM_P (rtl))
9222 mode = GET_MODE (rtl);
9223 rtl = XEXP (rtl, 0);
9224 ret = mem_loc_descriptor (rtl, mode);
9229 case TRUTH_AND_EXPR:
9230 case TRUTH_ANDIF_EXPR:
9235 case TRUTH_XOR_EXPR:
9241 case TRUTH_ORIF_EXPR:
9246 case FLOOR_DIV_EXPR:
9248 case ROUND_DIV_EXPR:
9249 case TRUNC_DIV_EXPR:
9257 case FLOOR_MOD_EXPR:
9259 case ROUND_MOD_EXPR:
9260 case TRUNC_MOD_EXPR:
9273 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
9277 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9278 && host_integerp (TREE_OPERAND (loc, 1), 0))
9280 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9284 add_loc_descr (&ret,
9285 new_loc_descr (DW_OP_plus_uconst,
9286 tree_low_cst (TREE_OPERAND (loc, 1),
9296 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9303 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9310 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9317 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9332 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9333 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9334 if (ret == 0 || ret1 == 0)
9337 add_loc_descr (&ret, ret1);
9338 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9341 case TRUTH_NOT_EXPR:
9355 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9359 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9365 const enum tree_code code =
9366 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9368 loc = build3 (COND_EXPR, TREE_TYPE (loc),
9369 build2 (code, integer_type_node,
9370 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9371 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9374 /* ... fall through ... */
9378 dw_loc_descr_ref lhs
9379 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9380 dw_loc_descr_ref rhs
9381 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9382 dw_loc_descr_ref bra_node, jump_node, tmp;
9384 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9385 if (ret == 0 || lhs == 0 || rhs == 0)
9388 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9389 add_loc_descr (&ret, bra_node);
9391 add_loc_descr (&ret, rhs);
9392 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9393 add_loc_descr (&ret, jump_node);
9395 add_loc_descr (&ret, lhs);
9396 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9397 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9399 /* ??? Need a node to point the skip at. Use a nop. */
9400 tmp = new_loc_descr (DW_OP_nop, 0, 0);
9401 add_loc_descr (&ret, tmp);
9402 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9403 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9407 case FIX_TRUNC_EXPR:
9409 case FIX_FLOOR_EXPR:
9410 case FIX_ROUND_EXPR:
9414 /* Leave front-end specific codes as simply unknown. This comes
9415 up, for instance, with the C STMT_EXPR. */
9416 if ((unsigned int) TREE_CODE (loc)
9417 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9420 #ifdef ENABLE_CHECKING
9421 /* Otherwise this is a generic code; we should just lists all of
9422 these explicitly. We forgot one. */
9425 /* In a release build, we want to degrade gracefully: better to
9426 generate incomplete debugging information than to crash. */
9431 /* Show if we can't fill the request for an address. */
9432 if (want_address && !have_address)
9435 /* If we've got an address and don't want one, dereference. */
9436 if (!want_address && have_address && ret)
9438 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9440 if (size > DWARF2_ADDR_SIZE || size == -1)
9442 else if (size == DWARF2_ADDR_SIZE)
9445 op = DW_OP_deref_size;
9447 add_loc_descr (&ret, new_loc_descr (op, size, 0));
9453 static inline dw_loc_descr_ref
9454 loc_descriptor_from_tree (tree loc)
9456 return loc_descriptor_from_tree_1 (loc, 2);
9459 /* Given a value, round it up to the lowest multiple of `boundary'
9460 which is not less than the value itself. */
9462 static inline HOST_WIDE_INT
9463 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9465 return (((value + boundary - 1) / boundary) * boundary);
9468 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9469 pointer to the declared type for the relevant field variable, or return
9470 `integer_type_node' if the given node turns out to be an
9474 field_type (tree decl)
9478 if (TREE_CODE (decl) == ERROR_MARK)
9479 return integer_type_node;
9481 type = DECL_BIT_FIELD_TYPE (decl);
9482 if (type == NULL_TREE)
9483 type = TREE_TYPE (decl);
9488 /* Given a pointer to a tree node, return the alignment in bits for
9489 it, or else return BITS_PER_WORD if the node actually turns out to
9490 be an ERROR_MARK node. */
9492 static inline unsigned
9493 simple_type_align_in_bits (tree type)
9495 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9498 static inline unsigned
9499 simple_decl_align_in_bits (tree decl)
9501 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9504 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9505 lowest addressed byte of the "containing object" for the given FIELD_DECL,
9506 or return 0 if we are unable to determine what that offset is, either
9507 because the argument turns out to be a pointer to an ERROR_MARK node, or
9508 because the offset is actually variable. (We can't handle the latter case
9511 static HOST_WIDE_INT
9512 field_byte_offset (tree decl)
9514 unsigned int type_align_in_bits;
9515 unsigned int decl_align_in_bits;
9516 unsigned HOST_WIDE_INT type_size_in_bits;
9517 HOST_WIDE_INT object_offset_in_bits;
9519 tree field_size_tree;
9520 HOST_WIDE_INT bitpos_int;
9521 HOST_WIDE_INT deepest_bitpos;
9522 unsigned HOST_WIDE_INT field_size_in_bits;
9524 if (TREE_CODE (decl) == ERROR_MARK)
9527 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9529 type = field_type (decl);
9530 field_size_tree = DECL_SIZE (decl);
9532 /* The size could be unspecified if there was an error, or for
9533 a flexible array member. */
9534 if (! field_size_tree)
9535 field_size_tree = bitsize_zero_node;
9537 /* We cannot yet cope with fields whose positions are variable, so
9538 for now, when we see such things, we simply return 0. Someday, we may
9539 be able to handle such cases, but it will be damn difficult. */
9540 if (! host_integerp (bit_position (decl), 0))
9543 bitpos_int = int_bit_position (decl);
9545 /* If we don't know the size of the field, pretend it's a full word. */
9546 if (host_integerp (field_size_tree, 1))
9547 field_size_in_bits = tree_low_cst (field_size_tree, 1);
9549 field_size_in_bits = BITS_PER_WORD;
9551 type_size_in_bits = simple_type_size_in_bits (type);
9552 type_align_in_bits = simple_type_align_in_bits (type);
9553 decl_align_in_bits = simple_decl_align_in_bits (decl);
9555 /* The GCC front-end doesn't make any attempt to keep track of the starting
9556 bit offset (relative to the start of the containing structure type) of the
9557 hypothetical "containing object" for a bit-field. Thus, when computing
9558 the byte offset value for the start of the "containing object" of a
9559 bit-field, we must deduce this information on our own. This can be rather
9560 tricky to do in some cases. For example, handling the following structure
9561 type definition when compiling for an i386/i486 target (which only aligns
9562 long long's to 32-bit boundaries) can be very tricky:
9564 struct S { int field1; long long field2:31; };
9566 Fortunately, there is a simple rule-of-thumb which can be used in such
9567 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
9568 structure shown above. It decides to do this based upon one simple rule
9569 for bit-field allocation. GCC allocates each "containing object" for each
9570 bit-field at the first (i.e. lowest addressed) legitimate alignment
9571 boundary (based upon the required minimum alignment for the declared type
9572 of the field) which it can possibly use, subject to the condition that
9573 there is still enough available space remaining in the containing object
9574 (when allocated at the selected point) to fully accommodate all of the
9575 bits of the bit-field itself.
9577 This simple rule makes it obvious why GCC allocates 8 bytes for each
9578 object of the structure type shown above. When looking for a place to
9579 allocate the "containing object" for `field2', the compiler simply tries
9580 to allocate a 64-bit "containing object" at each successive 32-bit
9581 boundary (starting at zero) until it finds a place to allocate that 64-
9582 bit field such that at least 31 contiguous (and previously unallocated)
9583 bits remain within that selected 64 bit field. (As it turns out, for the
9584 example above, the compiler finds it is OK to allocate the "containing
9585 object" 64-bit field at bit-offset zero within the structure type.)
9587 Here we attempt to work backwards from the limited set of facts we're
9588 given, and we try to deduce from those facts, where GCC must have believed
9589 that the containing object started (within the structure type). The value
9590 we deduce is then used (by the callers of this routine) to generate
9591 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9592 and, in the case of DW_AT_location, regular fields as well). */
9594 /* Figure out the bit-distance from the start of the structure to the
9595 "deepest" bit of the bit-field. */
9596 deepest_bitpos = bitpos_int + field_size_in_bits;
9598 /* This is the tricky part. Use some fancy footwork to deduce where the
9599 lowest addressed bit of the containing object must be. */
9600 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9602 /* Round up to type_align by default. This works best for bitfields. */
9603 object_offset_in_bits += type_align_in_bits - 1;
9604 object_offset_in_bits /= type_align_in_bits;
9605 object_offset_in_bits *= type_align_in_bits;
9607 if (object_offset_in_bits > bitpos_int)
9609 /* Sigh, the decl must be packed. */
9610 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9612 /* Round up to decl_align instead. */
9613 object_offset_in_bits += decl_align_in_bits - 1;
9614 object_offset_in_bits /= decl_align_in_bits;
9615 object_offset_in_bits *= decl_align_in_bits;
9618 return object_offset_in_bits / BITS_PER_UNIT;
9621 /* The following routines define various Dwarf attributes and any data
9622 associated with them. */
9624 /* Add a location description attribute value to a DIE.
9626 This emits location attributes suitable for whole variables and
9627 whole parameters. Note that the location attributes for struct fields are
9628 generated by the routine `data_member_location_attribute' below. */
9631 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9632 dw_loc_descr_ref descr)
9635 add_AT_loc (die, attr_kind, descr);
9638 /* Attach the specialized form of location attribute used for data members of
9639 struct and union types. In the special case of a FIELD_DECL node which
9640 represents a bit-field, the "offset" part of this special location
9641 descriptor must indicate the distance in bytes from the lowest-addressed
9642 byte of the containing struct or union type to the lowest-addressed byte of
9643 the "containing object" for the bit-field. (See the `field_byte_offset'
9646 For any given bit-field, the "containing object" is a hypothetical object
9647 (of some integral or enum type) within which the given bit-field lives. The
9648 type of this hypothetical "containing object" is always the same as the
9649 declared type of the individual bit-field itself (for GCC anyway... the
9650 DWARF spec doesn't actually mandate this). Note that it is the size (in
9651 bytes) of the hypothetical "containing object" which will be given in the
9652 DW_AT_byte_size attribute for this bit-field. (See the
9653 `byte_size_attribute' function below.) It is also used when calculating the
9654 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9658 add_data_member_location_attribute (dw_die_ref die, tree decl)
9660 HOST_WIDE_INT offset;
9661 dw_loc_descr_ref loc_descr = 0;
9663 if (TREE_CODE (decl) == TREE_BINFO)
9665 /* We're working on the TAG_inheritance for a base class. */
9666 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9668 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9669 aren't at a fixed offset from all (sub)objects of the same
9670 type. We need to extract the appropriate offset from our
9671 vtable. The following dwarf expression means
9673 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9675 This is specific to the V3 ABI, of course. */
9677 dw_loc_descr_ref tmp;
9679 /* Make a copy of the object address. */
9680 tmp = new_loc_descr (DW_OP_dup, 0, 0);
9681 add_loc_descr (&loc_descr, tmp);
9683 /* Extract the vtable address. */
9684 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9685 add_loc_descr (&loc_descr, tmp);
9687 /* Calculate the address of the offset. */
9688 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9689 gcc_assert (offset < 0);
9691 tmp = int_loc_descriptor (-offset);
9692 add_loc_descr (&loc_descr, tmp);
9693 tmp = new_loc_descr (DW_OP_minus, 0, 0);
9694 add_loc_descr (&loc_descr, tmp);
9696 /* Extract the offset. */
9697 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9698 add_loc_descr (&loc_descr, tmp);
9700 /* Add it to the object address. */
9701 tmp = new_loc_descr (DW_OP_plus, 0, 0);
9702 add_loc_descr (&loc_descr, tmp);
9705 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9708 offset = field_byte_offset (decl);
9712 enum dwarf_location_atom op;
9714 /* The DWARF2 standard says that we should assume that the structure
9715 address is already on the stack, so we can specify a structure field
9716 address by using DW_OP_plus_uconst. */
9718 #ifdef MIPS_DEBUGGING_INFO
9719 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9720 operator correctly. It works only if we leave the offset on the
9724 op = DW_OP_plus_uconst;
9727 loc_descr = new_loc_descr (op, offset, 0);
9730 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9733 /* Writes integer values to dw_vec_const array. */
9736 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9740 *dest++ = val & 0xff;
9746 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
9748 static HOST_WIDE_INT
9749 extract_int (const unsigned char *src, unsigned int size)
9751 HOST_WIDE_INT val = 0;
9757 val |= *--src & 0xff;
9763 /* Writes floating point values to dw_vec_const array. */
9766 insert_float (rtx rtl, unsigned char *array)
9772 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9773 real_to_target (val, &rv, GET_MODE (rtl));
9775 /* real_to_target puts 32-bit pieces in each long. Pack them. */
9776 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9778 insert_int (val[i], 4, array);
9783 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9784 does not have a "location" either in memory or in a register. These
9785 things can arise in GNU C when a constant is passed as an actual parameter
9786 to an inlined function. They can also arise in C++ where declared
9787 constants do not necessarily get memory "homes". */
9790 add_const_value_attribute (dw_die_ref die, rtx rtl)
9792 switch (GET_CODE (rtl))
9796 HOST_WIDE_INT val = INTVAL (rtl);
9799 add_AT_int (die, DW_AT_const_value, val);
9801 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9806 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9807 floating-point constant. A CONST_DOUBLE is used whenever the
9808 constant requires more than one word in order to be adequately
9809 represented. We output CONST_DOUBLEs as blocks. */
9811 enum machine_mode mode = GET_MODE (rtl);
9813 if (SCALAR_FLOAT_MODE_P (mode))
9815 unsigned int length = GET_MODE_SIZE (mode);
9816 unsigned char *array = ggc_alloc (length);
9818 insert_float (rtl, array);
9819 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9823 /* ??? We really should be using HOST_WIDE_INT throughout. */
9824 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9826 add_AT_long_long (die, DW_AT_const_value,
9827 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9834 enum machine_mode mode = GET_MODE (rtl);
9835 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9836 unsigned int length = CONST_VECTOR_NUNITS (rtl);
9837 unsigned char *array = ggc_alloc (length * elt_size);
9841 switch (GET_MODE_CLASS (mode))
9843 case MODE_VECTOR_INT:
9844 for (i = 0, p = array; i < length; i++, p += elt_size)
9846 rtx elt = CONST_VECTOR_ELT (rtl, i);
9847 HOST_WIDE_INT lo, hi;
9849 switch (GET_CODE (elt))
9857 lo = CONST_DOUBLE_LOW (elt);
9858 hi = CONST_DOUBLE_HIGH (elt);
9865 if (elt_size <= sizeof (HOST_WIDE_INT))
9866 insert_int (lo, elt_size, p);
9869 unsigned char *p0 = p;
9870 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9872 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9873 if (WORDS_BIG_ENDIAN)
9878 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9879 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9884 case MODE_VECTOR_FLOAT:
9885 for (i = 0, p = array; i < length; i++, p += elt_size)
9887 rtx elt = CONST_VECTOR_ELT (rtl, i);
9888 insert_float (elt, p);
9896 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9901 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9907 add_AT_addr (die, DW_AT_const_value, rtl);
9908 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9912 /* In cases where an inlined instance of an inline function is passed
9913 the address of an `auto' variable (which is local to the caller) we
9914 can get a situation where the DECL_RTL of the artificial local
9915 variable (for the inlining) which acts as a stand-in for the
9916 corresponding formal parameter (of the inline function) will look
9917 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
9918 exactly a compile-time constant expression, but it isn't the address
9919 of the (artificial) local variable either. Rather, it represents the
9920 *value* which the artificial local variable always has during its
9921 lifetime. We currently have no way to represent such quasi-constant
9922 values in Dwarf, so for now we just punt and generate nothing. */
9926 /* No other kinds of rtx should be possible here. */
9932 /* Determine whether the evaluation of EXPR references any variables
9933 or functions which aren't otherwise used (and therefore may not be
9936 reference_to_unused (tree * tp, int * walk_subtrees,
9937 void * data ATTRIBUTE_UNUSED)
9939 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
9942 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
9943 && ! TREE_ASM_WRITTEN (*tp))
9949 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
9950 for use in a later add_const_value_attribute call. */
9953 rtl_for_decl_init (tree init, tree type)
9957 /* If a variable is initialized with a string constant without embedded
9958 zeros, build CONST_STRING. */
9959 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
9961 tree enttype = TREE_TYPE (type);
9962 tree domain = TYPE_DOMAIN (type);
9963 enum machine_mode mode = TYPE_MODE (enttype);
9965 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9967 && integer_zerop (TYPE_MIN_VALUE (domain))
9968 && compare_tree_int (TYPE_MAX_VALUE (domain),
9969 TREE_STRING_LENGTH (init) - 1) == 0
9970 && ((size_t) TREE_STRING_LENGTH (init)
9971 == strlen (TREE_STRING_POINTER (init)) + 1))
9972 rtl = gen_rtx_CONST_STRING (VOIDmode,
9973 ggc_strdup (TREE_STRING_POINTER (init)));
9975 /* Although DWARF could easily handle other kinds of aggregates, we
9976 have no way to represent such values as RTL constants, so skip
9978 else if (AGGREGATE_TYPE_P (type))
9980 /* If the initializer is something that we know will expand into an
9981 immediate RTL constant, expand it now. We must be careful not to
9982 reference variables which won't be output. */
9983 else if (initializer_constant_valid_p (init, type)
9984 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
9986 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
9988 /* If expand_expr returns a MEM, it wasn't immediate. */
9989 gcc_assert (!rtl || !MEM_P (rtl));
9995 /* Generate RTL for the variable DECL to represent its location. */
9998 rtl_for_decl_location (tree decl)
10002 /* Here we have to decide where we are going to say the parameter "lives"
10003 (as far as the debugger is concerned). We only have a couple of
10004 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
10006 DECL_RTL normally indicates where the parameter lives during most of the
10007 activation of the function. If optimization is enabled however, this
10008 could be either NULL or else a pseudo-reg. Both of those cases indicate
10009 that the parameter doesn't really live anywhere (as far as the code
10010 generation parts of GCC are concerned) during most of the function's
10011 activation. That will happen (for example) if the parameter is never
10012 referenced within the function.
10014 We could just generate a location descriptor here for all non-NULL
10015 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
10016 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
10017 where DECL_RTL is NULL or is a pseudo-reg.
10019 Note however that we can only get away with using DECL_INCOMING_RTL as
10020 a backup substitute for DECL_RTL in certain limited cases. In cases
10021 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
10022 we can be sure that the parameter was passed using the same type as it is
10023 declared to have within the function, and that its DECL_INCOMING_RTL
10024 points us to a place where a value of that type is passed.
10026 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
10027 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
10028 because in these cases DECL_INCOMING_RTL points us to a value of some
10029 type which is *different* from the type of the parameter itself. Thus,
10030 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10031 such cases, the debugger would end up (for example) trying to fetch a
10032 `float' from a place which actually contains the first part of a
10033 `double'. That would lead to really incorrect and confusing
10034 output at debug-time.
10036 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10037 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
10038 are a couple of exceptions however. On little-endian machines we can
10039 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10040 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10041 an integral type that is smaller than TREE_TYPE (decl). These cases arise
10042 when (on a little-endian machine) a non-prototyped function has a
10043 parameter declared to be of type `short' or `char'. In such cases,
10044 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10045 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10046 passed `int' value. If the debugger then uses that address to fetch
10047 a `short' or a `char' (on a little-endian machine) the result will be
10048 the correct data, so we allow for such exceptional cases below.
10050 Note that our goal here is to describe the place where the given formal
10051 parameter lives during most of the function's activation (i.e. between the
10052 end of the prologue and the start of the epilogue). We'll do that as best
10053 as we can. Note however that if the given formal parameter is modified
10054 sometime during the execution of the function, then a stack backtrace (at
10055 debug-time) will show the function as having been called with the *new*
10056 value rather than the value which was originally passed in. This happens
10057 rarely enough that it is not a major problem, but it *is* a problem, and
10058 I'd like to fix it.
10060 A future version of dwarf2out.c may generate two additional attributes for
10061 any given DW_TAG_formal_parameter DIE which will describe the "passed
10062 type" and the "passed location" for the given formal parameter in addition
10063 to the attributes we now generate to indicate the "declared type" and the
10064 "active location" for each parameter. This additional set of attributes
10065 could be used by debuggers for stack backtraces. Separately, note that
10066 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10067 This happens (for example) for inlined-instances of inline function formal
10068 parameters which are never referenced. This really shouldn't be
10069 happening. All PARM_DECL nodes should get valid non-NULL
10070 DECL_INCOMING_RTL values. FIXME. */
10072 /* Use DECL_RTL as the "location" unless we find something better. */
10073 rtl = DECL_RTL_IF_SET (decl);
10075 /* When generating abstract instances, ignore everything except
10076 constants, symbols living in memory, and symbols living in
10077 fixed registers. */
10078 if (! reload_completed)
10081 && (CONSTANT_P (rtl)
10083 && CONSTANT_P (XEXP (rtl, 0)))
10085 && TREE_CODE (decl) == VAR_DECL
10086 && TREE_STATIC (decl))))
10088 rtl = targetm.delegitimize_address (rtl);
10093 else if (TREE_CODE (decl) == PARM_DECL)
10095 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10097 tree declared_type = TREE_TYPE (decl);
10098 tree passed_type = DECL_ARG_TYPE (decl);
10099 enum machine_mode dmode = TYPE_MODE (declared_type);
10100 enum machine_mode pmode = TYPE_MODE (passed_type);
10102 /* This decl represents a formal parameter which was optimized out.
10103 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10104 all cases where (rtl == NULL_RTX) just below. */
10105 if (dmode == pmode)
10106 rtl = DECL_INCOMING_RTL (decl);
10107 else if (SCALAR_INT_MODE_P (dmode)
10108 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10109 && DECL_INCOMING_RTL (decl))
10111 rtx inc = DECL_INCOMING_RTL (decl);
10114 else if (MEM_P (inc))
10116 if (BYTES_BIG_ENDIAN)
10117 rtl = adjust_address_nv (inc, dmode,
10118 GET_MODE_SIZE (pmode)
10119 - GET_MODE_SIZE (dmode));
10126 /* If the parm was passed in registers, but lives on the stack, then
10127 make a big endian correction if the mode of the type of the
10128 parameter is not the same as the mode of the rtl. */
10129 /* ??? This is the same series of checks that are made in dbxout.c before
10130 we reach the big endian correction code there. It isn't clear if all
10131 of these checks are necessary here, but keeping them all is the safe
10133 else if (MEM_P (rtl)
10134 && XEXP (rtl, 0) != const0_rtx
10135 && ! CONSTANT_P (XEXP (rtl, 0))
10136 /* Not passed in memory. */
10137 && !MEM_P (DECL_INCOMING_RTL (decl))
10138 /* Not passed by invisible reference. */
10139 && (!REG_P (XEXP (rtl, 0))
10140 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10141 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10142 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10143 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10146 /* Big endian correction check. */
10147 && BYTES_BIG_ENDIAN
10148 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10149 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10152 int offset = (UNITS_PER_WORD
10153 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10155 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10156 plus_constant (XEXP (rtl, 0), offset));
10159 else if (TREE_CODE (decl) == VAR_DECL
10162 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10163 && BYTES_BIG_ENDIAN)
10165 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10166 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10168 /* If a variable is declared "register" yet is smaller than
10169 a register, then if we store the variable to memory, it
10170 looks like we're storing a register-sized value, when in
10171 fact we are not. We need to adjust the offset of the
10172 storage location to reflect the actual value's bytes,
10173 else gdb will not be able to display it. */
10175 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10176 plus_constant (XEXP (rtl, 0), rsize-dsize));
10179 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10180 and will have been substituted directly into all expressions that use it.
10181 C does not have such a concept, but C++ and other languages do. */
10182 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10183 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10186 rtl = targetm.delegitimize_address (rtl);
10188 /* If we don't look past the constant pool, we risk emitting a
10189 reference to a constant pool entry that isn't referenced from
10190 code, and thus is not emitted. */
10192 rtl = avoid_constant_pool_reference (rtl);
10197 /* We need to figure out what section we should use as the base for the
10198 address ranges where a given location is valid.
10199 1. If this particular DECL has a section associated with it, use that.
10200 2. If this function has a section associated with it, use that.
10201 3. Otherwise, use the text section.
10202 XXX: If you split a variable across multiple sections, we won't notice. */
10204 static const char *
10205 secname_for_decl (tree decl)
10207 const char *secname;
10209 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10211 tree sectree = DECL_SECTION_NAME (decl);
10212 secname = TREE_STRING_POINTER (sectree);
10214 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10216 tree sectree = DECL_SECTION_NAME (current_function_decl);
10217 secname = TREE_STRING_POINTER (sectree);
10219 else if (cfun && in_cold_section_p)
10220 secname = cfun->cold_section_label;
10222 secname = text_section_label;
10227 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10228 data attribute for a variable or a parameter. We generate the
10229 DW_AT_const_value attribute only in those cases where the given variable
10230 or parameter does not have a true "location" either in memory or in a
10231 register. This can happen (for example) when a constant is passed as an
10232 actual argument in a call to an inline function. (It's possible that
10233 these things can crop up in other ways also.) Note that one type of
10234 constant value which can be passed into an inlined function is a constant
10235 pointer. This can happen for example if an actual argument in an inlined
10236 function call evaluates to a compile-time constant address. */
10239 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10240 enum dwarf_attribute attr)
10243 dw_loc_descr_ref descr;
10244 var_loc_list *loc_list;
10245 struct var_loc_node *node;
10246 if (TREE_CODE (decl) == ERROR_MARK)
10249 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10250 || TREE_CODE (decl) == RESULT_DECL);
10252 /* See if we possibly have multiple locations for this variable. */
10253 loc_list = lookup_decl_loc (decl);
10255 /* If it truly has multiple locations, the first and last node will
10257 if (loc_list && loc_list->first != loc_list->last)
10259 const char *endname, *secname;
10260 dw_loc_list_ref list;
10263 /* Now that we know what section we are using for a base,
10264 actually construct the list of locations.
10265 The first location information is what is passed to the
10266 function that creates the location list, and the remaining
10267 locations just get added on to that list.
10268 Note that we only know the start address for a location
10269 (IE location changes), so to build the range, we use
10270 the range [current location start, next location start].
10271 This means we have to special case the last node, and generate
10272 a range of [last location start, end of function label]. */
10274 node = loc_list->first;
10275 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10276 secname = secname_for_decl (decl);
10278 list = new_loc_list (loc_descriptor (varloc),
10279 node->label, node->next->label, secname, 1);
10282 for (; node->next; node = node->next)
10283 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10285 /* The variable has a location between NODE->LABEL and
10286 NODE->NEXT->LABEL. */
10287 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10288 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10289 node->label, node->next->label, secname);
10292 /* If the variable has a location at the last label
10293 it keeps its location until the end of function. */
10294 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10296 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10298 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10299 if (!current_function_decl)
10300 endname = text_end_label;
10303 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10304 current_function_funcdef_no);
10305 endname = ggc_strdup (label_id);
10307 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10308 node->label, endname, secname);
10311 /* Finally, add the location list to the DIE, and we are done. */
10312 add_AT_loc_list (die, attr, list);
10316 /* Try to get some constant RTL for this decl, and use that as the value of
10319 rtl = rtl_for_decl_location (decl);
10320 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10322 add_const_value_attribute (die, rtl);
10326 /* If we have tried to generate the location otherwise, and it
10327 didn't work out (we wouldn't be here if we did), and we have a one entry
10328 location list, try generating a location from that. */
10329 if (loc_list && loc_list->first)
10331 node = loc_list->first;
10332 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10335 add_AT_location_description (die, attr, descr);
10340 /* We couldn't get any rtl, so try directly generating the location
10341 description from the tree. */
10342 descr = loc_descriptor_from_tree (decl);
10345 add_AT_location_description (die, attr, descr);
10348 /* None of that worked, so it must not really have a location;
10349 try adding a constant value attribute from the DECL_INITIAL. */
10350 tree_add_const_value_attribute (die, decl);
10353 /* If we don't have a copy of this variable in memory for some reason (such
10354 as a C++ member constant that doesn't have an out-of-line definition),
10355 we should tell the debugger about the constant value. */
10358 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10360 tree init = DECL_INITIAL (decl);
10361 tree type = TREE_TYPE (decl);
10364 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10369 rtl = rtl_for_decl_init (init, type);
10371 add_const_value_attribute (var_die, rtl);
10374 /* Convert the CFI instructions for the current function into a
10375 location list. This is used for DW_AT_frame_base when we targeting
10376 a dwarf2 consumer that does not support the dwarf3
10377 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
10380 static dw_loc_list_ref
10381 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
10384 dw_loc_list_ref list, *list_tail;
10386 dw_cfa_location last_cfa, next_cfa;
10387 const char *start_label, *last_label, *section;
10389 fde = &fde_table[fde_table_in_use - 1];
10391 section = secname_for_decl (current_function_decl);
10395 next_cfa.reg = INVALID_REGNUM;
10396 next_cfa.offset = 0;
10397 next_cfa.indirect = 0;
10398 next_cfa.base_offset = 0;
10400 start_label = fde->dw_fde_begin;
10402 /* ??? Bald assumption that the CIE opcode list does not contain
10403 advance opcodes. */
10404 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10405 lookup_cfa_1 (cfi, &next_cfa);
10407 last_cfa = next_cfa;
10408 last_label = start_label;
10410 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10411 switch (cfi->dw_cfi_opc)
10413 case DW_CFA_advance_loc1:
10414 case DW_CFA_advance_loc2:
10415 case DW_CFA_advance_loc4:
10416 if (!cfa_equal_p (&last_cfa, &next_cfa))
10418 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10419 start_label, last_label, section,
10422 list_tail = &(*list_tail)->dw_loc_next;
10423 last_cfa = next_cfa;
10424 start_label = last_label;
10426 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10429 case DW_CFA_advance_loc:
10430 /* The encoding is complex enough that we should never emit this. */
10431 case DW_CFA_remember_state:
10432 case DW_CFA_restore_state:
10433 /* We don't handle these two in this function. It would be possible
10434 if it were to be required. */
10435 gcc_unreachable ();
10438 lookup_cfa_1 (cfi, &next_cfa);
10442 if (!cfa_equal_p (&last_cfa, &next_cfa))
10444 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
10445 start_label, last_label, section,
10447 list_tail = &(*list_tail)->dw_loc_next;
10448 start_label = last_label;
10450 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
10451 start_label, fde->dw_fde_end, section,
10457 /* Compute a displacement from the "steady-state frame pointer" to the
10458 frame base (often the same as the CFA), and store it in
10459 frame_pointer_fb_offset. OFFSET is added to the displacement
10460 before the latter is negated. */
10463 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
10467 #ifdef FRAME_POINTER_CFA_OFFSET
10468 reg = frame_pointer_rtx;
10469 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
10471 reg = arg_pointer_rtx;
10472 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
10475 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10476 if (GET_CODE (elim) == PLUS)
10478 offset += INTVAL (XEXP (elim, 1));
10479 elim = XEXP (elim, 0);
10481 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10482 : stack_pointer_rtx));
10484 frame_pointer_fb_offset = -offset;
10487 /* Generate a DW_AT_name attribute given some string value to be included as
10488 the value of the attribute. */
10491 add_name_attribute (dw_die_ref die, const char *name_string)
10493 if (name_string != NULL && *name_string != 0)
10495 if (demangle_name_func)
10496 name_string = (*demangle_name_func) (name_string);
10498 add_AT_string (die, DW_AT_name, name_string);
10502 /* Generate a DW_AT_comp_dir attribute for DIE. */
10505 add_comp_dir_attribute (dw_die_ref die)
10507 const char *wd = get_src_pwd ();
10509 add_AT_string (die, DW_AT_comp_dir, wd);
10512 /* Given a tree node describing an array bound (either lower or upper) output
10513 a representation for that bound. */
10516 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10518 switch (TREE_CODE (bound))
10523 /* All fixed-bounds are represented by INTEGER_CST nodes. */
10525 if (! host_integerp (bound, 0)
10526 || (bound_attr == DW_AT_lower_bound
10527 && (((is_c_family () || is_java ()) && integer_zerop (bound))
10528 || (is_fortran () && integer_onep (bound)))))
10529 /* Use the default. */
10532 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10537 case NON_LVALUE_EXPR:
10538 case VIEW_CONVERT_EXPR:
10539 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10549 dw_die_ref decl_die = lookup_decl_die (bound);
10551 /* ??? Can this happen, or should the variable have been bound
10552 first? Probably it can, since I imagine that we try to create
10553 the types of parameters in the order in which they exist in
10554 the list, and won't have created a forward reference to a
10555 later parameter. */
10556 if (decl_die != NULL)
10557 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10563 /* Otherwise try to create a stack operation procedure to
10564 evaluate the value of the array bound. */
10566 dw_die_ref ctx, decl_die;
10567 dw_loc_descr_ref loc;
10569 loc = loc_descriptor_from_tree (bound);
10573 if (current_function_decl == 0)
10574 ctx = comp_unit_die;
10576 ctx = lookup_decl_die (current_function_decl);
10578 decl_die = new_die (DW_TAG_variable, ctx, bound);
10579 add_AT_flag (decl_die, DW_AT_artificial, 1);
10580 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10581 add_AT_loc (decl_die, DW_AT_location, loc);
10583 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10589 /* Note that the block of subscript information for an array type also
10590 includes information about the element type of type given array type. */
10593 add_subscript_info (dw_die_ref type_die, tree type)
10595 #ifndef MIPS_DEBUGGING_INFO
10596 unsigned dimension_number;
10599 dw_die_ref subrange_die;
10601 /* The GNU compilers represent multidimensional array types as sequences of
10602 one dimensional array types whose element types are themselves array
10603 types. Here we squish that down, so that each multidimensional array
10604 type gets only one array_type DIE in the Dwarf debugging info. The draft
10605 Dwarf specification say that we are allowed to do this kind of
10606 compression in C (because there is no difference between an array or
10607 arrays and a multidimensional array in C) but for other source languages
10608 (e.g. Ada) we probably shouldn't do this. */
10610 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10611 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10612 We work around this by disabling this feature. See also
10613 gen_array_type_die. */
10614 #ifndef MIPS_DEBUGGING_INFO
10615 for (dimension_number = 0;
10616 TREE_CODE (type) == ARRAY_TYPE;
10617 type = TREE_TYPE (type), dimension_number++)
10620 tree domain = TYPE_DOMAIN (type);
10622 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10623 and (in GNU C only) variable bounds. Handle all three forms
10625 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10628 /* We have an array type with specified bounds. */
10629 lower = TYPE_MIN_VALUE (domain);
10630 upper = TYPE_MAX_VALUE (domain);
10632 /* Define the index type. */
10633 if (TREE_TYPE (domain))
10635 /* ??? This is probably an Ada unnamed subrange type. Ignore the
10636 TREE_TYPE field. We can't emit debug info for this
10637 because it is an unnamed integral type. */
10638 if (TREE_CODE (domain) == INTEGER_TYPE
10639 && TYPE_NAME (domain) == NULL_TREE
10640 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10641 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10644 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10648 /* ??? If upper is NULL, the array has unspecified length,
10649 but it does have a lower bound. This happens with Fortran
10651 Since the debugger is definitely going to need to know N
10652 to produce useful results, go ahead and output the lower
10653 bound solo, and hope the debugger can cope. */
10655 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10657 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10660 /* Otherwise we have an array type with an unspecified length. The
10661 DWARF-2 spec does not say how to handle this; let's just leave out the
10667 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10671 switch (TREE_CODE (tree_node))
10676 case ENUMERAL_TYPE:
10679 case QUAL_UNION_TYPE:
10680 size = int_size_in_bytes (tree_node);
10683 /* For a data member of a struct or union, the DW_AT_byte_size is
10684 generally given as the number of bytes normally allocated for an
10685 object of the *declared* type of the member itself. This is true
10686 even for bit-fields. */
10687 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10690 gcc_unreachable ();
10693 /* Note that `size' might be -1 when we get to this point. If it is, that
10694 indicates that the byte size of the entity in question is variable. We
10695 have no good way of expressing this fact in Dwarf at the present time,
10696 so just let the -1 pass on through. */
10697 add_AT_unsigned (die, DW_AT_byte_size, size);
10700 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10701 which specifies the distance in bits from the highest order bit of the
10702 "containing object" for the bit-field to the highest order bit of the
10705 For any given bit-field, the "containing object" is a hypothetical object
10706 (of some integral or enum type) within which the given bit-field lives. The
10707 type of this hypothetical "containing object" is always the same as the
10708 declared type of the individual bit-field itself. The determination of the
10709 exact location of the "containing object" for a bit-field is rather
10710 complicated. It's handled by the `field_byte_offset' function (above).
10712 Note that it is the size (in bytes) of the hypothetical "containing object"
10713 which will be given in the DW_AT_byte_size attribute for this bit-field.
10714 (See `byte_size_attribute' above). */
10717 add_bit_offset_attribute (dw_die_ref die, tree decl)
10719 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10720 tree type = DECL_BIT_FIELD_TYPE (decl);
10721 HOST_WIDE_INT bitpos_int;
10722 HOST_WIDE_INT highest_order_object_bit_offset;
10723 HOST_WIDE_INT highest_order_field_bit_offset;
10724 HOST_WIDE_INT unsigned bit_offset;
10726 /* Must be a field and a bit field. */
10727 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10729 /* We can't yet handle bit-fields whose offsets are variable, so if we
10730 encounter such things, just return without generating any attribute
10731 whatsoever. Likewise for variable or too large size. */
10732 if (! host_integerp (bit_position (decl), 0)
10733 || ! host_integerp (DECL_SIZE (decl), 1))
10736 bitpos_int = int_bit_position (decl);
10738 /* Note that the bit offset is always the distance (in bits) from the
10739 highest-order bit of the "containing object" to the highest-order bit of
10740 the bit-field itself. Since the "high-order end" of any object or field
10741 is different on big-endian and little-endian machines, the computation
10742 below must take account of these differences. */
10743 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10744 highest_order_field_bit_offset = bitpos_int;
10746 if (! BYTES_BIG_ENDIAN)
10748 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10749 highest_order_object_bit_offset += simple_type_size_in_bits (type);
10753 = (! BYTES_BIG_ENDIAN
10754 ? highest_order_object_bit_offset - highest_order_field_bit_offset
10755 : highest_order_field_bit_offset - highest_order_object_bit_offset);
10757 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10760 /* For a FIELD_DECL node which represents a bit field, output an attribute
10761 which specifies the length in bits of the given field. */
10764 add_bit_size_attribute (dw_die_ref die, tree decl)
10766 /* Must be a field and a bit field. */
10767 gcc_assert (TREE_CODE (decl) == FIELD_DECL
10768 && DECL_BIT_FIELD_TYPE (decl));
10770 if (host_integerp (DECL_SIZE (decl), 1))
10771 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10774 /* If the compiled language is ANSI C, then add a 'prototyped'
10775 attribute, if arg types are given for the parameters of a function. */
10778 add_prototyped_attribute (dw_die_ref die, tree func_type)
10780 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10781 && TYPE_ARG_TYPES (func_type) != NULL)
10782 add_AT_flag (die, DW_AT_prototyped, 1);
10785 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
10786 by looking in either the type declaration or object declaration
10790 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10792 dw_die_ref origin_die = NULL;
10794 if (TREE_CODE (origin) != FUNCTION_DECL)
10796 /* We may have gotten separated from the block for the inlined
10797 function, if we're in an exception handler or some such; make
10798 sure that the abstract function has been written out.
10800 Doing this for nested functions is wrong, however; functions are
10801 distinct units, and our context might not even be inline. */
10805 fn = TYPE_STUB_DECL (fn);
10807 fn = decl_function_context (fn);
10809 dwarf2out_abstract_function (fn);
10812 if (DECL_P (origin))
10813 origin_die = lookup_decl_die (origin);
10814 else if (TYPE_P (origin))
10815 origin_die = lookup_type_die (origin);
10817 /* XXX: Functions that are never lowered don't always have correct block
10818 trees (in the case of java, they simply have no block tree, in some other
10819 languages). For these functions, there is nothing we can really do to
10820 output correct debug info for inlined functions in all cases. Rather
10821 than die, we'll just produce deficient debug info now, in that we will
10822 have variables without a proper abstract origin. In the future, when all
10823 functions are lowered, we should re-add a gcc_assert (origin_die)
10827 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10830 /* We do not currently support the pure_virtual attribute. */
10833 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10835 if (DECL_VINDEX (func_decl))
10837 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10839 if (host_integerp (DECL_VINDEX (func_decl), 0))
10840 add_AT_loc (die, DW_AT_vtable_elem_location,
10841 new_loc_descr (DW_OP_constu,
10842 tree_low_cst (DECL_VINDEX (func_decl), 0),
10845 /* GNU extension: Record what type this method came from originally. */
10846 if (debug_info_level > DINFO_LEVEL_TERSE)
10847 add_AT_die_ref (die, DW_AT_containing_type,
10848 lookup_type_die (DECL_CONTEXT (func_decl)));
10852 /* Add source coordinate attributes for the given decl. */
10855 add_src_coords_attributes (dw_die_ref die, tree decl)
10857 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10858 unsigned file_index = lookup_filename (s.file);
10860 add_AT_unsigned (die, DW_AT_decl_file, file_index);
10861 add_AT_unsigned (die, DW_AT_decl_line, s.line);
10864 /* Add a DW_AT_name attribute and source coordinate attribute for the
10865 given decl, but only if it actually has a name. */
10868 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10872 decl_name = DECL_NAME (decl);
10873 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10875 add_name_attribute (die, dwarf2_name (decl, 0));
10876 if (! DECL_ARTIFICIAL (decl))
10877 add_src_coords_attributes (die, decl);
10879 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10880 && TREE_PUBLIC (decl)
10881 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10882 && !DECL_ABSTRACT (decl)
10883 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
10884 add_AT_string (die, DW_AT_MIPS_linkage_name,
10885 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10888 #ifdef VMS_DEBUGGING_INFO
10889 /* Get the function's name, as described by its RTL. This may be different
10890 from the DECL_NAME name used in the source file. */
10891 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10893 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10894 XEXP (DECL_RTL (decl), 0));
10895 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
10900 /* Push a new declaration scope. */
10903 push_decl_scope (tree scope)
10905 VEC_safe_push (tree, gc, decl_scope_table, scope);
10908 /* Pop a declaration scope. */
10911 pop_decl_scope (void)
10913 VEC_pop (tree, decl_scope_table);
10916 /* Return the DIE for the scope that immediately contains this type.
10917 Non-named types get global scope. Named types nested in other
10918 types get their containing scope if it's open, or global scope
10919 otherwise. All other types (i.e. function-local named types) get
10920 the current active scope. */
10923 scope_die_for (tree t, dw_die_ref context_die)
10925 dw_die_ref scope_die = NULL;
10926 tree containing_scope;
10929 /* Non-types always go in the current scope. */
10930 gcc_assert (TYPE_P (t));
10932 containing_scope = TYPE_CONTEXT (t);
10934 /* Use the containing namespace if it was passed in (for a declaration). */
10935 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10937 if (context_die == lookup_decl_die (containing_scope))
10940 containing_scope = NULL_TREE;
10943 /* Ignore function type "scopes" from the C frontend. They mean that
10944 a tagged type is local to a parmlist of a function declarator, but
10945 that isn't useful to DWARF. */
10946 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10947 containing_scope = NULL_TREE;
10949 if (containing_scope == NULL_TREE)
10950 scope_die = comp_unit_die;
10951 else if (TYPE_P (containing_scope))
10953 /* For types, we can just look up the appropriate DIE. But
10954 first we check to see if we're in the middle of emitting it
10955 so we know where the new DIE should go. */
10956 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
10957 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
10962 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
10963 || TREE_ASM_WRITTEN (containing_scope));
10965 /* If none of the current dies are suitable, we get file scope. */
10966 scope_die = comp_unit_die;
10969 scope_die = lookup_type_die (containing_scope);
10972 scope_die = context_die;
10977 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
10980 local_scope_p (dw_die_ref context_die)
10982 for (; context_die; context_die = context_die->die_parent)
10983 if (context_die->die_tag == DW_TAG_inlined_subroutine
10984 || context_die->die_tag == DW_TAG_subprogram)
10990 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10991 whether or not to treat a DIE in this context as a declaration. */
10994 class_or_namespace_scope_p (dw_die_ref context_die)
10996 return (context_die
10997 && (context_die->die_tag == DW_TAG_structure_type
10998 || context_die->die_tag == DW_TAG_union_type
10999 || context_die->die_tag == DW_TAG_namespace));
11002 /* Many forms of DIEs require a "type description" attribute. This
11003 routine locates the proper "type descriptor" die for the type given
11004 by 'type', and adds a DW_AT_type attribute below the given die. */
11007 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
11008 int decl_volatile, dw_die_ref context_die)
11010 enum tree_code code = TREE_CODE (type);
11011 dw_die_ref type_die = NULL;
11013 /* ??? If this type is an unnamed subrange type of an integral or
11014 floating-point type, use the inner type. This is because we have no
11015 support for unnamed types in base_type_die. This can happen if this is
11016 an Ada subrange type. Correct solution is emit a subrange type die. */
11017 if ((code == INTEGER_TYPE || code == REAL_TYPE)
11018 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
11019 type = TREE_TYPE (type), code = TREE_CODE (type);
11021 if (code == ERROR_MARK
11022 /* Handle a special case. For functions whose return type is void, we
11023 generate *no* type attribute. (Note that no object may have type
11024 `void', so this only applies to function return types). */
11025 || code == VOID_TYPE)
11028 type_die = modified_type_die (type,
11029 decl_const || TYPE_READONLY (type),
11030 decl_volatile || TYPE_VOLATILE (type),
11033 if (type_die != NULL)
11034 add_AT_die_ref (object_die, DW_AT_type, type_die);
11037 /* Given an object die, add the calling convention attribute for the
11038 function call type. */
11040 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11042 enum dwarf_calling_convention value = DW_CC_normal;
11044 value = targetm.dwarf_calling_convention (type);
11046 /* Only add the attribute if the backend requests it, and
11047 is not DW_CC_normal. */
11048 if (value && (value != DW_CC_normal))
11049 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11052 /* Given a tree pointer to a struct, class, union, or enum type node, return
11053 a pointer to the (string) tag name for the given type, or zero if the type
11054 was declared without a tag. */
11056 static const char *
11057 type_tag (tree type)
11059 const char *name = 0;
11061 if (TYPE_NAME (type) != 0)
11065 /* Find the IDENTIFIER_NODE for the type name. */
11066 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11067 t = TYPE_NAME (type);
11069 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11070 a TYPE_DECL node, regardless of whether or not a `typedef' was
11072 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11073 && ! DECL_IGNORED_P (TYPE_NAME (type)))
11074 t = DECL_NAME (TYPE_NAME (type));
11076 /* Now get the name as a string, or invent one. */
11078 name = IDENTIFIER_POINTER (t);
11081 return (name == 0 || *name == '\0') ? 0 : name;
11084 /* Return the type associated with a data member, make a special check
11085 for bit field types. */
11088 member_declared_type (tree member)
11090 return (DECL_BIT_FIELD_TYPE (member)
11091 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11094 /* Get the decl's label, as described by its RTL. This may be different
11095 from the DECL_NAME name used in the source file. */
11098 static const char *
11099 decl_start_label (tree decl)
11102 const char *fnname;
11104 x = DECL_RTL (decl);
11105 gcc_assert (MEM_P (x));
11108 gcc_assert (GET_CODE (x) == SYMBOL_REF);
11110 fnname = XSTR (x, 0);
11115 /* These routines generate the internal representation of the DIE's for
11116 the compilation unit. Debugging information is collected by walking
11117 the declaration trees passed in from dwarf2out_decl(). */
11120 gen_array_type_die (tree type, dw_die_ref context_die)
11122 dw_die_ref scope_die = scope_die_for (type, context_die);
11123 dw_die_ref array_die;
11126 /* ??? The SGI dwarf reader fails for array of array of enum types unless
11127 the inner array type comes before the outer array type. Thus we must
11128 call gen_type_die before we call new_die. See below also. */
11129 #ifdef MIPS_DEBUGGING_INFO
11130 gen_type_die (TREE_TYPE (type), context_die);
11133 array_die = new_die (DW_TAG_array_type, scope_die, type);
11134 add_name_attribute (array_die, type_tag (type));
11135 equate_type_number_to_die (type, array_die);
11137 if (TREE_CODE (type) == VECTOR_TYPE)
11139 /* The frontend feeds us a representation for the vector as a struct
11140 containing an array. Pull out the array type. */
11141 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11142 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11146 /* We default the array ordering. SDB will probably do
11147 the right things even if DW_AT_ordering is not present. It's not even
11148 an issue until we start to get into multidimensional arrays anyway. If
11149 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11150 then we'll have to put the DW_AT_ordering attribute back in. (But if
11151 and when we find out that we need to put these in, we will only do so
11152 for multidimensional arrays. */
11153 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11156 #ifdef MIPS_DEBUGGING_INFO
11157 /* The SGI compilers handle arrays of unknown bound by setting
11158 AT_declaration and not emitting any subrange DIEs. */
11159 if (! TYPE_DOMAIN (type))
11160 add_AT_flag (array_die, DW_AT_declaration, 1);
11163 add_subscript_info (array_die, type);
11165 /* Add representation of the type of the elements of this array type. */
11166 element_type = TREE_TYPE (type);
11168 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11169 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
11170 We work around this by disabling this feature. See also
11171 add_subscript_info. */
11172 #ifndef MIPS_DEBUGGING_INFO
11173 while (TREE_CODE (element_type) == ARRAY_TYPE)
11174 element_type = TREE_TYPE (element_type);
11176 gen_type_die (element_type, context_die);
11179 add_type_attribute (array_die, element_type, 0, 0, context_die);
11184 gen_entry_point_die (tree decl, dw_die_ref context_die)
11186 tree origin = decl_ultimate_origin (decl);
11187 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11189 if (origin != NULL)
11190 add_abstract_origin_attribute (decl_die, origin);
11193 add_name_and_src_coords_attributes (decl_die, decl);
11194 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11195 0, 0, context_die);
11198 if (DECL_ABSTRACT (decl))
11199 equate_decl_number_to_die (decl, decl_die);
11201 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11205 /* Walk through the list of incomplete types again, trying once more to
11206 emit full debugging info for them. */
11209 retry_incomplete_types (void)
11213 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11214 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11217 /* Generate a DIE to represent an inlined instance of an enumeration type. */
11220 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11222 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11224 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11225 be incomplete and such types are not marked. */
11226 add_abstract_origin_attribute (type_die, type);
11229 /* Generate a DIE to represent an inlined instance of a structure type. */
11232 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11234 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11236 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11237 be incomplete and such types are not marked. */
11238 add_abstract_origin_attribute (type_die, type);
11241 /* Generate a DIE to represent an inlined instance of a union type. */
11244 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11246 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11248 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11249 be incomplete and such types are not marked. */
11250 add_abstract_origin_attribute (type_die, type);
11253 /* Generate a DIE to represent an enumeration type. Note that these DIEs
11254 include all of the information about the enumeration values also. Each
11255 enumerated type name/value is listed as a child of the enumerated type
11259 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11261 dw_die_ref type_die = lookup_type_die (type);
11263 if (type_die == NULL)
11265 type_die = new_die (DW_TAG_enumeration_type,
11266 scope_die_for (type, context_die), type);
11267 equate_type_number_to_die (type, type_die);
11268 add_name_attribute (type_die, type_tag (type));
11270 else if (! TYPE_SIZE (type))
11273 remove_AT (type_die, DW_AT_declaration);
11275 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
11276 given enum type is incomplete, do not generate the DW_AT_byte_size
11277 attribute or the DW_AT_element_list attribute. */
11278 if (TYPE_SIZE (type))
11282 TREE_ASM_WRITTEN (type) = 1;
11283 add_byte_size_attribute (type_die, type);
11284 if (TYPE_STUB_DECL (type) != NULL_TREE)
11285 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11287 /* If the first reference to this type was as the return type of an
11288 inline function, then it may not have a parent. Fix this now. */
11289 if (type_die->die_parent == NULL)
11290 add_child_die (scope_die_for (type, context_die), type_die);
11292 for (link = TYPE_VALUES (type);
11293 link != NULL; link = TREE_CHAIN (link))
11295 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11296 tree value = TREE_VALUE (link);
11298 add_name_attribute (enum_die,
11299 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11301 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11302 /* DWARF2 does not provide a way of indicating whether or
11303 not enumeration constants are signed or unsigned. GDB
11304 always assumes the values are signed, so we output all
11305 values as if they were signed. That means that
11306 enumeration constants with very large unsigned values
11307 will appear to have negative values in the debugger. */
11308 add_AT_int (enum_die, DW_AT_const_value,
11309 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11313 add_AT_flag (type_die, DW_AT_declaration, 1);
11318 /* Generate a DIE to represent either a real live formal parameter decl or to
11319 represent just the type of some formal parameter position in some function
11322 Note that this routine is a bit unusual because its argument may be a
11323 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11324 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11325 node. If it's the former then this function is being called to output a
11326 DIE to represent a formal parameter object (or some inlining thereof). If
11327 it's the latter, then this function is only being called to output a
11328 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11329 argument type of some subprogram type. */
11332 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11334 dw_die_ref parm_die
11335 = new_die (DW_TAG_formal_parameter, context_die, node);
11338 switch (TREE_CODE_CLASS (TREE_CODE (node)))
11340 case tcc_declaration:
11341 origin = decl_ultimate_origin (node);
11342 if (origin != NULL)
11343 add_abstract_origin_attribute (parm_die, origin);
11346 add_name_and_src_coords_attributes (parm_die, node);
11347 add_type_attribute (parm_die, TREE_TYPE (node),
11348 TREE_READONLY (node),
11349 TREE_THIS_VOLATILE (node),
11351 if (DECL_ARTIFICIAL (node))
11352 add_AT_flag (parm_die, DW_AT_artificial, 1);
11355 equate_decl_number_to_die (node, parm_die);
11356 if (! DECL_ABSTRACT (node))
11357 add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11362 /* We were called with some kind of a ..._TYPE node. */
11363 add_type_attribute (parm_die, node, 0, 0, context_die);
11367 gcc_unreachable ();
11373 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11374 at the end of an (ANSI prototyped) formal parameters list. */
11377 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11379 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11382 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11383 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11384 parameters as specified in some function type specification (except for
11385 those which appear as part of a function *definition*). */
11388 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11391 tree formal_type = NULL;
11392 tree first_parm_type;
11395 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11397 arg = DECL_ARGUMENTS (function_or_method_type);
11398 function_or_method_type = TREE_TYPE (function_or_method_type);
11403 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11405 /* Make our first pass over the list of formal parameter types and output a
11406 DW_TAG_formal_parameter DIE for each one. */
11407 for (link = first_parm_type; link; )
11409 dw_die_ref parm_die;
11411 formal_type = TREE_VALUE (link);
11412 if (formal_type == void_type_node)
11415 /* Output a (nameless) DIE to represent the formal parameter itself. */
11416 parm_die = gen_formal_parameter_die (formal_type, context_die);
11417 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11418 && link == first_parm_type)
11419 || (arg && DECL_ARTIFICIAL (arg)))
11420 add_AT_flag (parm_die, DW_AT_artificial, 1);
11422 link = TREE_CHAIN (link);
11424 arg = TREE_CHAIN (arg);
11427 /* If this function type has an ellipsis, add a
11428 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
11429 if (formal_type != void_type_node)
11430 gen_unspecified_parameters_die (function_or_method_type, context_die);
11432 /* Make our second (and final) pass over the list of formal parameter types
11433 and output DIEs to represent those types (as necessary). */
11434 for (link = TYPE_ARG_TYPES (function_or_method_type);
11435 link && TREE_VALUE (link);
11436 link = TREE_CHAIN (link))
11437 gen_type_die (TREE_VALUE (link), context_die);
11440 /* We want to generate the DIE for TYPE so that we can generate the
11441 die for MEMBER, which has been defined; we will need to refer back
11442 to the member declaration nested within TYPE. If we're trying to
11443 generate minimal debug info for TYPE, processing TYPE won't do the
11444 trick; we need to attach the member declaration by hand. */
11447 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11449 gen_type_die (type, context_die);
11451 /* If we're trying to avoid duplicate debug info, we may not have
11452 emitted the member decl for this function. Emit it now. */
11453 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11454 && ! lookup_decl_die (member))
11456 dw_die_ref type_die;
11457 gcc_assert (!decl_ultimate_origin (member));
11459 push_decl_scope (type);
11460 type_die = lookup_type_die (type);
11461 if (TREE_CODE (member) == FUNCTION_DECL)
11462 gen_subprogram_die (member, type_die);
11463 else if (TREE_CODE (member) == FIELD_DECL)
11465 /* Ignore the nameless fields that are used to skip bits but handle
11466 C++ anonymous unions and structs. */
11467 if (DECL_NAME (member) != NULL_TREE
11468 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11469 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11471 gen_type_die (member_declared_type (member), type_die);
11472 gen_field_die (member, type_die);
11476 gen_variable_die (member, type_die);
11482 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11483 may later generate inlined and/or out-of-line instances of. */
11486 dwarf2out_abstract_function (tree decl)
11488 dw_die_ref old_die;
11491 int was_abstract = DECL_ABSTRACT (decl);
11493 /* Make sure we have the actual abstract inline, not a clone. */
11494 decl = DECL_ORIGIN (decl);
11496 old_die = lookup_decl_die (decl);
11497 if (old_die && get_AT (old_die, DW_AT_inline))
11498 /* We've already generated the abstract instance. */
11501 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11502 we don't get confused by DECL_ABSTRACT. */
11503 if (debug_info_level > DINFO_LEVEL_TERSE)
11505 context = decl_class_context (decl);
11507 gen_type_die_for_member
11508 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11511 /* Pretend we've just finished compiling this function. */
11512 save_fn = current_function_decl;
11513 current_function_decl = decl;
11515 set_decl_abstract_flags (decl, 1);
11516 dwarf2out_decl (decl);
11517 if (! was_abstract)
11518 set_decl_abstract_flags (decl, 0);
11520 current_function_decl = save_fn;
11523 /* Generate a DIE to represent a declared function (either file-scope or
11527 gen_subprogram_die (tree decl, dw_die_ref context_die)
11529 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11530 tree origin = decl_ultimate_origin (decl);
11531 dw_die_ref subr_die;
11534 dw_die_ref old_die = lookup_decl_die (decl);
11535 int declaration = (current_function_decl != decl
11536 || class_or_namespace_scope_p (context_die));
11538 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11539 started to generate the abstract instance of an inline, decided to output
11540 its containing class, and proceeded to emit the declaration of the inline
11541 from the member list for the class. If so, DECLARATION takes priority;
11542 we'll get back to the abstract instance when done with the class. */
11544 /* The class-scope declaration DIE must be the primary DIE. */
11545 if (origin && declaration && class_or_namespace_scope_p (context_die))
11548 gcc_assert (!old_die);
11551 /* Now that the C++ front end lazily declares artificial member fns, we
11552 might need to retrofit the declaration into its class. */
11553 if (!declaration && !origin && !old_die
11554 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11555 && !class_or_namespace_scope_p (context_die)
11556 && debug_info_level > DINFO_LEVEL_TERSE)
11557 old_die = force_decl_die (decl);
11559 if (origin != NULL)
11561 gcc_assert (!declaration || local_scope_p (context_die));
11563 /* Fixup die_parent for the abstract instance of a nested
11564 inline function. */
11565 if (old_die && old_die->die_parent == NULL)
11566 add_child_die (context_die, old_die);
11568 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11569 add_abstract_origin_attribute (subr_die, origin);
11573 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11574 unsigned file_index = lookup_filename (s.file);
11576 if (!get_AT_flag (old_die, DW_AT_declaration)
11577 /* We can have a normal definition following an inline one in the
11578 case of redefinition of GNU C extern inlines.
11579 It seems reasonable to use AT_specification in this case. */
11580 && !get_AT (old_die, DW_AT_inline))
11582 /* Detect and ignore this case, where we are trying to output
11583 something we have already output. */
11587 /* If the definition comes from the same place as the declaration,
11588 maybe use the old DIE. We always want the DIE for this function
11589 that has the *_pc attributes to be under comp_unit_die so the
11590 debugger can find it. We also need to do this for abstract
11591 instances of inlines, since the spec requires the out-of-line copy
11592 to have the same parent. For local class methods, this doesn't
11593 apply; we just use the old DIE. */
11594 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11595 && (DECL_ARTIFICIAL (decl)
11596 || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
11597 && (get_AT_unsigned (old_die, DW_AT_decl_line)
11598 == (unsigned) s.line))))
11600 subr_die = old_die;
11602 /* Clear out the declaration attribute and the formal parameters.
11603 Do not remove all children, because it is possible that this
11604 declaration die was forced using force_decl_die(). In such
11605 cases die that forced declaration die (e.g. TAG_imported_module)
11606 is one of the children that we do not want to remove. */
11607 remove_AT (subr_die, DW_AT_declaration);
11608 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11612 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11613 add_AT_specification (subr_die, old_die);
11614 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11615 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
11616 if (get_AT_unsigned (old_die, DW_AT_decl_line)
11617 != (unsigned) s.line)
11619 (subr_die, DW_AT_decl_line, s.line);
11624 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11626 if (TREE_PUBLIC (decl))
11627 add_AT_flag (subr_die, DW_AT_external, 1);
11629 add_name_and_src_coords_attributes (subr_die, decl);
11630 if (debug_info_level > DINFO_LEVEL_TERSE)
11632 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11633 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11634 0, 0, context_die);
11637 add_pure_or_virtual_attribute (subr_die, decl);
11638 if (DECL_ARTIFICIAL (decl))
11639 add_AT_flag (subr_die, DW_AT_artificial, 1);
11641 if (TREE_PROTECTED (decl))
11642 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11643 else if (TREE_PRIVATE (decl))
11644 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11649 if (!old_die || !get_AT (old_die, DW_AT_inline))
11651 add_AT_flag (subr_die, DW_AT_declaration, 1);
11653 /* The first time we see a member function, it is in the context of
11654 the class to which it belongs. We make sure of this by emitting
11655 the class first. The next time is the definition, which is
11656 handled above. The two may come from the same source text.
11658 Note that force_decl_die() forces function declaration die. It is
11659 later reused to represent definition. */
11660 equate_decl_number_to_die (decl, subr_die);
11663 else if (DECL_ABSTRACT (decl))
11665 if (DECL_DECLARED_INLINE_P (decl))
11667 if (cgraph_function_possibly_inlined_p (decl))
11668 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11670 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11674 if (cgraph_function_possibly_inlined_p (decl))
11675 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11677 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11680 equate_decl_number_to_die (decl, subr_die);
11682 else if (!DECL_EXTERNAL (decl))
11684 HOST_WIDE_INT cfa_fb_offset;
11686 if (!old_die || !get_AT (old_die, DW_AT_inline))
11687 equate_decl_number_to_die (decl, subr_die);
11689 if (!flag_reorder_blocks_and_partition)
11691 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11692 current_function_funcdef_no);
11693 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11694 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11695 current_function_funcdef_no);
11696 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11698 add_pubname (decl, subr_die);
11699 add_arange (decl, subr_die);
11702 { /* Do nothing for now; maybe need to duplicate die, one for
11703 hot section and ond for cold section, then use the hot/cold
11704 section begin/end labels to generate the aranges... */
11706 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11707 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11708 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11709 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11711 add_pubname (decl, subr_die);
11712 add_arange (decl, subr_die);
11713 add_arange (decl, subr_die);
11717 #ifdef MIPS_DEBUGGING_INFO
11718 /* Add a reference to the FDE for this routine. */
11719 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11722 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
11724 /* We define the "frame base" as the function's CFA. This is more
11725 convenient for several reasons: (1) It's stable across the prologue
11726 and epilogue, which makes it better than just a frame pointer,
11727 (2) With dwarf3, there exists a one-byte encoding that allows us
11728 to reference the .debug_frame data by proxy, but failing that,
11729 (3) We can at least reuse the code inspection and interpretation
11730 code that determines the CFA position at various points in the
11732 /* ??? Use some command-line or configury switch to enable the use
11733 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
11734 consumers that understand it; fall back to "pure" dwarf2 and
11735 convert the CFA data into a location list. */
11737 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
11738 if (list->dw_loc_next)
11739 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11741 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11744 /* Compute a displacement from the "steady-state frame pointer" to
11745 the CFA. The former is what all stack slots and argument slots
11746 will reference in the rtl; the later is what we've told the
11747 debugger about. We'll need to adjust all frame_base references
11748 by this displacement. */
11749 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
11751 if (cfun->static_chain_decl)
11752 add_AT_location_description (subr_die, DW_AT_static_link,
11753 loc_descriptor_from_tree (cfun->static_chain_decl));
11756 /* Now output descriptions of the arguments for this function. This gets
11757 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11758 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11759 `...' at the end of the formal parameter list. In order to find out if
11760 there was a trailing ellipsis or not, we must instead look at the type
11761 associated with the FUNCTION_DECL. This will be a node of type
11762 FUNCTION_TYPE. If the chain of type nodes hanging off of this
11763 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11764 an ellipsis at the end. */
11766 /* In the case where we are describing a mere function declaration, all we
11767 need to do here (and all we *can* do here) is to describe the *types* of
11768 its formal parameters. */
11769 if (debug_info_level <= DINFO_LEVEL_TERSE)
11771 else if (declaration)
11772 gen_formal_types_die (decl, subr_die);
11775 /* Generate DIEs to represent all known formal parameters. */
11776 tree arg_decls = DECL_ARGUMENTS (decl);
11779 /* When generating DIEs, generate the unspecified_parameters DIE
11780 instead if we come across the arg "__builtin_va_alist" */
11781 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11782 if (TREE_CODE (parm) == PARM_DECL)
11784 if (DECL_NAME (parm)
11785 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11786 "__builtin_va_alist"))
11787 gen_unspecified_parameters_die (parm, subr_die);
11789 gen_decl_die (parm, subr_die);
11792 /* Decide whether we need an unspecified_parameters DIE at the end.
11793 There are 2 more cases to do this for: 1) the ansi ... declaration -
11794 this is detectable when the end of the arg list is not a
11795 void_type_node 2) an unprototyped function declaration (not a
11796 definition). This just means that we have no info about the
11797 parameters at all. */
11798 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11799 if (fn_arg_types != NULL)
11801 /* This is the prototyped case, check for.... */
11802 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11803 gen_unspecified_parameters_die (decl, subr_die);
11805 else if (DECL_INITIAL (decl) == NULL_TREE)
11806 gen_unspecified_parameters_die (decl, subr_die);
11809 /* Output Dwarf info for all of the stuff within the body of the function
11810 (if it has one - it may be just a declaration). */
11811 outer_scope = DECL_INITIAL (decl);
11813 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11814 a function. This BLOCK actually represents the outermost binding contour
11815 for the function, i.e. the contour in which the function's formal
11816 parameters and labels get declared. Curiously, it appears that the front
11817 end doesn't actually put the PARM_DECL nodes for the current function onto
11818 the BLOCK_VARS list for this outer scope, but are strung off of the
11819 DECL_ARGUMENTS list for the function instead.
11821 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11822 the LABEL_DECL nodes for the function however, and we output DWARF info
11823 for those in decls_for_scope. Just within the `outer_scope' there will be
11824 a BLOCK node representing the function's outermost pair of curly braces,
11825 and any blocks used for the base and member initializers of a C++
11826 constructor function. */
11827 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11829 /* Emit a DW_TAG_variable DIE for a named return value. */
11830 if (DECL_NAME (DECL_RESULT (decl)))
11831 gen_decl_die (DECL_RESULT (decl), subr_die);
11833 current_function_has_inlines = 0;
11834 decls_for_scope (outer_scope, subr_die, 0);
11836 #if 0 && defined (MIPS_DEBUGGING_INFO)
11837 if (current_function_has_inlines)
11839 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11840 if (! comp_unit_has_inlines)
11842 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11843 comp_unit_has_inlines = 1;
11848 /* Add the calling convention attribute if requested. */
11849 add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
11853 /* Generate a DIE to represent a declared data object. */
11856 gen_variable_die (tree decl, dw_die_ref context_die)
11858 tree origin = decl_ultimate_origin (decl);
11859 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11861 dw_die_ref old_die = lookup_decl_die (decl);
11862 int declaration = (DECL_EXTERNAL (decl)
11863 /* If DECL is COMDAT and has not actually been
11864 emitted, we cannot take its address; there
11865 might end up being no definition anywhere in
11866 the program. For example, consider the C++
11870 struct S { static const int i = 7; };
11875 int f() { return S<int>::i; }
11877 Here, S<int>::i is not DECL_EXTERNAL, but no
11878 definition is required, so the compiler will
11879 not emit a definition. */
11880 || (TREE_CODE (decl) == VAR_DECL
11881 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
11882 || class_or_namespace_scope_p (context_die));
11884 if (origin != NULL)
11885 add_abstract_origin_attribute (var_die, origin);
11887 /* Loop unrolling can create multiple blocks that refer to the same
11888 static variable, so we must test for the DW_AT_declaration flag.
11890 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11891 copy decls and set the DECL_ABSTRACT flag on them instead of
11894 ??? Duplicated blocks have been rewritten to use .debug_ranges.
11896 ??? The declare_in_namespace support causes us to get two DIEs for one
11897 variable, both of which are declarations. We want to avoid considering
11898 one to be a specification, so we must test that this DIE is not a
11900 else if (old_die && TREE_STATIC (decl) && ! declaration
11901 && get_AT_flag (old_die, DW_AT_declaration) == 1)
11903 /* This is a definition of a C++ class level static. */
11904 add_AT_specification (var_die, old_die);
11905 if (DECL_NAME (decl))
11907 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11908 unsigned file_index = lookup_filename (s.file);
11910 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11911 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11913 if (get_AT_unsigned (old_die, DW_AT_decl_line)
11914 != (unsigned) s.line)
11916 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
11921 add_name_and_src_coords_attributes (var_die, decl);
11922 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11923 TREE_THIS_VOLATILE (decl), context_die);
11925 if (TREE_PUBLIC (decl))
11926 add_AT_flag (var_die, DW_AT_external, 1);
11928 if (DECL_ARTIFICIAL (decl))
11929 add_AT_flag (var_die, DW_AT_artificial, 1);
11931 if (TREE_PROTECTED (decl))
11932 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11933 else if (TREE_PRIVATE (decl))
11934 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11938 add_AT_flag (var_die, DW_AT_declaration, 1);
11940 if (DECL_ABSTRACT (decl) || declaration)
11941 equate_decl_number_to_die (decl, var_die);
11943 if (! declaration && ! DECL_ABSTRACT (decl))
11945 add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
11946 add_pubname (decl, var_die);
11949 tree_add_const_value_attribute (var_die, decl);
11952 /* Generate a DIE to represent a label identifier. */
11955 gen_label_die (tree decl, dw_die_ref context_die)
11957 tree origin = decl_ultimate_origin (decl);
11958 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11960 char label[MAX_ARTIFICIAL_LABEL_BYTES];
11962 if (origin != NULL)
11963 add_abstract_origin_attribute (lbl_die, origin);
11965 add_name_and_src_coords_attributes (lbl_die, decl);
11967 if (DECL_ABSTRACT (decl))
11968 equate_decl_number_to_die (decl, lbl_die);
11971 insn = DECL_RTL_IF_SET (decl);
11973 /* Deleted labels are programmer specified labels which have been
11974 eliminated because of various optimizations. We still emit them
11975 here so that it is possible to put breakpoints on them. */
11979 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
11981 /* When optimization is enabled (via -O) some parts of the compiler
11982 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11983 represent source-level labels which were explicitly declared by
11984 the user. This really shouldn't be happening though, so catch
11985 it if it ever does happen. */
11986 gcc_assert (!INSN_DELETED_P (insn));
11988 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11989 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11994 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
11995 attributes to the DIE for a block STMT, to describe where the inlined
11996 function was called from. This is similar to add_src_coords_attributes. */
11999 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
12001 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
12002 unsigned file_index = lookup_filename (s.file);
12004 add_AT_unsigned (die, DW_AT_call_file, file_index);
12005 add_AT_unsigned (die, DW_AT_call_line, s.line);
12008 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
12009 Add low_pc and high_pc attributes to the DIE for a block STMT. */
12012 add_high_low_attributes (tree stmt, dw_die_ref die)
12014 char label[MAX_ARTIFICIAL_LABEL_BYTES];
12016 if (BLOCK_FRAGMENT_CHAIN (stmt))
12020 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
12022 chain = BLOCK_FRAGMENT_CHAIN (stmt);
12025 add_ranges (chain);
12026 chain = BLOCK_FRAGMENT_CHAIN (chain);
12033 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
12034 BLOCK_NUMBER (stmt));
12035 add_AT_lbl_id (die, DW_AT_low_pc, label);
12036 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
12037 BLOCK_NUMBER (stmt));
12038 add_AT_lbl_id (die, DW_AT_high_pc, label);
12042 /* Generate a DIE for a lexical block. */
12045 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12047 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12049 if (! BLOCK_ABSTRACT (stmt))
12050 add_high_low_attributes (stmt, stmt_die);
12052 decls_for_scope (stmt, stmt_die, depth);
12055 /* Generate a DIE for an inlined subprogram. */
12058 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12060 tree decl = block_ultimate_origin (stmt);
12062 /* Emit info for the abstract instance first, if we haven't yet. We
12063 must emit this even if the block is abstract, otherwise when we
12064 emit the block below (or elsewhere), we may end up trying to emit
12065 a die whose origin die hasn't been emitted, and crashing. */
12066 dwarf2out_abstract_function (decl);
12068 if (! BLOCK_ABSTRACT (stmt))
12070 dw_die_ref subr_die
12071 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12073 add_abstract_origin_attribute (subr_die, decl);
12074 add_high_low_attributes (stmt, subr_die);
12075 add_call_src_coords_attributes (stmt, subr_die);
12077 decls_for_scope (stmt, subr_die, depth);
12078 current_function_has_inlines = 1;
12081 /* We may get here if we're the outer block of function A that was
12082 inlined into function B that was inlined into function C. When
12083 generating debugging info for C, dwarf2out_abstract_function(B)
12084 would mark all inlined blocks as abstract, including this one.
12085 So, we wouldn't (and shouldn't) expect labels to be generated
12086 for this one. Instead, just emit debugging info for
12087 declarations within the block. This is particularly important
12088 in the case of initializers of arguments passed from B to us:
12089 if they're statement expressions containing declarations, we
12090 wouldn't generate dies for their abstract variables, and then,
12091 when generating dies for the real variables, we'd die (pun
12093 gen_lexical_block_die (stmt, context_die, depth);
12096 /* Generate a DIE for a field in a record, or structure. */
12099 gen_field_die (tree decl, dw_die_ref context_die)
12101 dw_die_ref decl_die;
12103 if (TREE_TYPE (decl) == error_mark_node)
12106 decl_die = new_die (DW_TAG_member, context_die, decl);
12107 add_name_and_src_coords_attributes (decl_die, decl);
12108 add_type_attribute (decl_die, member_declared_type (decl),
12109 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12112 if (DECL_BIT_FIELD_TYPE (decl))
12114 add_byte_size_attribute (decl_die, decl);
12115 add_bit_size_attribute (decl_die, decl);
12116 add_bit_offset_attribute (decl_die, decl);
12119 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12120 add_data_member_location_attribute (decl_die, decl);
12122 if (DECL_ARTIFICIAL (decl))
12123 add_AT_flag (decl_die, DW_AT_artificial, 1);
12125 if (TREE_PROTECTED (decl))
12126 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12127 else if (TREE_PRIVATE (decl))
12128 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12130 /* Equate decl number to die, so that we can look up this decl later on. */
12131 equate_decl_number_to_die (decl, decl_die);
12135 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12136 Use modified_type_die instead.
12137 We keep this code here just in case these types of DIEs may be needed to
12138 represent certain things in other languages (e.g. Pascal) someday. */
12141 gen_pointer_type_die (tree type, dw_die_ref context_die)
12144 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12146 equate_type_number_to_die (type, ptr_die);
12147 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12148 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12151 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12152 Use modified_type_die instead.
12153 We keep this code here just in case these types of DIEs may be needed to
12154 represent certain things in other languages (e.g. Pascal) someday. */
12157 gen_reference_type_die (tree type, dw_die_ref context_die)
12160 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12162 equate_type_number_to_die (type, ref_die);
12163 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12164 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12168 /* Generate a DIE for a pointer to a member type. */
12171 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12174 = new_die (DW_TAG_ptr_to_member_type,
12175 scope_die_for (type, context_die), type);
12177 equate_type_number_to_die (type, ptr_die);
12178 add_AT_die_ref (ptr_die, DW_AT_containing_type,
12179 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12180 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12183 /* Generate the DIE for the compilation unit. */
12186 gen_compile_unit_die (const char *filename)
12189 char producer[250];
12190 const char *language_string = lang_hooks.name;
12193 die = new_die (DW_TAG_compile_unit, NULL, NULL);
12197 add_name_attribute (die, filename);
12198 /* Don't add cwd for <built-in>. */
12199 if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12200 add_comp_dir_attribute (die);
12203 sprintf (producer, "%s %s", language_string, version_string);
12205 #ifdef MIPS_DEBUGGING_INFO
12206 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12207 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12208 not appear in the producer string, the debugger reaches the conclusion
12209 that the object file is stripped and has no debugging information.
12210 To get the MIPS/SGI debugger to believe that there is debugging
12211 information in the object file, we add a -g to the producer string. */
12212 if (debug_info_level > DINFO_LEVEL_TERSE)
12213 strcat (producer, " -g");
12216 add_AT_string (die, DW_AT_producer, producer);
12218 if (strcmp (language_string, "GNU C++") == 0)
12219 language = DW_LANG_C_plus_plus;
12220 else if (strcmp (language_string, "GNU Ada") == 0)
12221 language = DW_LANG_Ada95;
12222 else if (strcmp (language_string, "GNU F77") == 0)
12223 language = DW_LANG_Fortran77;
12224 else if (strcmp (language_string, "GNU F95") == 0)
12225 language = DW_LANG_Fortran95;
12226 else if (strcmp (language_string, "GNU Pascal") == 0)
12227 language = DW_LANG_Pascal83;
12228 else if (strcmp (language_string, "GNU Java") == 0)
12229 language = DW_LANG_Java;
12230 else if (strcmp (language_string, "GNU Objective-C") == 0)
12231 language = DW_LANG_ObjC;
12232 else if (strcmp (language_string, "GNU Objective-C++") == 0)
12233 language = DW_LANG_ObjC_plus_plus;
12235 language = DW_LANG_C89;
12237 add_AT_unsigned (die, DW_AT_language, language);
12241 /* Generate the DIE for a base class. */
12244 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12246 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12248 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12249 add_data_member_location_attribute (die, binfo);
12251 if (BINFO_VIRTUAL_P (binfo))
12252 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12254 if (access == access_public_node)
12255 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12256 else if (access == access_protected_node)
12257 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12260 /* Generate a DIE for a class member. */
12263 gen_member_die (tree type, dw_die_ref context_die)
12266 tree binfo = TYPE_BINFO (type);
12269 /* If this is not an incomplete type, output descriptions of each of its
12270 members. Note that as we output the DIEs necessary to represent the
12271 members of this record or union type, we will also be trying to output
12272 DIEs to represent the *types* of those members. However the `type'
12273 function (above) will specifically avoid generating type DIEs for member
12274 types *within* the list of member DIEs for this (containing) type except
12275 for those types (of members) which are explicitly marked as also being
12276 members of this (containing) type themselves. The g++ front- end can
12277 force any given type to be treated as a member of some other (containing)
12278 type by setting the TYPE_CONTEXT of the given (member) type to point to
12279 the TREE node representing the appropriate (containing) type. */
12281 /* First output info about the base classes. */
12284 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12288 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12289 gen_inheritance_die (base,
12290 (accesses ? VEC_index (tree, accesses, i)
12291 : access_public_node), context_die);
12294 /* Now output info about the data members and type members. */
12295 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12297 /* If we thought we were generating minimal debug info for TYPE
12298 and then changed our minds, some of the member declarations
12299 may have already been defined. Don't define them again, but
12300 do put them in the right order. */
12302 child = lookup_decl_die (member);
12304 splice_child_die (context_die, child);
12306 gen_decl_die (member, context_die);
12309 /* Now output info about the function members (if any). */
12310 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12312 /* Don't include clones in the member list. */
12313 if (DECL_ABSTRACT_ORIGIN (member))
12316 child = lookup_decl_die (member);
12318 splice_child_die (context_die, child);
12320 gen_decl_die (member, context_die);
12324 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
12325 is set, we pretend that the type was never defined, so we only get the
12326 member DIEs needed by later specification DIEs. */
12329 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12331 dw_die_ref type_die = lookup_type_die (type);
12332 dw_die_ref scope_die = 0;
12334 int complete = (TYPE_SIZE (type)
12335 && (! TYPE_STUB_DECL (type)
12336 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12337 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12339 if (type_die && ! complete)
12342 if (TYPE_CONTEXT (type) != NULL_TREE
12343 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12344 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12347 scope_die = scope_die_for (type, context_die);
12349 if (! type_die || (nested && scope_die == comp_unit_die))
12350 /* First occurrence of type or toplevel definition of nested class. */
12352 dw_die_ref old_die = type_die;
12354 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12355 ? DW_TAG_structure_type : DW_TAG_union_type,
12357 equate_type_number_to_die (type, type_die);
12359 add_AT_specification (type_die, old_die);
12361 add_name_attribute (type_die, type_tag (type));
12364 remove_AT (type_die, DW_AT_declaration);
12366 /* If this type has been completed, then give it a byte_size attribute and
12367 then give a list of members. */
12368 if (complete && !ns_decl)
12370 /* Prevent infinite recursion in cases where the type of some member of
12371 this type is expressed in terms of this type itself. */
12372 TREE_ASM_WRITTEN (type) = 1;
12373 add_byte_size_attribute (type_die, type);
12374 if (TYPE_STUB_DECL (type) != NULL_TREE)
12375 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12377 /* If the first reference to this type was as the return type of an
12378 inline function, then it may not have a parent. Fix this now. */
12379 if (type_die->die_parent == NULL)
12380 add_child_die (scope_die, type_die);
12382 push_decl_scope (type);
12383 gen_member_die (type, type_die);
12386 /* GNU extension: Record what type our vtable lives in. */
12387 if (TYPE_VFIELD (type))
12389 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12391 gen_type_die (vtype, context_die);
12392 add_AT_die_ref (type_die, DW_AT_containing_type,
12393 lookup_type_die (vtype));
12398 add_AT_flag (type_die, DW_AT_declaration, 1);
12400 /* We don't need to do this for function-local types. */
12401 if (TYPE_STUB_DECL (type)
12402 && ! decl_function_context (TYPE_STUB_DECL (type)))
12403 VEC_safe_push (tree, gc, incomplete_types, type);
12407 /* Generate a DIE for a subroutine _type_. */
12410 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12412 tree return_type = TREE_TYPE (type);
12413 dw_die_ref subr_die
12414 = new_die (DW_TAG_subroutine_type,
12415 scope_die_for (type, context_die), type);
12417 equate_type_number_to_die (type, subr_die);
12418 add_prototyped_attribute (subr_die, type);
12419 add_type_attribute (subr_die, return_type, 0, 0, context_die);
12420 gen_formal_types_die (type, subr_die);
12423 /* Generate a DIE for a type definition. */
12426 gen_typedef_die (tree decl, dw_die_ref context_die)
12428 dw_die_ref type_die;
12431 if (TREE_ASM_WRITTEN (decl))
12434 TREE_ASM_WRITTEN (decl) = 1;
12435 type_die = new_die (DW_TAG_typedef, context_die, decl);
12436 origin = decl_ultimate_origin (decl);
12437 if (origin != NULL)
12438 add_abstract_origin_attribute (type_die, origin);
12443 add_name_and_src_coords_attributes (type_die, decl);
12444 if (DECL_ORIGINAL_TYPE (decl))
12446 type = DECL_ORIGINAL_TYPE (decl);
12448 gcc_assert (type != TREE_TYPE (decl));
12449 equate_type_number_to_die (TREE_TYPE (decl), type_die);
12452 type = TREE_TYPE (decl);
12454 add_type_attribute (type_die, type, TREE_READONLY (decl),
12455 TREE_THIS_VOLATILE (decl), context_die);
12458 if (DECL_ABSTRACT (decl))
12459 equate_decl_number_to_die (decl, type_die);
12462 /* Generate a type description DIE. */
12465 gen_type_die (tree type, dw_die_ref context_die)
12469 if (type == NULL_TREE || type == error_mark_node)
12472 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12473 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12475 if (TREE_ASM_WRITTEN (type))
12478 /* Prevent broken recursion; we can't hand off to the same type. */
12479 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12481 TREE_ASM_WRITTEN (type) = 1;
12482 gen_decl_die (TYPE_NAME (type), context_die);
12486 /* We are going to output a DIE to represent the unqualified version
12487 of this type (i.e. without any const or volatile qualifiers) so
12488 get the main variant (i.e. the unqualified version) of this type
12489 now. (Vectors are special because the debugging info is in the
12490 cloned type itself). */
12491 if (TREE_CODE (type) != VECTOR_TYPE)
12492 type = type_main_variant (type);
12494 if (TREE_ASM_WRITTEN (type))
12497 switch (TREE_CODE (type))
12503 case REFERENCE_TYPE:
12504 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
12505 ensures that the gen_type_die recursion will terminate even if the
12506 type is recursive. Recursive types are possible in Ada. */
12507 /* ??? We could perhaps do this for all types before the switch
12509 TREE_ASM_WRITTEN (type) = 1;
12511 /* For these types, all that is required is that we output a DIE (or a
12512 set of DIEs) to represent the "basis" type. */
12513 gen_type_die (TREE_TYPE (type), context_die);
12517 /* This code is used for C++ pointer-to-data-member types.
12518 Output a description of the relevant class type. */
12519 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12521 /* Output a description of the type of the object pointed to. */
12522 gen_type_die (TREE_TYPE (type), context_die);
12524 /* Now output a DIE to represent this pointer-to-data-member type
12526 gen_ptr_to_mbr_type_die (type, context_die);
12529 case FUNCTION_TYPE:
12530 /* Force out return type (in case it wasn't forced out already). */
12531 gen_type_die (TREE_TYPE (type), context_die);
12532 gen_subroutine_type_die (type, context_die);
12536 /* Force out return type (in case it wasn't forced out already). */
12537 gen_type_die (TREE_TYPE (type), context_die);
12538 gen_subroutine_type_die (type, context_die);
12542 gen_array_type_die (type, context_die);
12546 gen_array_type_die (type, context_die);
12549 case ENUMERAL_TYPE:
12552 case QUAL_UNION_TYPE:
12553 /* If this is a nested type whose containing class hasn't been written
12554 out yet, writing it out will cover this one, too. This does not apply
12555 to instantiations of member class templates; they need to be added to
12556 the containing class as they are generated. FIXME: This hurts the
12557 idea of combining type decls from multiple TUs, since we can't predict
12558 what set of template instantiations we'll get. */
12559 if (TYPE_CONTEXT (type)
12560 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12561 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12563 gen_type_die (TYPE_CONTEXT (type), context_die);
12565 if (TREE_ASM_WRITTEN (type))
12568 /* If that failed, attach ourselves to the stub. */
12569 push_decl_scope (TYPE_CONTEXT (type));
12570 context_die = lookup_type_die (TYPE_CONTEXT (type));
12575 declare_in_namespace (type, context_die);
12579 if (TREE_CODE (type) == ENUMERAL_TYPE)
12580 gen_enumeration_type_die (type, context_die);
12582 gen_struct_or_union_type_die (type, context_die);
12587 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12588 it up if it is ever completed. gen_*_type_die will set it for us
12589 when appropriate. */
12597 /* No DIEs needed for fundamental types. */
12601 /* No Dwarf representation currently defined. */
12605 gcc_unreachable ();
12608 TREE_ASM_WRITTEN (type) = 1;
12611 /* Generate a DIE for a tagged type instantiation. */
12614 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12616 if (type == NULL_TREE || type == error_mark_node)
12619 /* We are going to output a DIE to represent the unqualified version of
12620 this type (i.e. without any const or volatile qualifiers) so make sure
12621 that we have the main variant (i.e. the unqualified version) of this
12623 gcc_assert (type == type_main_variant (type));
12625 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12626 an instance of an unresolved type. */
12628 switch (TREE_CODE (type))
12633 case ENUMERAL_TYPE:
12634 gen_inlined_enumeration_type_die (type, context_die);
12638 gen_inlined_structure_type_die (type, context_die);
12642 case QUAL_UNION_TYPE:
12643 gen_inlined_union_type_die (type, context_die);
12647 gcc_unreachable ();
12651 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12652 things which are local to the given block. */
12655 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12657 int must_output_die = 0;
12660 enum tree_code origin_code;
12662 /* Ignore blocks that are NULL. */
12663 if (stmt == NULL_TREE)
12666 /* If the block is one fragment of a non-contiguous block, do not
12667 process the variables, since they will have been done by the
12668 origin block. Do process subblocks. */
12669 if (BLOCK_FRAGMENT_ORIGIN (stmt))
12673 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12674 gen_block_die (sub, context_die, depth + 1);
12679 /* Determine the "ultimate origin" of this block. This block may be an
12680 inlined instance of an inlined instance of inline function, so we have
12681 to trace all of the way back through the origin chain to find out what
12682 sort of node actually served as the original seed for the creation of
12683 the current block. */
12684 origin = block_ultimate_origin (stmt);
12685 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12687 /* Determine if we need to output any Dwarf DIEs at all to represent this
12689 if (origin_code == FUNCTION_DECL)
12690 /* The outer scopes for inlinings *must* always be represented. We
12691 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
12692 must_output_die = 1;
12695 /* In the case where the current block represents an inlining of the
12696 "body block" of an inline function, we must *NOT* output any DIE for
12697 this block because we have already output a DIE to represent the whole
12698 inlined function scope and the "body block" of any function doesn't
12699 really represent a different scope according to ANSI C rules. So we
12700 check here to make sure that this block does not represent a "body
12701 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
12702 if (! is_body_block (origin ? origin : stmt))
12704 /* Determine if this block directly contains any "significant"
12705 local declarations which we will need to output DIEs for. */
12706 if (debug_info_level > DINFO_LEVEL_TERSE)
12707 /* We are not in terse mode so *any* local declaration counts
12708 as being a "significant" one. */
12709 must_output_die = (BLOCK_VARS (stmt) != NULL
12710 && (TREE_USED (stmt)
12711 || TREE_ASM_WRITTEN (stmt)
12712 || BLOCK_ABSTRACT (stmt)));
12714 /* We are in terse mode, so only local (nested) function
12715 definitions count as "significant" local declarations. */
12716 for (decl = BLOCK_VARS (stmt);
12717 decl != NULL; decl = TREE_CHAIN (decl))
12718 if (TREE_CODE (decl) == FUNCTION_DECL
12719 && DECL_INITIAL (decl))
12721 must_output_die = 1;
12727 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12728 DIE for any block which contains no significant local declarations at
12729 all. Rather, in such cases we just call `decls_for_scope' so that any
12730 needed Dwarf info for any sub-blocks will get properly generated. Note
12731 that in terse mode, our definition of what constitutes a "significant"
12732 local declaration gets restricted to include only inlined function
12733 instances and local (nested) function definitions. */
12734 if (must_output_die)
12736 if (origin_code == FUNCTION_DECL)
12737 gen_inlined_subroutine_die (stmt, context_die, depth);
12739 gen_lexical_block_die (stmt, context_die, depth);
12742 decls_for_scope (stmt, context_die, depth);
12745 /* Generate all of the decls declared within a given scope and (recursively)
12746 all of its sub-blocks. */
12749 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12754 /* Ignore NULL blocks. */
12755 if (stmt == NULL_TREE)
12758 if (TREE_USED (stmt))
12760 /* Output the DIEs to represent all of the data objects and typedefs
12761 declared directly within this block but not within any nested
12762 sub-blocks. Also, nested function and tag DIEs have been
12763 generated with a parent of NULL; fix that up now. */
12764 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12768 if (TREE_CODE (decl) == FUNCTION_DECL)
12769 die = lookup_decl_die (decl);
12770 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12771 die = lookup_type_die (TREE_TYPE (decl));
12775 if (die != NULL && die->die_parent == NULL)
12776 add_child_die (context_die, die);
12777 /* Do not produce debug information for static variables since
12778 these might be optimized out. We are called for these later
12779 in cgraph_varpool_analyze_pending_decls. */
12780 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12783 gen_decl_die (decl, context_die);
12787 /* If we're at -g1, we're not interested in subblocks. */
12788 if (debug_info_level <= DINFO_LEVEL_TERSE)
12791 /* Output the DIEs to represent all sub-blocks (and the items declared
12792 therein) of this block. */
12793 for (subblocks = BLOCK_SUBBLOCKS (stmt);
12795 subblocks = BLOCK_CHAIN (subblocks))
12796 gen_block_die (subblocks, context_die, depth + 1);
12799 /* Is this a typedef we can avoid emitting? */
12802 is_redundant_typedef (tree decl)
12804 if (TYPE_DECL_IS_STUB (decl))
12807 if (DECL_ARTIFICIAL (decl)
12808 && DECL_CONTEXT (decl)
12809 && is_tagged_type (DECL_CONTEXT (decl))
12810 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12811 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12812 /* Also ignore the artificial member typedef for the class name. */
12818 /* Returns the DIE for decl. A DIE will always be returned. */
12821 force_decl_die (tree decl)
12823 dw_die_ref decl_die;
12824 unsigned saved_external_flag;
12825 tree save_fn = NULL_TREE;
12826 decl_die = lookup_decl_die (decl);
12829 dw_die_ref context_die;
12830 tree decl_context = DECL_CONTEXT (decl);
12833 /* Find die that represents this context. */
12834 if (TYPE_P (decl_context))
12835 context_die = force_type_die (decl_context);
12837 context_die = force_decl_die (decl_context);
12840 context_die = comp_unit_die;
12842 decl_die = lookup_decl_die (decl);
12846 switch (TREE_CODE (decl))
12848 case FUNCTION_DECL:
12849 /* Clear current_function_decl, so that gen_subprogram_die thinks
12850 that this is a declaration. At this point, we just want to force
12851 declaration die. */
12852 save_fn = current_function_decl;
12853 current_function_decl = NULL_TREE;
12854 gen_subprogram_die (decl, context_die);
12855 current_function_decl = save_fn;
12859 /* Set external flag to force declaration die. Restore it after
12860 gen_decl_die() call. */
12861 saved_external_flag = DECL_EXTERNAL (decl);
12862 DECL_EXTERNAL (decl) = 1;
12863 gen_decl_die (decl, context_die);
12864 DECL_EXTERNAL (decl) = saved_external_flag;
12867 case NAMESPACE_DECL:
12868 dwarf2out_decl (decl);
12872 gcc_unreachable ();
12875 /* We should be able to find the DIE now. */
12877 decl_die = lookup_decl_die (decl);
12878 gcc_assert (decl_die);
12884 /* Returns the DIE for TYPE. A DIE is always returned. */
12887 force_type_die (tree type)
12889 dw_die_ref type_die;
12891 type_die = lookup_type_die (type);
12894 dw_die_ref context_die;
12895 if (TYPE_CONTEXT (type))
12897 if (TYPE_P (TYPE_CONTEXT (type)))
12898 context_die = force_type_die (TYPE_CONTEXT (type));
12900 context_die = force_decl_die (TYPE_CONTEXT (type));
12903 context_die = comp_unit_die;
12905 type_die = lookup_type_die (type);
12908 gen_type_die (type, context_die);
12909 type_die = lookup_type_die (type);
12910 gcc_assert (type_die);
12915 /* Force out any required namespaces to be able to output DECL,
12916 and return the new context_die for it, if it's changed. */
12919 setup_namespace_context (tree thing, dw_die_ref context_die)
12921 tree context = (DECL_P (thing)
12922 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
12923 if (context && TREE_CODE (context) == NAMESPACE_DECL)
12924 /* Force out the namespace. */
12925 context_die = force_decl_die (context);
12927 return context_die;
12930 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12931 type) within its namespace, if appropriate.
12933 For compatibility with older debuggers, namespace DIEs only contain
12934 declarations; all definitions are emitted at CU scope. */
12937 declare_in_namespace (tree thing, dw_die_ref context_die)
12939 dw_die_ref ns_context;
12941 if (debug_info_level <= DINFO_LEVEL_TERSE)
12944 /* If this decl is from an inlined function, then don't try to emit it in its
12945 namespace, as we will get confused. It would have already been emitted
12946 when the abstract instance of the inline function was emitted anyways. */
12947 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
12950 ns_context = setup_namespace_context (thing, context_die);
12952 if (ns_context != context_die)
12954 if (DECL_P (thing))
12955 gen_decl_die (thing, ns_context);
12957 gen_type_die (thing, ns_context);
12961 /* Generate a DIE for a namespace or namespace alias. */
12964 gen_namespace_die (tree decl)
12966 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
12968 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12969 they are an alias of. */
12970 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
12972 /* Output a real namespace. */
12973 dw_die_ref namespace_die
12974 = new_die (DW_TAG_namespace, context_die, decl);
12975 add_name_and_src_coords_attributes (namespace_die, decl);
12976 equate_decl_number_to_die (decl, namespace_die);
12980 /* Output a namespace alias. */
12982 /* Force out the namespace we are an alias of, if necessary. */
12983 dw_die_ref origin_die
12984 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
12986 /* Now create the namespace alias DIE. */
12987 dw_die_ref namespace_die
12988 = new_die (DW_TAG_imported_declaration, context_die, decl);
12989 add_name_and_src_coords_attributes (namespace_die, decl);
12990 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
12991 equate_decl_number_to_die (decl, namespace_die);
12995 /* Generate Dwarf debug information for a decl described by DECL. */
12998 gen_decl_die (tree decl, dw_die_ref context_die)
13002 if (DECL_P (decl) && DECL_IGNORED_P (decl))
13005 switch (TREE_CODE (decl))
13011 /* The individual enumerators of an enum type get output when we output
13012 the Dwarf representation of the relevant enum type itself. */
13015 case FUNCTION_DECL:
13016 /* Don't output any DIEs to represent mere function declarations,
13017 unless they are class members or explicit block externs. */
13018 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13019 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13024 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13025 on local redeclarations of global functions. That seems broken. */
13026 if (current_function_decl != decl)
13027 /* This is only a declaration. */;
13030 /* If we're emitting a clone, emit info for the abstract instance. */
13031 if (DECL_ORIGIN (decl) != decl)
13032 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13034 /* If we're emitting an out-of-line copy of an inline function,
13035 emit info for the abstract instance and set up to refer to it. */
13036 else if (cgraph_function_possibly_inlined_p (decl)
13037 && ! DECL_ABSTRACT (decl)
13038 && ! class_or_namespace_scope_p (context_die)
13039 /* dwarf2out_abstract_function won't emit a die if this is just
13040 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
13041 that case, because that works only if we have a die. */
13042 && DECL_INITIAL (decl) != NULL_TREE)
13044 dwarf2out_abstract_function (decl);
13045 set_decl_origin_self (decl);
13048 /* Otherwise we're emitting the primary DIE for this decl. */
13049 else if (debug_info_level > DINFO_LEVEL_TERSE)
13051 /* Before we describe the FUNCTION_DECL itself, make sure that we
13052 have described its return type. */
13053 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13055 /* And its virtual context. */
13056 if (DECL_VINDEX (decl) != NULL_TREE)
13057 gen_type_die (DECL_CONTEXT (decl), context_die);
13059 /* And its containing type. */
13060 origin = decl_class_context (decl);
13061 if (origin != NULL_TREE)
13062 gen_type_die_for_member (origin, decl, context_die);
13064 /* And its containing namespace. */
13065 declare_in_namespace (decl, context_die);
13068 /* Now output a DIE to represent the function itself. */
13069 gen_subprogram_die (decl, context_die);
13073 /* If we are in terse mode, don't generate any DIEs to represent any
13074 actual typedefs. */
13075 if (debug_info_level <= DINFO_LEVEL_TERSE)
13078 /* In the special case of a TYPE_DECL node representing the declaration
13079 of some type tag, if the given TYPE_DECL is marked as having been
13080 instantiated from some other (original) TYPE_DECL node (e.g. one which
13081 was generated within the original definition of an inline function) we
13082 have to generate a special (abbreviated) DW_TAG_structure_type,
13083 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
13084 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13086 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13090 if (is_redundant_typedef (decl))
13091 gen_type_die (TREE_TYPE (decl), context_die);
13093 /* Output a DIE to represent the typedef itself. */
13094 gen_typedef_die (decl, context_die);
13098 if (debug_info_level >= DINFO_LEVEL_NORMAL)
13099 gen_label_die (decl, context_die);
13104 /* If we are in terse mode, don't generate any DIEs to represent any
13105 variable declarations or definitions. */
13106 if (debug_info_level <= DINFO_LEVEL_TERSE)
13109 /* Output any DIEs that are needed to specify the type of this data
13111 gen_type_die (TREE_TYPE (decl), context_die);
13113 /* And its containing type. */
13114 origin = decl_class_context (decl);
13115 if (origin != NULL_TREE)
13116 gen_type_die_for_member (origin, decl, context_die);
13118 /* And its containing namespace. */
13119 declare_in_namespace (decl, context_die);
13121 /* Now output the DIE to represent the data object itself. This gets
13122 complicated because of the possibility that the VAR_DECL really
13123 represents an inlined instance of a formal parameter for an inline
13125 origin = decl_ultimate_origin (decl);
13126 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13127 gen_formal_parameter_die (decl, context_die);
13129 gen_variable_die (decl, context_die);
13133 /* Ignore the nameless fields that are used to skip bits but handle C++
13134 anonymous unions and structs. */
13135 if (DECL_NAME (decl) != NULL_TREE
13136 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13137 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13139 gen_type_die (member_declared_type (decl), context_die);
13140 gen_field_die (decl, context_die);
13145 gen_type_die (TREE_TYPE (decl), context_die);
13146 gen_formal_parameter_die (decl, context_die);
13149 case NAMESPACE_DECL:
13150 gen_namespace_die (decl);
13154 /* Probably some frontend-internal decl. Assume we don't care. */
13155 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13160 /* Output debug information for global decl DECL. Called from toplev.c after
13161 compilation proper has finished. */
13164 dwarf2out_global_decl (tree decl)
13166 /* Output DWARF2 information for file-scope tentative data object
13167 declarations, file-scope (extern) function declarations (which had no
13168 corresponding body) and file-scope tagged type declarations and
13169 definitions which have not yet been forced out. */
13170 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13171 dwarf2out_decl (decl);
13174 /* Output debug information for type decl DECL. Called from toplev.c
13175 and from language front ends (to record built-in types). */
13177 dwarf2out_type_decl (tree decl, int local)
13180 dwarf2out_decl (decl);
13183 /* Output debug information for imported module or decl. */
13186 dwarf2out_imported_module_or_decl (tree decl, tree context)
13188 dw_die_ref imported_die, at_import_die;
13189 dw_die_ref scope_die;
13190 unsigned file_index;
13191 expanded_location xloc;
13193 if (debug_info_level <= DINFO_LEVEL_TERSE)
13198 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13199 We need decl DIE for reference and scope die. First, get DIE for the decl
13202 /* Get the scope die for decl context. Use comp_unit_die for global module
13203 or decl. If die is not found for non globals, force new die. */
13205 scope_die = comp_unit_die;
13206 else if (TYPE_P (context))
13207 scope_die = force_type_die (context);
13209 scope_die = force_decl_die (context);
13211 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */
13212 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13213 at_import_die = force_type_die (TREE_TYPE (decl));
13216 at_import_die = lookup_decl_die (decl);
13217 if (!at_import_die)
13219 /* If we're trying to avoid duplicate debug info, we may not have
13220 emitted the member decl for this field. Emit it now. */
13221 if (TREE_CODE (decl) == FIELD_DECL)
13223 tree type = DECL_CONTEXT (decl);
13224 dw_die_ref type_context_die;
13226 if (TYPE_CONTEXT (type))
13227 if (TYPE_P (TYPE_CONTEXT (type)))
13228 type_context_die = force_type_die (TYPE_CONTEXT (type));
13230 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13232 type_context_die = comp_unit_die;
13233 gen_type_die_for_member (type, decl, type_context_die);
13235 at_import_die = force_decl_die (decl);
13239 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
13240 if (TREE_CODE (decl) == NAMESPACE_DECL)
13241 imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13243 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13245 xloc = expand_location (input_location);
13246 file_index = lookup_filename (xloc.file);
13247 add_AT_unsigned (imported_die, DW_AT_decl_file, file_index);
13248 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13249 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13252 /* Write the debugging output for DECL. */
13255 dwarf2out_decl (tree decl)
13257 dw_die_ref context_die = comp_unit_die;
13259 switch (TREE_CODE (decl))
13264 case FUNCTION_DECL:
13265 /* What we would really like to do here is to filter out all mere
13266 file-scope declarations of file-scope functions which are never
13267 referenced later within this translation unit (and keep all of ones
13268 that *are* referenced later on) but we aren't clairvoyant, so we have
13269 no idea which functions will be referenced in the future (i.e. later
13270 on within the current translation unit). So here we just ignore all
13271 file-scope function declarations which are not also definitions. If
13272 and when the debugger needs to know something about these functions,
13273 it will have to hunt around and find the DWARF information associated
13274 with the definition of the function.
13276 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13277 nodes represent definitions and which ones represent mere
13278 declarations. We have to check DECL_INITIAL instead. That's because
13279 the C front-end supports some weird semantics for "extern inline"
13280 function definitions. These can get inlined within the current
13281 translation unit (and thus, we need to generate Dwarf info for their
13282 abstract instances so that the Dwarf info for the concrete inlined
13283 instances can have something to refer to) but the compiler never
13284 generates any out-of-lines instances of such things (despite the fact
13285 that they *are* definitions).
13287 The important point is that the C front-end marks these "extern
13288 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13289 them anyway. Note that the C++ front-end also plays some similar games
13290 for inline function definitions appearing within include files which
13291 also contain `#pragma interface' pragmas. */
13292 if (DECL_INITIAL (decl) == NULL_TREE)
13295 /* If we're a nested function, initially use a parent of NULL; if we're
13296 a plain function, this will be fixed up in decls_for_scope. If
13297 we're a method, it will be ignored, since we already have a DIE. */
13298 if (decl_function_context (decl)
13299 /* But if we're in terse mode, we don't care about scope. */
13300 && debug_info_level > DINFO_LEVEL_TERSE)
13301 context_die = NULL;
13305 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13306 declaration and if the declaration was never even referenced from
13307 within this entire compilation unit. We suppress these DIEs in
13308 order to save space in the .debug section (by eliminating entries
13309 which are probably useless). Note that we must not suppress
13310 block-local extern declarations (whether used or not) because that
13311 would screw-up the debugger's name lookup mechanism and cause it to
13312 miss things which really ought to be in scope at a given point. */
13313 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13316 /* For local statics lookup proper context die. */
13317 if (TREE_STATIC (decl) && decl_function_context (decl))
13318 context_die = lookup_decl_die (DECL_CONTEXT (decl));
13320 /* If we are in terse mode, don't generate any DIEs to represent any
13321 variable declarations or definitions. */
13322 if (debug_info_level <= DINFO_LEVEL_TERSE)
13326 case NAMESPACE_DECL:
13327 if (debug_info_level <= DINFO_LEVEL_TERSE)
13329 if (lookup_decl_die (decl) != NULL)
13334 /* Don't emit stubs for types unless they are needed by other DIEs. */
13335 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13338 /* Don't bother trying to generate any DIEs to represent any of the
13339 normal built-in types for the language we are compiling. */
13340 if (DECL_IS_BUILTIN (decl))
13342 /* OK, we need to generate one for `bool' so GDB knows what type
13343 comparisons have. */
13345 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13346 && ! DECL_IGNORED_P (decl))
13347 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13352 /* If we are in terse mode, don't generate any DIEs for types. */
13353 if (debug_info_level <= DINFO_LEVEL_TERSE)
13356 /* If we're a function-scope tag, initially use a parent of NULL;
13357 this will be fixed up in decls_for_scope. */
13358 if (decl_function_context (decl))
13359 context_die = NULL;
13367 gen_decl_die (decl, context_die);
13370 /* Output a marker (i.e. a label) for the beginning of the generated code for
13371 a lexical block. */
13374 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13375 unsigned int blocknum)
13377 switch_to_section (current_function_section ());
13378 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13381 /* Output a marker (i.e. a label) for the end of the generated code for a
13385 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13387 switch_to_section (current_function_section ());
13388 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13391 /* Returns nonzero if it is appropriate not to emit any debugging
13392 information for BLOCK, because it doesn't contain any instructions.
13394 Don't allow this for blocks with nested functions or local classes
13395 as we would end up with orphans, and in the presence of scheduling
13396 we may end up calling them anyway. */
13399 dwarf2out_ignore_block (tree block)
13403 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13404 if (TREE_CODE (decl) == FUNCTION_DECL
13405 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13411 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13412 dwarf2out.c) and return its "index". The index of each (known) filename is
13413 just a unique number which is associated with only that one filename. We
13414 need such numbers for the sake of generating labels (in the .debug_sfnames
13415 section) and references to those files numbers (in the .debug_srcinfo
13416 and.debug_macinfo sections). If the filename given as an argument is not
13417 found in our current list, add it to the list and assign it the next
13418 available unique index number. In order to speed up searches, we remember
13419 the index of the filename was looked up last. This handles the majority of
13423 lookup_filename (const char *file_name)
13426 char *save_file_name;
13428 /* Check to see if the file name that was searched on the previous
13429 call matches this file name. If so, return the index. */
13430 if (file_table_last_lookup_index != 0)
13433 = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
13434 if (strcmp (file_name, last) == 0)
13435 return file_table_last_lookup_index;
13438 /* Didn't match the previous lookup, search the table. */
13439 n = VARRAY_ACTIVE_SIZE (file_table);
13440 for (i = 1; i < n; i++)
13441 if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
13443 file_table_last_lookup_index = i;
13447 /* Add the new entry to the end of the filename table. */
13448 file_table_last_lookup_index = n;
13449 save_file_name = (char *) ggc_strdup (file_name);
13450 VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
13451 VARRAY_PUSH_UINT (file_table_emitted, 0);
13453 /* If the assembler is emitting the file table, and we aren't eliminating
13454 unused debug types, then we must emit .file here. If we are eliminating
13455 unused debug types, then this will be done by the maybe_emit_file call in
13456 prune_unused_types_walk_attribs. */
13458 if (DWARF2_ASM_LINE_DEBUG_INFO && ! flag_eliminate_unused_debug_types)
13459 return maybe_emit_file (i);
13464 /* If the assembler will construct the file table, then translate the compiler
13465 internal file table number into the assembler file table number, and emit
13466 a .file directive if we haven't already emitted one yet. The file table
13467 numbers are different because we prune debug info for unused variables and
13468 types, which may include filenames. */
13471 maybe_emit_file (int fileno)
13473 if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
13475 if (!VARRAY_UINT (file_table_emitted, fileno))
13477 VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
13478 fprintf (asm_out_file, "\t.file %u ",
13479 VARRAY_UINT (file_table_emitted, fileno));
13480 output_quoted_string (asm_out_file,
13481 VARRAY_CHAR_PTR (file_table, fileno));
13482 fputc ('\n', asm_out_file);
13484 return VARRAY_UINT (file_table_emitted, fileno);
13490 /* Initialize the compiler internal file table. */
13493 init_file_table (void)
13495 /* Allocate the initial hunk of the file_table. */
13496 VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
13497 VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
13499 /* Skip the first entry - file numbers begin at 1. */
13500 VARRAY_PUSH_CHAR_PTR (file_table, NULL);
13501 VARRAY_PUSH_UINT (file_table_emitted, 0);
13502 file_table_last_lookup_index = 0;
13505 /* Called by the final INSN scan whenever we see a var location. We
13506 use it to drop labels in the right places, and throw the location in
13507 our lookup table. */
13510 dwarf2out_var_location (rtx loc_note)
13512 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13513 struct var_loc_node *newloc;
13515 static rtx last_insn;
13516 static const char *last_label;
13519 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13521 prev_insn = PREV_INSN (loc_note);
13523 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13524 /* If the insn we processed last time is the previous insn
13525 and it is also a var location note, use the label we emitted
13527 if (last_insn != NULL_RTX
13528 && last_insn == prev_insn
13529 && NOTE_P (prev_insn)
13530 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13532 newloc->label = last_label;
13536 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13537 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13539 newloc->label = ggc_strdup (loclabel);
13541 newloc->var_loc_note = loc_note;
13542 newloc->next = NULL;
13544 if (cfun && in_cold_section_p)
13545 newloc->section_label = cfun->cold_section_label;
13547 newloc->section_label = text_section_label;
13549 last_insn = loc_note;
13550 last_label = newloc->label;
13551 decl = NOTE_VAR_LOCATION_DECL (loc_note);
13552 if (DECL_DEBUG_EXPR_IS_FROM (decl) && DECL_DEBUG_EXPR (decl)
13553 && DECL_P (DECL_DEBUG_EXPR (decl)))
13554 decl = DECL_DEBUG_EXPR (decl);
13555 add_var_loc_to_decl (decl, newloc);
13558 /* We need to reset the locations at the beginning of each
13559 function. We can't do this in the end_function hook, because the
13560 declarations that use the locations won't have been output when
13561 that hook is called. Also compute have_multiple_function_sections here. */
13564 dwarf2out_begin_function (tree fun)
13566 htab_empty (decl_loc_table);
13568 if (function_section (fun) != text_section)
13569 have_multiple_function_sections = true;
13572 /* Output a label to mark the beginning of a source code line entry
13573 and record information relating to this source line, in
13574 'line_info_table' for later output of the .debug_line section. */
13577 dwarf2out_source_line (unsigned int line, const char *filename)
13579 if (debug_info_level >= DINFO_LEVEL_NORMAL
13582 switch_to_section (current_function_section ());
13584 /* If requested, emit something human-readable. */
13585 if (flag_debug_asm)
13586 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13589 if (DWARF2_ASM_LINE_DEBUG_INFO)
13591 unsigned file_num = lookup_filename (filename);
13593 file_num = maybe_emit_file (file_num);
13595 /* Emit the .loc directive understood by GNU as. */
13596 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13598 /* Indicate that line number info exists. */
13599 line_info_table_in_use++;
13601 else if (function_section (current_function_decl) != text_section)
13603 dw_separate_line_info_ref line_info;
13604 targetm.asm_out.internal_label (asm_out_file, SEPARATE_LINE_CODE_LABEL,
13605 separate_line_info_table_in_use);
13607 /* Expand the line info table if necessary. */
13608 if (separate_line_info_table_in_use
13609 == separate_line_info_table_allocated)
13611 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13612 separate_line_info_table
13613 = ggc_realloc (separate_line_info_table,
13614 separate_line_info_table_allocated
13615 * sizeof (dw_separate_line_info_entry));
13616 memset (separate_line_info_table
13617 + separate_line_info_table_in_use,
13619 (LINE_INFO_TABLE_INCREMENT
13620 * sizeof (dw_separate_line_info_entry)));
13623 /* Add the new entry at the end of the line_info_table. */
13625 = &separate_line_info_table[separate_line_info_table_in_use++];
13626 line_info->dw_file_num = lookup_filename (filename);
13627 line_info->dw_line_num = line;
13628 line_info->function = current_function_funcdef_no;
13632 dw_line_info_ref line_info;
13634 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13635 line_info_table_in_use);
13637 /* Expand the line info table if necessary. */
13638 if (line_info_table_in_use == line_info_table_allocated)
13640 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13642 = ggc_realloc (line_info_table,
13643 (line_info_table_allocated
13644 * sizeof (dw_line_info_entry)));
13645 memset (line_info_table + line_info_table_in_use, 0,
13646 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13649 /* Add the new entry at the end of the line_info_table. */
13650 line_info = &line_info_table[line_info_table_in_use++];
13651 line_info->dw_file_num = lookup_filename (filename);
13652 line_info->dw_line_num = line;
13657 /* Record the beginning of a new source file. */
13660 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13662 if (flag_eliminate_dwarf2_dups)
13664 /* Record the beginning of the file for break_out_includes. */
13665 dw_die_ref bincl_die;
13667 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13668 add_AT_string (bincl_die, DW_AT_name, filename);
13671 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13675 switch_to_section (debug_macinfo_section);
13676 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13677 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13680 fileno = maybe_emit_file (lookup_filename (filename));
13681 dw2_asm_output_data_uleb128 (fileno, "Filename we just started");
13685 /* Record the end of a source file. */
13688 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13690 if (flag_eliminate_dwarf2_dups)
13691 /* Record the end of the file for break_out_includes. */
13692 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13694 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13696 switch_to_section (debug_macinfo_section);
13697 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13701 /* Called from debug_define in toplev.c. The `buffer' parameter contains
13702 the tail part of the directive line, i.e. the part which is past the
13703 initial whitespace, #, whitespace, directive-name, whitespace part. */
13706 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13707 const char *buffer ATTRIBUTE_UNUSED)
13709 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13711 switch_to_section (debug_macinfo_section);
13712 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13713 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13714 dw2_asm_output_nstring (buffer, -1, "The macro");
13718 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
13719 the tail part of the directive line, i.e. the part which is past the
13720 initial whitespace, #, whitespace, directive-name, whitespace part. */
13723 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13724 const char *buffer ATTRIBUTE_UNUSED)
13726 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13728 switch_to_section (debug_macinfo_section);
13729 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13730 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13731 dw2_asm_output_nstring (buffer, -1, "The macro");
13735 /* Set up for Dwarf output at the start of compilation. */
13738 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13740 init_file_table ();
13742 /* Allocate the decl_die_table. */
13743 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13744 decl_die_table_eq, NULL);
13746 /* Allocate the decl_loc_table. */
13747 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13748 decl_loc_table_eq, NULL);
13750 /* Allocate the initial hunk of the decl_scope_table. */
13751 decl_scope_table = VEC_alloc (tree, gc, 256);
13753 /* Allocate the initial hunk of the abbrev_die_table. */
13754 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13755 * sizeof (dw_die_ref));
13756 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13757 /* Zero-th entry is allocated, but unused. */
13758 abbrev_die_table_in_use = 1;
13760 /* Allocate the initial hunk of the line_info_table. */
13761 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13762 * sizeof (dw_line_info_entry));
13763 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13765 /* Zero-th entry is allocated, but unused. */
13766 line_info_table_in_use = 1;
13768 /* Generate the initial DIE for the .debug section. Note that the (string)
13769 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13770 will (typically) be a relative pathname and that this pathname should be
13771 taken as being relative to the directory from which the compiler was
13772 invoked when the given (base) source file was compiled. We will fill
13773 in this value in dwarf2out_finish. */
13774 comp_unit_die = gen_compile_unit_die (NULL);
13776 incomplete_types = VEC_alloc (tree, gc, 64);
13778 used_rtx_array = VEC_alloc (rtx, gc, 32);
13780 debug_info_section = get_section (DEBUG_INFO_SECTION,
13781 SECTION_DEBUG, NULL);
13782 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
13783 SECTION_DEBUG, NULL);
13784 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
13785 SECTION_DEBUG, NULL);
13786 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
13787 SECTION_DEBUG, NULL);
13788 debug_line_section = get_section (DEBUG_LINE_SECTION,
13789 SECTION_DEBUG, NULL);
13790 debug_loc_section = get_section (DEBUG_LOC_SECTION,
13791 SECTION_DEBUG, NULL);
13792 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
13793 SECTION_DEBUG, NULL);
13794 debug_str_section = get_section (DEBUG_STR_SECTION,
13795 DEBUG_STR_SECTION_FLAGS, NULL);
13796 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
13797 SECTION_DEBUG, NULL);
13798 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
13799 SECTION_DEBUG, NULL);
13801 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13802 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13803 DEBUG_ABBREV_SECTION_LABEL, 0);
13804 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13805 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13806 COLD_TEXT_SECTION_LABEL, 0);
13807 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13809 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13810 DEBUG_INFO_SECTION_LABEL, 0);
13811 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13812 DEBUG_LINE_SECTION_LABEL, 0);
13813 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13814 DEBUG_RANGES_SECTION_LABEL, 0);
13815 switch_to_section (debug_abbrev_section);
13816 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13817 switch_to_section (debug_info_section);
13818 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13819 switch_to_section (debug_line_section);
13820 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13822 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13824 switch_to_section (debug_macinfo_section);
13825 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13826 DEBUG_MACINFO_SECTION_LABEL, 0);
13827 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13830 switch_to_section (text_section);
13831 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13832 if (flag_reorder_blocks_and_partition)
13834 switch_to_section (unlikely_text_section ());
13835 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
13839 /* A helper function for dwarf2out_finish called through
13840 ht_forall. Emit one queued .debug_str string. */
13843 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
13845 struct indirect_string_node *node = (struct indirect_string_node *) *h;
13847 if (node->form == DW_FORM_strp)
13849 switch_to_section (debug_str_section);
13850 ASM_OUTPUT_LABEL (asm_out_file, node->label);
13851 assemble_string (node->str, strlen (node->str) + 1);
13859 /* Clear the marks for a die and its children.
13860 Be cool if the mark isn't set. */
13863 prune_unmark_dies (dw_die_ref die)
13867 for (c = die->die_child; c; c = c->die_sib)
13868 prune_unmark_dies (c);
13872 /* Given DIE that we're marking as used, find any other dies
13873 it references as attributes and mark them as used. */
13876 prune_unused_types_walk_attribs (dw_die_ref die)
13880 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
13882 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
13884 /* A reference to another DIE.
13885 Make sure that it will get emitted. */
13886 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
13888 else if (a->dw_attr == DW_AT_decl_file || a->dw_attr == DW_AT_call_file)
13890 /* A reference to a file. Make sure the file name is emitted. */
13891 a->dw_attr_val.v.val_unsigned =
13892 maybe_emit_file (a->dw_attr_val.v.val_unsigned);
13898 /* Mark DIE as being used. If DOKIDS is true, then walk down
13899 to DIE's children. */
13902 prune_unused_types_mark (dw_die_ref die, int dokids)
13906 if (die->die_mark == 0)
13908 /* We haven't done this node yet. Mark it as used. */
13911 /* We also have to mark its parents as used.
13912 (But we don't want to mark our parents' kids due to this.) */
13913 if (die->die_parent)
13914 prune_unused_types_mark (die->die_parent, 0);
13916 /* Mark any referenced nodes. */
13917 prune_unused_types_walk_attribs (die);
13919 /* If this node is a specification,
13920 also mark the definition, if it exists. */
13921 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
13922 prune_unused_types_mark (die->die_definition, 1);
13925 if (dokids && die->die_mark != 2)
13927 /* We need to walk the children, but haven't done so yet.
13928 Remember that we've walked the kids. */
13932 for (c = die->die_child; c; c = c->die_sib)
13934 /* If this is an array type, we need to make sure our
13935 kids get marked, even if they're types. */
13936 if (die->die_tag == DW_TAG_array_type)
13937 prune_unused_types_mark (c, 1);
13939 prune_unused_types_walk (c);
13945 /* Walk the tree DIE and mark types that we actually use. */
13948 prune_unused_types_walk (dw_die_ref die)
13952 /* Don't do anything if this node is already marked. */
13956 switch (die->die_tag) {
13957 case DW_TAG_const_type:
13958 case DW_TAG_packed_type:
13959 case DW_TAG_pointer_type:
13960 case DW_TAG_reference_type:
13961 case DW_TAG_volatile_type:
13962 case DW_TAG_typedef:
13963 case DW_TAG_array_type:
13964 case DW_TAG_structure_type:
13965 case DW_TAG_union_type:
13966 case DW_TAG_class_type:
13967 case DW_TAG_friend:
13968 case DW_TAG_variant_part:
13969 case DW_TAG_enumeration_type:
13970 case DW_TAG_subroutine_type:
13971 case DW_TAG_string_type:
13972 case DW_TAG_set_type:
13973 case DW_TAG_subrange_type:
13974 case DW_TAG_ptr_to_member_type:
13975 case DW_TAG_file_type:
13976 /* It's a type node --- don't mark it. */
13980 /* Mark everything else. */
13986 /* Now, mark any dies referenced from here. */
13987 prune_unused_types_walk_attribs (die);
13989 /* Mark children. */
13990 for (c = die->die_child; c; c = c->die_sib)
13991 prune_unused_types_walk (c);
13995 /* Remove from the tree DIE any dies that aren't marked. */
13998 prune_unused_types_prune (dw_die_ref die)
14000 dw_die_ref c, p, n;
14002 gcc_assert (die->die_mark);
14005 for (c = die->die_child; c; c = n)
14010 prune_unused_types_prune (c);
14018 die->die_child = n;
14025 /* Remove dies representing declarations that we never use. */
14028 prune_unused_types (void)
14031 limbo_die_node *node;
14033 /* Clear all the marks. */
14034 prune_unmark_dies (comp_unit_die);
14035 for (node = limbo_die_list; node; node = node->next)
14036 prune_unmark_dies (node->die);
14038 /* Set the mark on nodes that are actually used. */
14039 prune_unused_types_walk (comp_unit_die);
14040 for (node = limbo_die_list; node; node = node->next)
14041 prune_unused_types_walk (node->die);
14043 /* Also set the mark on nodes referenced from the
14044 pubname_table or arange_table. */
14045 for (i = 0; i < pubname_table_in_use; i++)
14046 prune_unused_types_mark (pubname_table[i].die, 1);
14047 for (i = 0; i < arange_table_in_use; i++)
14048 prune_unused_types_mark (arange_table[i], 1);
14050 /* Get rid of nodes that aren't marked. */
14051 prune_unused_types_prune (comp_unit_die);
14052 for (node = limbo_die_list; node; node = node->next)
14053 prune_unused_types_prune (node->die);
14055 /* Leave the marks clear. */
14056 prune_unmark_dies (comp_unit_die);
14057 for (node = limbo_die_list; node; node = node->next)
14058 prune_unmark_dies (node->die);
14061 /* Output stuff that dwarf requires at the end of every file,
14062 and generate the DWARF-2 debugging info. */
14065 dwarf2out_finish (const char *filename)
14067 limbo_die_node *node, *next_node;
14068 dw_die_ref die = 0;
14070 /* Add the name for the main input file now. We delayed this from
14071 dwarf2out_init to avoid complications with PCH. */
14072 add_name_attribute (comp_unit_die, filename);
14073 if (filename[0] != DIR_SEPARATOR)
14074 add_comp_dir_attribute (comp_unit_die);
14075 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14078 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
14079 if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR
14080 /* Don't add cwd for <built-in>. */
14081 && VARRAY_CHAR_PTR (file_table, i)[0] != '<')
14083 add_comp_dir_attribute (comp_unit_die);
14088 /* Traverse the limbo die list, and add parent/child links. The only
14089 dies without parents that should be here are concrete instances of
14090 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
14091 For concrete instances, we can get the parent die from the abstract
14093 for (node = limbo_die_list; node; node = next_node)
14095 next_node = node->next;
14098 if (die->die_parent == NULL)
14100 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14103 add_child_die (origin->die_parent, die);
14104 else if (die == comp_unit_die)
14106 else if (errorcount > 0 || sorrycount > 0)
14107 /* It's OK to be confused by errors in the input. */
14108 add_child_die (comp_unit_die, die);
14111 /* In certain situations, the lexical block containing a
14112 nested function can be optimized away, which results
14113 in the nested function die being orphaned. Likewise
14114 with the return type of that nested function. Force
14115 this to be a child of the containing function.
14117 It may happen that even the containing function got fully
14118 inlined and optimized out. In that case we are lost and
14119 assign the empty child. This should not be big issue as
14120 the function is likely unreachable too. */
14121 tree context = NULL_TREE;
14123 gcc_assert (node->created_for);
14125 if (DECL_P (node->created_for))
14126 context = DECL_CONTEXT (node->created_for);
14127 else if (TYPE_P (node->created_for))
14128 context = TYPE_CONTEXT (node->created_for);
14130 gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
14132 origin = lookup_decl_die (context);
14134 add_child_die (origin, die);
14136 add_child_die (comp_unit_die, die);
14141 limbo_die_list = NULL;
14143 /* Walk through the list of incomplete types again, trying once more to
14144 emit full debugging info for them. */
14145 retry_incomplete_types ();
14147 /* We need to reverse all the dies before break_out_includes, or
14148 we'll see the end of an include file before the beginning. */
14149 reverse_all_dies (comp_unit_die);
14151 if (flag_eliminate_unused_debug_types)
14152 prune_unused_types ();
14154 /* Generate separate CUs for each of the include files we've seen.
14155 They will go into limbo_die_list. */
14156 if (flag_eliminate_dwarf2_dups)
14157 break_out_includes (comp_unit_die);
14159 /* Traverse the DIE's and add add sibling attributes to those DIE's
14160 that have children. */
14161 add_sibling_attributes (comp_unit_die);
14162 for (node = limbo_die_list; node; node = node->next)
14163 add_sibling_attributes (node->die);
14165 /* Output a terminator label for the .text section. */
14166 switch_to_section (text_section);
14167 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14168 if (flag_reorder_blocks_and_partition)
14170 switch_to_section (unlikely_text_section ());
14171 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14174 /* Output the source line correspondence table. We must do this
14175 even if there is no line information. Otherwise, on an empty
14176 translation unit, we will generate a present, but empty,
14177 .debug_info section. IRIX 6.5 `nm' will then complain when
14178 examining the file. */
14179 if (! DWARF2_ASM_LINE_DEBUG_INFO)
14181 switch_to_section (debug_line_section);
14182 output_line_info ();
14185 /* We can only use the low/high_pc attributes if all of the code was
14187 if (!have_multiple_function_sections)
14189 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14190 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14193 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14194 "base address". Use zero so that these addresses become absolute. */
14195 else if (have_location_lists || ranges_table_in_use)
14196 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14198 /* Output location list section if necessary. */
14199 if (have_location_lists)
14201 /* Output the location lists info. */
14202 switch_to_section (debug_loc_section);
14203 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14204 DEBUG_LOC_SECTION_LABEL, 0);
14205 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14206 output_location_lists (die);
14209 if (debug_info_level >= DINFO_LEVEL_NORMAL)
14210 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
14211 debug_line_section_label);
14213 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14214 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14216 /* Output all of the compilation units. We put the main one last so that
14217 the offsets are available to output_pubnames. */
14218 for (node = limbo_die_list; node; node = node->next)
14219 output_comp_unit (node->die, 0);
14221 output_comp_unit (comp_unit_die, 0);
14223 /* Output the abbreviation table. */
14224 switch_to_section (debug_abbrev_section);
14225 output_abbrev_section ();
14227 /* Output public names table if necessary. */
14228 if (pubname_table_in_use)
14230 switch_to_section (debug_pubnames_section);
14231 output_pubnames ();
14234 /* Output the address range information. We only put functions in the arange
14235 table, so don't write it out if we don't have any. */
14236 if (fde_table_in_use)
14238 switch_to_section (debug_aranges_section);
14242 /* Output ranges section if necessary. */
14243 if (ranges_table_in_use)
14245 switch_to_section (debug_ranges_section);
14246 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14250 /* Have to end the macro section. */
14251 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14253 switch_to_section (debug_macinfo_section);
14254 dw2_asm_output_data (1, 0, "End compilation unit");
14257 /* If we emitted any DW_FORM_strp form attribute, output the string
14259 if (debug_str_hash)
14260 htab_traverse (debug_str_hash, output_indirect_string, NULL);
14264 /* This should never be used, but its address is needed for comparisons. */
14265 const struct gcc_debug_hooks dwarf2_debug_hooks;
14267 #endif /* DWARF2_DEBUGGING_INFO */
14269 #include "gt-dwarf2out.h"