1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* TODO: Emit .debug_line header even when there are no functions, since
25 the file numbers are used by .debug_info. Alternately, leave
26 out locations for types and decls.
27 Avoid talking about ctors and op= for PODs.
28 Factor out common prologue sequences into multiple CIEs. */
30 /* The first part of this file deals with the DWARF 2 frame unwind
31 information, which is also used by the GCC efficient exception handling
32 mechanism. The second part, controlled only by an #ifdef
33 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
36 /* DWARF2 Abbreviation Glossary:
38 CFA = Canonical Frame Address
39 a fixed address on the stack which identifies a call frame.
40 We define it to be the value of SP just before the call insn.
41 The CFA register and offset, which may change during the course
42 of the function, are used to calculate its value at runtime.
44 CFI = Call Frame Instruction
45 an instruction for the DWARF2 abstract machine
47 CIE = Common Information Entry
48 information describing information common to one or more FDEs
50 DIE = Debugging Information Entry
52 FDE = Frame Description Entry
53 information describing the stack call frame, in particular,
54 how to restore registers
56 DW_CFA_... = DWARF2 CFA call frame instruction
57 DW_TAG_... = DWARF2 DIE tag */
61 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
85 #include "diagnostic.h"
88 #include "langhooks.h"
93 #ifdef DWARF2_DEBUGGING_INFO
94 static void dwarf2out_source_line (unsigned int, const char *);
97 #ifndef DWARF2_FRAME_INFO
98 # ifdef DWARF2_DEBUGGING_INFO
99 # define DWARF2_FRAME_INFO \
100 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
102 # define DWARF2_FRAME_INFO 0
106 /* Map register numbers held in the call frame info that gcc has
107 collected using DWARF_FRAME_REGNUM to those that should be output in
108 .debug_frame and .eh_frame. */
109 #ifndef DWARF2_FRAME_REG_OUT
110 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
113 /* Save the result of dwarf2out_do_frame across PCH. */
114 static GTY(()) bool saved_do_cfi_asm = 0;
116 /* Decide whether we want to emit frame unwind information for the current
120 dwarf2out_do_frame (void)
122 /* We want to emit correct CFA location expressions or lists, so we
123 have to return true if we're going to output debug info, even if
124 we're not going to output frame or unwind info. */
125 return (write_symbols == DWARF2_DEBUG
126 || write_symbols == VMS_AND_DWARF2_DEBUG
127 || DWARF2_FRAME_INFO || saved_do_cfi_asm
128 #ifdef DWARF2_UNWIND_INFO
129 || (DWARF2_UNWIND_INFO
130 && (flag_unwind_tables
131 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
136 /* Decide whether to emit frame unwind via assembler directives. */
139 dwarf2out_do_cfi_asm (void)
143 #ifdef MIPS_DEBUGGING_INFO
146 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
148 if (saved_do_cfi_asm || !eh_personality_libfunc)
150 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
153 /* Make sure the personality encoding is one the assembler can support.
154 In particular, aligned addresses can't be handled. */
155 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
156 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
158 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
159 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
162 saved_do_cfi_asm = true;
166 /* The size of the target's pointer type. */
168 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
171 /* Array of RTXes referenced by the debugging information, which therefore
172 must be kept around forever. */
173 static GTY(()) VEC(rtx,gc) *used_rtx_array;
175 /* A pointer to the base of a list of incomplete types which might be
176 completed at some later time. incomplete_types_list needs to be a
177 VEC(tree,gc) because we want to tell the garbage collector about
179 static GTY(()) VEC(tree,gc) *incomplete_types;
181 /* A pointer to the base of a table of references to declaration
182 scopes. This table is a display which tracks the nesting
183 of declaration scopes at the current scope and containing
184 scopes. This table is used to find the proper place to
185 define type declaration DIE's. */
186 static GTY(()) VEC(tree,gc) *decl_scope_table;
188 /* Pointers to various DWARF2 sections. */
189 static GTY(()) section *debug_info_section;
190 static GTY(()) section *debug_abbrev_section;
191 static GTY(()) section *debug_aranges_section;
192 static GTY(()) section *debug_macinfo_section;
193 static GTY(()) section *debug_line_section;
194 static GTY(()) section *debug_loc_section;
195 static GTY(()) section *debug_pubnames_section;
196 static GTY(()) section *debug_pubtypes_section;
197 static GTY(()) section *debug_str_section;
198 static GTY(()) section *debug_ranges_section;
199 static GTY(()) section *debug_frame_section;
201 /* How to start an assembler comment. */
202 #ifndef ASM_COMMENT_START
203 #define ASM_COMMENT_START ";#"
206 typedef struct dw_cfi_struct *dw_cfi_ref;
207 typedef struct dw_fde_struct *dw_fde_ref;
208 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
210 /* Call frames are described using a sequence of Call Frame
211 Information instructions. The register number, offset
212 and address fields are provided as possible operands;
213 their use is selected by the opcode field. */
215 enum dw_cfi_oprnd_type {
217 dw_cfi_oprnd_reg_num,
223 typedef union dw_cfi_oprnd_struct GTY(())
225 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
226 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
227 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
228 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
232 typedef struct dw_cfi_struct GTY(())
234 dw_cfi_ref dw_cfi_next;
235 enum dwarf_call_frame_info dw_cfi_opc;
236 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
238 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
243 /* This is how we define the location of the CFA. We use to handle it
244 as REG + OFFSET all the time, but now it can be more complex.
245 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
246 Instead of passing around REG and OFFSET, we pass a copy
247 of this structure. */
248 typedef struct cfa_loc GTY(())
250 HOST_WIDE_INT offset;
251 HOST_WIDE_INT base_offset;
253 int indirect; /* 1 if CFA is accessed via a dereference. */
256 /* All call frame descriptions (FDE's) in the GCC generated DWARF
257 refer to a single Common Information Entry (CIE), defined at
258 the beginning of the .debug_frame section. This use of a single
259 CIE obviates the need to keep track of multiple CIE's
260 in the DWARF generation routines below. */
262 typedef struct dw_fde_struct GTY(())
265 const char *dw_fde_begin;
266 const char *dw_fde_current_label;
267 const char *dw_fde_end;
268 const char *dw_fde_hot_section_label;
269 const char *dw_fde_hot_section_end_label;
270 const char *dw_fde_unlikely_section_label;
271 const char *dw_fde_unlikely_section_end_label;
272 bool dw_fde_switched_sections;
273 dw_cfi_ref dw_fde_cfi;
274 unsigned funcdef_number;
275 HOST_WIDE_INT stack_realignment;
276 /* Dynamic realign argument pointer register. */
277 unsigned int drap_reg;
278 /* Virtual dynamic realign argument pointer register. */
279 unsigned int vdrap_reg;
280 unsigned all_throwers_are_sibcalls : 1;
281 unsigned nothrow : 1;
282 unsigned uses_eh_lsda : 1;
283 /* Whether we did stack realign in this call frame. */
284 unsigned stack_realign : 1;
285 /* Whether dynamic realign argument pointer register has been saved. */
286 unsigned drap_reg_saved: 1;
290 /* Maximum size (in bytes) of an artificially generated label. */
291 #define MAX_ARTIFICIAL_LABEL_BYTES 30
293 /* The size of addresses as they appear in the Dwarf 2 data.
294 Some architectures use word addresses to refer to code locations,
295 but Dwarf 2 info always uses byte addresses. On such machines,
296 Dwarf 2 addresses need to be larger than the architecture's
298 #ifndef DWARF2_ADDR_SIZE
299 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
302 /* The size in bytes of a DWARF field indicating an offset or length
303 relative to a debug info section, specified to be 4 bytes in the
304 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
307 #ifndef DWARF_OFFSET_SIZE
308 #define DWARF_OFFSET_SIZE 4
311 /* According to the (draft) DWARF 3 specification, the initial length
312 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
313 bytes are 0xffffffff, followed by the length stored in the next 8
316 However, the SGI/MIPS ABI uses an initial length which is equal to
317 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
319 #ifndef DWARF_INITIAL_LENGTH_SIZE
320 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
323 #define DWARF_VERSION 2
325 /* Round SIZE up to the nearest BOUNDARY. */
326 #define DWARF_ROUND(SIZE,BOUNDARY) \
327 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
329 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
330 #ifndef DWARF_CIE_DATA_ALIGNMENT
331 #ifdef STACK_GROWS_DOWNWARD
332 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
334 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
338 /* CIE identifier. */
339 #if HOST_BITS_PER_WIDE_INT >= 64
340 #define DWARF_CIE_ID \
341 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
343 #define DWARF_CIE_ID DW_CIE_ID
346 /* A pointer to the base of a table that contains frame description
347 information for each routine. */
348 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
350 /* Number of elements currently allocated for fde_table. */
351 static GTY(()) unsigned fde_table_allocated;
353 /* Number of elements in fde_table currently in use. */
354 static GTY(()) unsigned fde_table_in_use;
356 /* Size (in elements) of increments by which we may expand the
358 #define FDE_TABLE_INCREMENT 256
360 /* Get the current fde_table entry we should use. */
362 static inline dw_fde_ref
365 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
368 /* A list of call frame insns for the CIE. */
369 static GTY(()) dw_cfi_ref cie_cfi_head;
371 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
372 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
373 attribute that accelerates the lookup of the FDE associated
374 with the subprogram. This variable holds the table index of the FDE
375 associated with the current function (body) definition. */
376 static unsigned current_funcdef_fde;
379 struct indirect_string_node GTY(())
382 unsigned int refcount;
387 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
389 static GTY(()) int dw2_string_counter;
390 static GTY(()) unsigned long dwarf2out_cfi_label_num;
392 /* True if the compilation unit places functions in more than one section. */
393 static GTY(()) bool have_multiple_function_sections = false;
395 /* Whether the default text and cold text sections have been used at all. */
397 static GTY(()) bool text_section_used = false;
398 static GTY(()) bool cold_text_section_used = false;
400 /* The default cold text section. */
401 static GTY(()) section *cold_text_section;
403 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
405 /* Forward declarations for functions defined in this file. */
407 static char *stripattributes (const char *);
408 static const char *dwarf_cfi_name (unsigned);
409 static dw_cfi_ref new_cfi (void);
410 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
411 static void add_fde_cfi (const char *, dw_cfi_ref);
412 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
413 static void lookup_cfa (dw_cfa_location *);
414 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
415 #ifdef DWARF2_UNWIND_INFO
416 static void initial_return_save (rtx);
418 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
420 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
421 static void output_cfi_directive (dw_cfi_ref);
422 static void output_call_frame_info (int);
423 static void dwarf2out_note_section_used (void);
424 static void dwarf2out_stack_adjust (rtx, bool);
425 static void dwarf2out_args_size_adjust (HOST_WIDE_INT, const char *);
426 static void flush_queued_reg_saves (void);
427 static bool clobbers_queued_reg_save (const_rtx);
428 static void dwarf2out_frame_debug_expr (rtx, const char *);
430 /* Support for complex CFA locations. */
431 static void output_cfa_loc (dw_cfi_ref);
432 static void output_cfa_loc_raw (dw_cfi_ref);
433 static void get_cfa_from_loc_descr (dw_cfa_location *,
434 struct dw_loc_descr_struct *);
435 static struct dw_loc_descr_struct *build_cfa_loc
436 (dw_cfa_location *, HOST_WIDE_INT);
437 static struct dw_loc_descr_struct *build_cfa_aligned_loc
438 (HOST_WIDE_INT, HOST_WIDE_INT);
439 static void def_cfa_1 (const char *, dw_cfa_location *);
441 /* How to start an assembler comment. */
442 #ifndef ASM_COMMENT_START
443 #define ASM_COMMENT_START ";#"
446 /* Data and reference forms for relocatable data. */
447 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
448 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
450 #ifndef DEBUG_FRAME_SECTION
451 #define DEBUG_FRAME_SECTION ".debug_frame"
454 #ifndef FUNC_BEGIN_LABEL
455 #define FUNC_BEGIN_LABEL "LFB"
458 #ifndef FUNC_END_LABEL
459 #define FUNC_END_LABEL "LFE"
462 #ifndef FRAME_BEGIN_LABEL
463 #define FRAME_BEGIN_LABEL "Lframe"
465 #define CIE_AFTER_SIZE_LABEL "LSCIE"
466 #define CIE_END_LABEL "LECIE"
467 #define FDE_LABEL "LSFDE"
468 #define FDE_AFTER_SIZE_LABEL "LASFDE"
469 #define FDE_END_LABEL "LEFDE"
470 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
471 #define LINE_NUMBER_END_LABEL "LELT"
472 #define LN_PROLOG_AS_LABEL "LASLTP"
473 #define LN_PROLOG_END_LABEL "LELTP"
474 #define DIE_LABEL_PREFIX "DW"
476 /* The DWARF 2 CFA column which tracks the return address. Normally this
477 is the column for PC, or the first column after all of the hard
479 #ifndef DWARF_FRAME_RETURN_COLUMN
481 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
483 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
487 /* The mapping from gcc register number to DWARF 2 CFA column number. By
488 default, we just provide columns for all registers. */
489 #ifndef DWARF_FRAME_REGNUM
490 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
493 /* Hook used by __throw. */
496 expand_builtin_dwarf_sp_column (void)
498 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
499 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
502 /* Return a pointer to a copy of the section string name S with all
503 attributes stripped off, and an asterisk prepended (for assemble_name). */
506 stripattributes (const char *s)
508 char *stripped = XNEWVEC (char, strlen (s) + 2);
513 while (*s && *s != ',')
520 /* MEM is a memory reference for the register size table, each element of
521 which has mode MODE. Initialize column C as a return address column. */
524 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
526 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
527 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
528 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
531 /* Generate code to initialize the register size table. */
534 expand_builtin_init_dwarf_reg_sizes (tree address)
537 enum machine_mode mode = TYPE_MODE (char_type_node);
538 rtx addr = expand_normal (address);
539 rtx mem = gen_rtx_MEM (BLKmode, addr);
540 bool wrote_return_column = false;
542 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
544 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
546 if (rnum < DWARF_FRAME_REGISTERS)
548 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
549 enum machine_mode save_mode = reg_raw_mode[i];
552 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
553 save_mode = choose_hard_reg_mode (i, 1, true);
554 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
556 if (save_mode == VOIDmode)
558 wrote_return_column = true;
560 size = GET_MODE_SIZE (save_mode);
564 emit_move_insn (adjust_address (mem, mode, offset),
565 gen_int_mode (size, mode));
569 if (!wrote_return_column)
570 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
572 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
573 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
576 targetm.init_dwarf_reg_sizes_extra (address);
579 /* Convert a DWARF call frame info. operation to its string name */
582 dwarf_cfi_name (unsigned int cfi_opc)
586 case DW_CFA_advance_loc:
587 return "DW_CFA_advance_loc";
589 return "DW_CFA_offset";
591 return "DW_CFA_restore";
595 return "DW_CFA_set_loc";
596 case DW_CFA_advance_loc1:
597 return "DW_CFA_advance_loc1";
598 case DW_CFA_advance_loc2:
599 return "DW_CFA_advance_loc2";
600 case DW_CFA_advance_loc4:
601 return "DW_CFA_advance_loc4";
602 case DW_CFA_offset_extended:
603 return "DW_CFA_offset_extended";
604 case DW_CFA_restore_extended:
605 return "DW_CFA_restore_extended";
606 case DW_CFA_undefined:
607 return "DW_CFA_undefined";
608 case DW_CFA_same_value:
609 return "DW_CFA_same_value";
610 case DW_CFA_register:
611 return "DW_CFA_register";
612 case DW_CFA_remember_state:
613 return "DW_CFA_remember_state";
614 case DW_CFA_restore_state:
615 return "DW_CFA_restore_state";
617 return "DW_CFA_def_cfa";
618 case DW_CFA_def_cfa_register:
619 return "DW_CFA_def_cfa_register";
620 case DW_CFA_def_cfa_offset:
621 return "DW_CFA_def_cfa_offset";
624 case DW_CFA_def_cfa_expression:
625 return "DW_CFA_def_cfa_expression";
626 case DW_CFA_expression:
627 return "DW_CFA_expression";
628 case DW_CFA_offset_extended_sf:
629 return "DW_CFA_offset_extended_sf";
630 case DW_CFA_def_cfa_sf:
631 return "DW_CFA_def_cfa_sf";
632 case DW_CFA_def_cfa_offset_sf:
633 return "DW_CFA_def_cfa_offset_sf";
635 /* SGI/MIPS specific */
636 case DW_CFA_MIPS_advance_loc8:
637 return "DW_CFA_MIPS_advance_loc8";
640 case DW_CFA_GNU_window_save:
641 return "DW_CFA_GNU_window_save";
642 case DW_CFA_GNU_args_size:
643 return "DW_CFA_GNU_args_size";
644 case DW_CFA_GNU_negative_offset_extended:
645 return "DW_CFA_GNU_negative_offset_extended";
648 return "DW_CFA_<unknown>";
652 /* Return a pointer to a newly allocated Call Frame Instruction. */
654 static inline dw_cfi_ref
657 dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
659 cfi->dw_cfi_next = NULL;
660 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
661 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
666 /* Add a Call Frame Instruction to list of instructions. */
669 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
672 dw_fde_ref fde = current_fde ();
674 /* When DRAP is used, CFA is defined with an expression. Redefine
675 CFA may lead to a different CFA value. */
676 if (fde && fde->drap_reg != INVALID_REGNUM)
677 switch (cfi->dw_cfi_opc)
679 case DW_CFA_def_cfa_register:
680 case DW_CFA_def_cfa_offset:
681 case DW_CFA_def_cfa_offset_sf:
683 case DW_CFA_def_cfa_sf:
690 /* Find the end of the chain. */
691 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
697 /* Generate a new label for the CFI info to refer to. */
700 dwarf2out_cfi_label (void)
702 static char label[20];
704 if (dwarf2out_do_cfi_asm ())
706 /* In this case, we will be emitting the asm directive instead of
707 the label, so just return a placeholder to keep the rest of the
709 strcpy (label, "<do not output>");
713 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
714 ASM_OUTPUT_LABEL (asm_out_file, label);
720 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
721 or to the CIE if LABEL is NULL. */
724 add_fde_cfi (const char *label, dw_cfi_ref cfi)
726 dw_cfi_ref *list_head = &cie_cfi_head;
728 if (dwarf2out_do_cfi_asm ())
732 output_cfi_directive (cfi);
734 /* We still have to add the cfi to the list so that
735 lookup_cfa works later on. */
736 list_head = ¤t_fde ()->dw_fde_cfi;
738 /* ??? If this is a CFI for the CIE, we don't emit. This
739 assumes that the standard CIE contents that the assembler
740 uses matches the standard CIE contents that the compiler
741 uses. This is probably a bad assumption. I'm not quite
742 sure how to address this for now. */
746 dw_fde_ref fde = current_fde ();
748 gcc_assert (fde != NULL);
751 label = dwarf2out_cfi_label ();
753 if (fde->dw_fde_current_label == NULL
754 || strcmp (label, fde->dw_fde_current_label) != 0)
758 label = xstrdup (label);
760 /* Set the location counter to the new label. */
762 /* If we have a current label, advance from there, otherwise
763 set the location directly using set_loc. */
764 xcfi->dw_cfi_opc = fde->dw_fde_current_label
765 ? DW_CFA_advance_loc4
767 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
768 add_cfi (&fde->dw_fde_cfi, xcfi);
770 fde->dw_fde_current_label = label;
773 list_head = &fde->dw_fde_cfi;
776 add_cfi (list_head, cfi);
779 /* Subroutine of lookup_cfa. */
782 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
784 switch (cfi->dw_cfi_opc)
786 case DW_CFA_def_cfa_offset:
787 case DW_CFA_def_cfa_offset_sf:
788 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
790 case DW_CFA_def_cfa_register:
791 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
794 case DW_CFA_def_cfa_sf:
795 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
796 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
798 case DW_CFA_def_cfa_expression:
799 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
806 /* Find the previous value for the CFA. */
809 lookup_cfa (dw_cfa_location *loc)
814 loc->reg = INVALID_REGNUM;
817 loc->base_offset = 0;
819 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
820 lookup_cfa_1 (cfi, loc);
822 fde = current_fde ();
824 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
825 lookup_cfa_1 (cfi, loc);
828 /* The current rule for calculating the DWARF2 canonical frame address. */
829 static dw_cfa_location cfa;
831 /* The register used for saving registers to the stack, and its offset
833 static dw_cfa_location cfa_store;
835 /* The running total of the size of arguments pushed onto the stack. */
836 static HOST_WIDE_INT args_size;
838 /* The last args_size we actually output. */
839 static HOST_WIDE_INT old_args_size;
841 /* Entry point to update the canonical frame address (CFA).
842 LABEL is passed to add_fde_cfi. The value of CFA is now to be
843 calculated from REG+OFFSET. */
846 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
853 def_cfa_1 (label, &loc);
856 /* Determine if two dw_cfa_location structures define the same data. */
859 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
861 return (loc1->reg == loc2->reg
862 && loc1->offset == loc2->offset
863 && loc1->indirect == loc2->indirect
864 && (loc1->indirect == 0
865 || loc1->base_offset == loc2->base_offset));
868 /* This routine does the actual work. The CFA is now calculated from
869 the dw_cfa_location structure. */
872 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
875 dw_cfa_location old_cfa, loc;
880 if (cfa_store.reg == loc.reg && loc.indirect == 0)
881 cfa_store.offset = loc.offset;
883 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
884 lookup_cfa (&old_cfa);
886 /* If nothing changed, no need to issue any call frame instructions. */
887 if (cfa_equal_p (&loc, &old_cfa))
892 if (loc.reg == old_cfa.reg && !loc.indirect)
894 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
895 the CFA register did not change but the offset did. The data
896 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
897 in the assembler via the .cfi_def_cfa_offset directive. */
899 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
901 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
902 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
905 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
906 else if (loc.offset == old_cfa.offset
907 && old_cfa.reg != INVALID_REGNUM
910 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
911 indicating the CFA register has changed to <register> but the
912 offset has not changed. */
913 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
914 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
918 else if (loc.indirect == 0)
920 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
921 indicating the CFA register has changed to <register> with
922 the specified offset. The data factoring for DW_CFA_def_cfa_sf
923 happens in output_cfi, or in the assembler via the .cfi_def_cfa
926 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
928 cfi->dw_cfi_opc = DW_CFA_def_cfa;
929 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
930 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
934 /* Construct a DW_CFA_def_cfa_expression instruction to
935 calculate the CFA using a full location expression since no
936 register-offset pair is available. */
937 struct dw_loc_descr_struct *loc_list;
939 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
940 loc_list = build_cfa_loc (&loc, 0);
941 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
944 add_fde_cfi (label, cfi);
947 /* Add the CFI for saving a register. REG is the CFA column number.
948 LABEL is passed to add_fde_cfi.
949 If SREG is -1, the register is saved at OFFSET from the CFA;
950 otherwise it is saved in SREG. */
953 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
955 dw_cfi_ref cfi = new_cfi ();
956 dw_fde_ref fde = current_fde ();
958 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
960 /* When stack is aligned, store REG using DW_CFA_expression with
963 && fde->stack_realign
964 && sreg == INVALID_REGNUM)
966 cfi->dw_cfi_opc = DW_CFA_expression;
967 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = reg;
968 cfi->dw_cfi_oprnd1.dw_cfi_loc
969 = build_cfa_aligned_loc (offset, fde->stack_realignment);
971 else if (sreg == INVALID_REGNUM)
974 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
975 else if (reg & ~0x3f)
976 cfi->dw_cfi_opc = DW_CFA_offset_extended;
978 cfi->dw_cfi_opc = DW_CFA_offset;
979 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
981 else if (sreg == reg)
982 cfi->dw_cfi_opc = DW_CFA_same_value;
985 cfi->dw_cfi_opc = DW_CFA_register;
986 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
989 add_fde_cfi (label, cfi);
992 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
993 This CFI tells the unwinder that it needs to restore the window registers
994 from the previous frame's window save area.
996 ??? Perhaps we should note in the CIE where windows are saved (instead of
997 assuming 0(cfa)) and what registers are in the window. */
1000 dwarf2out_window_save (const char *label)
1002 dw_cfi_ref cfi = new_cfi ();
1004 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1005 add_fde_cfi (label, cfi);
1008 /* Add a CFI to update the running total of the size of arguments
1009 pushed onto the stack. */
1012 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1016 if (size == old_args_size)
1019 old_args_size = size;
1022 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1023 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1024 add_fde_cfi (label, cfi);
1027 /* Entry point for saving a register to the stack. REG is the GCC register
1028 number. LABEL and OFFSET are passed to reg_save. */
1031 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1033 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1036 /* Entry point for saving the return address in the stack.
1037 LABEL and OFFSET are passed to reg_save. */
1040 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1042 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1045 /* Entry point for saving the return address in a register.
1046 LABEL and SREG are passed to reg_save. */
1049 dwarf2out_return_reg (const char *label, unsigned int sreg)
1051 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1054 #ifdef DWARF2_UNWIND_INFO
1055 /* Record the initial position of the return address. RTL is
1056 INCOMING_RETURN_ADDR_RTX. */
1059 initial_return_save (rtx rtl)
1061 unsigned int reg = INVALID_REGNUM;
1062 HOST_WIDE_INT offset = 0;
1064 switch (GET_CODE (rtl))
1067 /* RA is in a register. */
1068 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1072 /* RA is on the stack. */
1073 rtl = XEXP (rtl, 0);
1074 switch (GET_CODE (rtl))
1077 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1082 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1083 offset = INTVAL (XEXP (rtl, 1));
1087 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1088 offset = -INTVAL (XEXP (rtl, 1));
1098 /* The return address is at some offset from any value we can
1099 actually load. For instance, on the SPARC it is in %i7+8. Just
1100 ignore the offset for now; it doesn't matter for unwinding frames. */
1101 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1102 initial_return_save (XEXP (rtl, 0));
1109 if (reg != DWARF_FRAME_RETURN_COLUMN)
1110 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1114 /* Given a SET, calculate the amount of stack adjustment it
1117 static HOST_WIDE_INT
1118 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1119 HOST_WIDE_INT cur_offset)
1121 const_rtx src = SET_SRC (pattern);
1122 const_rtx dest = SET_DEST (pattern);
1123 HOST_WIDE_INT offset = 0;
1126 if (dest == stack_pointer_rtx)
1128 code = GET_CODE (src);
1130 /* Assume (set (reg sp) (reg whatever)) sets args_size
1132 if (code == REG && src != stack_pointer_rtx)
1134 offset = -cur_args_size;
1135 #ifndef STACK_GROWS_DOWNWARD
1138 return offset - cur_offset;
1141 if (! (code == PLUS || code == MINUS)
1142 || XEXP (src, 0) != stack_pointer_rtx
1143 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1146 /* (set (reg sp) (plus (reg sp) (const_int))) */
1147 offset = INTVAL (XEXP (src, 1));
1153 if (MEM_P (src) && !MEM_P (dest))
1157 /* (set (mem (pre_dec (reg sp))) (foo)) */
1158 src = XEXP (dest, 0);
1159 code = GET_CODE (src);
1165 if (XEXP (src, 0) == stack_pointer_rtx)
1167 rtx val = XEXP (XEXP (src, 1), 1);
1168 /* We handle only adjustments by constant amount. */
1169 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1170 && GET_CODE (val) == CONST_INT);
1171 offset = -INTVAL (val);
1178 if (XEXP (src, 0) == stack_pointer_rtx)
1180 offset = GET_MODE_SIZE (GET_MODE (dest));
1187 if (XEXP (src, 0) == stack_pointer_rtx)
1189 offset = -GET_MODE_SIZE (GET_MODE (dest));
1204 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1205 indexed by INSN_UID. */
1207 static HOST_WIDE_INT *barrier_args_size;
1209 /* Helper function for compute_barrier_args_size. Handle one insn. */
1211 static HOST_WIDE_INT
1212 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1213 VEC (rtx, heap) **next)
1215 HOST_WIDE_INT offset = 0;
1218 if (! RTX_FRAME_RELATED_P (insn))
1220 if (prologue_epilogue_contains (insn)
1221 || sibcall_epilogue_contains (insn))
1223 else if (GET_CODE (PATTERN (insn)) == SET)
1224 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1225 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1226 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1228 /* There may be stack adjustments inside compound insns. Search
1230 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1231 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1232 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1233 cur_args_size, offset);
1238 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1242 expr = XEXP (expr, 0);
1243 if (GET_CODE (expr) == PARALLEL
1244 || GET_CODE (expr) == SEQUENCE)
1245 for (i = 1; i < XVECLEN (expr, 0); i++)
1247 rtx elem = XVECEXP (expr, 0, i);
1249 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1250 offset += stack_adjust_offset (elem, cur_args_size, offset);
1255 #ifndef STACK_GROWS_DOWNWARD
1259 cur_args_size += offset;
1260 if (cur_args_size < 0)
1265 rtx dest = JUMP_LABEL (insn);
1269 if (barrier_args_size [INSN_UID (dest)] < 0)
1271 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1272 VEC_safe_push (rtx, heap, *next, dest);
1277 return cur_args_size;
1280 /* Walk the whole function and compute args_size on BARRIERs. */
1283 compute_barrier_args_size (void)
1285 int max_uid = get_max_uid (), i;
1287 VEC (rtx, heap) *worklist, *next, *tmp;
1289 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1290 for (i = 0; i < max_uid; i++)
1291 barrier_args_size[i] = -1;
1293 worklist = VEC_alloc (rtx, heap, 20);
1294 next = VEC_alloc (rtx, heap, 20);
1295 insn = get_insns ();
1296 barrier_args_size[INSN_UID (insn)] = 0;
1297 VEC_quick_push (rtx, worklist, insn);
1300 while (!VEC_empty (rtx, worklist))
1302 rtx prev, body, first_insn;
1303 HOST_WIDE_INT cur_args_size;
1305 first_insn = insn = VEC_pop (rtx, worklist);
1306 cur_args_size = barrier_args_size[INSN_UID (insn)];
1307 prev = prev_nonnote_insn (insn);
1308 if (prev && BARRIER_P (prev))
1309 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1311 for (; insn; insn = NEXT_INSN (insn))
1313 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1315 if (BARRIER_P (insn))
1320 if (insn == first_insn)
1322 else if (barrier_args_size[INSN_UID (insn)] < 0)
1324 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1329 /* The insns starting with this label have been
1330 already scanned or are in the worklist. */
1335 body = PATTERN (insn);
1336 if (GET_CODE (body) == SEQUENCE)
1338 HOST_WIDE_INT dest_args_size = cur_args_size;
1339 for (i = 1; i < XVECLEN (body, 0); i++)
1340 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1341 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1343 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1344 dest_args_size, &next);
1347 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1348 cur_args_size, &next);
1350 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1351 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1352 dest_args_size, &next);
1355 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1356 cur_args_size, &next);
1360 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1364 if (VEC_empty (rtx, next))
1367 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1371 VEC_truncate (rtx, next, 0);
1374 VEC_free (rtx, heap, worklist);
1375 VEC_free (rtx, heap, next);
1379 /* Check INSN to see if it looks like a push or a stack adjustment, and
1380 make a note of it if it does. EH uses this information to find out how
1381 much extra space it needs to pop off the stack. */
1384 dwarf2out_stack_adjust (rtx insn, bool after_p)
1386 HOST_WIDE_INT offset;
1390 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1391 with this function. Proper support would require all frame-related
1392 insns to be marked, and to be able to handle saving state around
1393 epilogues textually in the middle of the function. */
1394 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1397 /* If INSN is an instruction from target of an annulled branch, the
1398 effects are for the target only and so current argument size
1399 shouldn't change at all. */
1401 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1402 && INSN_FROM_TARGET_P (insn))
1405 /* If only calls can throw, and we have a frame pointer,
1406 save up adjustments until we see the CALL_INSN. */
1407 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1409 if (CALL_P (insn) && !after_p)
1411 /* Extract the size of the args from the CALL rtx itself. */
1412 insn = PATTERN (insn);
1413 if (GET_CODE (insn) == PARALLEL)
1414 insn = XVECEXP (insn, 0, 0);
1415 if (GET_CODE (insn) == SET)
1416 insn = SET_SRC (insn);
1417 gcc_assert (GET_CODE (insn) == CALL);
1418 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1423 if (CALL_P (insn) && !after_p)
1425 if (!flag_asynchronous_unwind_tables)
1426 dwarf2out_args_size ("", args_size);
1429 else if (BARRIER_P (insn))
1431 /* Don't call compute_barrier_args_size () if the only
1432 BARRIER is at the end of function. */
1433 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1434 compute_barrier_args_size ();
1435 if (barrier_args_size == NULL)
1439 offset = barrier_args_size[INSN_UID (insn)];
1444 offset -= args_size;
1445 #ifndef STACK_GROWS_DOWNWARD
1449 else if (GET_CODE (PATTERN (insn)) == SET)
1450 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1451 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1452 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1454 /* There may be stack adjustments inside compound insns. Search
1456 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1457 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1458 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1467 label = dwarf2out_cfi_label ();
1468 dwarf2out_args_size_adjust (offset, label);
1471 /* Adjust args_size based on stack adjustment OFFSET. */
1474 dwarf2out_args_size_adjust (HOST_WIDE_INT offset, const char *label)
1476 if (cfa.reg == STACK_POINTER_REGNUM)
1477 cfa.offset += offset;
1479 if (cfa_store.reg == STACK_POINTER_REGNUM)
1480 cfa_store.offset += offset;
1482 #ifndef STACK_GROWS_DOWNWARD
1486 args_size += offset;
1490 def_cfa_1 (label, &cfa);
1491 if (flag_asynchronous_unwind_tables)
1492 dwarf2out_args_size (label, args_size);
1497 /* We delay emitting a register save until either (a) we reach the end
1498 of the prologue or (b) the register is clobbered. This clusters
1499 register saves so that there are fewer pc advances. */
1501 struct queued_reg_save GTY(())
1503 struct queued_reg_save *next;
1505 HOST_WIDE_INT cfa_offset;
1509 static GTY(()) struct queued_reg_save *queued_reg_saves;
1511 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1512 struct reg_saved_in_data GTY(()) {
1517 /* A list of registers saved in other registers.
1518 The list intentionally has a small maximum capacity of 4; if your
1519 port needs more than that, you might consider implementing a
1520 more efficient data structure. */
1521 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1522 static GTY(()) size_t num_regs_saved_in_regs;
1524 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1525 static const char *last_reg_save_label;
1527 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1528 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1531 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1533 struct queued_reg_save *q;
1535 /* Duplicates waste space, but it's also necessary to remove them
1536 for correctness, since the queue gets output in reverse
1538 for (q = queued_reg_saves; q != NULL; q = q->next)
1539 if (REGNO (q->reg) == REGNO (reg))
1544 q = GGC_NEW (struct queued_reg_save);
1545 q->next = queued_reg_saves;
1546 queued_reg_saves = q;
1550 q->cfa_offset = offset;
1551 q->saved_reg = sreg;
1553 last_reg_save_label = label;
1556 /* Output all the entries in QUEUED_REG_SAVES. */
1559 flush_queued_reg_saves (void)
1561 struct queued_reg_save *q;
1563 for (q = queued_reg_saves; q; q = q->next)
1566 unsigned int reg, sreg;
1568 for (i = 0; i < num_regs_saved_in_regs; i++)
1569 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1571 if (q->saved_reg && i == num_regs_saved_in_regs)
1573 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1574 num_regs_saved_in_regs++;
1576 if (i != num_regs_saved_in_regs)
1578 regs_saved_in_regs[i].orig_reg = q->reg;
1579 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1582 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1584 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1586 sreg = INVALID_REGNUM;
1587 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1590 queued_reg_saves = NULL;
1591 last_reg_save_label = NULL;
1594 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1595 location for? Or, does it clobber a register which we've previously
1596 said that some other register is saved in, and for which we now
1597 have a new location for? */
1600 clobbers_queued_reg_save (const_rtx insn)
1602 struct queued_reg_save *q;
1604 for (q = queued_reg_saves; q; q = q->next)
1607 if (modified_in_p (q->reg, insn))
1609 for (i = 0; i < num_regs_saved_in_regs; i++)
1610 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1611 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1618 /* Entry point for saving the first register into the second. */
1621 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1624 unsigned int regno, sregno;
1626 for (i = 0; i < num_regs_saved_in_regs; i++)
1627 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1629 if (i == num_regs_saved_in_regs)
1631 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1632 num_regs_saved_in_regs++;
1634 regs_saved_in_regs[i].orig_reg = reg;
1635 regs_saved_in_regs[i].saved_in_reg = sreg;
1637 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1638 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1639 reg_save (label, regno, sregno, 0);
1642 /* What register, if any, is currently saved in REG? */
1645 reg_saved_in (rtx reg)
1647 unsigned int regn = REGNO (reg);
1649 struct queued_reg_save *q;
1651 for (q = queued_reg_saves; q; q = q->next)
1652 if (q->saved_reg && regn == REGNO (q->saved_reg))
1655 for (i = 0; i < num_regs_saved_in_regs; i++)
1656 if (regs_saved_in_regs[i].saved_in_reg
1657 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1658 return regs_saved_in_regs[i].orig_reg;
1664 /* A temporary register holding an integral value used in adjusting SP
1665 or setting up the store_reg. The "offset" field holds the integer
1666 value, not an offset. */
1667 static dw_cfa_location cfa_temp;
1669 /* Record call frame debugging information for an expression EXPR,
1670 which either sets SP or FP (adjusting how we calculate the frame
1671 address) or saves a register to the stack or another register.
1672 LABEL indicates the address of EXPR.
1674 This function encodes a state machine mapping rtxes to actions on
1675 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1676 users need not read the source code.
1678 The High-Level Picture
1680 Changes in the register we use to calculate the CFA: Currently we
1681 assume that if you copy the CFA register into another register, we
1682 should take the other one as the new CFA register; this seems to
1683 work pretty well. If it's wrong for some target, it's simple
1684 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1686 Changes in the register we use for saving registers to the stack:
1687 This is usually SP, but not always. Again, we deduce that if you
1688 copy SP into another register (and SP is not the CFA register),
1689 then the new register is the one we will be using for register
1690 saves. This also seems to work.
1692 Register saves: There's not much guesswork about this one; if
1693 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1694 register save, and the register used to calculate the destination
1695 had better be the one we think we're using for this purpose.
1696 It's also assumed that a copy from a call-saved register to another
1697 register is saving that register if RTX_FRAME_RELATED_P is set on
1698 that instruction. If the copy is from a call-saved register to
1699 the *same* register, that means that the register is now the same
1700 value as in the caller.
1702 Except: If the register being saved is the CFA register, and the
1703 offset is nonzero, we are saving the CFA, so we assume we have to
1704 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1705 the intent is to save the value of SP from the previous frame.
1707 In addition, if a register has previously been saved to a different
1710 Invariants / Summaries of Rules
1712 cfa current rule for calculating the CFA. It usually
1713 consists of a register and an offset.
1714 cfa_store register used by prologue code to save things to the stack
1715 cfa_store.offset is the offset from the value of
1716 cfa_store.reg to the actual CFA
1717 cfa_temp register holding an integral value. cfa_temp.offset
1718 stores the value, which will be used to adjust the
1719 stack pointer. cfa_temp is also used like cfa_store,
1720 to track stores to the stack via fp or a temp reg.
1722 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1723 with cfa.reg as the first operand changes the cfa.reg and its
1724 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1727 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1728 expression yielding a constant. This sets cfa_temp.reg
1729 and cfa_temp.offset.
1731 Rule 5: Create a new register cfa_store used to save items to the
1734 Rules 10-14: Save a register to the stack. Define offset as the
1735 difference of the original location and cfa_store's
1736 location (or cfa_temp's location if cfa_temp is used).
1738 Rules 16-20: If AND operation happens on sp in prologue, we assume
1739 stack is realigned. We will use a group of DW_OP_XXX
1740 expressions to represent the location of the stored
1741 register instead of CFA+offset.
1745 "{a,b}" indicates a choice of a xor b.
1746 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1749 (set <reg1> <reg2>:cfa.reg)
1750 effects: cfa.reg = <reg1>
1751 cfa.offset unchanged
1752 cfa_temp.reg = <reg1>
1753 cfa_temp.offset = cfa.offset
1756 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1757 {<const_int>,<reg>:cfa_temp.reg}))
1758 effects: cfa.reg = sp if fp used
1759 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1760 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1761 if cfa_store.reg==sp
1764 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1765 effects: cfa.reg = fp
1766 cfa_offset += +/- <const_int>
1769 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1770 constraints: <reg1> != fp
1772 effects: cfa.reg = <reg1>
1773 cfa_temp.reg = <reg1>
1774 cfa_temp.offset = cfa.offset
1777 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1778 constraints: <reg1> != fp
1780 effects: cfa_store.reg = <reg1>
1781 cfa_store.offset = cfa.offset - cfa_temp.offset
1784 (set <reg> <const_int>)
1785 effects: cfa_temp.reg = <reg>
1786 cfa_temp.offset = <const_int>
1789 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1790 effects: cfa_temp.reg = <reg1>
1791 cfa_temp.offset |= <const_int>
1794 (set <reg> (high <exp>))
1798 (set <reg> (lo_sum <exp> <const_int>))
1799 effects: cfa_temp.reg = <reg>
1800 cfa_temp.offset = <const_int>
1803 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1804 effects: cfa_store.offset -= <const_int>
1805 cfa.offset = cfa_store.offset if cfa.reg == sp
1807 cfa.base_offset = -cfa_store.offset
1810 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1811 effects: cfa_store.offset += -/+ mode_size(mem)
1812 cfa.offset = cfa_store.offset if cfa.reg == sp
1814 cfa.base_offset = -cfa_store.offset
1817 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1820 effects: cfa.reg = <reg1>
1821 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1824 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1825 effects: cfa.reg = <reg1>
1826 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1829 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1830 effects: cfa.reg = <reg1>
1831 cfa.base_offset = -cfa_temp.offset
1832 cfa_temp.offset -= mode_size(mem)
1835 (set <reg> {unspec, unspec_volatile})
1836 effects: target-dependent
1839 (set sp (and: sp <const_int>))
1840 constraints: cfa_store.reg == sp
1841 effects: current_fde.stack_realign = 1
1842 cfa_store.offset = 0
1843 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
1846 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
1847 effects: cfa_store.offset += -/+ mode_size(mem)
1850 (set (mem ({pre_inc, pre_dec} sp)) fp)
1851 constraints: fde->stack_realign == 1
1852 effects: cfa_store.offset = 0
1853 cfa.reg != HARD_FRAME_POINTER_REGNUM
1856 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
1857 constraints: fde->stack_realign == 1
1859 && cfa.indirect == 0
1860 && cfa.reg != HARD_FRAME_POINTER_REGNUM
1861 effects: Use DW_CFA_def_cfa_expression to define cfa
1862 cfa.reg == fde->drap_reg
1865 (set reg fde->drap_reg)
1866 constraints: fde->vdrap_reg == INVALID_REGNUM
1867 effects: fde->vdrap_reg = reg.
1868 (set mem fde->drap_reg)
1869 constraints: fde->drap_reg_saved == 1
1873 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1875 rtx src, dest, span;
1876 HOST_WIDE_INT offset;
1879 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1880 the PARALLEL independently. The first element is always processed if
1881 it is a SET. This is for backward compatibility. Other elements
1882 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1883 flag is set in them. */
1884 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1887 int limit = XVECLEN (expr, 0);
1890 /* PARALLELs have strict read-modify-write semantics, so we
1891 ought to evaluate every rvalue before changing any lvalue.
1892 It's cumbersome to do that in general, but there's an
1893 easy approximation that is enough for all current users:
1894 handle register saves before register assignments. */
1895 if (GET_CODE (expr) == PARALLEL)
1896 for (par_index = 0; par_index < limit; par_index++)
1898 elem = XVECEXP (expr, 0, par_index);
1899 if (GET_CODE (elem) == SET
1900 && MEM_P (SET_DEST (elem))
1901 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1902 dwarf2out_frame_debug_expr (elem, label);
1905 for (par_index = 0; par_index < limit; par_index++)
1907 elem = XVECEXP (expr, 0, par_index);
1908 if (GET_CODE (elem) == SET
1909 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
1910 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1911 dwarf2out_frame_debug_expr (elem, label);
1912 else if (GET_CODE (elem) == SET
1914 && !RTX_FRAME_RELATED_P (elem))
1916 /* Stack adjustment combining might combine some post-prologue
1917 stack adjustment into a prologue stack adjustment. */
1918 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
1921 dwarf2out_args_size_adjust (offset, label);
1927 gcc_assert (GET_CODE (expr) == SET);
1929 src = SET_SRC (expr);
1930 dest = SET_DEST (expr);
1934 rtx rsi = reg_saved_in (src);
1939 fde = current_fde ();
1941 if (GET_CODE (src) == REG
1943 && fde->drap_reg == REGNO (src)
1944 && (fde->drap_reg_saved
1945 || GET_CODE (dest) == REG))
1948 /* If we are saving dynamic realign argument pointer to a
1949 register, the destination is virtual dynamic realign
1950 argument pointer. It may be used to access argument. */
1951 if (GET_CODE (dest) == REG)
1953 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
1954 fde->vdrap_reg = REGNO (dest);
1959 switch (GET_CODE (dest))
1962 switch (GET_CODE (src))
1964 /* Setting FP from SP. */
1966 if (cfa.reg == (unsigned) REGNO (src))
1969 /* Update the CFA rule wrt SP or FP. Make sure src is
1970 relative to the current CFA register.
1972 We used to require that dest be either SP or FP, but the
1973 ARM copies SP to a temporary register, and from there to
1974 FP. So we just rely on the backends to only set
1975 RTX_FRAME_RELATED_P on appropriate insns. */
1976 cfa.reg = REGNO (dest);
1977 cfa_temp.reg = cfa.reg;
1978 cfa_temp.offset = cfa.offset;
1982 /* Saving a register in a register. */
1983 gcc_assert (!fixed_regs [REGNO (dest)]
1984 /* For the SPARC and its register window. */
1985 || (DWARF_FRAME_REGNUM (REGNO (src))
1986 == DWARF_FRAME_RETURN_COLUMN));
1988 /* After stack is aligned, we can only save SP in FP
1989 if drap register is used. In this case, we have
1990 to restore stack pointer with the CFA value and we
1991 don't generate this DWARF information. */
1993 && fde->stack_realign
1994 && REGNO (src) == STACK_POINTER_REGNUM)
1995 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
1996 && fde->drap_reg != INVALID_REGNUM
1997 && cfa.reg != REGNO (src));
1999 queue_reg_save (label, src, dest, 0);
2006 if (dest == stack_pointer_rtx)
2010 switch (GET_CODE (XEXP (src, 1)))
2013 offset = INTVAL (XEXP (src, 1));
2016 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2018 offset = cfa_temp.offset;
2024 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2026 /* Restoring SP from FP in the epilogue. */
2027 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2028 cfa.reg = STACK_POINTER_REGNUM;
2030 else if (GET_CODE (src) == LO_SUM)
2031 /* Assume we've set the source reg of the LO_SUM from sp. */
2034 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2036 if (GET_CODE (src) != MINUS)
2038 if (cfa.reg == STACK_POINTER_REGNUM)
2039 cfa.offset += offset;
2040 if (cfa_store.reg == STACK_POINTER_REGNUM)
2041 cfa_store.offset += offset;
2043 else if (dest == hard_frame_pointer_rtx)
2046 /* Either setting the FP from an offset of the SP,
2047 or adjusting the FP */
2048 gcc_assert (frame_pointer_needed);
2050 gcc_assert (REG_P (XEXP (src, 0))
2051 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2052 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2053 offset = INTVAL (XEXP (src, 1));
2054 if (GET_CODE (src) != MINUS)
2056 cfa.offset += offset;
2057 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2061 gcc_assert (GET_CODE (src) != MINUS);
2064 if (REG_P (XEXP (src, 0))
2065 && REGNO (XEXP (src, 0)) == cfa.reg
2066 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2068 /* Setting a temporary CFA register that will be copied
2069 into the FP later on. */
2070 offset = - INTVAL (XEXP (src, 1));
2071 cfa.offset += offset;
2072 cfa.reg = REGNO (dest);
2073 /* Or used to save regs to the stack. */
2074 cfa_temp.reg = cfa.reg;
2075 cfa_temp.offset = cfa.offset;
2079 else if (REG_P (XEXP (src, 0))
2080 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2081 && XEXP (src, 1) == stack_pointer_rtx)
2083 /* Setting a scratch register that we will use instead
2084 of SP for saving registers to the stack. */
2085 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2086 cfa_store.reg = REGNO (dest);
2087 cfa_store.offset = cfa.offset - cfa_temp.offset;
2091 else if (GET_CODE (src) == LO_SUM
2092 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2094 cfa_temp.reg = REGNO (dest);
2095 cfa_temp.offset = INTVAL (XEXP (src, 1));
2104 cfa_temp.reg = REGNO (dest);
2105 cfa_temp.offset = INTVAL (src);
2110 gcc_assert (REG_P (XEXP (src, 0))
2111 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2112 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2114 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2115 cfa_temp.reg = REGNO (dest);
2116 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2119 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2120 which will fill in all of the bits. */
2127 case UNSPEC_VOLATILE:
2128 gcc_assert (targetm.dwarf_handle_frame_unspec);
2129 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2134 /* If this AND operation happens on stack pointer in prologue,
2135 we assume the stack is realigned and we extract the
2137 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2139 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2140 fde->stack_realign = 1;
2141 fde->stack_realignment = INTVAL (XEXP (src, 1));
2142 cfa_store.offset = 0;
2144 if (cfa.reg != STACK_POINTER_REGNUM
2145 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2146 fde->drap_reg = cfa.reg;
2154 def_cfa_1 (label, &cfa);
2159 /* Saving a register to the stack. Make sure dest is relative to the
2161 switch (GET_CODE (XEXP (dest, 0)))
2166 /* We can't handle variable size modifications. */
2167 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2169 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2171 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2172 && cfa_store.reg == STACK_POINTER_REGNUM);
2174 cfa_store.offset += offset;
2175 if (cfa.reg == STACK_POINTER_REGNUM)
2176 cfa.offset = cfa_store.offset;
2178 offset = -cfa_store.offset;
2184 offset = GET_MODE_SIZE (GET_MODE (dest));
2185 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2188 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2189 == STACK_POINTER_REGNUM)
2190 && cfa_store.reg == STACK_POINTER_REGNUM);
2192 cfa_store.offset += offset;
2194 /* Rule 18: If stack is aligned, we will use FP as a
2195 reference to represent the address of the stored
2198 && fde->stack_realign
2199 && src == hard_frame_pointer_rtx)
2201 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2202 cfa_store.offset = 0;
2205 if (cfa.reg == STACK_POINTER_REGNUM)
2206 cfa.offset = cfa_store.offset;
2208 offset = -cfa_store.offset;
2212 /* With an offset. */
2219 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
2220 && REG_P (XEXP (XEXP (dest, 0), 0)));
2221 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2222 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2225 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2227 if (cfa_store.reg == (unsigned) regno)
2228 offset -= cfa_store.offset;
2231 gcc_assert (cfa_temp.reg == (unsigned) regno);
2232 offset -= cfa_temp.offset;
2238 /* Without an offset. */
2241 int regno = REGNO (XEXP (dest, 0));
2243 if (cfa_store.reg == (unsigned) regno)
2244 offset = -cfa_store.offset;
2247 gcc_assert (cfa_temp.reg == (unsigned) regno);
2248 offset = -cfa_temp.offset;
2255 gcc_assert (cfa_temp.reg
2256 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2257 offset = -cfa_temp.offset;
2258 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2266 /* If the source operand of this MEM operation is not a
2267 register, basically the source is return address. Here
2268 we only care how much stack grew and we don't save it. */
2272 if (REGNO (src) != STACK_POINTER_REGNUM
2273 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2274 && (unsigned) REGNO (src) == cfa.reg)
2276 /* We're storing the current CFA reg into the stack. */
2278 if (cfa.offset == 0)
2281 /* If stack is aligned, putting CFA reg into stack means
2282 we can no longer use reg + offset to represent CFA.
2283 Here we use DW_CFA_def_cfa_expression instead. The
2284 result of this expression equals to the original CFA
2287 && fde->stack_realign
2288 && cfa.indirect == 0
2289 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2291 dw_cfa_location cfa_exp;
2293 gcc_assert (fde->drap_reg == cfa.reg);
2295 cfa_exp.indirect = 1;
2296 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2297 cfa_exp.base_offset = offset;
2300 fde->drap_reg_saved = 1;
2302 def_cfa_1 (label, &cfa_exp);
2306 /* If the source register is exactly the CFA, assume
2307 we're saving SP like any other register; this happens
2309 def_cfa_1 (label, &cfa);
2310 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2315 /* Otherwise, we'll need to look in the stack to
2316 calculate the CFA. */
2317 rtx x = XEXP (dest, 0);
2321 gcc_assert (REG_P (x));
2323 cfa.reg = REGNO (x);
2324 cfa.base_offset = offset;
2326 def_cfa_1 (label, &cfa);
2331 def_cfa_1 (label, &cfa);
2333 span = targetm.dwarf_register_span (src);
2336 queue_reg_save (label, src, NULL_RTX, offset);
2339 /* We have a PARALLEL describing where the contents of SRC
2340 live. Queue register saves for each piece of the
2344 HOST_WIDE_INT span_offset = offset;
2346 gcc_assert (GET_CODE (span) == PARALLEL);
2348 limit = XVECLEN (span, 0);
2349 for (par_index = 0; par_index < limit; par_index++)
2351 rtx elem = XVECEXP (span, 0, par_index);
2353 queue_reg_save (label, elem, NULL_RTX, span_offset);
2354 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2365 /* Record call frame debugging information for INSN, which either
2366 sets SP or FP (adjusting how we calculate the frame address) or saves a
2367 register to the stack. If INSN is NULL_RTX, initialize our state.
2369 If AFTER_P is false, we're being called before the insn is emitted,
2370 otherwise after. Call instructions get invoked twice. */
2373 dwarf2out_frame_debug (rtx insn, bool after_p)
2378 if (insn == NULL_RTX)
2382 /* Flush any queued register saves. */
2383 flush_queued_reg_saves ();
2385 /* Set up state for generating call frame debug info. */
2388 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2390 cfa.reg = STACK_POINTER_REGNUM;
2393 cfa_temp.offset = 0;
2395 for (i = 0; i < num_regs_saved_in_regs; i++)
2397 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2398 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2400 num_regs_saved_in_regs = 0;
2402 if (barrier_args_size)
2404 XDELETEVEC (barrier_args_size);
2405 barrier_args_size = NULL;
2410 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2411 flush_queued_reg_saves ();
2413 if (! RTX_FRAME_RELATED_P (insn))
2415 if (!ACCUMULATE_OUTGOING_ARGS)
2416 dwarf2out_stack_adjust (insn, after_p);
2420 label = dwarf2out_cfi_label ();
2421 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
2423 insn = XEXP (src, 0);
2425 insn = PATTERN (insn);
2427 dwarf2out_frame_debug_expr (insn, label);
2432 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2433 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2434 (enum dwarf_call_frame_info cfi);
2436 static enum dw_cfi_oprnd_type
2437 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2442 case DW_CFA_GNU_window_save:
2443 return dw_cfi_oprnd_unused;
2445 case DW_CFA_set_loc:
2446 case DW_CFA_advance_loc1:
2447 case DW_CFA_advance_loc2:
2448 case DW_CFA_advance_loc4:
2449 case DW_CFA_MIPS_advance_loc8:
2450 return dw_cfi_oprnd_addr;
2453 case DW_CFA_offset_extended:
2454 case DW_CFA_def_cfa:
2455 case DW_CFA_offset_extended_sf:
2456 case DW_CFA_def_cfa_sf:
2457 case DW_CFA_restore_extended:
2458 case DW_CFA_undefined:
2459 case DW_CFA_same_value:
2460 case DW_CFA_def_cfa_register:
2461 case DW_CFA_register:
2462 return dw_cfi_oprnd_reg_num;
2464 case DW_CFA_def_cfa_offset:
2465 case DW_CFA_GNU_args_size:
2466 case DW_CFA_def_cfa_offset_sf:
2467 return dw_cfi_oprnd_offset;
2469 case DW_CFA_def_cfa_expression:
2470 case DW_CFA_expression:
2471 return dw_cfi_oprnd_loc;
2478 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2479 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2480 (enum dwarf_call_frame_info cfi);
2482 static enum dw_cfi_oprnd_type
2483 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2487 case DW_CFA_def_cfa:
2488 case DW_CFA_def_cfa_sf:
2490 case DW_CFA_offset_extended_sf:
2491 case DW_CFA_offset_extended:
2492 return dw_cfi_oprnd_offset;
2494 case DW_CFA_register:
2495 return dw_cfi_oprnd_reg_num;
2498 return dw_cfi_oprnd_unused;
2502 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2504 /* Switch to eh_frame_section. If we don't have an eh_frame_section,
2505 switch to the data section instead, and write out a synthetic label
2509 switch_to_eh_frame_section (void)
2513 #ifdef EH_FRAME_SECTION_NAME
2514 if (eh_frame_section == 0)
2518 if (EH_TABLES_CAN_BE_READ_ONLY)
2524 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2526 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2528 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2530 flags = ((! flag_pic
2531 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2532 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2533 && (per_encoding & 0x70) != DW_EH_PE_absptr
2534 && (per_encoding & 0x70) != DW_EH_PE_aligned
2535 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2536 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2537 ? 0 : SECTION_WRITE);
2540 flags = SECTION_WRITE;
2541 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2545 if (eh_frame_section)
2546 switch_to_section (eh_frame_section);
2549 /* We have no special eh_frame section. Put the information in
2550 the data section and emit special labels to guide collect2. */
2551 switch_to_section (data_section);
2552 label = get_file_function_name ("F");
2553 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2554 targetm.asm_out.globalize_label (asm_out_file,
2555 IDENTIFIER_POINTER (label));
2556 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2560 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
2562 static HOST_WIDE_INT
2563 div_data_align (HOST_WIDE_INT off)
2565 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
2566 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
2570 /* Output a Call Frame Information opcode and its operand(s). */
2573 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2578 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2579 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2580 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2581 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2582 ((unsigned HOST_WIDE_INT)
2583 cfi->dw_cfi_oprnd1.dw_cfi_offset));
2584 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2586 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2587 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2588 "DW_CFA_offset, column 0x%lx", r);
2589 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2590 dw2_asm_output_data_uleb128 (off, NULL);
2592 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2594 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2595 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2596 "DW_CFA_restore, column 0x%lx", r);
2600 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2601 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2603 switch (cfi->dw_cfi_opc)
2605 case DW_CFA_set_loc:
2607 dw2_asm_output_encoded_addr_rtx (
2608 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2609 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2612 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2613 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2614 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2617 case DW_CFA_advance_loc1:
2618 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2619 fde->dw_fde_current_label, NULL);
2620 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2623 case DW_CFA_advance_loc2:
2624 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2625 fde->dw_fde_current_label, NULL);
2626 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2629 case DW_CFA_advance_loc4:
2630 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2631 fde->dw_fde_current_label, NULL);
2632 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2635 case DW_CFA_MIPS_advance_loc8:
2636 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2637 fde->dw_fde_current_label, NULL);
2638 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2641 case DW_CFA_offset_extended:
2642 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2643 dw2_asm_output_data_uleb128 (r, NULL);
2644 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2645 dw2_asm_output_data_uleb128 (off, NULL);
2648 case DW_CFA_def_cfa:
2649 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2650 dw2_asm_output_data_uleb128 (r, NULL);
2651 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2654 case DW_CFA_offset_extended_sf:
2655 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2656 dw2_asm_output_data_uleb128 (r, NULL);
2657 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2658 dw2_asm_output_data_sleb128 (off, NULL);
2661 case DW_CFA_def_cfa_sf:
2662 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2663 dw2_asm_output_data_uleb128 (r, NULL);
2664 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2665 dw2_asm_output_data_sleb128 (off, NULL);
2668 case DW_CFA_restore_extended:
2669 case DW_CFA_undefined:
2670 case DW_CFA_same_value:
2671 case DW_CFA_def_cfa_register:
2672 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2673 dw2_asm_output_data_uleb128 (r, NULL);
2676 case DW_CFA_register:
2677 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2678 dw2_asm_output_data_uleb128 (r, NULL);
2679 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2680 dw2_asm_output_data_uleb128 (r, NULL);
2683 case DW_CFA_def_cfa_offset:
2684 case DW_CFA_GNU_args_size:
2685 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2688 case DW_CFA_def_cfa_offset_sf:
2689 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
2690 dw2_asm_output_data_sleb128 (off, NULL);
2693 case DW_CFA_GNU_window_save:
2696 case DW_CFA_def_cfa_expression:
2697 case DW_CFA_expression:
2698 output_cfa_loc (cfi);
2701 case DW_CFA_GNU_negative_offset_extended:
2702 /* Obsoleted by DW_CFA_offset_extended_sf. */
2711 /* Similar, but do it via assembler directives instead. */
2714 output_cfi_directive (dw_cfi_ref cfi)
2716 unsigned long r, r2;
2718 switch (cfi->dw_cfi_opc)
2720 case DW_CFA_advance_loc:
2721 case DW_CFA_advance_loc1:
2722 case DW_CFA_advance_loc2:
2723 case DW_CFA_advance_loc4:
2724 case DW_CFA_MIPS_advance_loc8:
2725 case DW_CFA_set_loc:
2726 /* Should only be created by add_fde_cfi in a code path not
2727 followed when emitting via directives. The assembler is
2728 going to take care of this for us. */
2732 case DW_CFA_offset_extended:
2733 case DW_CFA_offset_extended_sf:
2734 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2735 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
2736 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
2739 case DW_CFA_restore:
2740 case DW_CFA_restore_extended:
2741 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2742 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
2745 case DW_CFA_undefined:
2746 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2747 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
2750 case DW_CFA_same_value:
2751 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2752 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
2755 case DW_CFA_def_cfa:
2756 case DW_CFA_def_cfa_sf:
2757 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2758 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
2759 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
2762 case DW_CFA_def_cfa_register:
2763 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2764 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
2767 case DW_CFA_register:
2768 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2769 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 0);
2770 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
2773 case DW_CFA_def_cfa_offset:
2774 case DW_CFA_def_cfa_offset_sf:
2775 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
2776 HOST_WIDE_INT_PRINT_DEC"\n",
2777 cfi->dw_cfi_oprnd1.dw_cfi_offset);
2780 case DW_CFA_GNU_args_size:
2781 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size);
2782 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
2784 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
2785 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
2786 fputc ('\n', asm_out_file);
2789 case DW_CFA_GNU_window_save:
2790 fprintf (asm_out_file, "\t.cfi_window_save\n");
2793 case DW_CFA_def_cfa_expression:
2794 case DW_CFA_expression:
2795 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", cfi->dw_cfi_opc);
2796 output_cfa_loc_raw (cfi);
2797 fputc ('\n', asm_out_file);
2805 /* Output the call frame information used to record information
2806 that relates to calculating the frame pointer, and records the
2807 location of saved registers. */
2810 output_call_frame_info (int for_eh)
2815 char l1[20], l2[20], section_start_label[20];
2816 bool any_lsda_needed = false;
2817 char augmentation[6];
2818 int augmentation_size;
2819 int fde_encoding = DW_EH_PE_absptr;
2820 int per_encoding = DW_EH_PE_absptr;
2821 int lsda_encoding = DW_EH_PE_absptr;
2824 /* Don't emit a CIE if there won't be any FDEs. */
2825 if (fde_table_in_use == 0)
2828 /* Nothing to do if the assembler's doing it all. */
2829 if (dwarf2out_do_cfi_asm ())
2832 /* If we make FDEs linkonce, we may have to emit an empty label for
2833 an FDE that wouldn't otherwise be emitted. We want to avoid
2834 having an FDE kept around when the function it refers to is
2835 discarded. Example where this matters: a primary function
2836 template in C++ requires EH information, but an explicit
2837 specialization doesn't. */
2838 if (TARGET_USES_WEAK_UNWIND_INFO
2839 && ! flag_asynchronous_unwind_tables
2842 for (i = 0; i < fde_table_in_use; i++)
2843 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2844 && !fde_table[i].uses_eh_lsda
2845 && ! DECL_WEAK (fde_table[i].decl))
2846 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2847 for_eh, /* empty */ 1);
2849 /* If we don't have any functions we'll want to unwind out of, don't
2850 emit any EH unwind information. Note that if exceptions aren't
2851 enabled, we won't have collected nothrow information, and if we
2852 asked for asynchronous tables, we always want this info. */
2855 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2857 for (i = 0; i < fde_table_in_use; i++)
2858 if (fde_table[i].uses_eh_lsda)
2859 any_eh_needed = any_lsda_needed = true;
2860 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2861 any_eh_needed = true;
2862 else if (! fde_table[i].nothrow
2863 && ! fde_table[i].all_throwers_are_sibcalls)
2864 any_eh_needed = true;
2866 if (! any_eh_needed)
2870 /* We're going to be generating comments, so turn on app. */
2875 switch_to_eh_frame_section ();
2878 if (!debug_frame_section)
2879 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
2880 SECTION_DEBUG, NULL);
2881 switch_to_section (debug_frame_section);
2884 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2885 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2887 /* Output the CIE. */
2888 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2889 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2890 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2891 dw2_asm_output_data (4, 0xffffffff,
2892 "Initial length escape value indicating 64-bit DWARF extension");
2893 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2894 "Length of Common Information Entry");
2895 ASM_OUTPUT_LABEL (asm_out_file, l1);
2897 /* Now that the CIE pointer is PC-relative for EH,
2898 use 0 to identify the CIE. */
2899 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2900 (for_eh ? 0 : DWARF_CIE_ID),
2901 "CIE Identifier Tag");
2903 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2905 augmentation[0] = 0;
2906 augmentation_size = 0;
2912 z Indicates that a uleb128 is present to size the
2913 augmentation section.
2914 L Indicates the encoding (and thus presence) of
2915 an LSDA pointer in the FDE augmentation.
2916 R Indicates a non-default pointer encoding for
2918 P Indicates the presence of an encoding + language
2919 personality routine in the CIE augmentation. */
2921 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2922 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2923 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2925 p = augmentation + 1;
2926 if (eh_personality_libfunc)
2929 augmentation_size += 1 + size_of_encoded_value (per_encoding);
2930 assemble_external_libcall (eh_personality_libfunc);
2932 if (any_lsda_needed)
2935 augmentation_size += 1;
2937 if (fde_encoding != DW_EH_PE_absptr)
2940 augmentation_size += 1;
2942 if (p > augmentation + 1)
2944 augmentation[0] = 'z';
2948 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2949 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2951 int offset = ( 4 /* Length */
2953 + 1 /* CIE version */
2954 + strlen (augmentation) + 1 /* Augmentation */
2955 + size_of_uleb128 (1) /* Code alignment */
2956 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2958 + 1 /* Augmentation size */
2959 + 1 /* Personality encoding */ );
2960 int pad = -offset & (PTR_SIZE - 1);
2962 augmentation_size += pad;
2964 /* Augmentations should be small, so there's scarce need to
2965 iterate for a solution. Die if we exceed one uleb128 byte. */
2966 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2970 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2971 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2972 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2973 "CIE Data Alignment Factor");
2975 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2976 if (DW_CIE_VERSION == 1)
2977 dw2_asm_output_data (1, return_reg, "CIE RA Column");
2979 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2981 if (augmentation[0])
2983 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2984 if (eh_personality_libfunc)
2986 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2987 eh_data_format_name (per_encoding));
2988 dw2_asm_output_encoded_addr_rtx (per_encoding,
2989 eh_personality_libfunc,
2993 if (any_lsda_needed)
2994 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2995 eh_data_format_name (lsda_encoding));
2997 if (fde_encoding != DW_EH_PE_absptr)
2998 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2999 eh_data_format_name (fde_encoding));
3002 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3003 output_cfi (cfi, NULL, for_eh);
3005 /* Pad the CIE out to an address sized boundary. */
3006 ASM_OUTPUT_ALIGN (asm_out_file,
3007 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3008 ASM_OUTPUT_LABEL (asm_out_file, l2);
3010 /* Loop through all of the FDE's. */
3011 for (i = 0; i < fde_table_in_use; i++)
3013 fde = &fde_table[i];
3015 /* Don't emit EH unwind info for leaf functions that don't need it. */
3016 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3017 && (fde->nothrow || fde->all_throwers_are_sibcalls)
3018 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3019 && !fde->uses_eh_lsda)
3022 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
3023 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
3024 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
3025 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
3026 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3027 dw2_asm_output_data (4, 0xffffffff,
3028 "Initial length escape value indicating 64-bit DWARF extension");
3029 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3031 ASM_OUTPUT_LABEL (asm_out_file, l1);
3034 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3036 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3037 debug_frame_section, "FDE CIE offset");
3041 if (fde->dw_fde_switched_sections)
3043 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
3044 fde->dw_fde_unlikely_section_label);
3045 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
3046 fde->dw_fde_hot_section_label);
3047 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
3048 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
3049 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
3050 "FDE initial location");
3051 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3052 fde->dw_fde_hot_section_end_label,
3053 fde->dw_fde_hot_section_label,
3054 "FDE address range");
3055 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
3056 "FDE initial location");
3057 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3058 fde->dw_fde_unlikely_section_end_label,
3059 fde->dw_fde_unlikely_section_label,
3060 "FDE address range");
3064 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
3065 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3066 dw2_asm_output_encoded_addr_rtx (fde_encoding,
3069 "FDE initial location");
3070 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3071 fde->dw_fde_end, fde->dw_fde_begin,
3072 "FDE address range");
3077 if (fde->dw_fde_switched_sections)
3079 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3080 fde->dw_fde_hot_section_label,
3081 "FDE initial location");
3082 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3083 fde->dw_fde_hot_section_end_label,
3084 fde->dw_fde_hot_section_label,
3085 "FDE address range");
3086 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3087 fde->dw_fde_unlikely_section_label,
3088 "FDE initial location");
3089 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3090 fde->dw_fde_unlikely_section_end_label,
3091 fde->dw_fde_unlikely_section_label,
3092 "FDE address range");
3096 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
3097 "FDE initial location");
3098 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3099 fde->dw_fde_end, fde->dw_fde_begin,
3100 "FDE address range");
3104 if (augmentation[0])
3106 if (any_lsda_needed)
3108 int size = size_of_encoded_value (lsda_encoding);
3110 if (lsda_encoding == DW_EH_PE_aligned)
3112 int offset = ( 4 /* Length */
3113 + 4 /* CIE offset */
3114 + 2 * size_of_encoded_value (fde_encoding)
3115 + 1 /* Augmentation size */ );
3116 int pad = -offset & (PTR_SIZE - 1);
3119 gcc_assert (size_of_uleb128 (size) == 1);
3122 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3124 if (fde->uses_eh_lsda)
3126 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
3127 fde->funcdef_number);
3128 dw2_asm_output_encoded_addr_rtx (
3129 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
3130 false, "Language Specific Data Area");
3134 if (lsda_encoding == DW_EH_PE_aligned)
3135 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3137 (size_of_encoded_value (lsda_encoding), 0,
3138 "Language Specific Data Area (none)");
3142 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3145 /* Loop through the Call Frame Instructions associated with
3147 fde->dw_fde_current_label = fde->dw_fde_begin;
3148 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3149 output_cfi (cfi, fde, for_eh);
3151 /* Pad the FDE out to an address sized boundary. */
3152 ASM_OUTPUT_ALIGN (asm_out_file,
3153 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3154 ASM_OUTPUT_LABEL (asm_out_file, l2);
3157 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3158 dw2_asm_output_data (4, 0, "End of Table");
3159 #ifdef MIPS_DEBUGGING_INFO
3160 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3161 get a value of 0. Putting .align 0 after the label fixes it. */
3162 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3165 /* Turn off app to make assembly quicker. */
3170 /* Output a marker (i.e. a label) for the beginning of a function, before
3174 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3175 const char *file ATTRIBUTE_UNUSED)
3177 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3181 current_function_func_begin_label = NULL;
3183 #ifdef TARGET_UNWIND_INFO
3184 /* ??? current_function_func_begin_label is also used by except.c
3185 for call-site information. We must emit this label if it might
3187 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3188 && ! dwarf2out_do_frame ())
3191 if (! dwarf2out_do_frame ())
3195 switch_to_section (function_section (current_function_decl));
3196 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3197 current_function_funcdef_no);
3198 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3199 current_function_funcdef_no);
3200 dup_label = xstrdup (label);
3201 current_function_func_begin_label = dup_label;
3203 #ifdef TARGET_UNWIND_INFO
3204 /* We can elide the fde allocation if we're not emitting debug info. */
3205 if (! dwarf2out_do_frame ())
3209 /* Expand the fde table if necessary. */
3210 if (fde_table_in_use == fde_table_allocated)
3212 fde_table_allocated += FDE_TABLE_INCREMENT;
3213 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3214 memset (fde_table + fde_table_in_use, 0,
3215 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3218 /* Record the FDE associated with this function. */
3219 current_funcdef_fde = fde_table_in_use;
3221 /* Add the new FDE at the end of the fde_table. */
3222 fde = &fde_table[fde_table_in_use++];
3223 fde->decl = current_function_decl;
3224 fde->dw_fde_begin = dup_label;
3225 fde->dw_fde_current_label = dup_label;
3226 fde->dw_fde_hot_section_label = NULL;
3227 fde->dw_fde_hot_section_end_label = NULL;
3228 fde->dw_fde_unlikely_section_label = NULL;
3229 fde->dw_fde_unlikely_section_end_label = NULL;
3230 fde->dw_fde_switched_sections = false;
3231 fde->dw_fde_end = NULL;
3232 fde->dw_fde_cfi = NULL;
3233 fde->funcdef_number = current_function_funcdef_no;
3234 fde->nothrow = crtl->nothrow;
3235 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3236 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3237 fde->drap_reg = INVALID_REGNUM;
3238 fde->vdrap_reg = INVALID_REGNUM;
3240 args_size = old_args_size = 0;
3242 /* We only want to output line number information for the genuine dwarf2
3243 prologue case, not the eh frame case. */
3244 #ifdef DWARF2_DEBUGGING_INFO
3246 dwarf2out_source_line (line, file);
3249 if (dwarf2out_do_cfi_asm ())
3254 fprintf (asm_out_file, "\t.cfi_startproc\n");
3256 if (eh_personality_libfunc)
3258 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3259 ref = eh_personality_libfunc;
3261 /* ??? The GAS support isn't entirely consistent. We have to
3262 handle indirect support ourselves, but PC-relative is done
3263 in the assembler. Further, the assembler can't handle any
3264 of the weirder relocation types. */
3265 if (enc & DW_EH_PE_indirect)
3266 ref = dw2_force_const_mem (ref, true);
3268 fprintf (asm_out_file, "\t.cfi_personality 0x%x,", enc);
3269 output_addr_const (asm_out_file, ref);
3270 fputc ('\n', asm_out_file);
3273 if (crtl->uses_eh_lsda)
3277 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3278 ASM_GENERATE_INTERNAL_LABEL (lab, "LLSDA",
3279 current_function_funcdef_no);
3280 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3281 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3283 if (enc & DW_EH_PE_indirect)
3284 ref = dw2_force_const_mem (ref, true);
3286 fprintf (asm_out_file, "\t.cfi_lsda 0x%x,", enc);
3287 output_addr_const (asm_out_file, ref);
3288 fputc ('\n', asm_out_file);
3293 /* Output a marker (i.e. a label) for the absolute end of the generated code
3294 for a function definition. This gets called *after* the epilogue code has
3298 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
3299 const char *file ATTRIBUTE_UNUSED)
3302 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3304 if (dwarf2out_do_cfi_asm ())
3305 fprintf (asm_out_file, "\t.cfi_endproc\n");
3307 /* Output a label to mark the endpoint of the code generated for this
3309 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
3310 current_function_funcdef_no);
3311 ASM_OUTPUT_LABEL (asm_out_file, label);
3312 fde = current_fde ();
3313 gcc_assert (fde != NULL);
3314 fde->dw_fde_end = xstrdup (label);
3318 dwarf2out_frame_init (void)
3320 /* Allocate the initial hunk of the fde_table. */
3321 fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
3322 fde_table_allocated = FDE_TABLE_INCREMENT;
3323 fde_table_in_use = 0;
3325 /* Generate the CFA instructions common to all FDE's. Do it now for the
3326 sake of lookup_cfa. */
3328 /* On entry, the Canonical Frame Address is at SP. */
3329 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
3331 #ifdef DWARF2_UNWIND_INFO
3332 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
3333 initial_return_save (INCOMING_RETURN_ADDR_RTX);
3338 dwarf2out_frame_finish (void)
3340 /* Output call frame information. */
3341 if (DWARF2_FRAME_INFO)
3342 output_call_frame_info (0);
3344 #ifndef TARGET_UNWIND_INFO
3345 /* Output another copy for the unwinder. */
3346 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
3347 output_call_frame_info (1);
3351 /* Note that the current function section is being used for code. */
3354 dwarf2out_note_section_used (void)
3356 section *sec = current_function_section ();
3357 if (sec == text_section)
3358 text_section_used = true;
3359 else if (sec == cold_text_section)
3360 cold_text_section_used = true;
3364 dwarf2out_switch_text_section (void)
3366 dw_fde_ref fde = current_fde ();
3368 gcc_assert (cfun && fde);
3370 fde->dw_fde_switched_sections = true;
3371 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
3372 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
3373 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
3374 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
3375 have_multiple_function_sections = true;
3377 /* Reset the current label on switching text sections, so that we
3378 don't attempt to advance_loc4 between labels in different sections. */
3379 fde->dw_fde_current_label = NULL;
3381 /* There is no need to mark used sections when not debugging. */
3382 if (cold_text_section != NULL)
3383 dwarf2out_note_section_used ();
3387 /* And now, the subset of the debugging information support code necessary
3388 for emitting location expressions. */
3390 /* Data about a single source file. */
3391 struct dwarf_file_data GTY(())
3393 const char * filename;
3397 /* We need some way to distinguish DW_OP_addr with a direct symbol
3398 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
3399 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
3402 typedef struct dw_val_struct *dw_val_ref;
3403 typedef struct die_struct *dw_die_ref;
3404 typedef const struct die_struct *const_dw_die_ref;
3405 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
3406 typedef struct dw_loc_list_struct *dw_loc_list_ref;
3408 typedef struct deferred_locations_struct GTY(())
3412 } deferred_locations;
3414 DEF_VEC_O(deferred_locations);
3415 DEF_VEC_ALLOC_O(deferred_locations,gc);
3417 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
3419 /* Each DIE may have a series of attribute/value pairs. Values
3420 can take on several forms. The forms that are used in this
3421 implementation are listed below. */
3426 dw_val_class_offset,
3428 dw_val_class_loc_list,
3429 dw_val_class_range_list,
3431 dw_val_class_unsigned_const,
3432 dw_val_class_long_long,
3435 dw_val_class_die_ref,
3436 dw_val_class_fde_ref,
3437 dw_val_class_lbl_id,
3438 dw_val_class_lineptr,
3440 dw_val_class_macptr,
3444 /* Describe a double word constant value. */
3445 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
3447 typedef struct dw_long_long_struct GTY(())
3454 /* Describe a floating point constant value, or a vector constant value. */
3456 typedef struct dw_vec_struct GTY(())
3458 unsigned char * GTY((length ("%h.length"))) array;
3464 /* The dw_val_node describes an attribute's value, as it is
3465 represented internally. */
3467 typedef struct dw_val_struct GTY(())
3469 enum dw_val_class val_class;
3470 union dw_val_struct_union
3472 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
3473 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
3474 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
3475 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
3476 HOST_WIDE_INT GTY ((default)) val_int;
3477 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
3478 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
3479 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
3480 struct dw_val_die_union
3484 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
3485 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
3486 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
3487 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
3488 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
3489 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
3491 GTY ((desc ("%1.val_class"))) v;
3495 /* Locations in memory are described using a sequence of stack machine
3498 typedef struct dw_loc_descr_struct GTY(())
3500 dw_loc_descr_ref dw_loc_next;
3501 enum dwarf_location_atom dw_loc_opc;
3503 dw_val_node dw_loc_oprnd1;
3504 dw_val_node dw_loc_oprnd2;
3508 /* Location lists are ranges + location descriptions for that range,
3509 so you can track variables that are in different places over
3510 their entire life. */
3511 typedef struct dw_loc_list_struct GTY(())
3513 dw_loc_list_ref dw_loc_next;
3514 const char *begin; /* Label for begin address of range */
3515 const char *end; /* Label for end address of range */
3516 char *ll_symbol; /* Label for beginning of location list.
3517 Only on head of list */
3518 const char *section; /* Section this loclist is relative to */
3519 dw_loc_descr_ref expr;
3522 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
3524 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
3526 /* Convert a DWARF stack opcode into its string name. */
3529 dwarf_stack_op_name (unsigned int op)
3534 case INTERNAL_DW_OP_tls_addr:
3535 return "DW_OP_addr";
3537 return "DW_OP_deref";
3539 return "DW_OP_const1u";
3541 return "DW_OP_const1s";
3543 return "DW_OP_const2u";
3545 return "DW_OP_const2s";
3547 return "DW_OP_const4u";
3549 return "DW_OP_const4s";
3551 return "DW_OP_const8u";
3553 return "DW_OP_const8s";
3555 return "DW_OP_constu";
3557 return "DW_OP_consts";
3561 return "DW_OP_drop";
3563 return "DW_OP_over";
3565 return "DW_OP_pick";
3567 return "DW_OP_swap";
3571 return "DW_OP_xderef";
3579 return "DW_OP_minus";
3591 return "DW_OP_plus";
3592 case DW_OP_plus_uconst:
3593 return "DW_OP_plus_uconst";
3599 return "DW_OP_shra";
3617 return "DW_OP_skip";
3619 return "DW_OP_lit0";
3621 return "DW_OP_lit1";
3623 return "DW_OP_lit2";
3625 return "DW_OP_lit3";
3627 return "DW_OP_lit4";
3629 return "DW_OP_lit5";
3631 return "DW_OP_lit6";
3633 return "DW_OP_lit7";
3635 return "DW_OP_lit8";
3637 return "DW_OP_lit9";
3639 return "DW_OP_lit10";
3641 return "DW_OP_lit11";
3643 return "DW_OP_lit12";
3645 return "DW_OP_lit13";
3647 return "DW_OP_lit14";
3649 return "DW_OP_lit15";
3651 return "DW_OP_lit16";
3653 return "DW_OP_lit17";
3655 return "DW_OP_lit18";
3657 return "DW_OP_lit19";
3659 return "DW_OP_lit20";
3661 return "DW_OP_lit21";
3663 return "DW_OP_lit22";
3665 return "DW_OP_lit23";
3667 return "DW_OP_lit24";
3669 return "DW_OP_lit25";
3671 return "DW_OP_lit26";
3673 return "DW_OP_lit27";
3675 return "DW_OP_lit28";
3677 return "DW_OP_lit29";
3679 return "DW_OP_lit30";
3681 return "DW_OP_lit31";
3683 return "DW_OP_reg0";
3685 return "DW_OP_reg1";
3687 return "DW_OP_reg2";
3689 return "DW_OP_reg3";
3691 return "DW_OP_reg4";
3693 return "DW_OP_reg5";
3695 return "DW_OP_reg6";
3697 return "DW_OP_reg7";
3699 return "DW_OP_reg8";
3701 return "DW_OP_reg9";
3703 return "DW_OP_reg10";
3705 return "DW_OP_reg11";
3707 return "DW_OP_reg12";
3709 return "DW_OP_reg13";
3711 return "DW_OP_reg14";
3713 return "DW_OP_reg15";
3715 return "DW_OP_reg16";
3717 return "DW_OP_reg17";
3719 return "DW_OP_reg18";
3721 return "DW_OP_reg19";
3723 return "DW_OP_reg20";
3725 return "DW_OP_reg21";
3727 return "DW_OP_reg22";
3729 return "DW_OP_reg23";
3731 return "DW_OP_reg24";
3733 return "DW_OP_reg25";
3735 return "DW_OP_reg26";
3737 return "DW_OP_reg27";
3739 return "DW_OP_reg28";
3741 return "DW_OP_reg29";
3743 return "DW_OP_reg30";
3745 return "DW_OP_reg31";
3747 return "DW_OP_breg0";
3749 return "DW_OP_breg1";
3751 return "DW_OP_breg2";
3753 return "DW_OP_breg3";
3755 return "DW_OP_breg4";
3757 return "DW_OP_breg5";
3759 return "DW_OP_breg6";
3761 return "DW_OP_breg7";
3763 return "DW_OP_breg8";
3765 return "DW_OP_breg9";
3767 return "DW_OP_breg10";
3769 return "DW_OP_breg11";
3771 return "DW_OP_breg12";
3773 return "DW_OP_breg13";
3775 return "DW_OP_breg14";
3777 return "DW_OP_breg15";
3779 return "DW_OP_breg16";
3781 return "DW_OP_breg17";
3783 return "DW_OP_breg18";
3785 return "DW_OP_breg19";
3787 return "DW_OP_breg20";
3789 return "DW_OP_breg21";
3791 return "DW_OP_breg22";
3793 return "DW_OP_breg23";
3795 return "DW_OP_breg24";
3797 return "DW_OP_breg25";
3799 return "DW_OP_breg26";
3801 return "DW_OP_breg27";
3803 return "DW_OP_breg28";
3805 return "DW_OP_breg29";
3807 return "DW_OP_breg30";
3809 return "DW_OP_breg31";
3811 return "DW_OP_regx";
3813 return "DW_OP_fbreg";
3815 return "DW_OP_bregx";
3817 return "DW_OP_piece";
3818 case DW_OP_deref_size:
3819 return "DW_OP_deref_size";
3820 case DW_OP_xderef_size:
3821 return "DW_OP_xderef_size";
3824 case DW_OP_push_object_address:
3825 return "DW_OP_push_object_address";
3827 return "DW_OP_call2";
3829 return "DW_OP_call4";
3830 case DW_OP_call_ref:
3831 return "DW_OP_call_ref";
3832 case DW_OP_GNU_push_tls_address:
3833 return "DW_OP_GNU_push_tls_address";
3834 case DW_OP_GNU_uninit:
3835 return "DW_OP_GNU_uninit";
3837 return "OP_<unknown>";
3841 /* Return a pointer to a newly allocated location description. Location
3842 descriptions are simple expression terms that can be strung
3843 together to form more complicated location (address) descriptions. */
3845 static inline dw_loc_descr_ref
3846 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3847 unsigned HOST_WIDE_INT oprnd2)
3849 dw_loc_descr_ref descr = GGC_CNEW (dw_loc_descr_node);
3851 descr->dw_loc_opc = op;
3852 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3853 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3854 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3855 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3860 /* Return a pointer to a newly allocated location description for
3863 static inline dw_loc_descr_ref
3864 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
3869 return new_loc_descr (DW_OP_breg0 + reg, offset, 0);
3871 return new_loc_descr (DW_OP_bregx, reg, offset);
3874 return new_loc_descr (DW_OP_reg0 + reg, 0, 0);
3876 return new_loc_descr (DW_OP_regx, reg, 0);
3879 /* Add a location description term to a location description expression. */
3882 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3884 dw_loc_descr_ref *d;
3886 /* Find the end of the chain. */
3887 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3893 /* Return the size of a location descriptor. */
3895 static unsigned long
3896 size_of_loc_descr (dw_loc_descr_ref loc)
3898 unsigned long size = 1;
3900 switch (loc->dw_loc_opc)
3903 case INTERNAL_DW_OP_tls_addr:
3904 size += DWARF2_ADDR_SIZE;
3923 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3926 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3931 case DW_OP_plus_uconst:
3932 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3970 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3973 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3976 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3979 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3980 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3983 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3985 case DW_OP_deref_size:
3986 case DW_OP_xderef_size:
3995 case DW_OP_call_ref:
3996 size += DWARF2_ADDR_SIZE;
4005 /* Return the size of a series of location descriptors. */
4007 static unsigned long
4008 size_of_locs (dw_loc_descr_ref loc)
4013 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4014 field, to avoid writing to a PCH file. */
4015 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4017 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4019 size += size_of_loc_descr (l);
4024 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4026 l->dw_loc_addr = size;
4027 size += size_of_loc_descr (l);
4033 /* Output location description stack opcode's operands (if any). */
4036 output_loc_operands (dw_loc_descr_ref loc)
4038 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4039 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4041 switch (loc->dw_loc_opc)
4043 #ifdef DWARF2_DEBUGGING_INFO
4045 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
4049 dw2_asm_output_data (2, val1->v.val_int, NULL);
4053 dw2_asm_output_data (4, val1->v.val_int, NULL);
4057 gcc_assert (HOST_BITS_PER_LONG >= 64);
4058 dw2_asm_output_data (8, val1->v.val_int, NULL);
4065 gcc_assert (val1->val_class == dw_val_class_loc);
4066 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4068 dw2_asm_output_data (2, offset, NULL);
4081 /* We currently don't make any attempt to make sure these are
4082 aligned properly like we do for the main unwind info, so
4083 don't support emitting things larger than a byte if we're
4084 only doing unwinding. */
4089 dw2_asm_output_data (1, val1->v.val_int, NULL);
4092 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4095 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4098 dw2_asm_output_data (1, val1->v.val_int, NULL);
4100 case DW_OP_plus_uconst:
4101 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4135 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4138 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4141 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4144 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4145 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
4148 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4150 case DW_OP_deref_size:
4151 case DW_OP_xderef_size:
4152 dw2_asm_output_data (1, val1->v.val_int, NULL);
4155 case INTERNAL_DW_OP_tls_addr:
4156 if (targetm.asm_out.output_dwarf_dtprel)
4158 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
4161 fputc ('\n', asm_out_file);
4168 /* Other codes have no operands. */
4173 /* Output a sequence of location operations. */
4176 output_loc_sequence (dw_loc_descr_ref loc)
4178 for (; loc != NULL; loc = loc->dw_loc_next)
4180 /* Output the opcode. */
4181 dw2_asm_output_data (1, loc->dw_loc_opc,
4182 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
4184 /* Output the operand(s) (if any). */
4185 output_loc_operands (loc);
4189 /* Output location description stack opcode's operands (if any).
4190 The output is single bytes on a line, suitable for .cfi_escape. */
4193 output_loc_operands_raw (dw_loc_descr_ref loc)
4195 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4196 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4198 switch (loc->dw_loc_opc)
4201 /* We cannot output addresses in .cfi_escape, only bytes. */
4207 case DW_OP_deref_size:
4208 case DW_OP_xderef_size:
4209 fputc (',', asm_out_file);
4210 dw2_asm_output_data_raw (1, val1->v.val_int);
4215 fputc (',', asm_out_file);
4216 dw2_asm_output_data_raw (2, val1->v.val_int);
4221 fputc (',', asm_out_file);
4222 dw2_asm_output_data_raw (4, val1->v.val_int);
4227 gcc_assert (HOST_BITS_PER_LONG >= 64);
4228 fputc (',', asm_out_file);
4229 dw2_asm_output_data_raw (8, val1->v.val_int);
4237 gcc_assert (val1->val_class == dw_val_class_loc);
4238 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4240 fputc (',', asm_out_file);
4241 dw2_asm_output_data_raw (2, offset);
4246 case DW_OP_plus_uconst:
4249 fputc (',', asm_out_file);
4250 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4287 fputc (',', asm_out_file);
4288 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
4292 fputc (',', asm_out_file);
4293 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4294 fputc (',', asm_out_file);
4295 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
4298 case INTERNAL_DW_OP_tls_addr:
4302 /* Other codes have no operands. */
4308 output_loc_sequence_raw (dw_loc_descr_ref loc)
4312 /* Output the opcode. */
4313 fprintf (asm_out_file, "0x%x", loc->dw_loc_opc);
4314 output_loc_operands_raw (loc);
4316 if (!loc->dw_loc_next)
4318 loc = loc->dw_loc_next;
4320 fputc (',', asm_out_file);
4324 /* This routine will generate the correct assembly data for a location
4325 description based on a cfi entry with a complex address. */
4328 output_cfa_loc (dw_cfi_ref cfi)
4330 dw_loc_descr_ref loc;
4333 if (cfi->dw_cfi_opc == DW_CFA_expression)
4334 dw2_asm_output_data (1, cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL);
4336 /* Output the size of the block. */
4337 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4338 size = size_of_locs (loc);
4339 dw2_asm_output_data_uleb128 (size, NULL);
4341 /* Now output the operations themselves. */
4342 output_loc_sequence (loc);
4345 /* Similar, but used for .cfi_escape. */
4348 output_cfa_loc_raw (dw_cfi_ref cfi)
4350 dw_loc_descr_ref loc;
4353 if (cfi->dw_cfi_opc == DW_CFA_expression)
4354 fprintf (asm_out_file, "0x%x,", cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4356 /* Output the size of the block. */
4357 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4358 size = size_of_locs (loc);
4359 dw2_asm_output_data_uleb128_raw (size);
4360 fputc (',', asm_out_file);
4362 /* Now output the operations themselves. */
4363 output_loc_sequence_raw (loc);
4366 /* This function builds a dwarf location descriptor sequence from a
4367 dw_cfa_location, adding the given OFFSET to the result of the
4370 static struct dw_loc_descr_struct *
4371 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
4373 struct dw_loc_descr_struct *head, *tmp;
4375 offset += cfa->offset;
4379 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
4380 head->dw_loc_oprnd1.val_class = dw_val_class_const;
4381 tmp = new_loc_descr (DW_OP_deref, 0, 0);
4382 add_loc_descr (&head, tmp);
4385 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4386 add_loc_descr (&head, tmp);
4390 head = new_reg_loc_descr (cfa->reg, offset);
4395 /* This function builds a dwarf location descriptor sequence for
4396 the address at OFFSET from the CFA when stack is aligned to
4399 static struct dw_loc_descr_struct *
4400 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
4402 struct dw_loc_descr_struct *head;
4403 unsigned int dwarf_fp
4404 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
4406 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
4407 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
4409 head = new_reg_loc_descr (dwarf_fp, 0);
4410 add_loc_descr (&head, int_loc_descriptor (alignment));
4411 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
4413 add_loc_descr (&head, int_loc_descriptor (offset));
4414 add_loc_descr (&head, new_loc_descr (DW_OP_plus, 0, 0));
4417 head = new_reg_loc_descr (dwarf_fp, offset);
4421 /* This function fills in aa dw_cfa_location structure from a dwarf location
4422 descriptor sequence. */
4425 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
4427 struct dw_loc_descr_struct *ptr;
4429 cfa->base_offset = 0;
4433 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
4435 enum dwarf_location_atom op = ptr->dw_loc_opc;
4471 cfa->reg = op - DW_OP_reg0;
4474 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4508 cfa->reg = op - DW_OP_breg0;
4509 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
4512 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4513 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
4518 case DW_OP_plus_uconst:
4519 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
4522 internal_error ("DW_LOC_OP %s not implemented",
4523 dwarf_stack_op_name (ptr->dw_loc_opc));
4527 #endif /* .debug_frame support */
4529 /* And now, the support for symbolic debugging information. */
4530 #ifdef DWARF2_DEBUGGING_INFO
4532 /* .debug_str support. */
4533 static int output_indirect_string (void **, void *);
4535 static void dwarf2out_init (const char *);
4536 static void dwarf2out_finish (const char *);
4537 static void dwarf2out_define (unsigned int, const char *);
4538 static void dwarf2out_undef (unsigned int, const char *);
4539 static void dwarf2out_start_source_file (unsigned, const char *);
4540 static void dwarf2out_end_source_file (unsigned);
4541 static void dwarf2out_begin_block (unsigned, unsigned);
4542 static void dwarf2out_end_block (unsigned, unsigned);
4543 static bool dwarf2out_ignore_block (const_tree);
4544 static void dwarf2out_global_decl (tree);
4545 static void dwarf2out_type_decl (tree, int);
4546 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
4547 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
4549 static void dwarf2out_abstract_function (tree);
4550 static void dwarf2out_var_location (rtx);
4551 static void dwarf2out_begin_function (tree);
4553 /* The debug hooks structure. */
4555 const struct gcc_debug_hooks dwarf2_debug_hooks =
4561 dwarf2out_start_source_file,
4562 dwarf2out_end_source_file,
4563 dwarf2out_begin_block,
4564 dwarf2out_end_block,
4565 dwarf2out_ignore_block,
4566 dwarf2out_source_line,
4567 dwarf2out_begin_prologue,
4568 debug_nothing_int_charstar, /* end_prologue */
4569 dwarf2out_end_epilogue,
4570 dwarf2out_begin_function,
4571 debug_nothing_int, /* end_function */
4572 dwarf2out_decl, /* function_decl */
4573 dwarf2out_global_decl,
4574 dwarf2out_type_decl, /* type_decl */
4575 dwarf2out_imported_module_or_decl,
4576 debug_nothing_tree, /* deferred_inline_function */
4577 /* The DWARF 2 backend tries to reduce debugging bloat by not
4578 emitting the abstract description of inline functions until
4579 something tries to reference them. */
4580 dwarf2out_abstract_function, /* outlining_inline_function */
4581 debug_nothing_rtx, /* label */
4582 debug_nothing_int, /* handle_pch */
4583 dwarf2out_var_location,
4584 dwarf2out_switch_text_section,
4585 1 /* start_end_main_source_file */
4589 /* NOTE: In the comments in this file, many references are made to
4590 "Debugging Information Entries". This term is abbreviated as `DIE'
4591 throughout the remainder of this file. */
4593 /* An internal representation of the DWARF output is built, and then
4594 walked to generate the DWARF debugging info. The walk of the internal
4595 representation is done after the entire program has been compiled.
4596 The types below are used to describe the internal representation. */
4598 /* Various DIE's use offsets relative to the beginning of the
4599 .debug_info section to refer to each other. */
4601 typedef long int dw_offset;
4603 /* Define typedefs here to avoid circular dependencies. */
4605 typedef struct dw_attr_struct *dw_attr_ref;
4606 typedef struct dw_line_info_struct *dw_line_info_ref;
4607 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
4608 typedef struct pubname_struct *pubname_ref;
4609 typedef struct dw_ranges_struct *dw_ranges_ref;
4610 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
4612 /* Each entry in the line_info_table maintains the file and
4613 line number associated with the label generated for that
4614 entry. The label gives the PC value associated with
4615 the line number entry. */
4617 typedef struct dw_line_info_struct GTY(())
4619 unsigned long dw_file_num;
4620 unsigned long dw_line_num;
4624 /* Line information for functions in separate sections; each one gets its
4626 typedef struct dw_separate_line_info_struct GTY(())
4628 unsigned long dw_file_num;
4629 unsigned long dw_line_num;
4630 unsigned long function;
4632 dw_separate_line_info_entry;
4634 /* Each DIE attribute has a field specifying the attribute kind,
4635 a link to the next attribute in the chain, and an attribute value.
4636 Attributes are typically linked below the DIE they modify. */
4638 typedef struct dw_attr_struct GTY(())
4640 enum dwarf_attribute dw_attr;
4641 dw_val_node dw_attr_val;
4645 DEF_VEC_O(dw_attr_node);
4646 DEF_VEC_ALLOC_O(dw_attr_node,gc);
4648 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
4649 The children of each node form a circular list linked by
4650 die_sib. die_child points to the node *before* the "first" child node. */
4652 typedef struct die_struct GTY((chain_circular ("%h.die_sib")))
4654 enum dwarf_tag die_tag;
4656 VEC(dw_attr_node,gc) * die_attr;
4657 dw_die_ref die_parent;
4658 dw_die_ref die_child;
4660 dw_die_ref die_definition; /* ref from a specification to its definition */
4661 dw_offset die_offset;
4662 unsigned long die_abbrev;
4664 /* Die is used and must not be pruned as unused. */
4665 int die_perennial_p;
4666 unsigned int decl_id;
4670 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
4671 #define FOR_EACH_CHILD(die, c, expr) do { \
4672 c = die->die_child; \
4676 } while (c != die->die_child); \
4679 /* The pubname structure */
4681 typedef struct pubname_struct GTY(())
4688 DEF_VEC_O(pubname_entry);
4689 DEF_VEC_ALLOC_O(pubname_entry, gc);
4691 struct dw_ranges_struct GTY(())
4693 /* If this is positive, it's a block number, otherwise it's a
4694 bitwise-negated index into dw_ranges_by_label. */
4698 struct dw_ranges_by_label_struct GTY(())
4704 /* The limbo die list structure. */
4705 typedef struct limbo_die_struct GTY(())
4709 struct limbo_die_struct *next;
4713 /* How to start an assembler comment. */
4714 #ifndef ASM_COMMENT_START
4715 #define ASM_COMMENT_START ";#"
4718 /* Define a macro which returns nonzero for a TYPE_DECL which was
4719 implicitly generated for a tagged type.
4721 Note that unlike the gcc front end (which generates a NULL named
4722 TYPE_DECL node for each complete tagged type, each array type, and
4723 each function type node created) the g++ front end generates a
4724 _named_ TYPE_DECL node for each tagged type node created.
4725 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
4726 generate a DW_TAG_typedef DIE for them. */
4728 #define TYPE_DECL_IS_STUB(decl) \
4729 (DECL_NAME (decl) == NULL_TREE \
4730 || (DECL_ARTIFICIAL (decl) \
4731 && is_tagged_type (TREE_TYPE (decl)) \
4732 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
4733 /* This is necessary for stub decls that \
4734 appear in nested inline functions. */ \
4735 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
4736 && (decl_ultimate_origin (decl) \
4737 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
4739 /* Information concerning the compilation unit's programming
4740 language, and compiler version. */
4742 /* Fixed size portion of the DWARF compilation unit header. */
4743 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
4744 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
4746 /* Fixed size portion of public names info. */
4747 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
4749 /* Fixed size portion of the address range info. */
4750 #define DWARF_ARANGES_HEADER_SIZE \
4751 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4752 DWARF2_ADDR_SIZE * 2) \
4753 - DWARF_INITIAL_LENGTH_SIZE)
4755 /* Size of padding portion in the address range info. It must be
4756 aligned to twice the pointer size. */
4757 #define DWARF_ARANGES_PAD_SIZE \
4758 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4759 DWARF2_ADDR_SIZE * 2) \
4760 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
4762 /* Use assembler line directives if available. */
4763 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
4764 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
4765 #define DWARF2_ASM_LINE_DEBUG_INFO 1
4767 #define DWARF2_ASM_LINE_DEBUG_INFO 0
4771 /* Minimum line offset in a special line info. opcode.
4772 This value was chosen to give a reasonable range of values. */
4773 #define DWARF_LINE_BASE -10
4775 /* First special line opcode - leave room for the standard opcodes. */
4776 #define DWARF_LINE_OPCODE_BASE 10
4778 /* Range of line offsets in a special line info. opcode. */
4779 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
4781 /* Flag that indicates the initial value of the is_stmt_start flag.
4782 In the present implementation, we do not mark any lines as
4783 the beginning of a source statement, because that information
4784 is not made available by the GCC front-end. */
4785 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
4787 #ifdef DWARF2_DEBUGGING_INFO
4788 /* This location is used by calc_die_sizes() to keep track
4789 the offset of each DIE within the .debug_info section. */
4790 static unsigned long next_die_offset;
4793 /* Record the root of the DIE's built for the current compilation unit. */
4794 static GTY(()) dw_die_ref comp_unit_die;
4796 /* A list of DIEs with a NULL parent waiting to be relocated. */
4797 static GTY(()) limbo_die_node *limbo_die_list;
4799 /* Filenames referenced by this compilation unit. */
4800 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
4802 /* A hash table of references to DIE's that describe declarations.
4803 The key is a DECL_UID() which is a unique number identifying each decl. */
4804 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
4806 /* A hash table of references to DIE's that describe COMMON blocks.
4807 The key is DECL_UID() ^ die_parent. */
4808 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
4810 /* Node of the variable location list. */
4811 struct var_loc_node GTY ((chain_next ("%h.next")))
4813 rtx GTY (()) var_loc_note;
4814 const char * GTY (()) label;
4815 const char * GTY (()) section_label;
4816 struct var_loc_node * GTY (()) next;
4819 /* Variable location list. */
4820 struct var_loc_list_def GTY (())
4822 struct var_loc_node * GTY (()) first;
4824 /* Do not mark the last element of the chained list because
4825 it is marked through the chain. */
4826 struct var_loc_node * GTY ((skip ("%h"))) last;
4828 /* DECL_UID of the variable decl. */
4829 unsigned int decl_id;
4831 typedef struct var_loc_list_def var_loc_list;
4834 /* Table of decl location linked lists. */
4835 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
4837 /* A pointer to the base of a list of references to DIE's that
4838 are uniquely identified by their tag, presence/absence of
4839 children DIE's, and list of attribute/value pairs. */
4840 static GTY((length ("abbrev_die_table_allocated")))
4841 dw_die_ref *abbrev_die_table;
4843 /* Number of elements currently allocated for abbrev_die_table. */
4844 static GTY(()) unsigned abbrev_die_table_allocated;
4846 /* Number of elements in type_die_table currently in use. */
4847 static GTY(()) unsigned abbrev_die_table_in_use;
4849 /* Size (in elements) of increments by which we may expand the
4850 abbrev_die_table. */
4851 #define ABBREV_DIE_TABLE_INCREMENT 256
4853 /* A pointer to the base of a table that contains line information
4854 for each source code line in .text in the compilation unit. */
4855 static GTY((length ("line_info_table_allocated")))
4856 dw_line_info_ref line_info_table;
4858 /* Number of elements currently allocated for line_info_table. */
4859 static GTY(()) unsigned line_info_table_allocated;
4861 /* Number of elements in line_info_table currently in use. */
4862 static GTY(()) unsigned line_info_table_in_use;
4864 /* A pointer to the base of a table that contains line information
4865 for each source code line outside of .text in the compilation unit. */
4866 static GTY ((length ("separate_line_info_table_allocated")))
4867 dw_separate_line_info_ref separate_line_info_table;
4869 /* Number of elements currently allocated for separate_line_info_table. */
4870 static GTY(()) unsigned separate_line_info_table_allocated;
4872 /* Number of elements in separate_line_info_table currently in use. */
4873 static GTY(()) unsigned separate_line_info_table_in_use;
4875 /* Size (in elements) of increments by which we may expand the
4877 #define LINE_INFO_TABLE_INCREMENT 1024
4879 /* A pointer to the base of a table that contains a list of publicly
4880 accessible names. */
4881 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
4883 /* A pointer to the base of a table that contains a list of publicly
4884 accessible types. */
4885 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
4887 /* Array of dies for which we should generate .debug_arange info. */
4888 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
4890 /* Number of elements currently allocated for arange_table. */
4891 static GTY(()) unsigned arange_table_allocated;
4893 /* Number of elements in arange_table currently in use. */
4894 static GTY(()) unsigned arange_table_in_use;
4896 /* Size (in elements) of increments by which we may expand the
4898 #define ARANGE_TABLE_INCREMENT 64
4900 /* Array of dies for which we should generate .debug_ranges info. */
4901 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
4903 /* Number of elements currently allocated for ranges_table. */
4904 static GTY(()) unsigned ranges_table_allocated;
4906 /* Number of elements in ranges_table currently in use. */
4907 static GTY(()) unsigned ranges_table_in_use;
4909 /* Array of pairs of labels referenced in ranges_table. */
4910 static GTY ((length ("ranges_by_label_allocated")))
4911 dw_ranges_by_label_ref ranges_by_label;
4913 /* Number of elements currently allocated for ranges_by_label. */
4914 static GTY(()) unsigned ranges_by_label_allocated;
4916 /* Number of elements in ranges_by_label currently in use. */
4917 static GTY(()) unsigned ranges_by_label_in_use;
4919 /* Size (in elements) of increments by which we may expand the
4921 #define RANGES_TABLE_INCREMENT 64
4923 /* Whether we have location lists that need outputting */
4924 static GTY(()) bool have_location_lists;
4926 /* Unique label counter. */
4927 static GTY(()) unsigned int loclabel_num;
4929 #ifdef DWARF2_DEBUGGING_INFO
4930 /* Record whether the function being analyzed contains inlined functions. */
4931 static int current_function_has_inlines;
4933 #if 0 && defined (MIPS_DEBUGGING_INFO)
4934 static int comp_unit_has_inlines;
4937 /* The last file entry emitted by maybe_emit_file(). */
4938 static GTY(()) struct dwarf_file_data * last_emitted_file;
4940 /* Number of internal labels generated by gen_internal_sym(). */
4941 static GTY(()) int label_num;
4943 /* Cached result of previous call to lookup_filename. */
4944 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
4946 #ifdef DWARF2_DEBUGGING_INFO
4948 /* Offset from the "steady-state frame pointer" to the frame base,
4949 within the current function. */
4950 static HOST_WIDE_INT frame_pointer_fb_offset;
4952 /* Forward declarations for functions defined in this file. */
4954 static int is_pseudo_reg (const_rtx);
4955 static tree type_main_variant (tree);
4956 static int is_tagged_type (const_tree);
4957 static const char *dwarf_tag_name (unsigned);
4958 static const char *dwarf_attr_name (unsigned);
4959 static const char *dwarf_form_name (unsigned);
4960 static tree decl_ultimate_origin (const_tree);
4961 static tree decl_class_context (tree);
4962 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4963 static inline enum dw_val_class AT_class (dw_attr_ref);
4964 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4965 static inline unsigned AT_flag (dw_attr_ref);
4966 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4967 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4968 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4969 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4970 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4972 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4973 unsigned int, unsigned char *);
4974 static hashval_t debug_str_do_hash (const void *);
4975 static int debug_str_eq (const void *, const void *);
4976 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4977 static inline const char *AT_string (dw_attr_ref);
4978 static int AT_string_form (dw_attr_ref);
4979 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4980 static void add_AT_specification (dw_die_ref, dw_die_ref);
4981 static inline dw_die_ref AT_ref (dw_attr_ref);
4982 static inline int AT_ref_external (dw_attr_ref);
4983 static inline void set_AT_ref_external (dw_attr_ref, int);
4984 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4985 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4986 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4987 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4989 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4990 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4991 static inline rtx AT_addr (dw_attr_ref);
4992 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4993 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4994 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4995 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4996 unsigned HOST_WIDE_INT);
4997 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
4999 static inline const char *AT_lbl (dw_attr_ref);
5000 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
5001 static const char *get_AT_low_pc (dw_die_ref);
5002 static const char *get_AT_hi_pc (dw_die_ref);
5003 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
5004 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
5005 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
5006 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
5007 static bool is_c_family (void);
5008 static bool is_cxx (void);
5009 static bool is_java (void);
5010 static bool is_fortran (void);
5011 static bool is_ada (void);
5012 static void remove_AT (dw_die_ref, enum dwarf_attribute);
5013 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
5014 static void add_child_die (dw_die_ref, dw_die_ref);
5015 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
5016 static dw_die_ref lookup_type_die (tree);
5017 static void equate_type_number_to_die (tree, dw_die_ref);
5018 static hashval_t decl_die_table_hash (const void *);
5019 static int decl_die_table_eq (const void *, const void *);
5020 static dw_die_ref lookup_decl_die (tree);
5021 static hashval_t common_block_die_table_hash (const void *);
5022 static int common_block_die_table_eq (const void *, const void *);
5023 static hashval_t decl_loc_table_hash (const void *);
5024 static int decl_loc_table_eq (const void *, const void *);
5025 static var_loc_list *lookup_decl_loc (const_tree);
5026 static void equate_decl_number_to_die (tree, dw_die_ref);
5027 static void add_var_loc_to_decl (tree, struct var_loc_node *);
5028 static void print_spaces (FILE *);
5029 static void print_die (dw_die_ref, FILE *);
5030 static void print_dwarf_line_table (FILE *);
5031 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
5032 static dw_die_ref pop_compile_unit (dw_die_ref);
5033 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
5034 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
5035 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
5036 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
5037 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
5038 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
5039 static int same_die_p (dw_die_ref, dw_die_ref, int *);
5040 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
5041 static void compute_section_prefix (dw_die_ref);
5042 static int is_type_die (dw_die_ref);
5043 static int is_comdat_die (dw_die_ref);
5044 static int is_symbol_die (dw_die_ref);
5045 static void assign_symbol_names (dw_die_ref);
5046 static void break_out_includes (dw_die_ref);
5047 static hashval_t htab_cu_hash (const void *);
5048 static int htab_cu_eq (const void *, const void *);
5049 static void htab_cu_del (void *);
5050 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
5051 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
5052 static void add_sibling_attributes (dw_die_ref);
5053 static void build_abbrev_table (dw_die_ref);
5054 static void output_location_lists (dw_die_ref);
5055 static int constant_size (unsigned HOST_WIDE_INT);
5056 static unsigned long size_of_die (dw_die_ref);
5057 static void calc_die_sizes (dw_die_ref);
5058 static void mark_dies (dw_die_ref);
5059 static void unmark_dies (dw_die_ref);
5060 static void unmark_all_dies (dw_die_ref);
5061 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
5062 static unsigned long size_of_aranges (void);
5063 static enum dwarf_form value_format (dw_attr_ref);
5064 static void output_value_format (dw_attr_ref);
5065 static void output_abbrev_section (void);
5066 static void output_die_symbol (dw_die_ref);
5067 static void output_die (dw_die_ref);
5068 static void output_compilation_unit_header (void);
5069 static void output_comp_unit (dw_die_ref, int);
5070 static const char *dwarf2_name (tree, int);
5071 static void add_pubname (tree, dw_die_ref);
5072 static void add_pubname_string (const char *, dw_die_ref);
5073 static void add_pubtype (tree, dw_die_ref);
5074 static void output_pubnames (VEC (pubname_entry,gc) *);
5075 static void add_arange (tree, dw_die_ref);
5076 static void output_aranges (void);
5077 static unsigned int add_ranges_num (int);
5078 static unsigned int add_ranges (const_tree);
5079 static unsigned int add_ranges_by_labels (const char *, const char *);
5080 static void output_ranges (void);
5081 static void output_line_info (void);
5082 static void output_file_names (void);
5083 static dw_die_ref base_type_die (tree);
5084 static int is_base_type (tree);
5085 static bool is_subrange_type (const_tree);
5086 static dw_die_ref subrange_type_die (tree, dw_die_ref);
5087 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
5088 static int type_is_enum (const_tree);
5089 static unsigned int dbx_reg_number (const_rtx);
5090 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
5091 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
5092 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
5093 enum var_init_status);
5094 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
5095 enum var_init_status);
5096 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
5097 enum var_init_status);
5098 static int is_based_loc (const_rtx);
5099 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
5100 enum var_init_status);
5101 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
5102 enum var_init_status);
5103 static dw_loc_descr_ref loc_descriptor (rtx, enum var_init_status);
5104 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
5105 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
5106 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
5107 static tree field_type (const_tree);
5108 static unsigned int simple_type_align_in_bits (const_tree);
5109 static unsigned int simple_decl_align_in_bits (const_tree);
5110 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
5111 static HOST_WIDE_INT field_byte_offset (const_tree);
5112 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
5114 static void add_data_member_location_attribute (dw_die_ref, tree);
5115 static void add_const_value_attribute (dw_die_ref, rtx);
5116 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
5117 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
5118 static void insert_float (const_rtx, unsigned char *);
5119 static rtx rtl_for_decl_location (tree);
5120 static void add_location_or_const_value_attribute (dw_die_ref, tree,
5121 enum dwarf_attribute);
5122 static void tree_add_const_value_attribute (dw_die_ref, tree);
5123 static void add_name_attribute (dw_die_ref, const char *);
5124 static void add_comp_dir_attribute (dw_die_ref);
5125 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
5126 static void add_subscript_info (dw_die_ref, tree, bool);
5127 static void add_byte_size_attribute (dw_die_ref, tree);
5128 static void add_bit_offset_attribute (dw_die_ref, tree);
5129 static void add_bit_size_attribute (dw_die_ref, tree);
5130 static void add_prototyped_attribute (dw_die_ref, tree);
5131 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
5132 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
5133 static void add_src_coords_attributes (dw_die_ref, tree);
5134 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
5135 static void push_decl_scope (tree);
5136 static void pop_decl_scope (void);
5137 static dw_die_ref scope_die_for (tree, dw_die_ref);
5138 static inline int local_scope_p (dw_die_ref);
5139 static inline int class_or_namespace_scope_p (dw_die_ref);
5140 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
5141 static void add_calling_convention_attribute (dw_die_ref, tree);
5142 static const char *type_tag (const_tree);
5143 static tree member_declared_type (const_tree);
5145 static const char *decl_start_label (tree);
5147 static void gen_array_type_die (tree, dw_die_ref);
5148 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
5150 static void gen_entry_point_die (tree, dw_die_ref);
5152 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
5153 static dw_die_ref gen_formal_parameter_die (tree, tree, dw_die_ref);
5154 static void gen_unspecified_parameters_die (tree, dw_die_ref);
5155 static void gen_formal_types_die (tree, dw_die_ref);
5156 static void gen_subprogram_die (tree, dw_die_ref);
5157 static void gen_variable_die (tree, tree, dw_die_ref);
5158 static void gen_const_die (tree, dw_die_ref);
5159 static void gen_label_die (tree, dw_die_ref);
5160 static void gen_lexical_block_die (tree, dw_die_ref, int);
5161 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
5162 static void gen_field_die (tree, dw_die_ref);
5163 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
5164 static dw_die_ref gen_compile_unit_die (const char *);
5165 static void gen_inheritance_die (tree, tree, dw_die_ref);
5166 static void gen_member_die (tree, dw_die_ref);
5167 static void gen_struct_or_union_type_die (tree, dw_die_ref,
5168 enum debug_info_usage);
5169 static void gen_subroutine_type_die (tree, dw_die_ref);
5170 static void gen_typedef_die (tree, dw_die_ref);
5171 static void gen_type_die (tree, dw_die_ref);
5172 static void gen_block_die (tree, dw_die_ref, int);
5173 static void decls_for_scope (tree, dw_die_ref, int);
5174 static int is_redundant_typedef (const_tree);
5175 static void gen_namespace_die (tree, dw_die_ref);
5176 static void gen_decl_die (tree, tree, dw_die_ref);
5177 static dw_die_ref force_decl_die (tree);
5178 static dw_die_ref force_type_die (tree);
5179 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
5180 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
5181 static struct dwarf_file_data * lookup_filename (const char *);
5182 static void retry_incomplete_types (void);
5183 static void gen_type_die_for_member (tree, tree, dw_die_ref);
5184 static void splice_child_die (dw_die_ref, dw_die_ref);
5185 static int file_info_cmp (const void *, const void *);
5186 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
5187 const char *, const char *, unsigned);
5188 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
5189 const char *, const char *,
5191 static void output_loc_list (dw_loc_list_ref);
5192 static char *gen_internal_sym (const char *);
5194 static void prune_unmark_dies (dw_die_ref);
5195 static void prune_unused_types_mark (dw_die_ref, int);
5196 static void prune_unused_types_walk (dw_die_ref);
5197 static void prune_unused_types_walk_attribs (dw_die_ref);
5198 static void prune_unused_types_prune (dw_die_ref);
5199 static void prune_unused_types (void);
5200 static int maybe_emit_file (struct dwarf_file_data *fd);
5202 /* Section names used to hold DWARF debugging information. */
5203 #ifndef DEBUG_INFO_SECTION
5204 #define DEBUG_INFO_SECTION ".debug_info"
5206 #ifndef DEBUG_ABBREV_SECTION
5207 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
5209 #ifndef DEBUG_ARANGES_SECTION
5210 #define DEBUG_ARANGES_SECTION ".debug_aranges"
5212 #ifndef DEBUG_MACINFO_SECTION
5213 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
5215 #ifndef DEBUG_LINE_SECTION
5216 #define DEBUG_LINE_SECTION ".debug_line"
5218 #ifndef DEBUG_LOC_SECTION
5219 #define DEBUG_LOC_SECTION ".debug_loc"
5221 #ifndef DEBUG_PUBNAMES_SECTION
5222 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
5224 #ifndef DEBUG_STR_SECTION
5225 #define DEBUG_STR_SECTION ".debug_str"
5227 #ifndef DEBUG_RANGES_SECTION
5228 #define DEBUG_RANGES_SECTION ".debug_ranges"
5231 /* Standard ELF section names for compiled code and data. */
5232 #ifndef TEXT_SECTION_NAME
5233 #define TEXT_SECTION_NAME ".text"
5236 /* Section flags for .debug_str section. */
5237 #define DEBUG_STR_SECTION_FLAGS \
5238 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
5239 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
5242 /* Labels we insert at beginning sections we can reference instead of
5243 the section names themselves. */
5245 #ifndef TEXT_SECTION_LABEL
5246 #define TEXT_SECTION_LABEL "Ltext"
5248 #ifndef COLD_TEXT_SECTION_LABEL
5249 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
5251 #ifndef DEBUG_LINE_SECTION_LABEL
5252 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
5254 #ifndef DEBUG_INFO_SECTION_LABEL
5255 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
5257 #ifndef DEBUG_ABBREV_SECTION_LABEL
5258 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
5260 #ifndef DEBUG_LOC_SECTION_LABEL
5261 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
5263 #ifndef DEBUG_RANGES_SECTION_LABEL
5264 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
5266 #ifndef DEBUG_MACINFO_SECTION_LABEL
5267 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
5270 /* Definitions of defaults for formats and names of various special
5271 (artificial) labels which may be generated within this file (when the -g
5272 options is used and DWARF2_DEBUGGING_INFO is in effect.
5273 If necessary, these may be overridden from within the tm.h file, but
5274 typically, overriding these defaults is unnecessary. */
5276 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5277 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5278 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5279 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5280 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5281 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5282 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5283 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5284 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5285 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
5287 #ifndef TEXT_END_LABEL
5288 #define TEXT_END_LABEL "Letext"
5290 #ifndef COLD_END_LABEL
5291 #define COLD_END_LABEL "Letext_cold"
5293 #ifndef BLOCK_BEGIN_LABEL
5294 #define BLOCK_BEGIN_LABEL "LBB"
5296 #ifndef BLOCK_END_LABEL
5297 #define BLOCK_END_LABEL "LBE"
5299 #ifndef LINE_CODE_LABEL
5300 #define LINE_CODE_LABEL "LM"
5302 #ifndef SEPARATE_LINE_CODE_LABEL
5303 #define SEPARATE_LINE_CODE_LABEL "LSM"
5307 /* We allow a language front-end to designate a function that is to be
5308 called to "demangle" any name before it is put into a DIE. */
5310 static const char *(*demangle_name_func) (const char *);
5313 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
5315 demangle_name_func = func;
5318 /* Test if rtl node points to a pseudo register. */
5321 is_pseudo_reg (const_rtx rtl)
5323 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
5324 || (GET_CODE (rtl) == SUBREG
5325 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
5328 /* Return a reference to a type, with its const and volatile qualifiers
5332 type_main_variant (tree type)
5334 type = TYPE_MAIN_VARIANT (type);
5336 /* ??? There really should be only one main variant among any group of
5337 variants of a given type (and all of the MAIN_VARIANT values for all
5338 members of the group should point to that one type) but sometimes the C
5339 front-end messes this up for array types, so we work around that bug
5341 if (TREE_CODE (type) == ARRAY_TYPE)
5342 while (type != TYPE_MAIN_VARIANT (type))
5343 type = TYPE_MAIN_VARIANT (type);
5348 /* Return nonzero if the given type node represents a tagged type. */
5351 is_tagged_type (const_tree type)
5353 enum tree_code code = TREE_CODE (type);
5355 return (code == RECORD_TYPE || code == UNION_TYPE
5356 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
5359 /* Convert a DIE tag into its string name. */
5362 dwarf_tag_name (unsigned int tag)
5366 case DW_TAG_padding:
5367 return "DW_TAG_padding";
5368 case DW_TAG_array_type:
5369 return "DW_TAG_array_type";
5370 case DW_TAG_class_type:
5371 return "DW_TAG_class_type";
5372 case DW_TAG_entry_point:
5373 return "DW_TAG_entry_point";
5374 case DW_TAG_enumeration_type:
5375 return "DW_TAG_enumeration_type";
5376 case DW_TAG_formal_parameter:
5377 return "DW_TAG_formal_parameter";
5378 case DW_TAG_imported_declaration:
5379 return "DW_TAG_imported_declaration";
5381 return "DW_TAG_label";
5382 case DW_TAG_lexical_block:
5383 return "DW_TAG_lexical_block";
5385 return "DW_TAG_member";
5386 case DW_TAG_pointer_type:
5387 return "DW_TAG_pointer_type";
5388 case DW_TAG_reference_type:
5389 return "DW_TAG_reference_type";
5390 case DW_TAG_compile_unit:
5391 return "DW_TAG_compile_unit";
5392 case DW_TAG_string_type:
5393 return "DW_TAG_string_type";
5394 case DW_TAG_structure_type:
5395 return "DW_TAG_structure_type";
5396 case DW_TAG_subroutine_type:
5397 return "DW_TAG_subroutine_type";
5398 case DW_TAG_typedef:
5399 return "DW_TAG_typedef";
5400 case DW_TAG_union_type:
5401 return "DW_TAG_union_type";
5402 case DW_TAG_unspecified_parameters:
5403 return "DW_TAG_unspecified_parameters";
5404 case DW_TAG_variant:
5405 return "DW_TAG_variant";
5406 case DW_TAG_common_block:
5407 return "DW_TAG_common_block";
5408 case DW_TAG_common_inclusion:
5409 return "DW_TAG_common_inclusion";
5410 case DW_TAG_inheritance:
5411 return "DW_TAG_inheritance";
5412 case DW_TAG_inlined_subroutine:
5413 return "DW_TAG_inlined_subroutine";
5415 return "DW_TAG_module";
5416 case DW_TAG_ptr_to_member_type:
5417 return "DW_TAG_ptr_to_member_type";
5418 case DW_TAG_set_type:
5419 return "DW_TAG_set_type";
5420 case DW_TAG_subrange_type:
5421 return "DW_TAG_subrange_type";
5422 case DW_TAG_with_stmt:
5423 return "DW_TAG_with_stmt";
5424 case DW_TAG_access_declaration:
5425 return "DW_TAG_access_declaration";
5426 case DW_TAG_base_type:
5427 return "DW_TAG_base_type";
5428 case DW_TAG_catch_block:
5429 return "DW_TAG_catch_block";
5430 case DW_TAG_const_type:
5431 return "DW_TAG_const_type";
5432 case DW_TAG_constant:
5433 return "DW_TAG_constant";
5434 case DW_TAG_enumerator:
5435 return "DW_TAG_enumerator";
5436 case DW_TAG_file_type:
5437 return "DW_TAG_file_type";
5439 return "DW_TAG_friend";
5440 case DW_TAG_namelist:
5441 return "DW_TAG_namelist";
5442 case DW_TAG_namelist_item:
5443 return "DW_TAG_namelist_item";
5444 case DW_TAG_packed_type:
5445 return "DW_TAG_packed_type";
5446 case DW_TAG_subprogram:
5447 return "DW_TAG_subprogram";
5448 case DW_TAG_template_type_param:
5449 return "DW_TAG_template_type_param";
5450 case DW_TAG_template_value_param:
5451 return "DW_TAG_template_value_param";
5452 case DW_TAG_thrown_type:
5453 return "DW_TAG_thrown_type";
5454 case DW_TAG_try_block:
5455 return "DW_TAG_try_block";
5456 case DW_TAG_variant_part:
5457 return "DW_TAG_variant_part";
5458 case DW_TAG_variable:
5459 return "DW_TAG_variable";
5460 case DW_TAG_volatile_type:
5461 return "DW_TAG_volatile_type";
5462 case DW_TAG_dwarf_procedure:
5463 return "DW_TAG_dwarf_procedure";
5464 case DW_TAG_restrict_type:
5465 return "DW_TAG_restrict_type";
5466 case DW_TAG_interface_type:
5467 return "DW_TAG_interface_type";
5468 case DW_TAG_namespace:
5469 return "DW_TAG_namespace";
5470 case DW_TAG_imported_module:
5471 return "DW_TAG_imported_module";
5472 case DW_TAG_unspecified_type:
5473 return "DW_TAG_unspecified_type";
5474 case DW_TAG_partial_unit:
5475 return "DW_TAG_partial_unit";
5476 case DW_TAG_imported_unit:
5477 return "DW_TAG_imported_unit";
5478 case DW_TAG_condition:
5479 return "DW_TAG_condition";
5480 case DW_TAG_shared_type:
5481 return "DW_TAG_shared_type";
5482 case DW_TAG_MIPS_loop:
5483 return "DW_TAG_MIPS_loop";
5484 case DW_TAG_format_label:
5485 return "DW_TAG_format_label";
5486 case DW_TAG_function_template:
5487 return "DW_TAG_function_template";
5488 case DW_TAG_class_template:
5489 return "DW_TAG_class_template";
5490 case DW_TAG_GNU_BINCL:
5491 return "DW_TAG_GNU_BINCL";
5492 case DW_TAG_GNU_EINCL:
5493 return "DW_TAG_GNU_EINCL";
5495 return "DW_TAG_<unknown>";
5499 /* Convert a DWARF attribute code into its string name. */
5502 dwarf_attr_name (unsigned int attr)
5507 return "DW_AT_sibling";
5508 case DW_AT_location:
5509 return "DW_AT_location";
5511 return "DW_AT_name";
5512 case DW_AT_ordering:
5513 return "DW_AT_ordering";
5514 case DW_AT_subscr_data:
5515 return "DW_AT_subscr_data";
5516 case DW_AT_byte_size:
5517 return "DW_AT_byte_size";
5518 case DW_AT_bit_offset:
5519 return "DW_AT_bit_offset";
5520 case DW_AT_bit_size:
5521 return "DW_AT_bit_size";
5522 case DW_AT_element_list:
5523 return "DW_AT_element_list";
5524 case DW_AT_stmt_list:
5525 return "DW_AT_stmt_list";
5527 return "DW_AT_low_pc";
5529 return "DW_AT_high_pc";
5530 case DW_AT_language:
5531 return "DW_AT_language";
5533 return "DW_AT_member";
5535 return "DW_AT_discr";
5536 case DW_AT_discr_value:
5537 return "DW_AT_discr_value";
5538 case DW_AT_visibility:
5539 return "DW_AT_visibility";
5541 return "DW_AT_import";
5542 case DW_AT_string_length:
5543 return "DW_AT_string_length";
5544 case DW_AT_common_reference:
5545 return "DW_AT_common_reference";
5546 case DW_AT_comp_dir:
5547 return "DW_AT_comp_dir";
5548 case DW_AT_const_value:
5549 return "DW_AT_const_value";
5550 case DW_AT_containing_type:
5551 return "DW_AT_containing_type";
5552 case DW_AT_default_value:
5553 return "DW_AT_default_value";
5555 return "DW_AT_inline";
5556 case DW_AT_is_optional:
5557 return "DW_AT_is_optional";
5558 case DW_AT_lower_bound:
5559 return "DW_AT_lower_bound";
5560 case DW_AT_producer:
5561 return "DW_AT_producer";
5562 case DW_AT_prototyped:
5563 return "DW_AT_prototyped";
5564 case DW_AT_return_addr:
5565 return "DW_AT_return_addr";
5566 case DW_AT_start_scope:
5567 return "DW_AT_start_scope";
5568 case DW_AT_bit_stride:
5569 return "DW_AT_bit_stride";
5570 case DW_AT_upper_bound:
5571 return "DW_AT_upper_bound";
5572 case DW_AT_abstract_origin:
5573 return "DW_AT_abstract_origin";
5574 case DW_AT_accessibility:
5575 return "DW_AT_accessibility";
5576 case DW_AT_address_class:
5577 return "DW_AT_address_class";
5578 case DW_AT_artificial:
5579 return "DW_AT_artificial";
5580 case DW_AT_base_types:
5581 return "DW_AT_base_types";
5582 case DW_AT_calling_convention:
5583 return "DW_AT_calling_convention";
5585 return "DW_AT_count";
5586 case DW_AT_data_member_location:
5587 return "DW_AT_data_member_location";
5588 case DW_AT_decl_column:
5589 return "DW_AT_decl_column";
5590 case DW_AT_decl_file:
5591 return "DW_AT_decl_file";
5592 case DW_AT_decl_line:
5593 return "DW_AT_decl_line";
5594 case DW_AT_declaration:
5595 return "DW_AT_declaration";
5596 case DW_AT_discr_list:
5597 return "DW_AT_discr_list";
5598 case DW_AT_encoding:
5599 return "DW_AT_encoding";
5600 case DW_AT_external:
5601 return "DW_AT_external";
5602 case DW_AT_explicit:
5603 return "DW_AT_explicit";
5604 case DW_AT_frame_base:
5605 return "DW_AT_frame_base";
5607 return "DW_AT_friend";
5608 case DW_AT_identifier_case:
5609 return "DW_AT_identifier_case";
5610 case DW_AT_macro_info:
5611 return "DW_AT_macro_info";
5612 case DW_AT_namelist_items:
5613 return "DW_AT_namelist_items";
5614 case DW_AT_priority:
5615 return "DW_AT_priority";
5617 return "DW_AT_segment";
5618 case DW_AT_specification:
5619 return "DW_AT_specification";
5620 case DW_AT_static_link:
5621 return "DW_AT_static_link";
5623 return "DW_AT_type";
5624 case DW_AT_use_location:
5625 return "DW_AT_use_location";
5626 case DW_AT_variable_parameter:
5627 return "DW_AT_variable_parameter";
5628 case DW_AT_virtuality:
5629 return "DW_AT_virtuality";
5630 case DW_AT_vtable_elem_location:
5631 return "DW_AT_vtable_elem_location";
5633 case DW_AT_allocated:
5634 return "DW_AT_allocated";
5635 case DW_AT_associated:
5636 return "DW_AT_associated";
5637 case DW_AT_data_location:
5638 return "DW_AT_data_location";
5639 case DW_AT_byte_stride:
5640 return "DW_AT_byte_stride";
5641 case DW_AT_entry_pc:
5642 return "DW_AT_entry_pc";
5643 case DW_AT_use_UTF8:
5644 return "DW_AT_use_UTF8";
5645 case DW_AT_extension:
5646 return "DW_AT_extension";
5648 return "DW_AT_ranges";
5649 case DW_AT_trampoline:
5650 return "DW_AT_trampoline";
5651 case DW_AT_call_column:
5652 return "DW_AT_call_column";
5653 case DW_AT_call_file:
5654 return "DW_AT_call_file";
5655 case DW_AT_call_line:
5656 return "DW_AT_call_line";
5658 case DW_AT_MIPS_fde:
5659 return "DW_AT_MIPS_fde";
5660 case DW_AT_MIPS_loop_begin:
5661 return "DW_AT_MIPS_loop_begin";
5662 case DW_AT_MIPS_tail_loop_begin:
5663 return "DW_AT_MIPS_tail_loop_begin";
5664 case DW_AT_MIPS_epilog_begin:
5665 return "DW_AT_MIPS_epilog_begin";
5666 case DW_AT_MIPS_loop_unroll_factor:
5667 return "DW_AT_MIPS_loop_unroll_factor";
5668 case DW_AT_MIPS_software_pipeline_depth:
5669 return "DW_AT_MIPS_software_pipeline_depth";
5670 case DW_AT_MIPS_linkage_name:
5671 return "DW_AT_MIPS_linkage_name";
5672 case DW_AT_MIPS_stride:
5673 return "DW_AT_MIPS_stride";
5674 case DW_AT_MIPS_abstract_name:
5675 return "DW_AT_MIPS_abstract_name";
5676 case DW_AT_MIPS_clone_origin:
5677 return "DW_AT_MIPS_clone_origin";
5678 case DW_AT_MIPS_has_inlines:
5679 return "DW_AT_MIPS_has_inlines";
5681 case DW_AT_sf_names:
5682 return "DW_AT_sf_names";
5683 case DW_AT_src_info:
5684 return "DW_AT_src_info";
5685 case DW_AT_mac_info:
5686 return "DW_AT_mac_info";
5687 case DW_AT_src_coords:
5688 return "DW_AT_src_coords";
5689 case DW_AT_body_begin:
5690 return "DW_AT_body_begin";
5691 case DW_AT_body_end:
5692 return "DW_AT_body_end";
5693 case DW_AT_GNU_vector:
5694 return "DW_AT_GNU_vector";
5696 case DW_AT_VMS_rtnbeg_pd_address:
5697 return "DW_AT_VMS_rtnbeg_pd_address";
5700 return "DW_AT_<unknown>";
5704 /* Convert a DWARF value form code into its string name. */
5707 dwarf_form_name (unsigned int form)
5712 return "DW_FORM_addr";
5713 case DW_FORM_block2:
5714 return "DW_FORM_block2";
5715 case DW_FORM_block4:
5716 return "DW_FORM_block4";
5718 return "DW_FORM_data2";
5720 return "DW_FORM_data4";
5722 return "DW_FORM_data8";
5723 case DW_FORM_string:
5724 return "DW_FORM_string";
5726 return "DW_FORM_block";
5727 case DW_FORM_block1:
5728 return "DW_FORM_block1";
5730 return "DW_FORM_data1";
5732 return "DW_FORM_flag";
5734 return "DW_FORM_sdata";
5736 return "DW_FORM_strp";
5738 return "DW_FORM_udata";
5739 case DW_FORM_ref_addr:
5740 return "DW_FORM_ref_addr";
5742 return "DW_FORM_ref1";
5744 return "DW_FORM_ref2";
5746 return "DW_FORM_ref4";
5748 return "DW_FORM_ref8";
5749 case DW_FORM_ref_udata:
5750 return "DW_FORM_ref_udata";
5751 case DW_FORM_indirect:
5752 return "DW_FORM_indirect";
5754 return "DW_FORM_<unknown>";
5758 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
5759 instance of an inlined instance of a decl which is local to an inline
5760 function, so we have to trace all of the way back through the origin chain
5761 to find out what sort of node actually served as the original seed for the
5765 decl_ultimate_origin (const_tree decl)
5767 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
5770 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
5771 nodes in the function to point to themselves; ignore that if
5772 we're trying to output the abstract instance of this function. */
5773 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
5776 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
5777 most distant ancestor, this should never happen. */
5778 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
5780 return DECL_ABSTRACT_ORIGIN (decl);
5783 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
5784 of a virtual function may refer to a base class, so we check the 'this'
5788 decl_class_context (tree decl)
5790 tree context = NULL_TREE;
5792 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
5793 context = DECL_CONTEXT (decl);
5795 context = TYPE_MAIN_VARIANT
5796 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
5798 if (context && !TYPE_P (context))
5799 context = NULL_TREE;
5804 /* Add an attribute/value pair to a DIE. */
5807 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
5809 /* Maybe this should be an assert? */
5813 if (die->die_attr == NULL)
5814 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
5815 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
5818 static inline enum dw_val_class
5819 AT_class (dw_attr_ref a)
5821 return a->dw_attr_val.val_class;
5824 /* Add a flag value attribute to a DIE. */
5827 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
5831 attr.dw_attr = attr_kind;
5832 attr.dw_attr_val.val_class = dw_val_class_flag;
5833 attr.dw_attr_val.v.val_flag = flag;
5834 add_dwarf_attr (die, &attr);
5837 static inline unsigned
5838 AT_flag (dw_attr_ref a)
5840 gcc_assert (a && AT_class (a) == dw_val_class_flag);
5841 return a->dw_attr_val.v.val_flag;
5844 /* Add a signed integer attribute value to a DIE. */
5847 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
5851 attr.dw_attr = attr_kind;
5852 attr.dw_attr_val.val_class = dw_val_class_const;
5853 attr.dw_attr_val.v.val_int = int_val;
5854 add_dwarf_attr (die, &attr);
5857 static inline HOST_WIDE_INT
5858 AT_int (dw_attr_ref a)
5860 gcc_assert (a && AT_class (a) == dw_val_class_const);
5861 return a->dw_attr_val.v.val_int;
5864 /* Add an unsigned integer attribute value to a DIE. */
5867 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
5868 unsigned HOST_WIDE_INT unsigned_val)
5872 attr.dw_attr = attr_kind;
5873 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
5874 attr.dw_attr_val.v.val_unsigned = unsigned_val;
5875 add_dwarf_attr (die, &attr);
5878 static inline unsigned HOST_WIDE_INT
5879 AT_unsigned (dw_attr_ref a)
5881 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
5882 return a->dw_attr_val.v.val_unsigned;
5885 /* Add an unsigned double integer attribute value to a DIE. */
5888 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
5889 long unsigned int val_hi, long unsigned int val_low)
5893 attr.dw_attr = attr_kind;
5894 attr.dw_attr_val.val_class = dw_val_class_long_long;
5895 attr.dw_attr_val.v.val_long_long.hi = val_hi;
5896 attr.dw_attr_val.v.val_long_long.low = val_low;
5897 add_dwarf_attr (die, &attr);
5900 /* Add a floating point attribute value to a DIE and return it. */
5903 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
5904 unsigned int length, unsigned int elt_size, unsigned char *array)
5908 attr.dw_attr = attr_kind;
5909 attr.dw_attr_val.val_class = dw_val_class_vec;
5910 attr.dw_attr_val.v.val_vec.length = length;
5911 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
5912 attr.dw_attr_val.v.val_vec.array = array;
5913 add_dwarf_attr (die, &attr);
5916 /* Hash and equality functions for debug_str_hash. */
5919 debug_str_do_hash (const void *x)
5921 return htab_hash_string (((const struct indirect_string_node *)x)->str);
5925 debug_str_eq (const void *x1, const void *x2)
5927 return strcmp ((((const struct indirect_string_node *)x1)->str),
5928 (const char *)x2) == 0;
5931 /* Add a string attribute value to a DIE. */
5934 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5937 struct indirect_string_node *node;
5940 if (! debug_str_hash)
5941 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5942 debug_str_eq, NULL);
5944 slot = htab_find_slot_with_hash (debug_str_hash, str,
5945 htab_hash_string (str), INSERT);
5948 node = (struct indirect_string_node *)
5949 ggc_alloc_cleared (sizeof (struct indirect_string_node));
5950 node->str = ggc_strdup (str);
5954 node = (struct indirect_string_node *) *slot;
5958 attr.dw_attr = attr_kind;
5959 attr.dw_attr_val.val_class = dw_val_class_str;
5960 attr.dw_attr_val.v.val_str = node;
5961 add_dwarf_attr (die, &attr);
5964 static inline const char *
5965 AT_string (dw_attr_ref a)
5967 gcc_assert (a && AT_class (a) == dw_val_class_str);
5968 return a->dw_attr_val.v.val_str->str;
5971 /* Find out whether a string should be output inline in DIE
5972 or out-of-line in .debug_str section. */
5975 AT_string_form (dw_attr_ref a)
5977 struct indirect_string_node *node;
5981 gcc_assert (a && AT_class (a) == dw_val_class_str);
5983 node = a->dw_attr_val.v.val_str;
5987 len = strlen (node->str) + 1;
5989 /* If the string is shorter or equal to the size of the reference, it is
5990 always better to put it inline. */
5991 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5992 return node->form = DW_FORM_string;
5994 /* If we cannot expect the linker to merge strings in .debug_str
5995 section, only put it into .debug_str if it is worth even in this
5997 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5998 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5999 return node->form = DW_FORM_string;
6001 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
6002 ++dw2_string_counter;
6003 node->label = xstrdup (label);
6005 return node->form = DW_FORM_strp;
6008 /* Add a DIE reference attribute value to a DIE. */
6011 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
6015 attr.dw_attr = attr_kind;
6016 attr.dw_attr_val.val_class = dw_val_class_die_ref;
6017 attr.dw_attr_val.v.val_die_ref.die = targ_die;
6018 attr.dw_attr_val.v.val_die_ref.external = 0;
6019 add_dwarf_attr (die, &attr);
6022 /* Add an AT_specification attribute to a DIE, and also make the back
6023 pointer from the specification to the definition. */
6026 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
6028 add_AT_die_ref (die, DW_AT_specification, targ_die);
6029 gcc_assert (!targ_die->die_definition);
6030 targ_die->die_definition = die;
6033 static inline dw_die_ref
6034 AT_ref (dw_attr_ref a)
6036 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6037 return a->dw_attr_val.v.val_die_ref.die;
6041 AT_ref_external (dw_attr_ref a)
6043 if (a && AT_class (a) == dw_val_class_die_ref)
6044 return a->dw_attr_val.v.val_die_ref.external;
6050 set_AT_ref_external (dw_attr_ref a, int i)
6052 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6053 a->dw_attr_val.v.val_die_ref.external = i;
6056 /* Add an FDE reference attribute value to a DIE. */
6059 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
6063 attr.dw_attr = attr_kind;
6064 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
6065 attr.dw_attr_val.v.val_fde_index = targ_fde;
6066 add_dwarf_attr (die, &attr);
6069 /* Add a location description attribute value to a DIE. */
6072 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
6076 attr.dw_attr = attr_kind;
6077 attr.dw_attr_val.val_class = dw_val_class_loc;
6078 attr.dw_attr_val.v.val_loc = loc;
6079 add_dwarf_attr (die, &attr);
6082 static inline dw_loc_descr_ref
6083 AT_loc (dw_attr_ref a)
6085 gcc_assert (a && AT_class (a) == dw_val_class_loc);
6086 return a->dw_attr_val.v.val_loc;
6090 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
6094 attr.dw_attr = attr_kind;
6095 attr.dw_attr_val.val_class = dw_val_class_loc_list;
6096 attr.dw_attr_val.v.val_loc_list = loc_list;
6097 add_dwarf_attr (die, &attr);
6098 have_location_lists = true;
6101 static inline dw_loc_list_ref
6102 AT_loc_list (dw_attr_ref a)
6104 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
6105 return a->dw_attr_val.v.val_loc_list;
6108 /* Add an address constant attribute value to a DIE. */
6111 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
6115 attr.dw_attr = attr_kind;
6116 attr.dw_attr_val.val_class = dw_val_class_addr;
6117 attr.dw_attr_val.v.val_addr = addr;
6118 add_dwarf_attr (die, &attr);
6121 /* Get the RTX from to an address DIE attribute. */
6124 AT_addr (dw_attr_ref a)
6126 gcc_assert (a && AT_class (a) == dw_val_class_addr);
6127 return a->dw_attr_val.v.val_addr;
6130 /* Add a file attribute value to a DIE. */
6133 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
6134 struct dwarf_file_data *fd)
6138 attr.dw_attr = attr_kind;
6139 attr.dw_attr_val.val_class = dw_val_class_file;
6140 attr.dw_attr_val.v.val_file = fd;
6141 add_dwarf_attr (die, &attr);
6144 /* Get the dwarf_file_data from a file DIE attribute. */
6146 static inline struct dwarf_file_data *
6147 AT_file (dw_attr_ref a)
6149 gcc_assert (a && AT_class (a) == dw_val_class_file);
6150 return a->dw_attr_val.v.val_file;
6153 /* Add a label identifier attribute value to a DIE. */
6156 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
6160 attr.dw_attr = attr_kind;
6161 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
6162 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
6163 add_dwarf_attr (die, &attr);
6166 /* Add a section offset attribute value to a DIE, an offset into the
6167 debug_line section. */
6170 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6175 attr.dw_attr = attr_kind;
6176 attr.dw_attr_val.val_class = dw_val_class_lineptr;
6177 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6178 add_dwarf_attr (die, &attr);
6181 /* Add a section offset attribute value to a DIE, an offset into the
6182 debug_macinfo section. */
6185 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6190 attr.dw_attr = attr_kind;
6191 attr.dw_attr_val.val_class = dw_val_class_macptr;
6192 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6193 add_dwarf_attr (die, &attr);
6196 /* Add an offset attribute value to a DIE. */
6199 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
6200 unsigned HOST_WIDE_INT offset)
6204 attr.dw_attr = attr_kind;
6205 attr.dw_attr_val.val_class = dw_val_class_offset;
6206 attr.dw_attr_val.v.val_offset = offset;
6207 add_dwarf_attr (die, &attr);
6210 /* Add an range_list attribute value to a DIE. */
6213 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
6214 long unsigned int offset)
6218 attr.dw_attr = attr_kind;
6219 attr.dw_attr_val.val_class = dw_val_class_range_list;
6220 attr.dw_attr_val.v.val_offset = offset;
6221 add_dwarf_attr (die, &attr);
6224 static inline const char *
6225 AT_lbl (dw_attr_ref a)
6227 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
6228 || AT_class (a) == dw_val_class_lineptr
6229 || AT_class (a) == dw_val_class_macptr));
6230 return a->dw_attr_val.v.val_lbl_id;
6233 /* Get the attribute of type attr_kind. */
6236 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6240 dw_die_ref spec = NULL;
6245 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6246 if (a->dw_attr == attr_kind)
6248 else if (a->dw_attr == DW_AT_specification
6249 || a->dw_attr == DW_AT_abstract_origin)
6253 return get_AT (spec, attr_kind);
6258 /* Return the "low pc" attribute value, typically associated with a subprogram
6259 DIE. Return null if the "low pc" attribute is either not present, or if it
6260 cannot be represented as an assembler label identifier. */
6262 static inline const char *
6263 get_AT_low_pc (dw_die_ref die)
6265 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
6267 return a ? AT_lbl (a) : NULL;
6270 /* Return the "high pc" attribute value, typically associated with a subprogram
6271 DIE. Return null if the "high pc" attribute is either not present, or if it
6272 cannot be represented as an assembler label identifier. */
6274 static inline const char *
6275 get_AT_hi_pc (dw_die_ref die)
6277 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
6279 return a ? AT_lbl (a) : NULL;
6282 /* Return the value of the string attribute designated by ATTR_KIND, or
6283 NULL if it is not present. */
6285 static inline const char *
6286 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
6288 dw_attr_ref a = get_AT (die, attr_kind);
6290 return a ? AT_string (a) : NULL;
6293 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
6294 if it is not present. */
6297 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
6299 dw_attr_ref a = get_AT (die, attr_kind);
6301 return a ? AT_flag (a) : 0;
6304 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
6305 if it is not present. */
6307 static inline unsigned
6308 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
6310 dw_attr_ref a = get_AT (die, attr_kind);
6312 return a ? AT_unsigned (a) : 0;
6315 static inline dw_die_ref
6316 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
6318 dw_attr_ref a = get_AT (die, attr_kind);
6320 return a ? AT_ref (a) : NULL;
6323 static inline struct dwarf_file_data *
6324 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
6326 dw_attr_ref a = get_AT (die, attr_kind);
6328 return a ? AT_file (a) : NULL;
6331 /* Return TRUE if the language is C or C++. */
6336 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6338 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
6339 || lang == DW_LANG_C99
6340 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
6343 /* Return TRUE if the language is C++. */
6348 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6350 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
6353 /* Return TRUE if the language is Fortran. */
6358 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6360 return (lang == DW_LANG_Fortran77
6361 || lang == DW_LANG_Fortran90
6362 || lang == DW_LANG_Fortran95);
6365 /* Return TRUE if the language is Java. */
6370 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6372 return lang == DW_LANG_Java;
6375 /* Return TRUE if the language is Ada. */
6380 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6382 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
6385 /* Remove the specified attribute if present. */
6388 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6396 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6397 if (a->dw_attr == attr_kind)
6399 if (AT_class (a) == dw_val_class_str)
6400 if (a->dw_attr_val.v.val_str->refcount)
6401 a->dw_attr_val.v.val_str->refcount--;
6403 /* VEC_ordered_remove should help reduce the number of abbrevs
6405 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
6410 /* Remove CHILD from its parent. PREV must have the property that
6411 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
6414 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
6416 gcc_assert (child->die_parent == prev->die_parent);
6417 gcc_assert (prev->die_sib == child);
6420 gcc_assert (child->die_parent->die_child == child);
6424 prev->die_sib = child->die_sib;
6425 if (child->die_parent->die_child == child)
6426 child->die_parent->die_child = prev;
6429 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
6433 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
6439 dw_die_ref prev = c;
6441 while (c->die_tag == tag)
6443 remove_child_with_prev (c, prev);
6444 /* Might have removed every child. */
6445 if (c == c->die_sib)
6449 } while (c != die->die_child);
6452 /* Add a CHILD_DIE as the last child of DIE. */
6455 add_child_die (dw_die_ref die, dw_die_ref child_die)
6457 /* FIXME this should probably be an assert. */
6458 if (! die || ! child_die)
6460 gcc_assert (die != child_die);
6462 child_die->die_parent = die;
6465 child_die->die_sib = die->die_child->die_sib;
6466 die->die_child->die_sib = child_die;
6469 child_die->die_sib = child_die;
6470 die->die_child = child_die;
6473 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
6474 is the specification, to the end of PARENT's list of children.
6475 This is done by removing and re-adding it. */
6478 splice_child_die (dw_die_ref parent, dw_die_ref child)
6482 /* We want the declaration DIE from inside the class, not the
6483 specification DIE at toplevel. */
6484 if (child->die_parent != parent)
6486 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
6492 gcc_assert (child->die_parent == parent
6493 || (child->die_parent
6494 == get_AT_ref (parent, DW_AT_specification)));
6496 for (p = child->die_parent->die_child; ; p = p->die_sib)
6497 if (p->die_sib == child)
6499 remove_child_with_prev (child, p);
6503 add_child_die (parent, child);
6506 /* Return a pointer to a newly created DIE node. */
6508 static inline dw_die_ref
6509 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
6511 dw_die_ref die = GGC_CNEW (die_node);
6513 die->die_tag = tag_value;
6515 if (parent_die != NULL)
6516 add_child_die (parent_die, die);
6519 limbo_die_node *limbo_node;
6521 limbo_node = GGC_CNEW (limbo_die_node);
6522 limbo_node->die = die;
6523 limbo_node->created_for = t;
6524 limbo_node->next = limbo_die_list;
6525 limbo_die_list = limbo_node;
6531 /* Return the DIE associated with the given type specifier. */
6533 static inline dw_die_ref
6534 lookup_type_die (tree type)
6536 return TYPE_SYMTAB_DIE (type);
6539 /* Equate a DIE to a given type specifier. */
6542 equate_type_number_to_die (tree type, dw_die_ref type_die)
6544 TYPE_SYMTAB_DIE (type) = type_die;
6547 /* Returns a hash value for X (which really is a die_struct). */
6550 decl_die_table_hash (const void *x)
6552 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
6555 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
6558 decl_die_table_eq (const void *x, const void *y)
6560 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
6563 /* Return the DIE associated with a given declaration. */
6565 static inline dw_die_ref
6566 lookup_decl_die (tree decl)
6568 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
6571 /* Returns a hash value for X (which really is a var_loc_list). */
6574 decl_loc_table_hash (const void *x)
6576 return (hashval_t) ((const var_loc_list *) x)->decl_id;
6579 /* Return nonzero if decl_id of var_loc_list X is the same as
6583 decl_loc_table_eq (const void *x, const void *y)
6585 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
6588 /* Return the var_loc list associated with a given declaration. */
6590 static inline var_loc_list *
6591 lookup_decl_loc (const_tree decl)
6593 return (var_loc_list *)
6594 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
6597 /* Equate a DIE to a particular declaration. */
6600 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
6602 unsigned int decl_id = DECL_UID (decl);
6605 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
6607 decl_die->decl_id = decl_id;
6610 /* Add a variable location node to the linked list for DECL. */
6613 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
6615 unsigned int decl_id = DECL_UID (decl);
6619 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
6622 temp = GGC_CNEW (var_loc_list);
6623 temp->decl_id = decl_id;
6627 temp = (var_loc_list *) *slot;
6631 /* If the current location is the same as the end of the list,
6632 and either both or neither of the locations is uninitialized,
6633 we have nothing to do. */
6634 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
6635 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
6636 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6637 != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
6638 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6639 == VAR_INIT_STATUS_UNINITIALIZED)
6640 || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
6641 == VAR_INIT_STATUS_UNINITIALIZED))))
6643 /* Add LOC to the end of list and update LAST. */
6644 temp->last->next = loc;
6648 /* Do not add empty location to the beginning of the list. */
6649 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
6656 /* Keep track of the number of spaces used to indent the
6657 output of the debugging routines that print the structure of
6658 the DIE internal representation. */
6659 static int print_indent;
6661 /* Indent the line the number of spaces given by print_indent. */
6664 print_spaces (FILE *outfile)
6666 fprintf (outfile, "%*s", print_indent, "");
6669 /* Print the information associated with a given DIE, and its children.
6670 This routine is a debugging aid only. */
6673 print_die (dw_die_ref die, FILE *outfile)
6679 print_spaces (outfile);
6680 fprintf (outfile, "DIE %4ld: %s\n",
6681 die->die_offset, dwarf_tag_name (die->die_tag));
6682 print_spaces (outfile);
6683 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
6684 fprintf (outfile, " offset: %ld\n", die->die_offset);
6686 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6688 print_spaces (outfile);
6689 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
6691 switch (AT_class (a))
6693 case dw_val_class_addr:
6694 fprintf (outfile, "address");
6696 case dw_val_class_offset:
6697 fprintf (outfile, "offset");
6699 case dw_val_class_loc:
6700 fprintf (outfile, "location descriptor");
6702 case dw_val_class_loc_list:
6703 fprintf (outfile, "location list -> label:%s",
6704 AT_loc_list (a)->ll_symbol);
6706 case dw_val_class_range_list:
6707 fprintf (outfile, "range list");
6709 case dw_val_class_const:
6710 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
6712 case dw_val_class_unsigned_const:
6713 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
6715 case dw_val_class_long_long:
6716 fprintf (outfile, "constant (%lu,%lu)",
6717 a->dw_attr_val.v.val_long_long.hi,
6718 a->dw_attr_val.v.val_long_long.low);
6720 case dw_val_class_vec:
6721 fprintf (outfile, "floating-point or vector constant");
6723 case dw_val_class_flag:
6724 fprintf (outfile, "%u", AT_flag (a));
6726 case dw_val_class_die_ref:
6727 if (AT_ref (a) != NULL)
6729 if (AT_ref (a)->die_symbol)
6730 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
6732 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
6735 fprintf (outfile, "die -> <null>");
6737 case dw_val_class_lbl_id:
6738 case dw_val_class_lineptr:
6739 case dw_val_class_macptr:
6740 fprintf (outfile, "label: %s", AT_lbl (a));
6742 case dw_val_class_str:
6743 if (AT_string (a) != NULL)
6744 fprintf (outfile, "\"%s\"", AT_string (a));
6746 fprintf (outfile, "<null>");
6748 case dw_val_class_file:
6749 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
6750 AT_file (a)->emitted_number);
6756 fprintf (outfile, "\n");
6759 if (die->die_child != NULL)
6762 FOR_EACH_CHILD (die, c, print_die (c, outfile));
6765 if (print_indent == 0)
6766 fprintf (outfile, "\n");
6769 /* Print the contents of the source code line number correspondence table.
6770 This routine is a debugging aid only. */
6773 print_dwarf_line_table (FILE *outfile)
6776 dw_line_info_ref line_info;
6778 fprintf (outfile, "\n\nDWARF source line information\n");
6779 for (i = 1; i < line_info_table_in_use; i++)
6781 line_info = &line_info_table[i];
6782 fprintf (outfile, "%5d: %4ld %6ld\n", i,
6783 line_info->dw_file_num,
6784 line_info->dw_line_num);
6787 fprintf (outfile, "\n\n");
6790 /* Print the information collected for a given DIE. */
6793 debug_dwarf_die (dw_die_ref die)
6795 print_die (die, stderr);
6798 /* Print all DWARF information collected for the compilation unit.
6799 This routine is a debugging aid only. */
6805 print_die (comp_unit_die, stderr);
6806 if (! DWARF2_ASM_LINE_DEBUG_INFO)
6807 print_dwarf_line_table (stderr);
6810 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
6811 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
6812 DIE that marks the start of the DIEs for this include file. */
6815 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
6817 const char *filename = get_AT_string (bincl_die, DW_AT_name);
6818 dw_die_ref new_unit = gen_compile_unit_die (filename);
6820 new_unit->die_sib = old_unit;
6824 /* Close an include-file CU and reopen the enclosing one. */
6827 pop_compile_unit (dw_die_ref old_unit)
6829 dw_die_ref new_unit = old_unit->die_sib;
6831 old_unit->die_sib = NULL;
6835 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6836 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6838 /* Calculate the checksum of a location expression. */
6841 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
6843 CHECKSUM (loc->dw_loc_opc);
6844 CHECKSUM (loc->dw_loc_oprnd1);
6845 CHECKSUM (loc->dw_loc_oprnd2);
6848 /* Calculate the checksum of an attribute. */
6851 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
6853 dw_loc_descr_ref loc;
6856 CHECKSUM (at->dw_attr);
6858 /* We don't care that this was compiled with a different compiler
6859 snapshot; if the output is the same, that's what matters. */
6860 if (at->dw_attr == DW_AT_producer)
6863 switch (AT_class (at))
6865 case dw_val_class_const:
6866 CHECKSUM (at->dw_attr_val.v.val_int);
6868 case dw_val_class_unsigned_const:
6869 CHECKSUM (at->dw_attr_val.v.val_unsigned);
6871 case dw_val_class_long_long:
6872 CHECKSUM (at->dw_attr_val.v.val_long_long);
6874 case dw_val_class_vec:
6875 CHECKSUM (at->dw_attr_val.v.val_vec);
6877 case dw_val_class_flag:
6878 CHECKSUM (at->dw_attr_val.v.val_flag);
6880 case dw_val_class_str:
6881 CHECKSUM_STRING (AT_string (at));
6884 case dw_val_class_addr:
6886 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6887 CHECKSUM_STRING (XSTR (r, 0));
6890 case dw_val_class_offset:
6891 CHECKSUM (at->dw_attr_val.v.val_offset);
6894 case dw_val_class_loc:
6895 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6896 loc_checksum (loc, ctx);
6899 case dw_val_class_die_ref:
6900 die_checksum (AT_ref (at), ctx, mark);
6903 case dw_val_class_fde_ref:
6904 case dw_val_class_lbl_id:
6905 case dw_val_class_lineptr:
6906 case dw_val_class_macptr:
6909 case dw_val_class_file:
6910 CHECKSUM_STRING (AT_file (at)->filename);
6918 /* Calculate the checksum of a DIE. */
6921 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6927 /* To avoid infinite recursion. */
6930 CHECKSUM (die->die_mark);
6933 die->die_mark = ++(*mark);
6935 CHECKSUM (die->die_tag);
6937 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6938 attr_checksum (a, ctx, mark);
6940 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6944 #undef CHECKSUM_STRING
6946 /* Do the location expressions look same? */
6948 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6950 return loc1->dw_loc_opc == loc2->dw_loc_opc
6951 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6952 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6955 /* Do the values look the same? */
6957 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6959 dw_loc_descr_ref loc1, loc2;
6962 if (v1->val_class != v2->val_class)
6965 switch (v1->val_class)
6967 case dw_val_class_const:
6968 return v1->v.val_int == v2->v.val_int;
6969 case dw_val_class_unsigned_const:
6970 return v1->v.val_unsigned == v2->v.val_unsigned;
6971 case dw_val_class_long_long:
6972 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6973 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6974 case dw_val_class_vec:
6975 if (v1->v.val_vec.length != v2->v.val_vec.length
6976 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6978 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6979 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6982 case dw_val_class_flag:
6983 return v1->v.val_flag == v2->v.val_flag;
6984 case dw_val_class_str:
6985 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6987 case dw_val_class_addr:
6988 r1 = v1->v.val_addr;
6989 r2 = v2->v.val_addr;
6990 if (GET_CODE (r1) != GET_CODE (r2))
6992 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6993 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6995 case dw_val_class_offset:
6996 return v1->v.val_offset == v2->v.val_offset;
6998 case dw_val_class_loc:
6999 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
7001 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7002 if (!same_loc_p (loc1, loc2, mark))
7004 return !loc1 && !loc2;
7006 case dw_val_class_die_ref:
7007 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7009 case dw_val_class_fde_ref:
7010 case dw_val_class_lbl_id:
7011 case dw_val_class_lineptr:
7012 case dw_val_class_macptr:
7015 case dw_val_class_file:
7016 return v1->v.val_file == v2->v.val_file;
7023 /* Do the attributes look the same? */
7026 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
7028 if (at1->dw_attr != at2->dw_attr)
7031 /* We don't care that this was compiled with a different compiler
7032 snapshot; if the output is the same, that's what matters. */
7033 if (at1->dw_attr == DW_AT_producer)
7036 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7039 /* Do the dies look the same? */
7042 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7048 /* To avoid infinite recursion. */
7050 return die1->die_mark == die2->die_mark;
7051 die1->die_mark = die2->die_mark = ++(*mark);
7053 if (die1->die_tag != die2->die_tag)
7056 if (VEC_length (dw_attr_node, die1->die_attr)
7057 != VEC_length (dw_attr_node, die2->die_attr))
7060 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
7061 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
7064 c1 = die1->die_child;
7065 c2 = die2->die_child;
7074 if (!same_die_p (c1, c2, mark))
7078 if (c1 == die1->die_child)
7080 if (c2 == die2->die_child)
7090 /* Do the dies look the same? Wrapper around same_die_p. */
7093 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
7096 int ret = same_die_p (die1, die2, &mark);
7098 unmark_all_dies (die1);
7099 unmark_all_dies (die2);
7104 /* The prefix to attach to symbols on DIEs in the current comdat debug
7106 static char *comdat_symbol_id;
7108 /* The index of the current symbol within the current comdat CU. */
7109 static unsigned int comdat_symbol_number;
7111 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7112 children, and set comdat_symbol_id accordingly. */
7115 compute_section_prefix (dw_die_ref unit_die)
7117 const char *die_name = get_AT_string (unit_die, DW_AT_name);
7118 const char *base = die_name ? lbasename (die_name) : "anonymous";
7119 char *name = XALLOCAVEC (char, strlen (base) + 64);
7122 unsigned char checksum[16];
7125 /* Compute the checksum of the DIE, then append part of it as hex digits to
7126 the name filename of the unit. */
7128 md5_init_ctx (&ctx);
7130 die_checksum (unit_die, &ctx, &mark);
7131 unmark_all_dies (unit_die);
7132 md5_finish_ctx (&ctx, checksum);
7134 sprintf (name, "%s.", base);
7135 clean_symbol_name (name);
7137 p = name + strlen (name);
7138 for (i = 0; i < 4; i++)
7140 sprintf (p, "%.2x", checksum[i]);
7144 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
7145 comdat_symbol_number = 0;
7148 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7151 is_type_die (dw_die_ref die)
7153 switch (die->die_tag)
7155 case DW_TAG_array_type:
7156 case DW_TAG_class_type:
7157 case DW_TAG_interface_type:
7158 case DW_TAG_enumeration_type:
7159 case DW_TAG_pointer_type:
7160 case DW_TAG_reference_type:
7161 case DW_TAG_string_type:
7162 case DW_TAG_structure_type:
7163 case DW_TAG_subroutine_type:
7164 case DW_TAG_union_type:
7165 case DW_TAG_ptr_to_member_type:
7166 case DW_TAG_set_type:
7167 case DW_TAG_subrange_type:
7168 case DW_TAG_base_type:
7169 case DW_TAG_const_type:
7170 case DW_TAG_file_type:
7171 case DW_TAG_packed_type:
7172 case DW_TAG_volatile_type:
7173 case DW_TAG_typedef:
7180 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7181 Basically, we want to choose the bits that are likely to be shared between
7182 compilations (types) and leave out the bits that are specific to individual
7183 compilations (functions). */
7186 is_comdat_die (dw_die_ref c)
7188 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7189 we do for stabs. The advantage is a greater likelihood of sharing between
7190 objects that don't include headers in the same order (and therefore would
7191 put the base types in a different comdat). jason 8/28/00 */
7193 if (c->die_tag == DW_TAG_base_type)
7196 if (c->die_tag == DW_TAG_pointer_type
7197 || c->die_tag == DW_TAG_reference_type
7198 || c->die_tag == DW_TAG_const_type
7199 || c->die_tag == DW_TAG_volatile_type)
7201 dw_die_ref t = get_AT_ref (c, DW_AT_type);
7203 return t ? is_comdat_die (t) : 0;
7206 return is_type_die (c);
7209 /* Returns 1 iff C is the sort of DIE that might be referred to from another
7210 compilation unit. */
7213 is_symbol_die (dw_die_ref c)
7215 return (is_type_die (c)
7216 || (get_AT (c, DW_AT_declaration)
7217 && !get_AT (c, DW_AT_specification))
7218 || c->die_tag == DW_TAG_namespace
7219 || c->die_tag == DW_TAG_module);
7223 gen_internal_sym (const char *prefix)
7227 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
7228 return xstrdup (buf);
7231 /* Assign symbols to all worthy DIEs under DIE. */
7234 assign_symbol_names (dw_die_ref die)
7238 if (is_symbol_die (die))
7240 if (comdat_symbol_id)
7242 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
7244 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
7245 comdat_symbol_id, comdat_symbol_number++);
7246 die->die_symbol = xstrdup (p);
7249 die->die_symbol = gen_internal_sym ("LDIE");
7252 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
7255 struct cu_hash_table_entry
7258 unsigned min_comdat_num, max_comdat_num;
7259 struct cu_hash_table_entry *next;
7262 /* Routines to manipulate hash table of CUs. */
7264 htab_cu_hash (const void *of)
7266 const struct cu_hash_table_entry *const entry =
7267 (const struct cu_hash_table_entry *) of;
7269 return htab_hash_string (entry->cu->die_symbol);
7273 htab_cu_eq (const void *of1, const void *of2)
7275 const struct cu_hash_table_entry *const entry1 =
7276 (const struct cu_hash_table_entry *) of1;
7277 const struct die_struct *const entry2 = (const struct die_struct *) of2;
7279 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
7283 htab_cu_del (void *what)
7285 struct cu_hash_table_entry *next,
7286 *entry = (struct cu_hash_table_entry *) what;
7296 /* Check whether we have already seen this CU and set up SYM_NUM
7299 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
7301 struct cu_hash_table_entry dummy;
7302 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
7304 dummy.max_comdat_num = 0;
7306 slot = (struct cu_hash_table_entry **)
7307 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7311 for (; entry; last = entry, entry = entry->next)
7313 if (same_die_p_wrap (cu, entry->cu))
7319 *sym_num = entry->min_comdat_num;
7323 entry = XCNEW (struct cu_hash_table_entry);
7325 entry->min_comdat_num = *sym_num = last->max_comdat_num;
7326 entry->next = *slot;
7332 /* Record SYM_NUM to record of CU in HTABLE. */
7334 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
7336 struct cu_hash_table_entry **slot, *entry;
7338 slot = (struct cu_hash_table_entry **)
7339 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7343 entry->max_comdat_num = sym_num;
7346 /* Traverse the DIE (which is always comp_unit_die), and set up
7347 additional compilation units for each of the include files we see
7348 bracketed by BINCL/EINCL. */
7351 break_out_includes (dw_die_ref die)
7354 dw_die_ref unit = NULL;
7355 limbo_die_node *node, **pnode;
7356 htab_t cu_hash_table;
7360 dw_die_ref prev = c;
7362 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
7363 || (unit && is_comdat_die (c)))
7365 dw_die_ref next = c->die_sib;
7367 /* This DIE is for a secondary CU; remove it from the main one. */
7368 remove_child_with_prev (c, prev);
7370 if (c->die_tag == DW_TAG_GNU_BINCL)
7371 unit = push_new_compile_unit (unit, c);
7372 else if (c->die_tag == DW_TAG_GNU_EINCL)
7373 unit = pop_compile_unit (unit);
7375 add_child_die (unit, c);
7377 if (c == die->die_child)
7380 } while (c != die->die_child);
7383 /* We can only use this in debugging, since the frontend doesn't check
7384 to make sure that we leave every include file we enter. */
7388 assign_symbol_names (die);
7389 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
7390 for (node = limbo_die_list, pnode = &limbo_die_list;
7396 compute_section_prefix (node->die);
7397 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
7398 &comdat_symbol_number);
7399 assign_symbol_names (node->die);
7401 *pnode = node->next;
7404 pnode = &node->next;
7405 record_comdat_symbol_number (node->die, cu_hash_table,
7406 comdat_symbol_number);
7409 htab_delete (cu_hash_table);
7412 /* Traverse the DIE and add a sibling attribute if it may have the
7413 effect of speeding up access to siblings. To save some space,
7414 avoid generating sibling attributes for DIE's without children. */
7417 add_sibling_attributes (dw_die_ref die)
7421 if (! die->die_child)
7424 if (die->die_parent && die != die->die_parent->die_child)
7425 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7427 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7430 /* Output all location lists for the DIE and its children. */
7433 output_location_lists (dw_die_ref die)
7439 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7440 if (AT_class (a) == dw_val_class_loc_list)
7441 output_loc_list (AT_loc_list (a));
7443 FOR_EACH_CHILD (die, c, output_location_lists (c));
7446 /* The format of each DIE (and its attribute value pairs) is encoded in an
7447 abbreviation table. This routine builds the abbreviation table and assigns
7448 a unique abbreviation id for each abbreviation entry. The children of each
7449 die are visited recursively. */
7452 build_abbrev_table (dw_die_ref die)
7454 unsigned long abbrev_id;
7455 unsigned int n_alloc;
7460 /* Scan the DIE references, and mark as external any that refer to
7461 DIEs from other CUs (i.e. those which are not marked). */
7462 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7463 if (AT_class (a) == dw_val_class_die_ref
7464 && AT_ref (a)->die_mark == 0)
7466 gcc_assert (AT_ref (a)->die_symbol);
7468 set_AT_ref_external (a, 1);
7471 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7473 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7474 dw_attr_ref die_a, abbrev_a;
7478 if (abbrev->die_tag != die->die_tag)
7480 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7483 if (VEC_length (dw_attr_node, abbrev->die_attr)
7484 != VEC_length (dw_attr_node, die->die_attr))
7487 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
7489 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
7490 if ((abbrev_a->dw_attr != die_a->dw_attr)
7491 || (value_format (abbrev_a) != value_format (die_a)))
7501 if (abbrev_id >= abbrev_die_table_in_use)
7503 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7505 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7506 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7509 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7510 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7511 abbrev_die_table_allocated = n_alloc;
7514 ++abbrev_die_table_in_use;
7515 abbrev_die_table[abbrev_id] = die;
7518 die->die_abbrev = abbrev_id;
7519 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
7522 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7525 constant_size (unsigned HOST_WIDE_INT value)
7532 log = floor_log2 (value);
7535 log = 1 << (floor_log2 (log) + 1);
7540 /* Return the size of a DIE as it is represented in the
7541 .debug_info section. */
7543 static unsigned long
7544 size_of_die (dw_die_ref die)
7546 unsigned long size = 0;
7550 size += size_of_uleb128 (die->die_abbrev);
7551 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7553 switch (AT_class (a))
7555 case dw_val_class_addr:
7556 size += DWARF2_ADDR_SIZE;
7558 case dw_val_class_offset:
7559 size += DWARF_OFFSET_SIZE;
7561 case dw_val_class_loc:
7563 unsigned long lsize = size_of_locs (AT_loc (a));
7566 size += constant_size (lsize);
7570 case dw_val_class_loc_list:
7571 size += DWARF_OFFSET_SIZE;
7573 case dw_val_class_range_list:
7574 size += DWARF_OFFSET_SIZE;
7576 case dw_val_class_const:
7577 size += size_of_sleb128 (AT_int (a));
7579 case dw_val_class_unsigned_const:
7580 size += constant_size (AT_unsigned (a));
7582 case dw_val_class_long_long:
7583 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
7585 case dw_val_class_vec:
7586 size += constant_size (a->dw_attr_val.v.val_vec.length
7587 * a->dw_attr_val.v.val_vec.elt_size)
7588 + a->dw_attr_val.v.val_vec.length
7589 * a->dw_attr_val.v.val_vec.elt_size; /* block */
7591 case dw_val_class_flag:
7594 case dw_val_class_die_ref:
7595 if (AT_ref_external (a))
7596 size += DWARF2_ADDR_SIZE;
7598 size += DWARF_OFFSET_SIZE;
7600 case dw_val_class_fde_ref:
7601 size += DWARF_OFFSET_SIZE;
7603 case dw_val_class_lbl_id:
7604 size += DWARF2_ADDR_SIZE;
7606 case dw_val_class_lineptr:
7607 case dw_val_class_macptr:
7608 size += DWARF_OFFSET_SIZE;
7610 case dw_val_class_str:
7611 if (AT_string_form (a) == DW_FORM_strp)
7612 size += DWARF_OFFSET_SIZE;
7614 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
7616 case dw_val_class_file:
7617 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
7627 /* Size the debugging information associated with a given DIE. Visits the
7628 DIE's children recursively. Updates the global variable next_die_offset, on
7629 each time through. Uses the current value of next_die_offset to update the
7630 die_offset field in each DIE. */
7633 calc_die_sizes (dw_die_ref die)
7637 die->die_offset = next_die_offset;
7638 next_die_offset += size_of_die (die);
7640 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
7642 if (die->die_child != NULL)
7643 /* Count the null byte used to terminate sibling lists. */
7644 next_die_offset += 1;
7647 /* Set the marks for a die and its children. We do this so
7648 that we know whether or not a reference needs to use FORM_ref_addr; only
7649 DIEs in the same CU will be marked. We used to clear out the offset
7650 and use that as the flag, but ran into ordering problems. */
7653 mark_dies (dw_die_ref die)
7657 gcc_assert (!die->die_mark);
7660 FOR_EACH_CHILD (die, c, mark_dies (c));
7663 /* Clear the marks for a die and its children. */
7666 unmark_dies (dw_die_ref die)
7670 gcc_assert (die->die_mark);
7673 FOR_EACH_CHILD (die, c, unmark_dies (c));
7676 /* Clear the marks for a die, its children and referred dies. */
7679 unmark_all_dies (dw_die_ref die)
7689 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
7691 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7692 if (AT_class (a) == dw_val_class_die_ref)
7693 unmark_all_dies (AT_ref (a));
7696 /* Return the size of the .debug_pubnames or .debug_pubtypes table
7697 generated for the compilation unit. */
7699 static unsigned long
7700 size_of_pubnames (VEC (pubname_entry, gc) * names)
7706 size = DWARF_PUBNAMES_HEADER_SIZE;
7707 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
7708 if (names != pubtype_table
7709 || p->die->die_offset != 0
7710 || !flag_eliminate_unused_debug_types)
7711 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
7713 size += DWARF_OFFSET_SIZE;
7717 /* Return the size of the information in the .debug_aranges section. */
7719 static unsigned long
7720 size_of_aranges (void)
7724 size = DWARF_ARANGES_HEADER_SIZE;
7726 /* Count the address/length pair for this compilation unit. */
7727 if (text_section_used)
7728 size += 2 * DWARF2_ADDR_SIZE;
7729 if (cold_text_section_used)
7730 size += 2 * DWARF2_ADDR_SIZE;
7731 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
7733 /* Count the two zero words used to terminated the address range table. */
7734 size += 2 * DWARF2_ADDR_SIZE;
7738 /* Select the encoding of an attribute value. */
7740 static enum dwarf_form
7741 value_format (dw_attr_ref a)
7743 switch (a->dw_attr_val.val_class)
7745 case dw_val_class_addr:
7746 return DW_FORM_addr;
7747 case dw_val_class_range_list:
7748 case dw_val_class_offset:
7749 case dw_val_class_loc_list:
7750 switch (DWARF_OFFSET_SIZE)
7753 return DW_FORM_data4;
7755 return DW_FORM_data8;
7759 case dw_val_class_loc:
7760 switch (constant_size (size_of_locs (AT_loc (a))))
7763 return DW_FORM_block1;
7765 return DW_FORM_block2;
7769 case dw_val_class_const:
7770 return DW_FORM_sdata;
7771 case dw_val_class_unsigned_const:
7772 switch (constant_size (AT_unsigned (a)))
7775 return DW_FORM_data1;
7777 return DW_FORM_data2;
7779 return DW_FORM_data4;
7781 return DW_FORM_data8;
7785 case dw_val_class_long_long:
7786 return DW_FORM_block1;
7787 case dw_val_class_vec:
7788 switch (constant_size (a->dw_attr_val.v.val_vec.length
7789 * a->dw_attr_val.v.val_vec.elt_size))
7792 return DW_FORM_block1;
7794 return DW_FORM_block2;
7796 return DW_FORM_block4;
7800 case dw_val_class_flag:
7801 return DW_FORM_flag;
7802 case dw_val_class_die_ref:
7803 if (AT_ref_external (a))
7804 return DW_FORM_ref_addr;
7807 case dw_val_class_fde_ref:
7808 return DW_FORM_data;
7809 case dw_val_class_lbl_id:
7810 return DW_FORM_addr;
7811 case dw_val_class_lineptr:
7812 case dw_val_class_macptr:
7813 return DW_FORM_data;
7814 case dw_val_class_str:
7815 return AT_string_form (a);
7816 case dw_val_class_file:
7817 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
7820 return DW_FORM_data1;
7822 return DW_FORM_data2;
7824 return DW_FORM_data4;
7834 /* Output the encoding of an attribute value. */
7837 output_value_format (dw_attr_ref a)
7839 enum dwarf_form form = value_format (a);
7841 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
7844 /* Output the .debug_abbrev section which defines the DIE abbreviation
7848 output_abbrev_section (void)
7850 unsigned long abbrev_id;
7852 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7854 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7858 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
7859 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
7860 dwarf_tag_name (abbrev->die_tag));
7862 if (abbrev->die_child != NULL)
7863 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
7865 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
7867 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
7870 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
7871 dwarf_attr_name (a_attr->dw_attr));
7872 output_value_format (a_attr);
7875 dw2_asm_output_data (1, 0, NULL);
7876 dw2_asm_output_data (1, 0, NULL);
7879 /* Terminate the table. */
7880 dw2_asm_output_data (1, 0, NULL);
7883 /* Output a symbol we can use to refer to this DIE from another CU. */
7886 output_die_symbol (dw_die_ref die)
7888 char *sym = die->die_symbol;
7893 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
7894 /* We make these global, not weak; if the target doesn't support
7895 .linkonce, it doesn't support combining the sections, so debugging
7897 targetm.asm_out.globalize_label (asm_out_file, sym);
7899 ASM_OUTPUT_LABEL (asm_out_file, sym);
7902 /* Return a new location list, given the begin and end range, and the
7903 expression. gensym tells us whether to generate a new internal symbol for
7904 this location list node, which is done for the head of the list only. */
7906 static inline dw_loc_list_ref
7907 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
7908 const char *section, unsigned int gensym)
7910 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
7912 retlist->begin = begin;
7914 retlist->expr = expr;
7915 retlist->section = section;
7917 retlist->ll_symbol = gen_internal_sym ("LLST");
7922 /* Add a location description expression to a location list. */
7925 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
7926 const char *begin, const char *end,
7927 const char *section)
7931 /* Find the end of the chain. */
7932 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
7935 /* Add a new location list node to the list. */
7936 *d = new_loc_list (descr, begin, end, section, 0);
7939 /* Output the location list given to us. */
7942 output_loc_list (dw_loc_list_ref list_head)
7944 dw_loc_list_ref curr = list_head;
7946 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7948 /* Walk the location list, and output each range + expression. */
7949 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7952 /* Don't output an entry that starts and ends at the same address. */
7953 if (strcmp (curr->begin, curr->end) == 0)
7955 if (!have_multiple_function_sections)
7957 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7958 "Location list begin address (%s)",
7959 list_head->ll_symbol);
7960 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7961 "Location list end address (%s)",
7962 list_head->ll_symbol);
7966 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7967 "Location list begin address (%s)",
7968 list_head->ll_symbol);
7969 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7970 "Location list end address (%s)",
7971 list_head->ll_symbol);
7973 size = size_of_locs (curr->expr);
7975 /* Output the block length for this list of location operations. */
7976 gcc_assert (size <= 0xffff);
7977 dw2_asm_output_data (2, size, "%s", "Location expression size");
7979 output_loc_sequence (curr->expr);
7982 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7983 "Location list terminator begin (%s)",
7984 list_head->ll_symbol);
7985 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7986 "Location list terminator end (%s)",
7987 list_head->ll_symbol);
7990 /* Output the DIE and its attributes. Called recursively to generate
7991 the definitions of each child DIE. */
7994 output_die (dw_die_ref die)
8001 /* If someone in another CU might refer to us, set up a symbol for
8002 them to point to. */
8003 if (die->die_symbol)
8004 output_die_symbol (die);
8006 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
8007 (unsigned long)die->die_offset,
8008 dwarf_tag_name (die->die_tag));
8010 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8012 const char *name = dwarf_attr_name (a->dw_attr);
8014 switch (AT_class (a))
8016 case dw_val_class_addr:
8017 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8020 case dw_val_class_offset:
8021 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8025 case dw_val_class_range_list:
8027 char *p = strchr (ranges_section_label, '\0');
8029 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8030 a->dw_attr_val.v.val_offset);
8031 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8032 debug_ranges_section, "%s", name);
8037 case dw_val_class_loc:
8038 size = size_of_locs (AT_loc (a));
8040 /* Output the block length for this list of location operations. */
8041 dw2_asm_output_data (constant_size (size), size, "%s", name);
8043 output_loc_sequence (AT_loc (a));
8046 case dw_val_class_const:
8047 /* ??? It would be slightly more efficient to use a scheme like is
8048 used for unsigned constants below, but gdb 4.x does not sign
8049 extend. Gdb 5.x does sign extend. */
8050 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8053 case dw_val_class_unsigned_const:
8054 dw2_asm_output_data (constant_size (AT_unsigned (a)),
8055 AT_unsigned (a), "%s", name);
8058 case dw_val_class_long_long:
8060 unsigned HOST_WIDE_INT first, second;
8062 dw2_asm_output_data (1,
8063 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8066 if (WORDS_BIG_ENDIAN)
8068 first = a->dw_attr_val.v.val_long_long.hi;
8069 second = a->dw_attr_val.v.val_long_long.low;
8073 first = a->dw_attr_val.v.val_long_long.low;
8074 second = a->dw_attr_val.v.val_long_long.hi;
8077 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8078 first, "long long constant");
8079 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8084 case dw_val_class_vec:
8086 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8087 unsigned int len = a->dw_attr_val.v.val_vec.length;
8091 dw2_asm_output_data (constant_size (len * elt_size),
8092 len * elt_size, "%s", name);
8093 if (elt_size > sizeof (HOST_WIDE_INT))
8098 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8101 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8102 "fp or vector constant word %u", i);
8106 case dw_val_class_flag:
8107 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8110 case dw_val_class_loc_list:
8112 char *sym = AT_loc_list (a)->ll_symbol;
8115 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8120 case dw_val_class_die_ref:
8121 if (AT_ref_external (a))
8123 char *sym = AT_ref (a)->die_symbol;
8126 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
8131 gcc_assert (AT_ref (a)->die_offset);
8132 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8137 case dw_val_class_fde_ref:
8141 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8142 a->dw_attr_val.v.val_fde_index * 2);
8143 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
8148 case dw_val_class_lbl_id:
8149 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8152 case dw_val_class_lineptr:
8153 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8154 debug_line_section, "%s", name);
8157 case dw_val_class_macptr:
8158 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8159 debug_macinfo_section, "%s", name);
8162 case dw_val_class_str:
8163 if (AT_string_form (a) == DW_FORM_strp)
8164 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
8165 a->dw_attr_val.v.val_str->label,
8167 "%s: \"%s\"", name, AT_string (a));
8169 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
8172 case dw_val_class_file:
8174 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
8176 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
8177 a->dw_attr_val.v.val_file->filename);
8186 FOR_EACH_CHILD (die, c, output_die (c));
8188 /* Add null byte to terminate sibling list. */
8189 if (die->die_child != NULL)
8190 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
8191 (unsigned long) die->die_offset);
8194 /* Output the compilation unit that appears at the beginning of the
8195 .debug_info section, and precedes the DIE descriptions. */
8198 output_compilation_unit_header (void)
8200 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8201 dw2_asm_output_data (4, 0xffffffff,
8202 "Initial length escape value indicating 64-bit DWARF extension");
8203 dw2_asm_output_data (DWARF_OFFSET_SIZE,
8204 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
8205 "Length of Compilation Unit Info");
8206 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
8207 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
8208 debug_abbrev_section,
8209 "Offset Into Abbrev. Section");
8210 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
8213 /* Output the compilation unit DIE and its children. */
8216 output_comp_unit (dw_die_ref die, int output_if_empty)
8218 const char *secname;
8221 /* Unless we are outputting main CU, we may throw away empty ones. */
8222 if (!output_if_empty && die->die_child == NULL)
8225 /* Even if there are no children of this DIE, we must output the information
8226 about the compilation unit. Otherwise, on an empty translation unit, we
8227 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8228 will then complain when examining the file. First mark all the DIEs in
8229 this CU so we know which get local refs. */
8232 build_abbrev_table (die);
8234 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8235 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8236 calc_die_sizes (die);
8238 oldsym = die->die_symbol;
8241 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
8243 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
8245 die->die_symbol = NULL;
8246 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
8249 switch_to_section (debug_info_section);
8251 /* Output debugging information. */
8252 output_compilation_unit_header ();
8255 /* Leave the marks on the main CU, so we can check them in
8260 die->die_symbol = oldsym;
8264 /* Return the DWARF2/3 pubname associated with a decl. */
8267 dwarf2_name (tree decl, int scope)
8269 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
8272 /* Add a new entry to .debug_pubnames if appropriate. */
8275 add_pubname_string (const char *str, dw_die_ref die)
8280 e.name = xstrdup (str);
8281 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
8285 add_pubname (tree decl, dw_die_ref die)
8288 if (TREE_PUBLIC (decl))
8289 add_pubname_string (dwarf2_name (decl, 1), die);
8292 /* Add a new entry to .debug_pubtypes if appropriate. */
8295 add_pubtype (tree decl, dw_die_ref die)
8300 if ((TREE_PUBLIC (decl)
8301 || die->die_parent == comp_unit_die)
8302 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
8307 if (TYPE_NAME (decl))
8309 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
8310 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
8311 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
8312 && DECL_NAME (TYPE_NAME (decl)))
8313 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
8315 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
8319 e.name = xstrdup (dwarf2_name (decl, 1));
8321 /* If we don't have a name for the type, there's no point in adding
8323 if (e.name && e.name[0] != '\0')
8324 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
8328 /* Output the public names table used to speed up access to externally
8329 visible names; or the public types table used to find type definitions. */
8332 output_pubnames (VEC (pubname_entry, gc) * names)
8335 unsigned long pubnames_length = size_of_pubnames (names);
8338 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8339 dw2_asm_output_data (4, 0xffffffff,
8340 "Initial length escape value indicating 64-bit DWARF extension");
8341 if (names == pubname_table)
8342 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8343 "Length of Public Names Info");
8345 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8346 "Length of Public Type Names Info");
8347 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8348 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8350 "Offset of Compilation Unit Info");
8351 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
8352 "Compilation Unit Length");
8354 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
8356 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8357 if (names == pubname_table)
8358 gcc_assert (pub->die->die_mark);
8360 if (names != pubtype_table
8361 || pub->die->die_offset != 0
8362 || !flag_eliminate_unused_debug_types)
8364 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
8367 dw2_asm_output_nstring (pub->name, -1, "external name");
8371 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
8374 /* Add a new entry to .debug_aranges if appropriate. */
8377 add_arange (tree decl, dw_die_ref die)
8379 if (! DECL_SECTION_NAME (decl))
8382 if (arange_table_in_use == arange_table_allocated)
8384 arange_table_allocated += ARANGE_TABLE_INCREMENT;
8385 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
8386 arange_table_allocated);
8387 memset (arange_table + arange_table_in_use, 0,
8388 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
8391 arange_table[arange_table_in_use++] = die;
8394 /* Output the information that goes into the .debug_aranges table.
8395 Namely, define the beginning and ending address range of the
8396 text section generated for this compilation unit. */
8399 output_aranges (void)
8402 unsigned long aranges_length = size_of_aranges ();
8404 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8405 dw2_asm_output_data (4, 0xffffffff,
8406 "Initial length escape value indicating 64-bit DWARF extension");
8407 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
8408 "Length of Address Ranges Info");
8409 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8410 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8412 "Offset of Compilation Unit Info");
8413 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
8414 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8416 /* We need to align to twice the pointer size here. */
8417 if (DWARF_ARANGES_PAD_SIZE)
8419 /* Pad using a 2 byte words so that padding is correct for any
8421 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8422 2 * DWARF2_ADDR_SIZE);
8423 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
8424 dw2_asm_output_data (2, 0, NULL);
8427 /* It is necessary not to output these entries if the sections were
8428 not used; if the sections were not used, the length will be 0 and
8429 the address may end up as 0 if the section is discarded by ld
8430 --gc-sections, leaving an invalid (0, 0) entry that can be
8431 confused with the terminator. */
8432 if (text_section_used)
8434 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
8435 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
8436 text_section_label, "Length");
8438 if (cold_text_section_used)
8440 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
8442 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
8443 cold_text_section_label, "Length");
8446 for (i = 0; i < arange_table_in_use; i++)
8448 dw_die_ref die = arange_table[i];
8450 /* We shouldn't see aranges for DIEs outside of the main CU. */
8451 gcc_assert (die->die_mark);
8453 if (die->die_tag == DW_TAG_subprogram)
8455 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
8457 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
8458 get_AT_low_pc (die), "Length");
8462 /* A static variable; extract the symbol from DW_AT_location.
8463 Note that this code isn't currently hit, as we only emit
8464 aranges for functions (jason 9/23/99). */
8465 dw_attr_ref a = get_AT (die, DW_AT_location);
8466 dw_loc_descr_ref loc;
8468 gcc_assert (a && AT_class (a) == dw_val_class_loc);
8471 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
8473 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
8474 loc->dw_loc_oprnd1.v.val_addr, "Address");
8475 dw2_asm_output_data (DWARF2_ADDR_SIZE,
8476 get_AT_unsigned (die, DW_AT_byte_size),
8481 /* Output the terminator words. */
8482 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8483 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8486 /* Add a new entry to .debug_ranges. Return the offset at which it
8490 add_ranges_num (int num)
8492 unsigned int in_use = ranges_table_in_use;
8494 if (in_use == ranges_table_allocated)
8496 ranges_table_allocated += RANGES_TABLE_INCREMENT;
8497 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
8498 ranges_table_allocated);
8499 memset (ranges_table + ranges_table_in_use, 0,
8500 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
8503 ranges_table[in_use].num = num;
8504 ranges_table_in_use = in_use + 1;
8506 return in_use * 2 * DWARF2_ADDR_SIZE;
8509 /* Add a new entry to .debug_ranges corresponding to a block, or a
8510 range terminator if BLOCK is NULL. */
8513 add_ranges (const_tree block)
8515 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
8518 /* Add a new entry to .debug_ranges corresponding to a pair of
8522 add_ranges_by_labels (const char *begin, const char *end)
8524 unsigned int in_use = ranges_by_label_in_use;
8526 if (in_use == ranges_by_label_allocated)
8528 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
8529 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
8531 ranges_by_label_allocated);
8532 memset (ranges_by_label + ranges_by_label_in_use, 0,
8533 RANGES_TABLE_INCREMENT
8534 * sizeof (struct dw_ranges_by_label_struct));
8537 ranges_by_label[in_use].begin = begin;
8538 ranges_by_label[in_use].end = end;
8539 ranges_by_label_in_use = in_use + 1;
8541 return add_ranges_num (-(int)in_use - 1);
8545 output_ranges (void)
8548 static const char *const start_fmt = "Offset 0x%x";
8549 const char *fmt = start_fmt;
8551 for (i = 0; i < ranges_table_in_use; i++)
8553 int block_num = ranges_table[i].num;
8557 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
8558 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
8560 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
8561 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
8563 /* If all code is in the text section, then the compilation
8564 unit base address defaults to DW_AT_low_pc, which is the
8565 base of the text section. */
8566 if (!have_multiple_function_sections)
8568 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
8570 fmt, i * 2 * DWARF2_ADDR_SIZE);
8571 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
8572 text_section_label, NULL);
8575 /* Otherwise, the compilation unit base address is zero,
8576 which allows us to use absolute addresses, and not worry
8577 about whether the target supports cross-section
8581 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
8582 fmt, i * 2 * DWARF2_ADDR_SIZE);
8583 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
8589 /* Negative block_num stands for an index into ranges_by_label. */
8590 else if (block_num < 0)
8592 int lab_idx = - block_num - 1;
8594 if (!have_multiple_function_sections)
8598 /* If we ever use add_ranges_by_labels () for a single
8599 function section, all we have to do is to take out
8601 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8602 ranges_by_label[lab_idx].begin,
8604 fmt, i * 2 * DWARF2_ADDR_SIZE);
8605 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8606 ranges_by_label[lab_idx].end,
8607 text_section_label, NULL);
8612 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8613 ranges_by_label[lab_idx].begin,
8614 fmt, i * 2 * DWARF2_ADDR_SIZE);
8615 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8616 ranges_by_label[lab_idx].end,
8622 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8623 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8629 /* Data structure containing information about input files. */
8632 const char *path; /* Complete file name. */
8633 const char *fname; /* File name part. */
8634 int length; /* Length of entire string. */
8635 struct dwarf_file_data * file_idx; /* Index in input file table. */
8636 int dir_idx; /* Index in directory table. */
8639 /* Data structure containing information about directories with source
8643 const char *path; /* Path including directory name. */
8644 int length; /* Path length. */
8645 int prefix; /* Index of directory entry which is a prefix. */
8646 int count; /* Number of files in this directory. */
8647 int dir_idx; /* Index of directory used as base. */
8650 /* Callback function for file_info comparison. We sort by looking at
8651 the directories in the path. */
8654 file_info_cmp (const void *p1, const void *p2)
8656 const struct file_info *const s1 = (const struct file_info *) p1;
8657 const struct file_info *const s2 = (const struct file_info *) p2;
8658 const unsigned char *cp1;
8659 const unsigned char *cp2;
8661 /* Take care of file names without directories. We need to make sure that
8662 we return consistent values to qsort since some will get confused if
8663 we return the same value when identical operands are passed in opposite
8664 orders. So if neither has a directory, return 0 and otherwise return
8665 1 or -1 depending on which one has the directory. */
8666 if ((s1->path == s1->fname || s2->path == s2->fname))
8667 return (s2->path == s2->fname) - (s1->path == s1->fname);
8669 cp1 = (const unsigned char *) s1->path;
8670 cp2 = (const unsigned char *) s2->path;
8676 /* Reached the end of the first path? If so, handle like above. */
8677 if ((cp1 == (const unsigned char *) s1->fname)
8678 || (cp2 == (const unsigned char *) s2->fname))
8679 return ((cp2 == (const unsigned char *) s2->fname)
8680 - (cp1 == (const unsigned char *) s1->fname));
8682 /* Character of current path component the same? */
8683 else if (*cp1 != *cp2)
8688 struct file_name_acquire_data
8690 struct file_info *files;
8695 /* Traversal function for the hash table. */
8698 file_name_acquire (void ** slot, void *data)
8700 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
8701 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
8702 struct file_info *fi;
8705 gcc_assert (fnad->max_files >= d->emitted_number);
8707 if (! d->emitted_number)
8710 gcc_assert (fnad->max_files != fnad->used_files);
8712 fi = fnad->files + fnad->used_files++;
8714 /* Skip all leading "./". */
8716 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
8719 /* Create a new array entry. */
8721 fi->length = strlen (f);
8724 /* Search for the file name part. */
8725 f = strrchr (f, DIR_SEPARATOR);
8726 #if defined (DIR_SEPARATOR_2)
8728 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
8732 if (f == NULL || f < g)
8738 fi->fname = f == NULL ? fi->path : f + 1;
8742 /* Output the directory table and the file name table. We try to minimize
8743 the total amount of memory needed. A heuristic is used to avoid large
8744 slowdowns with many input files. */
8747 output_file_names (void)
8749 struct file_name_acquire_data fnad;
8751 struct file_info *files;
8752 struct dir_info *dirs;
8761 if (!last_emitted_file)
8763 dw2_asm_output_data (1, 0, "End directory table");
8764 dw2_asm_output_data (1, 0, "End file name table");
8768 numfiles = last_emitted_file->emitted_number;
8770 /* Allocate the various arrays we need. */
8771 files = XALLOCAVEC (struct file_info, numfiles);
8772 dirs = XALLOCAVEC (struct dir_info, numfiles);
8775 fnad.used_files = 0;
8776 fnad.max_files = numfiles;
8777 htab_traverse (file_table, file_name_acquire, &fnad);
8778 gcc_assert (fnad.used_files == fnad.max_files);
8780 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
8782 /* Find all the different directories used. */
8783 dirs[0].path = files[0].path;
8784 dirs[0].length = files[0].fname - files[0].path;
8785 dirs[0].prefix = -1;
8787 dirs[0].dir_idx = 0;
8788 files[0].dir_idx = 0;
8791 for (i = 1; i < numfiles; i++)
8792 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
8793 && memcmp (dirs[ndirs - 1].path, files[i].path,
8794 dirs[ndirs - 1].length) == 0)
8796 /* Same directory as last entry. */
8797 files[i].dir_idx = ndirs - 1;
8798 ++dirs[ndirs - 1].count;
8804 /* This is a new directory. */
8805 dirs[ndirs].path = files[i].path;
8806 dirs[ndirs].length = files[i].fname - files[i].path;
8807 dirs[ndirs].count = 1;
8808 dirs[ndirs].dir_idx = ndirs;
8809 files[i].dir_idx = ndirs;
8811 /* Search for a prefix. */
8812 dirs[ndirs].prefix = -1;
8813 for (j = 0; j < ndirs; j++)
8814 if (dirs[j].length < dirs[ndirs].length
8815 && dirs[j].length > 1
8816 && (dirs[ndirs].prefix == -1
8817 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
8818 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
8819 dirs[ndirs].prefix = j;
8824 /* Now to the actual work. We have to find a subset of the directories which
8825 allow expressing the file name using references to the directory table
8826 with the least amount of characters. We do not do an exhaustive search
8827 where we would have to check out every combination of every single
8828 possible prefix. Instead we use a heuristic which provides nearly optimal
8829 results in most cases and never is much off. */
8830 saved = XALLOCAVEC (int, ndirs);
8831 savehere = XALLOCAVEC (int, ndirs);
8833 memset (saved, '\0', ndirs * sizeof (saved[0]));
8834 for (i = 0; i < ndirs; i++)
8839 /* We can always save some space for the current directory. But this
8840 does not mean it will be enough to justify adding the directory. */
8841 savehere[i] = dirs[i].length;
8842 total = (savehere[i] - saved[i]) * dirs[i].count;
8844 for (j = i + 1; j < ndirs; j++)
8847 if (saved[j] < dirs[i].length)
8849 /* Determine whether the dirs[i] path is a prefix of the
8854 while (k != -1 && k != (int) i)
8859 /* Yes it is. We can possibly save some memory by
8860 writing the filenames in dirs[j] relative to
8862 savehere[j] = dirs[i].length;
8863 total += (savehere[j] - saved[j]) * dirs[j].count;
8868 /* Check whether we can save enough to justify adding the dirs[i]
8870 if (total > dirs[i].length + 1)
8872 /* It's worthwhile adding. */
8873 for (j = i; j < ndirs; j++)
8874 if (savehere[j] > 0)
8876 /* Remember how much we saved for this directory so far. */
8877 saved[j] = savehere[j];
8879 /* Remember the prefix directory. */
8880 dirs[j].dir_idx = i;
8885 /* Emit the directory name table. */
8887 idx_offset = dirs[0].length > 0 ? 1 : 0;
8888 for (i = 1 - idx_offset; i < ndirs; i++)
8889 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
8890 "Directory Entry: 0x%x", i + idx_offset);
8892 dw2_asm_output_data (1, 0, "End directory table");
8894 /* We have to emit them in the order of emitted_number since that's
8895 used in the debug info generation. To do this efficiently we
8896 generate a back-mapping of the indices first. */
8897 backmap = XALLOCAVEC (int, numfiles);
8898 for (i = 0; i < numfiles; i++)
8899 backmap[files[i].file_idx->emitted_number - 1] = i;
8901 /* Now write all the file names. */
8902 for (i = 0; i < numfiles; i++)
8904 int file_idx = backmap[i];
8905 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
8907 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
8908 "File Entry: 0x%x", (unsigned) i + 1);
8910 /* Include directory index. */
8911 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
8913 /* Modification time. */
8914 dw2_asm_output_data_uleb128 (0, NULL);
8916 /* File length in bytes. */
8917 dw2_asm_output_data_uleb128 (0, NULL);
8920 dw2_asm_output_data (1, 0, "End file name table");
8924 /* Output the source line number correspondence information. This
8925 information goes into the .debug_line section. */
8928 output_line_info (void)
8930 char l1[20], l2[20], p1[20], p2[20];
8931 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8932 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8935 unsigned long lt_index;
8936 unsigned long current_line;
8939 unsigned long current_file;
8940 unsigned long function;
8942 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
8943 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
8944 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
8945 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
8947 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8948 dw2_asm_output_data (4, 0xffffffff,
8949 "Initial length escape value indicating 64-bit DWARF extension");
8950 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
8951 "Length of Source Line Info");
8952 ASM_OUTPUT_LABEL (asm_out_file, l1);
8954 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8955 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
8956 ASM_OUTPUT_LABEL (asm_out_file, p1);
8958 /* Define the architecture-dependent minimum instruction length (in
8959 bytes). In this implementation of DWARF, this field is used for
8960 information purposes only. Since GCC generates assembly language,
8961 we have no a priori knowledge of how many instruction bytes are
8962 generated for each source line, and therefore can use only the
8963 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
8964 commands. Accordingly, we fix this as `1', which is "correct
8965 enough" for all architectures, and don't let the target override. */
8966 dw2_asm_output_data (1, 1,
8967 "Minimum Instruction Length");
8969 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
8970 "Default is_stmt_start flag");
8971 dw2_asm_output_data (1, DWARF_LINE_BASE,
8972 "Line Base Value (Special Opcodes)");
8973 dw2_asm_output_data (1, DWARF_LINE_RANGE,
8974 "Line Range Value (Special Opcodes)");
8975 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
8976 "Special Opcode Base");
8978 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
8982 case DW_LNS_advance_pc:
8983 case DW_LNS_advance_line:
8984 case DW_LNS_set_file:
8985 case DW_LNS_set_column:
8986 case DW_LNS_fixed_advance_pc:
8994 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
8998 /* Write out the information about the files we use. */
8999 output_file_names ();
9000 ASM_OUTPUT_LABEL (asm_out_file, p2);
9002 /* We used to set the address register to the first location in the text
9003 section here, but that didn't accomplish anything since we already
9004 have a line note for the opening brace of the first function. */
9006 /* Generate the line number to PC correspondence table, encoded as
9007 a series of state machine operations. */
9011 if (cfun && in_cold_section_p)
9012 strcpy (prev_line_label, crtl->subsections.cold_section_label);
9014 strcpy (prev_line_label, text_section_label);
9015 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
9017 dw_line_info_ref line_info = &line_info_table[lt_index];
9020 /* Disable this optimization for now; GDB wants to see two line notes
9021 at the beginning of a function so it can find the end of the
9024 /* Don't emit anything for redundant notes. Just updating the
9025 address doesn't accomplish anything, because we already assume
9026 that anything after the last address is this line. */
9027 if (line_info->dw_line_num == current_line
9028 && line_info->dw_file_num == current_file)
9032 /* Emit debug info for the address of the current line.
9034 Unfortunately, we have little choice here currently, and must always
9035 use the most general form. GCC does not know the address delta
9036 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9037 attributes which will give an upper bound on the address range. We
9038 could perhaps use length attributes to determine when it is safe to
9039 use DW_LNS_fixed_advance_pc. */
9041 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
9044 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
9045 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9046 "DW_LNS_fixed_advance_pc");
9047 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9051 /* This can handle any delta. This takes
9052 4+DWARF2_ADDR_SIZE bytes. */
9053 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9054 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9055 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9056 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9059 strcpy (prev_line_label, line_label);
9061 /* Emit debug info for the source file of the current line, if
9062 different from the previous line. */
9063 if (line_info->dw_file_num != current_file)
9065 current_file = line_info->dw_file_num;
9066 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9067 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9070 /* Emit debug info for the current line number, choosing the encoding
9071 that uses the least amount of space. */
9072 if (line_info->dw_line_num != current_line)
9074 line_offset = line_info->dw_line_num - current_line;
9075 line_delta = line_offset - DWARF_LINE_BASE;
9076 current_line = line_info->dw_line_num;
9077 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9078 /* This can handle deltas from -10 to 234, using the current
9079 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
9081 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9082 "line %lu", current_line);
9085 /* This can handle any delta. This takes at least 4 bytes,
9086 depending on the value being encoded. */
9087 dw2_asm_output_data (1, DW_LNS_advance_line,
9088 "advance to line %lu", current_line);
9089 dw2_asm_output_data_sleb128 (line_offset, NULL);
9090 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9094 /* We still need to start a new row, so output a copy insn. */
9095 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9098 /* Emit debug info for the address of the end of the function. */
9101 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9102 "DW_LNS_fixed_advance_pc");
9103 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
9107 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9108 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9109 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9110 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
9113 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9114 dw2_asm_output_data_uleb128 (1, NULL);
9115 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9120 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
9122 dw_separate_line_info_ref line_info
9123 = &separate_line_info_table[lt_index];
9126 /* Don't emit anything for redundant notes. */
9127 if (line_info->dw_line_num == current_line
9128 && line_info->dw_file_num == current_file
9129 && line_info->function == function)
9133 /* Emit debug info for the address of the current line. If this is
9134 a new function, or the first line of a function, then we need
9135 to handle it differently. */
9136 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
9138 if (function != line_info->function)
9140 function = line_info->function;
9142 /* Set the address register to the first line in the function. */
9143 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9144 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9145 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9146 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9150 /* ??? See the DW_LNS_advance_pc comment above. */
9153 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9154 "DW_LNS_fixed_advance_pc");
9155 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9159 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9160 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9161 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9162 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9166 strcpy (prev_line_label, line_label);
9168 /* Emit debug info for the source file of the current line, if
9169 different from the previous line. */
9170 if (line_info->dw_file_num != current_file)
9172 current_file = line_info->dw_file_num;
9173 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9174 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9177 /* Emit debug info for the current line number, choosing the encoding
9178 that uses the least amount of space. */
9179 if (line_info->dw_line_num != current_line)
9181 line_offset = line_info->dw_line_num - current_line;
9182 line_delta = line_offset - DWARF_LINE_BASE;
9183 current_line = line_info->dw_line_num;
9184 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9185 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9186 "line %lu", current_line);
9189 dw2_asm_output_data (1, DW_LNS_advance_line,
9190 "advance to line %lu", current_line);
9191 dw2_asm_output_data_sleb128 (line_offset, NULL);
9192 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9196 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9204 /* If we're done with a function, end its sequence. */
9205 if (lt_index == separate_line_info_table_in_use
9206 || separate_line_info_table[lt_index].function != function)
9211 /* Emit debug info for the address of the end of the function. */
9212 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
9215 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9216 "DW_LNS_fixed_advance_pc");
9217 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9221 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9222 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9223 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9224 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9227 /* Output the marker for the end of this sequence. */
9228 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9229 dw2_asm_output_data_uleb128 (1, NULL);
9230 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9234 /* Output the marker for the end of the line number info. */
9235 ASM_OUTPUT_LABEL (asm_out_file, l2);
9238 /* Given a pointer to a tree node for some base type, return a pointer to
9239 a DIE that describes the given type.
9241 This routine must only be called for GCC type nodes that correspond to
9242 Dwarf base (fundamental) types. */
9245 base_type_die (tree type)
9247 dw_die_ref base_type_result;
9248 enum dwarf_type encoding;
9250 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
9253 switch (TREE_CODE (type))
9256 if (TYPE_STRING_FLAG (type))
9258 if (TYPE_UNSIGNED (type))
9259 encoding = DW_ATE_unsigned_char;
9261 encoding = DW_ATE_signed_char;
9263 else if (TYPE_UNSIGNED (type))
9264 encoding = DW_ATE_unsigned;
9266 encoding = DW_ATE_signed;
9270 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
9271 encoding = DW_ATE_decimal_float;
9273 encoding = DW_ATE_float;
9276 case FIXED_POINT_TYPE:
9277 if (TYPE_UNSIGNED (type))
9278 encoding = DW_ATE_unsigned_fixed;
9280 encoding = DW_ATE_signed_fixed;
9283 /* Dwarf2 doesn't know anything about complex ints, so use
9284 a user defined type for it. */
9286 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
9287 encoding = DW_ATE_complex_float;
9289 encoding = DW_ATE_lo_user;
9293 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9294 encoding = DW_ATE_boolean;
9298 /* No other TREE_CODEs are Dwarf fundamental types. */
9302 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
9304 /* This probably indicates a bug. */
9305 if (! TYPE_NAME (type))
9306 add_name_attribute (base_type_result, "__unknown__");
9308 add_AT_unsigned (base_type_result, DW_AT_byte_size,
9309 int_size_in_bytes (type));
9310 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
9312 return base_type_result;
9315 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9316 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9319 is_base_type (tree type)
9321 switch (TREE_CODE (type))
9327 case FIXED_POINT_TYPE:
9335 case QUAL_UNION_TYPE:
9340 case REFERENCE_TYPE:
9353 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9354 node, return the size in bits for the type if it is a constant, or else
9355 return the alignment for the type if the type's size is not constant, or
9356 else return BITS_PER_WORD if the type actually turns out to be an
9359 static inline unsigned HOST_WIDE_INT
9360 simple_type_size_in_bits (const_tree type)
9362 if (TREE_CODE (type) == ERROR_MARK)
9363 return BITS_PER_WORD;
9364 else if (TYPE_SIZE (type) == NULL_TREE)
9366 else if (host_integerp (TYPE_SIZE (type), 1))
9367 return tree_low_cst (TYPE_SIZE (type), 1);
9369 return TYPE_ALIGN (type);
9372 /* Return true if the debug information for the given type should be
9373 emitted as a subrange type. */
9376 is_subrange_type (const_tree type)
9378 tree subtype = TREE_TYPE (type);
9380 /* Subrange types are identified by the fact that they are integer
9381 types, and that they have a subtype which is either an integer type
9382 or an enumeral type. */
9384 if (TREE_CODE (type) != INTEGER_TYPE
9385 || subtype == NULL_TREE)
9388 if (TREE_CODE (subtype) != INTEGER_TYPE
9389 && TREE_CODE (subtype) != ENUMERAL_TYPE
9390 && TREE_CODE (subtype) != BOOLEAN_TYPE)
9393 if (TREE_CODE (type) == TREE_CODE (subtype)
9394 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
9395 && TYPE_MIN_VALUE (type) != NULL
9396 && TYPE_MIN_VALUE (subtype) != NULL
9397 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
9398 && TYPE_MAX_VALUE (type) != NULL
9399 && TYPE_MAX_VALUE (subtype) != NULL
9400 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
9402 /* The type and its subtype have the same representation. If in
9403 addition the two types also have the same name, then the given
9404 type is not a subrange type, but rather a plain base type. */
9405 /* FIXME: brobecker/2004-03-22:
9406 Sizetype INTEGER_CSTs nodes are canonicalized. It should
9407 therefore be sufficient to check the TYPE_SIZE node pointers
9408 rather than checking the actual size. Unfortunately, we have
9409 found some cases, such as in the Ada "integer" type, where
9410 this is not the case. Until this problem is solved, we need to
9411 keep checking the actual size. */
9412 tree type_name = TYPE_NAME (type);
9413 tree subtype_name = TYPE_NAME (subtype);
9415 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
9416 type_name = DECL_NAME (type_name);
9418 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
9419 subtype_name = DECL_NAME (subtype_name);
9421 if (type_name == subtype_name)
9428 /* Given a pointer to a tree node for a subrange type, return a pointer
9429 to a DIE that describes the given type. */
9432 subrange_type_die (tree type, dw_die_ref context_die)
9434 dw_die_ref subrange_die;
9435 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
9437 if (context_die == NULL)
9438 context_die = comp_unit_die;
9440 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
9442 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
9444 /* The size of the subrange type and its base type do not match,
9445 so we need to generate a size attribute for the subrange type. */
9446 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
9449 if (TYPE_MIN_VALUE (type) != NULL)
9450 add_bound_info (subrange_die, DW_AT_lower_bound,
9451 TYPE_MIN_VALUE (type));
9452 if (TYPE_MAX_VALUE (type) != NULL)
9453 add_bound_info (subrange_die, DW_AT_upper_bound,
9454 TYPE_MAX_VALUE (type));
9456 return subrange_die;
9459 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9460 entry that chains various modifiers in front of the given type. */
9463 modified_type_die (tree type, int is_const_type, int is_volatile_type,
9464 dw_die_ref context_die)
9466 enum tree_code code = TREE_CODE (type);
9467 dw_die_ref mod_type_die;
9468 dw_die_ref sub_die = NULL;
9469 tree item_type = NULL;
9470 tree qualified_type;
9473 if (code == ERROR_MARK)
9476 /* See if we already have the appropriately qualified variant of
9479 = get_qualified_type (type,
9480 ((is_const_type ? TYPE_QUAL_CONST : 0)
9481 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
9483 /* If we do, then we can just use its DIE, if it exists. */
9486 mod_type_die = lookup_type_die (qualified_type);
9488 return mod_type_die;
9491 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
9493 /* Handle C typedef types. */
9494 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
9496 tree dtype = TREE_TYPE (name);
9498 if (qualified_type == dtype)
9500 /* For a named type, use the typedef. */
9501 gen_type_die (qualified_type, context_die);
9502 return lookup_type_die (qualified_type);
9504 else if (is_const_type < TYPE_READONLY (dtype)
9505 || is_volatile_type < TYPE_VOLATILE (dtype)
9506 || (is_const_type <= TYPE_READONLY (dtype)
9507 && is_volatile_type <= TYPE_VOLATILE (dtype)
9508 && DECL_ORIGINAL_TYPE (name) != type))
9509 /* cv-unqualified version of named type. Just use the unnamed
9510 type to which it refers. */
9511 return modified_type_die (DECL_ORIGINAL_TYPE (name),
9512 is_const_type, is_volatile_type,
9514 /* Else cv-qualified version of named type; fall through. */
9519 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
9520 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
9522 else if (is_volatile_type)
9524 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
9525 sub_die = modified_type_die (type, 0, 0, context_die);
9527 else if (code == POINTER_TYPE)
9529 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
9530 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9531 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9532 item_type = TREE_TYPE (type);
9534 else if (code == REFERENCE_TYPE)
9536 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
9537 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9538 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9539 item_type = TREE_TYPE (type);
9541 else if (is_subrange_type (type))
9543 mod_type_die = subrange_type_die (type, context_die);
9544 item_type = TREE_TYPE (type);
9546 else if (is_base_type (type))
9547 mod_type_die = base_type_die (type);
9550 gen_type_die (type, context_die);
9552 /* We have to get the type_main_variant here (and pass that to the
9553 `lookup_type_die' routine) because the ..._TYPE node we have
9554 might simply be a *copy* of some original type node (where the
9555 copy was created to help us keep track of typedef names) and
9556 that copy might have a different TYPE_UID from the original
9558 if (TREE_CODE (type) != VECTOR_TYPE)
9559 return lookup_type_die (type_main_variant (type));
9561 /* Vectors have the debugging information in the type,
9562 not the main variant. */
9563 return lookup_type_die (type);
9566 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9567 don't output a DW_TAG_typedef, since there isn't one in the
9568 user's program; just attach a DW_AT_name to the type. */
9570 && (TREE_CODE (name) != TYPE_DECL
9571 || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
9573 if (TREE_CODE (name) == TYPE_DECL)
9574 /* Could just call add_name_and_src_coords_attributes here,
9575 but since this is a builtin type it doesn't have any
9576 useful source coordinates anyway. */
9577 name = DECL_NAME (name);
9578 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
9582 equate_type_number_to_die (qualified_type, mod_type_die);
9585 /* We must do this after the equate_type_number_to_die call, in case
9586 this is a recursive type. This ensures that the modified_type_die
9587 recursion will terminate even if the type is recursive. Recursive
9588 types are possible in Ada. */
9589 sub_die = modified_type_die (item_type,
9590 TYPE_READONLY (item_type),
9591 TYPE_VOLATILE (item_type),
9594 if (sub_die != NULL)
9595 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
9597 return mod_type_die;
9600 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
9601 an enumerated type. */
9604 type_is_enum (const_tree type)
9606 return TREE_CODE (type) == ENUMERAL_TYPE;
9609 /* Return the DBX register number described by a given RTL node. */
9612 dbx_reg_number (const_rtx rtl)
9614 unsigned regno = REGNO (rtl);
9616 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
9618 #ifdef LEAF_REG_REMAP
9619 if (current_function_uses_only_leaf_regs)
9621 int leaf_reg = LEAF_REG_REMAP (regno);
9623 regno = (unsigned) leaf_reg;
9627 return DBX_REGISTER_NUMBER (regno);
9630 /* Optionally add a DW_OP_piece term to a location description expression.
9631 DW_OP_piece is only added if the location description expression already
9632 doesn't end with DW_OP_piece. */
9635 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
9637 dw_loc_descr_ref loc;
9639 if (*list_head != NULL)
9641 /* Find the end of the chain. */
9642 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
9645 if (loc->dw_loc_opc != DW_OP_piece)
9646 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
9650 /* Return a location descriptor that designates a machine register or
9651 zero if there is none. */
9653 static dw_loc_descr_ref
9654 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
9658 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
9661 regs = targetm.dwarf_register_span (rtl);
9663 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
9664 return multiple_reg_loc_descriptor (rtl, regs, initialized);
9666 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
9669 /* Return a location descriptor that designates a machine register for
9670 a given hard register number. */
9672 static dw_loc_descr_ref
9673 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
9675 dw_loc_descr_ref reg_loc_descr = new_reg_loc_descr (regno, 0);
9677 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9678 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9680 return reg_loc_descr;
9683 /* Given an RTL of a register, return a location descriptor that
9684 designates a value that spans more than one register. */
9686 static dw_loc_descr_ref
9687 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
9688 enum var_init_status initialized)
9692 dw_loc_descr_ref loc_result = NULL;
9695 #ifdef LEAF_REG_REMAP
9696 if (current_function_uses_only_leaf_regs)
9698 int leaf_reg = LEAF_REG_REMAP (reg);
9700 reg = (unsigned) leaf_reg;
9703 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
9704 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
9706 /* Simple, contiguous registers. */
9707 if (regs == NULL_RTX)
9709 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
9716 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
9717 VAR_INIT_STATUS_INITIALIZED);
9718 add_loc_descr (&loc_result, t);
9719 add_loc_descr_op_piece (&loc_result, size);
9725 /* Now onto stupid register sets in non contiguous locations. */
9727 gcc_assert (GET_CODE (regs) == PARALLEL);
9729 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9732 for (i = 0; i < XVECLEN (regs, 0); ++i)
9736 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
9737 VAR_INIT_STATUS_INITIALIZED);
9738 add_loc_descr (&loc_result, t);
9739 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9740 add_loc_descr_op_piece (&loc_result, size);
9743 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9744 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9748 #endif /* DWARF2_DEBUGGING_INFO */
9750 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
9752 /* Return a location descriptor that designates a constant. */
9754 static dw_loc_descr_ref
9755 int_loc_descriptor (HOST_WIDE_INT i)
9757 enum dwarf_location_atom op;
9759 /* Pick the smallest representation of a constant, rather than just
9760 defaulting to the LEB encoding. */
9764 op = DW_OP_lit0 + i;
9767 else if (i <= 0xffff)
9769 else if (HOST_BITS_PER_WIDE_INT == 32
9779 else if (i >= -0x8000)
9781 else if (HOST_BITS_PER_WIDE_INT == 32
9782 || i >= -0x80000000)
9788 return new_loc_descr (op, i, 0);
9792 #ifdef DWARF2_DEBUGGING_INFO
9794 /* Return a location descriptor that designates a base+offset location. */
9796 static dw_loc_descr_ref
9797 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
9798 enum var_init_status initialized)
9801 dw_loc_descr_ref result;
9802 dw_fde_ref fde = current_fde ();
9804 /* We only use "frame base" when we're sure we're talking about the
9805 post-prologue local stack frame. We do this by *not* running
9806 register elimination until this point, and recognizing the special
9807 argument pointer and soft frame pointer rtx's. */
9808 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
9810 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
9814 if (GET_CODE (elim) == PLUS)
9816 offset += INTVAL (XEXP (elim, 1));
9817 elim = XEXP (elim, 0);
9819 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
9820 && (elim == hard_frame_pointer_rtx
9821 || elim == stack_pointer_rtx))
9822 || elim == (frame_pointer_needed
9823 ? hard_frame_pointer_rtx
9824 : stack_pointer_rtx));
9826 /* If drap register is used to align stack, use frame
9827 pointer + offset to access stack variables. If stack
9828 is aligned without drap, use stack pointer + offset to
9829 access stack variables. */
9830 if (crtl->stack_realign_tried
9831 && cfa.reg == HARD_FRAME_POINTER_REGNUM
9832 && reg == frame_pointer_rtx)
9835 = DWARF_FRAME_REGNUM (cfa.indirect
9836 ? HARD_FRAME_POINTER_REGNUM
9837 : STACK_POINTER_REGNUM);
9838 return new_reg_loc_descr (base_reg, offset);
9841 offset += frame_pointer_fb_offset;
9842 return new_loc_descr (DW_OP_fbreg, offset, 0);
9846 && fde->drap_reg != INVALID_REGNUM
9847 && (fde->drap_reg == REGNO (reg)
9848 || fde->vdrap_reg == REGNO (reg)))
9850 /* Use cfa+offset to represent the location of arguments passed
9851 on stack when drap is used to align stack. */
9852 return new_loc_descr (DW_OP_fbreg, offset, 0);
9855 regno = dbx_reg_number (reg);
9857 result = new_loc_descr (DW_OP_breg0 + regno, offset, 0);
9859 result = new_loc_descr (DW_OP_bregx, regno, offset);
9861 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9862 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9867 /* Return true if this RTL expression describes a base+offset calculation. */
9870 is_based_loc (const_rtx rtl)
9872 return (GET_CODE (rtl) == PLUS
9873 && ((REG_P (XEXP (rtl, 0))
9874 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
9875 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
9878 /* Return a descriptor that describes the concatenation of N locations
9879 used to form the address of a memory location. */
9881 static dw_loc_descr_ref
9882 concatn_mem_loc_descriptor (rtx concatn, enum machine_mode mode,
9883 enum var_init_status initialized)
9886 dw_loc_descr_ref cc_loc_result = NULL;
9887 unsigned int n = XVECLEN (concatn, 0);
9889 for (i = 0; i < n; ++i)
9891 dw_loc_descr_ref ref;
9892 rtx x = XVECEXP (concatn, 0, i);
9894 ref = mem_loc_descriptor (x, mode, VAR_INIT_STATUS_INITIALIZED);
9898 add_loc_descr (&cc_loc_result, ref);
9899 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9902 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9903 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9905 return cc_loc_result;
9908 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
9911 static dw_loc_descr_ref
9912 tls_mem_loc_descriptor (rtx mem)
9915 dw_loc_descr_ref loc_result, loc_result2;
9917 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
9920 base = get_base_address (MEM_EXPR (mem));
9922 || TREE_CODE (base) != VAR_DECL
9923 || !DECL_THREAD_LOCAL_P (base))
9926 loc_result = loc_descriptor_from_tree_1 (MEM_EXPR (mem), 2);
9927 if (loc_result == NULL)
9930 if (INTVAL (MEM_OFFSET (mem)))
9932 if (INTVAL (MEM_OFFSET (mem)) >= 0)
9933 add_loc_descr (&loc_result,
9934 new_loc_descr (DW_OP_plus_uconst,
9935 INTVAL (MEM_OFFSET (mem)), 0));
9938 loc_result2 = mem_loc_descriptor (MEM_OFFSET (mem), GET_MODE (mem),
9939 VAR_INIT_STATUS_INITIALIZED);
9940 if (loc_result2 == 0)
9942 add_loc_descr (&loc_result, loc_result2);
9943 add_loc_descr (&loc_result, new_loc_descr (DW_OP_plus, 0, 0));
9950 /* The following routine converts the RTL for a variable or parameter
9951 (resident in memory) into an equivalent Dwarf representation of a
9952 mechanism for getting the address of that same variable onto the top of a
9953 hypothetical "address evaluation" stack.
9955 When creating memory location descriptors, we are effectively transforming
9956 the RTL for a memory-resident object into its Dwarf postfix expression
9957 equivalent. This routine recursively descends an RTL tree, turning
9958 it into Dwarf postfix code as it goes.
9960 MODE is the mode of the memory reference, needed to handle some
9961 autoincrement addressing modes.
9963 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
9964 location list for RTL.
9966 Return 0 if we can't represent the location. */
9968 static dw_loc_descr_ref
9969 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
9970 enum var_init_status initialized)
9972 dw_loc_descr_ref mem_loc_result = NULL;
9973 enum dwarf_location_atom op;
9975 /* Note that for a dynamically sized array, the location we will generate a
9976 description of here will be the lowest numbered location which is
9977 actually within the array. That's *not* necessarily the same as the
9978 zeroth element of the array. */
9980 rtl = targetm.delegitimize_address (rtl);
9982 switch (GET_CODE (rtl))
9987 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
9988 just fall into the SUBREG code. */
9990 /* ... fall through ... */
9993 /* The case of a subreg may arise when we have a local (register)
9994 variable or a formal (register) parameter which doesn't quite fill
9995 up an entire register. For now, just assume that it is
9996 legitimate to make the Dwarf info refer to the whole register which
9997 contains the given subreg. */
9998 rtl = XEXP (rtl, 0);
10000 /* ... fall through ... */
10003 /* Whenever a register number forms a part of the description of the
10004 method for calculating the (dynamic) address of a memory resident
10005 object, DWARF rules require the register number be referred to as
10006 a "base register". This distinction is not based in any way upon
10007 what category of register the hardware believes the given register
10008 belongs to. This is strictly DWARF terminology we're dealing with
10009 here. Note that in cases where the location of a memory-resident
10010 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
10011 OP_CONST (0)) the actual DWARF location descriptor that we generate
10012 may just be OP_BASEREG (basereg). This may look deceptively like
10013 the object in question was allocated to a register (rather than in
10014 memory) so DWARF consumers need to be aware of the subtle
10015 distinction between OP_REG and OP_BASEREG. */
10016 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
10017 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
10018 else if (stack_realign_drap
10020 && crtl->args.internal_arg_pointer == rtl
10021 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
10023 /* If RTL is internal_arg_pointer, which has been optimized
10024 out, use DRAP instead. */
10025 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
10026 VAR_INIT_STATUS_INITIALIZED);
10031 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10032 VAR_INIT_STATUS_INITIALIZED);
10033 if (mem_loc_result == NULL)
10034 mem_loc_result = tls_mem_loc_descriptor (rtl);
10035 if (mem_loc_result != 0)
10036 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
10040 rtl = XEXP (rtl, 1);
10042 /* ... fall through ... */
10045 /* Some ports can transform a symbol ref into a label ref, because
10046 the symbol ref is too far away and has to be dumped into a constant
10050 /* Alternatively, the symbol in the constant pool might be referenced
10051 by a different symbol. */
10052 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
10055 rtx tmp = get_pool_constant_mark (rtl, &marked);
10057 if (GET_CODE (tmp) == SYMBOL_REF)
10060 if (CONSTANT_POOL_ADDRESS_P (tmp))
10061 get_pool_constant_mark (tmp, &marked);
10066 /* If all references to this pool constant were optimized away,
10067 it was not output and thus we can't represent it.
10068 FIXME: might try to use DW_OP_const_value here, though
10069 DW_OP_piece complicates it. */
10074 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
10075 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
10076 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
10077 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10081 /* Extract the PLUS expression nested inside and fall into
10082 PLUS code below. */
10083 rtl = XEXP (rtl, 1);
10088 /* Turn these into a PLUS expression and fall into the PLUS code
10090 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
10091 GEN_INT (GET_CODE (rtl) == PRE_INC
10092 ? GET_MODE_UNIT_SIZE (mode)
10093 : -GET_MODE_UNIT_SIZE (mode)));
10095 /* ... fall through ... */
10099 if (is_based_loc (rtl))
10100 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
10101 INTVAL (XEXP (rtl, 1)),
10102 VAR_INIT_STATUS_INITIALIZED);
10105 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
10106 VAR_INIT_STATUS_INITIALIZED);
10107 if (mem_loc_result == 0)
10110 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
10111 && INTVAL (XEXP (rtl, 1)) >= 0)
10112 add_loc_descr (&mem_loc_result,
10113 new_loc_descr (DW_OP_plus_uconst,
10114 INTVAL (XEXP (rtl, 1)), 0));
10117 dw_loc_descr_ref mem_loc_result2
10118 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10119 VAR_INIT_STATUS_INITIALIZED);
10120 if (mem_loc_result2 == 0)
10122 add_loc_descr (&mem_loc_result, mem_loc_result2);
10123 add_loc_descr (&mem_loc_result,
10124 new_loc_descr (DW_OP_plus, 0, 0));
10129 /* If a pseudo-reg is optimized away, it is possible for it to
10130 be replaced with a MEM containing a multiply or shift. */
10149 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
10150 VAR_INIT_STATUS_INITIALIZED);
10151 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10152 VAR_INIT_STATUS_INITIALIZED);
10154 if (op0 == 0 || op1 == 0)
10157 mem_loc_result = op0;
10158 add_loc_descr (&mem_loc_result, op1);
10159 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
10164 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
10168 mem_loc_result = concatn_mem_loc_descriptor (rtl, mode,
10169 VAR_INIT_STATUS_INITIALIZED);
10173 /* If delegitimize_address couldn't do anything with the UNSPEC, we
10174 can't express it in the debug info. This can happen e.g. with some
10179 gcc_unreachable ();
10182 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10183 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10185 return mem_loc_result;
10188 /* Return a descriptor that describes the concatenation of two locations.
10189 This is typically a complex variable. */
10191 static dw_loc_descr_ref
10192 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
10194 dw_loc_descr_ref cc_loc_result = NULL;
10195 dw_loc_descr_ref x0_ref = loc_descriptor (x0, VAR_INIT_STATUS_INITIALIZED);
10196 dw_loc_descr_ref x1_ref = loc_descriptor (x1, VAR_INIT_STATUS_INITIALIZED);
10198 if (x0_ref == 0 || x1_ref == 0)
10201 cc_loc_result = x0_ref;
10202 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
10204 add_loc_descr (&cc_loc_result, x1_ref);
10205 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
10207 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10208 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10210 return cc_loc_result;
10213 /* Return a descriptor that describes the concatenation of N
10216 static dw_loc_descr_ref
10217 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
10220 dw_loc_descr_ref cc_loc_result = NULL;
10221 unsigned int n = XVECLEN (concatn, 0);
10223 for (i = 0; i < n; ++i)
10225 dw_loc_descr_ref ref;
10226 rtx x = XVECEXP (concatn, 0, i);
10228 ref = loc_descriptor (x, VAR_INIT_STATUS_INITIALIZED);
10232 add_loc_descr (&cc_loc_result, ref);
10233 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
10236 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10237 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10239 return cc_loc_result;
10242 /* Output a proper Dwarf location descriptor for a variable or parameter
10243 which is either allocated in a register or in a memory location. For a
10244 register, we just generate an OP_REG and the register number. For a
10245 memory location we provide a Dwarf postfix expression describing how to
10246 generate the (dynamic) address of the object onto the address stack.
10248 If we don't know how to describe it, return 0. */
10250 static dw_loc_descr_ref
10251 loc_descriptor (rtx rtl, enum var_init_status initialized)
10253 dw_loc_descr_ref loc_result = NULL;
10255 switch (GET_CODE (rtl))
10258 /* The case of a subreg may arise when we have a local (register)
10259 variable or a formal (register) parameter which doesn't quite fill
10260 up an entire register. For now, just assume that it is
10261 legitimate to make the Dwarf info refer to the whole register which
10262 contains the given subreg. */
10263 rtl = SUBREG_REG (rtl);
10265 /* ... fall through ... */
10268 loc_result = reg_loc_descriptor (rtl, initialized);
10272 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10274 if (loc_result == NULL)
10275 loc_result = tls_mem_loc_descriptor (rtl);
10279 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
10284 loc_result = concatn_loc_descriptor (rtl, initialized);
10289 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
10291 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), initialized);
10295 rtl = XEXP (rtl, 1);
10300 rtvec par_elems = XVEC (rtl, 0);
10301 int num_elem = GET_NUM_ELEM (par_elems);
10302 enum machine_mode mode;
10305 /* Create the first one, so we have something to add to. */
10306 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
10308 if (loc_result == NULL)
10310 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
10311 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10312 for (i = 1; i < num_elem; i++)
10314 dw_loc_descr_ref temp;
10316 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
10320 add_loc_descr (&loc_result, temp);
10321 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
10322 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10328 gcc_unreachable ();
10334 /* Similar, but generate the descriptor from trees instead of rtl. This comes
10335 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
10336 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
10337 top-level invocation, and we require the address of LOC; is 0 if we require
10338 the value of LOC. */
10340 static dw_loc_descr_ref
10341 loc_descriptor_from_tree_1 (tree loc, int want_address)
10343 dw_loc_descr_ref ret, ret1;
10344 int have_address = 0;
10345 enum dwarf_location_atom op;
10347 /* ??? Most of the time we do not take proper care for sign/zero
10348 extending the values properly. Hopefully this won't be a real
10351 switch (TREE_CODE (loc))
10356 case PLACEHOLDER_EXPR:
10357 /* This case involves extracting fields from an object to determine the
10358 position of other fields. We don't try to encode this here. The
10359 only user of this is Ada, which encodes the needed information using
10360 the names of types. */
10366 case PREINCREMENT_EXPR:
10367 case PREDECREMENT_EXPR:
10368 case POSTINCREMENT_EXPR:
10369 case POSTDECREMENT_EXPR:
10370 /* There are no opcodes for these operations. */
10374 /* If we already want an address, there's nothing we can do. */
10378 /* Otherwise, process the argument and look for the address. */
10379 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
10382 if (DECL_THREAD_LOCAL_P (loc))
10386 unsigned second_op;
10388 if (targetm.have_tls)
10390 /* If this is not defined, we have no way to emit the
10392 if (!targetm.asm_out.output_dwarf_dtprel)
10395 /* The way DW_OP_GNU_push_tls_address is specified, we
10396 can only look up addresses of objects in the current
10398 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
10400 first_op = INTERNAL_DW_OP_tls_addr;
10401 second_op = DW_OP_GNU_push_tls_address;
10405 if (!targetm.emutls.debug_form_tls_address)
10407 loc = emutls_decl (loc);
10408 first_op = DW_OP_addr;
10409 second_op = DW_OP_form_tls_address;
10412 rtl = rtl_for_decl_location (loc);
10413 if (rtl == NULL_RTX)
10418 rtl = XEXP (rtl, 0);
10419 if (! CONSTANT_P (rtl))
10422 ret = new_loc_descr (first_op, 0, 0);
10423 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10424 ret->dw_loc_oprnd1.v.val_addr = rtl;
10426 ret1 = new_loc_descr (second_op, 0, 0);
10427 add_loc_descr (&ret, ret1);
10435 if (DECL_HAS_VALUE_EXPR_P (loc))
10436 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
10441 case FUNCTION_DECL:
10443 rtx rtl = rtl_for_decl_location (loc);
10445 if (rtl == NULL_RTX)
10447 else if (GET_CODE (rtl) == CONST_INT)
10449 HOST_WIDE_INT val = INTVAL (rtl);
10450 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
10451 val &= GET_MODE_MASK (DECL_MODE (loc));
10452 ret = int_loc_descriptor (val);
10454 else if (GET_CODE (rtl) == CONST_STRING)
10456 else if (CONSTANT_P (rtl))
10458 ret = new_loc_descr (DW_OP_addr, 0, 0);
10459 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10460 ret->dw_loc_oprnd1.v.val_addr = rtl;
10464 enum machine_mode mode;
10466 /* Certain constructs can only be represented at top-level. */
10467 if (want_address == 2)
10468 return loc_descriptor (rtl, VAR_INIT_STATUS_INITIALIZED);
10470 mode = GET_MODE (rtl);
10473 rtl = XEXP (rtl, 0);
10476 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10482 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10486 case COMPOUND_EXPR:
10487 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
10490 case VIEW_CONVERT_EXPR:
10493 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
10495 case COMPONENT_REF:
10496 case BIT_FIELD_REF:
10498 case ARRAY_RANGE_REF:
10501 HOST_WIDE_INT bitsize, bitpos, bytepos;
10502 enum machine_mode mode;
10504 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
10506 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
10507 &unsignedp, &volatilep, false);
10512 ret = loc_descriptor_from_tree_1 (obj, 1);
10514 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
10517 if (offset != NULL_TREE)
10519 /* Variable offset. */
10520 ret1 = loc_descriptor_from_tree_1 (offset, 0);
10523 add_loc_descr (&ret, ret1);
10524 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10527 bytepos = bitpos / BITS_PER_UNIT;
10529 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
10530 else if (bytepos < 0)
10532 add_loc_descr (&ret, int_loc_descriptor (bytepos));
10533 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10541 if (host_integerp (loc, 0))
10542 ret = int_loc_descriptor (tree_low_cst (loc, 0));
10549 /* Get an RTL for this, if something has been emitted. */
10550 rtx rtl = lookup_constant_def (loc);
10551 enum machine_mode mode;
10553 if (!rtl || !MEM_P (rtl))
10555 mode = GET_MODE (rtl);
10556 rtl = XEXP (rtl, 0);
10557 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10562 case TRUTH_AND_EXPR:
10563 case TRUTH_ANDIF_EXPR:
10568 case TRUTH_XOR_EXPR:
10573 case TRUTH_OR_EXPR:
10574 case TRUTH_ORIF_EXPR:
10579 case FLOOR_DIV_EXPR:
10580 case CEIL_DIV_EXPR:
10581 case ROUND_DIV_EXPR:
10582 case TRUNC_DIV_EXPR:
10590 case FLOOR_MOD_EXPR:
10591 case CEIL_MOD_EXPR:
10592 case ROUND_MOD_EXPR:
10593 case TRUNC_MOD_EXPR:
10606 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
10609 case POINTER_PLUS_EXPR:
10611 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
10612 && host_integerp (TREE_OPERAND (loc, 1), 0))
10614 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10618 add_loc_descr (&ret,
10619 new_loc_descr (DW_OP_plus_uconst,
10620 tree_low_cst (TREE_OPERAND (loc, 1),
10630 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10637 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10644 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10651 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10666 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10667 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10668 if (ret == 0 || ret1 == 0)
10671 add_loc_descr (&ret, ret1);
10672 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10675 case TRUTH_NOT_EXPR:
10689 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10693 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10699 const enum tree_code code =
10700 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
10702 loc = build3 (COND_EXPR, TREE_TYPE (loc),
10703 build2 (code, integer_type_node,
10704 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
10705 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
10708 /* ... fall through ... */
10712 dw_loc_descr_ref lhs
10713 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10714 dw_loc_descr_ref rhs
10715 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
10716 dw_loc_descr_ref bra_node, jump_node, tmp;
10718 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10719 if (ret == 0 || lhs == 0 || rhs == 0)
10722 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
10723 add_loc_descr (&ret, bra_node);
10725 add_loc_descr (&ret, rhs);
10726 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
10727 add_loc_descr (&ret, jump_node);
10729 add_loc_descr (&ret, lhs);
10730 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10731 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
10733 /* ??? Need a node to point the skip at. Use a nop. */
10734 tmp = new_loc_descr (DW_OP_nop, 0, 0);
10735 add_loc_descr (&ret, tmp);
10736 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10737 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
10741 case FIX_TRUNC_EXPR:
10745 /* Leave front-end specific codes as simply unknown. This comes
10746 up, for instance, with the C STMT_EXPR. */
10747 if ((unsigned int) TREE_CODE (loc)
10748 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
10751 #ifdef ENABLE_CHECKING
10752 /* Otherwise this is a generic code; we should just lists all of
10753 these explicitly. We forgot one. */
10754 gcc_unreachable ();
10756 /* In a release build, we want to degrade gracefully: better to
10757 generate incomplete debugging information than to crash. */
10762 /* Show if we can't fill the request for an address. */
10763 if (want_address && !have_address)
10766 /* If we've got an address and don't want one, dereference. */
10767 if (!want_address && have_address && ret)
10769 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
10771 if (size > DWARF2_ADDR_SIZE || size == -1)
10773 else if (size == DWARF2_ADDR_SIZE)
10776 op = DW_OP_deref_size;
10778 add_loc_descr (&ret, new_loc_descr (op, size, 0));
10784 static inline dw_loc_descr_ref
10785 loc_descriptor_from_tree (tree loc)
10787 return loc_descriptor_from_tree_1 (loc, 2);
10790 /* Given a value, round it up to the lowest multiple of `boundary'
10791 which is not less than the value itself. */
10793 static inline HOST_WIDE_INT
10794 ceiling (HOST_WIDE_INT value, unsigned int boundary)
10796 return (((value + boundary - 1) / boundary) * boundary);
10799 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
10800 pointer to the declared type for the relevant field variable, or return
10801 `integer_type_node' if the given node turns out to be an
10802 ERROR_MARK node. */
10805 field_type (const_tree decl)
10809 if (TREE_CODE (decl) == ERROR_MARK)
10810 return integer_type_node;
10812 type = DECL_BIT_FIELD_TYPE (decl);
10813 if (type == NULL_TREE)
10814 type = TREE_TYPE (decl);
10819 /* Given a pointer to a tree node, return the alignment in bits for
10820 it, or else return BITS_PER_WORD if the node actually turns out to
10821 be an ERROR_MARK node. */
10823 static inline unsigned
10824 simple_type_align_in_bits (const_tree type)
10826 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
10829 static inline unsigned
10830 simple_decl_align_in_bits (const_tree decl)
10832 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
10835 /* Return the result of rounding T up to ALIGN. */
10837 static inline HOST_WIDE_INT
10838 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
10840 /* We must be careful if T is negative because HOST_WIDE_INT can be
10841 either "above" or "below" unsigned int as per the C promotion
10842 rules, depending on the host, thus making the signedness of the
10843 direct multiplication and division unpredictable. */
10844 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
10850 return (HOST_WIDE_INT) u;
10853 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
10854 lowest addressed byte of the "containing object" for the given FIELD_DECL,
10855 or return 0 if we are unable to determine what that offset is, either
10856 because the argument turns out to be a pointer to an ERROR_MARK node, or
10857 because the offset is actually variable. (We can't handle the latter case
10860 static HOST_WIDE_INT
10861 field_byte_offset (const_tree decl)
10863 HOST_WIDE_INT object_offset_in_bits;
10864 HOST_WIDE_INT bitpos_int;
10866 if (TREE_CODE (decl) == ERROR_MARK)
10869 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
10871 /* We cannot yet cope with fields whose positions are variable, so
10872 for now, when we see such things, we simply return 0. Someday, we may
10873 be able to handle such cases, but it will be damn difficult. */
10874 if (! host_integerp (bit_position (decl), 0))
10877 bitpos_int = int_bit_position (decl);
10879 #ifdef PCC_BITFIELD_TYPE_MATTERS
10880 if (PCC_BITFIELD_TYPE_MATTERS)
10883 tree field_size_tree;
10884 HOST_WIDE_INT deepest_bitpos;
10885 unsigned HOST_WIDE_INT field_size_in_bits;
10886 unsigned int type_align_in_bits;
10887 unsigned int decl_align_in_bits;
10888 unsigned HOST_WIDE_INT type_size_in_bits;
10890 type = field_type (decl);
10891 field_size_tree = DECL_SIZE (decl);
10893 /* The size could be unspecified if there was an error, or for
10894 a flexible array member. */
10895 if (! field_size_tree)
10896 field_size_tree = bitsize_zero_node;
10898 /* If we don't know the size of the field, pretend it's a full word. */
10899 if (host_integerp (field_size_tree, 1))
10900 field_size_in_bits = tree_low_cst (field_size_tree, 1);
10902 field_size_in_bits = BITS_PER_WORD;
10904 type_size_in_bits = simple_type_size_in_bits (type);
10905 type_align_in_bits = simple_type_align_in_bits (type);
10906 decl_align_in_bits = simple_decl_align_in_bits (decl);
10908 /* The GCC front-end doesn't make any attempt to keep track of the
10909 starting bit offset (relative to the start of the containing
10910 structure type) of the hypothetical "containing object" for a
10911 bit-field. Thus, when computing the byte offset value for the
10912 start of the "containing object" of a bit-field, we must deduce
10913 this information on our own. This can be rather tricky to do in
10914 some cases. For example, handling the following structure type
10915 definition when compiling for an i386/i486 target (which only
10916 aligns long long's to 32-bit boundaries) can be very tricky:
10918 struct S { int field1; long long field2:31; };
10920 Fortunately, there is a simple rule-of-thumb which can be used
10921 in such cases. When compiling for an i386/i486, GCC will
10922 allocate 8 bytes for the structure shown above. It decides to
10923 do this based upon one simple rule for bit-field allocation.
10924 GCC allocates each "containing object" for each bit-field at
10925 the first (i.e. lowest addressed) legitimate alignment boundary
10926 (based upon the required minimum alignment for the declared
10927 type of the field) which it can possibly use, subject to the
10928 condition that there is still enough available space remaining
10929 in the containing object (when allocated at the selected point)
10930 to fully accommodate all of the bits of the bit-field itself.
10932 This simple rule makes it obvious why GCC allocates 8 bytes for
10933 each object of the structure type shown above. When looking
10934 for a place to allocate the "containing object" for `field2',
10935 the compiler simply tries to allocate a 64-bit "containing
10936 object" at each successive 32-bit boundary (starting at zero)
10937 until it finds a place to allocate that 64- bit field such that
10938 at least 31 contiguous (and previously unallocated) bits remain
10939 within that selected 64 bit field. (As it turns out, for the
10940 example above, the compiler finds it is OK to allocate the
10941 "containing object" 64-bit field at bit-offset zero within the
10944 Here we attempt to work backwards from the limited set of facts
10945 we're given, and we try to deduce from those facts, where GCC
10946 must have believed that the containing object started (within
10947 the structure type). The value we deduce is then used (by the
10948 callers of this routine) to generate DW_AT_location and
10949 DW_AT_bit_offset attributes for fields (both bit-fields and, in
10950 the case of DW_AT_location, regular fields as well). */
10952 /* Figure out the bit-distance from the start of the structure to
10953 the "deepest" bit of the bit-field. */
10954 deepest_bitpos = bitpos_int + field_size_in_bits;
10956 /* This is the tricky part. Use some fancy footwork to deduce
10957 where the lowest addressed bit of the containing object must
10959 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10961 /* Round up to type_align by default. This works best for
10963 object_offset_in_bits
10964 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
10966 if (object_offset_in_bits > bitpos_int)
10968 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10970 /* Round up to decl_align instead. */
10971 object_offset_in_bits
10972 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
10977 object_offset_in_bits = bitpos_int;
10979 return object_offset_in_bits / BITS_PER_UNIT;
10982 /* The following routines define various Dwarf attributes and any data
10983 associated with them. */
10985 /* Add a location description attribute value to a DIE.
10987 This emits location attributes suitable for whole variables and
10988 whole parameters. Note that the location attributes for struct fields are
10989 generated by the routine `data_member_location_attribute' below. */
10992 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
10993 dw_loc_descr_ref descr)
10996 add_AT_loc (die, attr_kind, descr);
10999 /* Attach the specialized form of location attribute used for data members of
11000 struct and union types. In the special case of a FIELD_DECL node which
11001 represents a bit-field, the "offset" part of this special location
11002 descriptor must indicate the distance in bytes from the lowest-addressed
11003 byte of the containing struct or union type to the lowest-addressed byte of
11004 the "containing object" for the bit-field. (See the `field_byte_offset'
11007 For any given bit-field, the "containing object" is a hypothetical object
11008 (of some integral or enum type) within which the given bit-field lives. The
11009 type of this hypothetical "containing object" is always the same as the
11010 declared type of the individual bit-field itself (for GCC anyway... the
11011 DWARF spec doesn't actually mandate this). Note that it is the size (in
11012 bytes) of the hypothetical "containing object" which will be given in the
11013 DW_AT_byte_size attribute for this bit-field. (See the
11014 `byte_size_attribute' function below.) It is also used when calculating the
11015 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
11016 function below.) */
11019 add_data_member_location_attribute (dw_die_ref die, tree decl)
11021 HOST_WIDE_INT offset;
11022 dw_loc_descr_ref loc_descr = 0;
11024 if (TREE_CODE (decl) == TREE_BINFO)
11026 /* We're working on the TAG_inheritance for a base class. */
11027 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
11029 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
11030 aren't at a fixed offset from all (sub)objects of the same
11031 type. We need to extract the appropriate offset from our
11032 vtable. The following dwarf expression means
11034 BaseAddr = ObAddr + *((*ObAddr) - Offset)
11036 This is specific to the V3 ABI, of course. */
11038 dw_loc_descr_ref tmp;
11040 /* Make a copy of the object address. */
11041 tmp = new_loc_descr (DW_OP_dup, 0, 0);
11042 add_loc_descr (&loc_descr, tmp);
11044 /* Extract the vtable address. */
11045 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11046 add_loc_descr (&loc_descr, tmp);
11048 /* Calculate the address of the offset. */
11049 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
11050 gcc_assert (offset < 0);
11052 tmp = int_loc_descriptor (-offset);
11053 add_loc_descr (&loc_descr, tmp);
11054 tmp = new_loc_descr (DW_OP_minus, 0, 0);
11055 add_loc_descr (&loc_descr, tmp);
11057 /* Extract the offset. */
11058 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11059 add_loc_descr (&loc_descr, tmp);
11061 /* Add it to the object address. */
11062 tmp = new_loc_descr (DW_OP_plus, 0, 0);
11063 add_loc_descr (&loc_descr, tmp);
11066 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
11069 offset = field_byte_offset (decl);
11073 enum dwarf_location_atom op;
11075 /* The DWARF2 standard says that we should assume that the structure
11076 address is already on the stack, so we can specify a structure field
11077 address by using DW_OP_plus_uconst. */
11079 #ifdef MIPS_DEBUGGING_INFO
11080 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
11081 operator correctly. It works only if we leave the offset on the
11085 op = DW_OP_plus_uconst;
11088 loc_descr = new_loc_descr (op, offset, 0);
11091 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
11094 /* Writes integer values to dw_vec_const array. */
11097 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
11101 *dest++ = val & 0xff;
11107 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
11109 static HOST_WIDE_INT
11110 extract_int (const unsigned char *src, unsigned int size)
11112 HOST_WIDE_INT val = 0;
11118 val |= *--src & 0xff;
11124 /* Writes floating point values to dw_vec_const array. */
11127 insert_float (const_rtx rtl, unsigned char *array)
11129 REAL_VALUE_TYPE rv;
11133 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
11134 real_to_target (val, &rv, GET_MODE (rtl));
11136 /* real_to_target puts 32-bit pieces in each long. Pack them. */
11137 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
11139 insert_int (val[i], 4, array);
11144 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
11145 does not have a "location" either in memory or in a register. These
11146 things can arise in GNU C when a constant is passed as an actual parameter
11147 to an inlined function. They can also arise in C++ where declared
11148 constants do not necessarily get memory "homes". */
11151 add_const_value_attribute (dw_die_ref die, rtx rtl)
11153 switch (GET_CODE (rtl))
11157 HOST_WIDE_INT val = INTVAL (rtl);
11160 add_AT_int (die, DW_AT_const_value, val);
11162 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
11167 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
11168 floating-point constant. A CONST_DOUBLE is used whenever the
11169 constant requires more than one word in order to be adequately
11170 represented. We output CONST_DOUBLEs as blocks. */
11172 enum machine_mode mode = GET_MODE (rtl);
11174 if (SCALAR_FLOAT_MODE_P (mode))
11176 unsigned int length = GET_MODE_SIZE (mode);
11177 unsigned char *array = GGC_NEWVEC (unsigned char, length);
11179 insert_float (rtl, array);
11180 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
11184 /* ??? We really should be using HOST_WIDE_INT throughout. */
11185 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
11187 add_AT_long_long (die, DW_AT_const_value,
11188 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
11195 enum machine_mode mode = GET_MODE (rtl);
11196 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
11197 unsigned int length = CONST_VECTOR_NUNITS (rtl);
11198 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
11202 switch (GET_MODE_CLASS (mode))
11204 case MODE_VECTOR_INT:
11205 for (i = 0, p = array; i < length; i++, p += elt_size)
11207 rtx elt = CONST_VECTOR_ELT (rtl, i);
11208 HOST_WIDE_INT lo, hi;
11210 switch (GET_CODE (elt))
11218 lo = CONST_DOUBLE_LOW (elt);
11219 hi = CONST_DOUBLE_HIGH (elt);
11223 gcc_unreachable ();
11226 if (elt_size <= sizeof (HOST_WIDE_INT))
11227 insert_int (lo, elt_size, p);
11230 unsigned char *p0 = p;
11231 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
11233 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
11234 if (WORDS_BIG_ENDIAN)
11239 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
11240 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
11245 case MODE_VECTOR_FLOAT:
11246 for (i = 0, p = array; i < length; i++, p += elt_size)
11248 rtx elt = CONST_VECTOR_ELT (rtl, i);
11249 insert_float (elt, p);
11254 gcc_unreachable ();
11257 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
11262 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
11268 add_AT_addr (die, DW_AT_const_value, rtl);
11269 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11273 /* In cases where an inlined instance of an inline function is passed
11274 the address of an `auto' variable (which is local to the caller) we
11275 can get a situation where the DECL_RTL of the artificial local
11276 variable (for the inlining) which acts as a stand-in for the
11277 corresponding formal parameter (of the inline function) will look
11278 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
11279 exactly a compile-time constant expression, but it isn't the address
11280 of the (artificial) local variable either. Rather, it represents the
11281 *value* which the artificial local variable always has during its
11282 lifetime. We currently have no way to represent such quasi-constant
11283 values in Dwarf, so for now we just punt and generate nothing. */
11287 /* No other kinds of rtx should be possible here. */
11288 gcc_unreachable ();
11293 /* Determine whether the evaluation of EXPR references any variables
11294 or functions which aren't otherwise used (and therefore may not be
11297 reference_to_unused (tree * tp, int * walk_subtrees,
11298 void * data ATTRIBUTE_UNUSED)
11300 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
11301 *walk_subtrees = 0;
11303 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
11304 && ! TREE_ASM_WRITTEN (*tp))
11306 /* ??? The C++ FE emits debug information for using decls, so
11307 putting gcc_unreachable here falls over. See PR31899. For now
11308 be conservative. */
11309 else if (!cgraph_global_info_ready
11310 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
11312 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
11314 struct varpool_node *node = varpool_node (*tp);
11318 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
11319 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
11321 struct cgraph_node *node = cgraph_node (*tp);
11322 if (node->process || TREE_ASM_WRITTEN (*tp))
11325 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
11331 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
11332 for use in a later add_const_value_attribute call. */
11335 rtl_for_decl_init (tree init, tree type)
11337 rtx rtl = NULL_RTX;
11339 /* If a variable is initialized with a string constant without embedded
11340 zeros, build CONST_STRING. */
11341 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
11343 tree enttype = TREE_TYPE (type);
11344 tree domain = TYPE_DOMAIN (type);
11345 enum machine_mode mode = TYPE_MODE (enttype);
11347 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
11349 && integer_zerop (TYPE_MIN_VALUE (domain))
11350 && compare_tree_int (TYPE_MAX_VALUE (domain),
11351 TREE_STRING_LENGTH (init) - 1) == 0
11352 && ((size_t) TREE_STRING_LENGTH (init)
11353 == strlen (TREE_STRING_POINTER (init)) + 1))
11354 rtl = gen_rtx_CONST_STRING (VOIDmode,
11355 ggc_strdup (TREE_STRING_POINTER (init)));
11357 /* Other aggregates, and complex values, could be represented using
11359 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
11361 /* Vectors only work if their mode is supported by the target.
11362 FIXME: generic vectors ought to work too. */
11363 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
11365 /* If the initializer is something that we know will expand into an
11366 immediate RTL constant, expand it now. We must be careful not to
11367 reference variables which won't be output. */
11368 else if (initializer_constant_valid_p (init, type)
11369 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
11371 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
11373 if (TREE_CODE (type) == VECTOR_TYPE)
11374 switch (TREE_CODE (init))
11379 if (TREE_CONSTANT (init))
11381 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
11382 bool constant_p = true;
11384 unsigned HOST_WIDE_INT ix;
11386 /* Even when ctor is constant, it might contain non-*_CST
11387 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
11388 belong into VECTOR_CST nodes. */
11389 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
11390 if (!CONSTANT_CLASS_P (value))
11392 constant_p = false;
11398 init = build_vector_from_ctor (type, elts);
11408 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
11410 /* If expand_expr returns a MEM, it wasn't immediate. */
11411 gcc_assert (!rtl || !MEM_P (rtl));
11417 /* Generate RTL for the variable DECL to represent its location. */
11420 rtl_for_decl_location (tree decl)
11424 /* Here we have to decide where we are going to say the parameter "lives"
11425 (as far as the debugger is concerned). We only have a couple of
11426 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
11428 DECL_RTL normally indicates where the parameter lives during most of the
11429 activation of the function. If optimization is enabled however, this
11430 could be either NULL or else a pseudo-reg. Both of those cases indicate
11431 that the parameter doesn't really live anywhere (as far as the code
11432 generation parts of GCC are concerned) during most of the function's
11433 activation. That will happen (for example) if the parameter is never
11434 referenced within the function.
11436 We could just generate a location descriptor here for all non-NULL
11437 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
11438 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
11439 where DECL_RTL is NULL or is a pseudo-reg.
11441 Note however that we can only get away with using DECL_INCOMING_RTL as
11442 a backup substitute for DECL_RTL in certain limited cases. In cases
11443 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
11444 we can be sure that the parameter was passed using the same type as it is
11445 declared to have within the function, and that its DECL_INCOMING_RTL
11446 points us to a place where a value of that type is passed.
11448 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
11449 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
11450 because in these cases DECL_INCOMING_RTL points us to a value of some
11451 type which is *different* from the type of the parameter itself. Thus,
11452 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
11453 such cases, the debugger would end up (for example) trying to fetch a
11454 `float' from a place which actually contains the first part of a
11455 `double'. That would lead to really incorrect and confusing
11456 output at debug-time.
11458 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
11459 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
11460 are a couple of exceptions however. On little-endian machines we can
11461 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
11462 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
11463 an integral type that is smaller than TREE_TYPE (decl). These cases arise
11464 when (on a little-endian machine) a non-prototyped function has a
11465 parameter declared to be of type `short' or `char'. In such cases,
11466 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
11467 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
11468 passed `int' value. If the debugger then uses that address to fetch
11469 a `short' or a `char' (on a little-endian machine) the result will be
11470 the correct data, so we allow for such exceptional cases below.
11472 Note that our goal here is to describe the place where the given formal
11473 parameter lives during most of the function's activation (i.e. between the
11474 end of the prologue and the start of the epilogue). We'll do that as best
11475 as we can. Note however that if the given formal parameter is modified
11476 sometime during the execution of the function, then a stack backtrace (at
11477 debug-time) will show the function as having been called with the *new*
11478 value rather than the value which was originally passed in. This happens
11479 rarely enough that it is not a major problem, but it *is* a problem, and
11480 I'd like to fix it.
11482 A future version of dwarf2out.c may generate two additional attributes for
11483 any given DW_TAG_formal_parameter DIE which will describe the "passed
11484 type" and the "passed location" for the given formal parameter in addition
11485 to the attributes we now generate to indicate the "declared type" and the
11486 "active location" for each parameter. This additional set of attributes
11487 could be used by debuggers for stack backtraces. Separately, note that
11488 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
11489 This happens (for example) for inlined-instances of inline function formal
11490 parameters which are never referenced. This really shouldn't be
11491 happening. All PARM_DECL nodes should get valid non-NULL
11492 DECL_INCOMING_RTL values. FIXME. */
11494 /* Use DECL_RTL as the "location" unless we find something better. */
11495 rtl = DECL_RTL_IF_SET (decl);
11497 /* When generating abstract instances, ignore everything except
11498 constants, symbols living in memory, and symbols living in
11499 fixed registers. */
11500 if (! reload_completed)
11503 && (CONSTANT_P (rtl)
11505 && CONSTANT_P (XEXP (rtl, 0)))
11507 && TREE_CODE (decl) == VAR_DECL
11508 && TREE_STATIC (decl))))
11510 rtl = targetm.delegitimize_address (rtl);
11515 else if (TREE_CODE (decl) == PARM_DECL)
11517 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
11519 tree declared_type = TREE_TYPE (decl);
11520 tree passed_type = DECL_ARG_TYPE (decl);
11521 enum machine_mode dmode = TYPE_MODE (declared_type);
11522 enum machine_mode pmode = TYPE_MODE (passed_type);
11524 /* This decl represents a formal parameter which was optimized out.
11525 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
11526 all cases where (rtl == NULL_RTX) just below. */
11527 if (dmode == pmode)
11528 rtl = DECL_INCOMING_RTL (decl);
11529 else if (SCALAR_INT_MODE_P (dmode)
11530 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
11531 && DECL_INCOMING_RTL (decl))
11533 rtx inc = DECL_INCOMING_RTL (decl);
11536 else if (MEM_P (inc))
11538 if (BYTES_BIG_ENDIAN)
11539 rtl = adjust_address_nv (inc, dmode,
11540 GET_MODE_SIZE (pmode)
11541 - GET_MODE_SIZE (dmode));
11548 /* If the parm was passed in registers, but lives on the stack, then
11549 make a big endian correction if the mode of the type of the
11550 parameter is not the same as the mode of the rtl. */
11551 /* ??? This is the same series of checks that are made in dbxout.c before
11552 we reach the big endian correction code there. It isn't clear if all
11553 of these checks are necessary here, but keeping them all is the safe
11555 else if (MEM_P (rtl)
11556 && XEXP (rtl, 0) != const0_rtx
11557 && ! CONSTANT_P (XEXP (rtl, 0))
11558 /* Not passed in memory. */
11559 && !MEM_P (DECL_INCOMING_RTL (decl))
11560 /* Not passed by invisible reference. */
11561 && (!REG_P (XEXP (rtl, 0))
11562 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
11563 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
11564 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
11565 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
11568 /* Big endian correction check. */
11569 && BYTES_BIG_ENDIAN
11570 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
11571 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
11574 int offset = (UNITS_PER_WORD
11575 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
11577 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11578 plus_constant (XEXP (rtl, 0), offset));
11581 else if (TREE_CODE (decl) == VAR_DECL
11584 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
11585 && BYTES_BIG_ENDIAN)
11587 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
11588 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
11590 /* If a variable is declared "register" yet is smaller than
11591 a register, then if we store the variable to memory, it
11592 looks like we're storing a register-sized value, when in
11593 fact we are not. We need to adjust the offset of the
11594 storage location to reflect the actual value's bytes,
11595 else gdb will not be able to display it. */
11597 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11598 plus_constant (XEXP (rtl, 0), rsize-dsize));
11601 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
11602 and will have been substituted directly into all expressions that use it.
11603 C does not have such a concept, but C++ and other languages do. */
11604 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
11605 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
11608 rtl = targetm.delegitimize_address (rtl);
11610 /* If we don't look past the constant pool, we risk emitting a
11611 reference to a constant pool entry that isn't referenced from
11612 code, and thus is not emitted. */
11614 rtl = avoid_constant_pool_reference (rtl);
11619 /* We need to figure out what section we should use as the base for the
11620 address ranges where a given location is valid.
11621 1. If this particular DECL has a section associated with it, use that.
11622 2. If this function has a section associated with it, use that.
11623 3. Otherwise, use the text section.
11624 XXX: If you split a variable across multiple sections, we won't notice. */
11626 static const char *
11627 secname_for_decl (const_tree decl)
11629 const char *secname;
11631 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
11633 tree sectree = DECL_SECTION_NAME (decl);
11634 secname = TREE_STRING_POINTER (sectree);
11636 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
11638 tree sectree = DECL_SECTION_NAME (current_function_decl);
11639 secname = TREE_STRING_POINTER (sectree);
11641 else if (cfun && in_cold_section_p)
11642 secname = crtl->subsections.cold_section_label;
11644 secname = text_section_label;
11649 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
11650 returned. If so, the decl for the COMMON block is returned, and the
11651 value is the offset into the common block for the symbol. */
11654 fortran_common (tree decl, HOST_WIDE_INT *value)
11656 tree val_expr, cvar;
11657 enum machine_mode mode;
11658 HOST_WIDE_INT bitsize, bitpos;
11660 int volatilep = 0, unsignedp = 0;
11662 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
11663 it does not have a value (the offset into the common area), or if it
11664 is thread local (as opposed to global) then it isn't common, and shouldn't
11665 be handled as such. */
11666 if (TREE_CODE (decl) != VAR_DECL
11667 || !TREE_PUBLIC (decl)
11668 || !TREE_STATIC (decl)
11669 || !DECL_HAS_VALUE_EXPR_P (decl)
11673 val_expr = DECL_VALUE_EXPR (decl);
11674 if (TREE_CODE (val_expr) != COMPONENT_REF)
11677 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
11678 &mode, &unsignedp, &volatilep, true);
11680 if (cvar == NULL_TREE
11681 || TREE_CODE (cvar) != VAR_DECL
11682 || DECL_ARTIFICIAL (cvar)
11683 || !TREE_PUBLIC (cvar))
11687 if (offset != NULL)
11689 if (!host_integerp (offset, 0))
11691 *value = tree_low_cst (offset, 0);
11694 *value += bitpos / BITS_PER_UNIT;
11699 /* Dereference a location expression LOC if DECL is passed by invisible
11702 static dw_loc_descr_ref
11703 loc_by_reference (dw_loc_descr_ref loc, tree decl)
11705 HOST_WIDE_INT size;
11706 enum dwarf_location_atom op;
11711 if ((TREE_CODE (decl) != PARM_DECL && TREE_CODE (decl) != RESULT_DECL)
11712 || !DECL_BY_REFERENCE (decl))
11715 size = int_size_in_bytes (TREE_TYPE (decl));
11716 if (size > DWARF2_ADDR_SIZE || size == -1)
11718 else if (size == DWARF2_ADDR_SIZE)
11721 op = DW_OP_deref_size;
11722 add_loc_descr (&loc, new_loc_descr (op, size, 0));
11726 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
11727 data attribute for a variable or a parameter. We generate the
11728 DW_AT_const_value attribute only in those cases where the given variable
11729 or parameter does not have a true "location" either in memory or in a
11730 register. This can happen (for example) when a constant is passed as an
11731 actual argument in a call to an inline function. (It's possible that
11732 these things can crop up in other ways also.) Note that one type of
11733 constant value which can be passed into an inlined function is a constant
11734 pointer. This can happen for example if an actual argument in an inlined
11735 function call evaluates to a compile-time constant address. */
11738 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
11739 enum dwarf_attribute attr)
11742 dw_loc_descr_ref descr;
11743 var_loc_list *loc_list;
11744 struct var_loc_node *node;
11745 if (TREE_CODE (decl) == ERROR_MARK)
11748 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
11749 || TREE_CODE (decl) == RESULT_DECL);
11751 /* See if we possibly have multiple locations for this variable. */
11752 loc_list = lookup_decl_loc (decl);
11754 /* If it truly has multiple locations, the first and last node will
11756 if (loc_list && loc_list->first != loc_list->last)
11758 const char *endname, *secname;
11759 dw_loc_list_ref list;
11761 enum var_init_status initialized;
11763 /* Now that we know what section we are using for a base,
11764 actually construct the list of locations.
11765 The first location information is what is passed to the
11766 function that creates the location list, and the remaining
11767 locations just get added on to that list.
11768 Note that we only know the start address for a location
11769 (IE location changes), so to build the range, we use
11770 the range [current location start, next location start].
11771 This means we have to special case the last node, and generate
11772 a range of [last location start, end of function label]. */
11774 node = loc_list->first;
11775 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11776 secname = secname_for_decl (decl);
11778 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
11779 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11781 initialized = VAR_INIT_STATUS_INITIALIZED;
11783 descr = loc_by_reference (loc_descriptor (varloc, initialized), decl);
11784 list = new_loc_list (descr, node->label, node->next->label, secname, 1);
11787 for (; node->next; node = node->next)
11788 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11790 /* The variable has a location between NODE->LABEL and
11791 NODE->NEXT->LABEL. */
11792 enum var_init_status initialized =
11793 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11794 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11795 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11797 add_loc_descr_to_loc_list (&list, descr,
11798 node->label, node->next->label, secname);
11801 /* If the variable has a location at the last label
11802 it keeps its location until the end of function. */
11803 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11805 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11806 enum var_init_status initialized =
11807 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11809 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11810 if (!current_function_decl)
11811 endname = text_end_label;
11814 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11815 current_function_funcdef_no);
11816 endname = ggc_strdup (label_id);
11818 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11820 add_loc_descr_to_loc_list (&list, descr,
11821 node->label, endname, secname);
11824 /* Finally, add the location list to the DIE, and we are done. */
11825 add_AT_loc_list (die, attr, list);
11829 /* Try to get some constant RTL for this decl, and use that as the value of
11832 rtl = rtl_for_decl_location (decl);
11833 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
11835 add_const_value_attribute (die, rtl);
11839 /* If we have tried to generate the location otherwise, and it
11840 didn't work out (we wouldn't be here if we did), and we have a one entry
11841 location list, try generating a location from that. */
11842 if (loc_list && loc_list->first)
11844 enum var_init_status status;
11845 node = loc_list->first;
11846 status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11847 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note), status);
11850 descr = loc_by_reference (descr, decl);
11851 add_AT_location_description (die, attr, descr);
11856 /* We couldn't get any rtl, so try directly generating the location
11857 description from the tree. */
11858 descr = loc_descriptor_from_tree (decl);
11861 descr = loc_by_reference (descr, decl);
11862 add_AT_location_description (die, attr, descr);
11865 /* None of that worked, so it must not really have a location;
11866 try adding a constant value attribute from the DECL_INITIAL. */
11867 tree_add_const_value_attribute (die, decl);
11870 /* Add VARIABLE and DIE into deferred locations list. */
11873 defer_location (tree variable, dw_die_ref die)
11875 deferred_locations entry;
11876 entry.variable = variable;
11878 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
11881 /* Helper function for tree_add_const_value_attribute. Natively encode
11882 initializer INIT into an array. Return true if successful. */
11885 native_encode_initializer (tree init, unsigned char *array, int size)
11889 if (init == NULL_TREE)
11893 switch (TREE_CODE (init))
11896 type = TREE_TYPE (init);
11897 if (TREE_CODE (type) == ARRAY_TYPE)
11899 tree enttype = TREE_TYPE (type);
11900 enum machine_mode mode = TYPE_MODE (enttype);
11902 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
11904 if (int_size_in_bytes (type) != size)
11906 if (size > TREE_STRING_LENGTH (init))
11908 memcpy (array, TREE_STRING_POINTER (init),
11909 TREE_STRING_LENGTH (init));
11910 memset (array + TREE_STRING_LENGTH (init),
11911 '\0', size - TREE_STRING_LENGTH (init));
11914 memcpy (array, TREE_STRING_POINTER (init), size);
11919 type = TREE_TYPE (init);
11920 if (int_size_in_bytes (type) != size)
11922 if (TREE_CODE (type) == ARRAY_TYPE)
11924 HOST_WIDE_INT min_index;
11925 unsigned HOST_WIDE_INT cnt;
11926 int curpos = 0, fieldsize;
11927 constructor_elt *ce;
11929 if (TYPE_DOMAIN (type) == NULL_TREE
11930 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
11933 fieldsize = int_size_in_bytes (TREE_TYPE (type));
11934 if (fieldsize <= 0)
11937 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
11938 memset (array, '\0', size);
11940 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
11943 tree val = ce->value;
11944 tree index = ce->index;
11946 if (index && TREE_CODE (index) == RANGE_EXPR)
11947 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
11950 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
11955 if (!native_encode_initializer (val, array + pos, fieldsize))
11958 curpos = pos + fieldsize;
11959 if (index && TREE_CODE (index) == RANGE_EXPR)
11961 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
11962 - tree_low_cst (TREE_OPERAND (index, 0), 0);
11966 memcpy (array + curpos, array + pos, fieldsize);
11967 curpos += fieldsize;
11970 gcc_assert (curpos <= size);
11974 else if (TREE_CODE (type) == RECORD_TYPE
11975 || TREE_CODE (type) == UNION_TYPE)
11977 tree field = NULL_TREE;
11978 unsigned HOST_WIDE_INT cnt;
11979 constructor_elt *ce;
11981 if (int_size_in_bytes (type) != size)
11984 if (TREE_CODE (type) == RECORD_TYPE)
11985 field = TYPE_FIELDS (type);
11988 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
11989 cnt++, field = field ? TREE_CHAIN (field) : 0)
11991 tree val = ce->value;
11992 int pos, fieldsize;
11994 if (ce->index != 0)
12000 if (field == NULL_TREE || DECL_BIT_FIELD (field))
12003 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
12004 && TYPE_DOMAIN (TREE_TYPE (field))
12005 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
12007 else if (DECL_SIZE_UNIT (field) == NULL_TREE
12008 || !host_integerp (DECL_SIZE_UNIT (field), 0))
12010 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
12011 pos = int_byte_position (field);
12012 gcc_assert (pos + fieldsize <= size);
12014 && !native_encode_initializer (val, array + pos, fieldsize))
12020 case VIEW_CONVERT_EXPR:
12021 case NON_LVALUE_EXPR:
12022 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
12024 return native_encode_expr (init, array, size) == size;
12028 /* If we don't have a copy of this variable in memory for some reason (such
12029 as a C++ member constant that doesn't have an out-of-line definition),
12030 we should tell the debugger about the constant value. */
12033 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
12036 tree type = TREE_TYPE (decl);
12039 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
12042 init = DECL_INITIAL (decl);
12043 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
12048 rtl = rtl_for_decl_init (init, type);
12050 add_const_value_attribute (var_die, rtl);
12051 /* If the host and target are sane, try harder. */
12052 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
12053 && initializer_constant_valid_p (init, type))
12055 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
12056 if (size > 0 && (int) size == size)
12058 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
12060 if (native_encode_initializer (init, array, size))
12061 add_AT_vec (var_die, DW_AT_const_value, size, 1, array);
12066 /* Convert the CFI instructions for the current function into a
12067 location list. This is used for DW_AT_frame_base when we targeting
12068 a dwarf2 consumer that does not support the dwarf3
12069 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
12072 static dw_loc_list_ref
12073 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
12076 dw_loc_list_ref list, *list_tail;
12078 dw_cfa_location last_cfa, next_cfa;
12079 const char *start_label, *last_label, *section;
12081 fde = current_fde ();
12082 gcc_assert (fde != NULL);
12084 section = secname_for_decl (current_function_decl);
12088 next_cfa.reg = INVALID_REGNUM;
12089 next_cfa.offset = 0;
12090 next_cfa.indirect = 0;
12091 next_cfa.base_offset = 0;
12093 start_label = fde->dw_fde_begin;
12095 /* ??? Bald assumption that the CIE opcode list does not contain
12096 advance opcodes. */
12097 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
12098 lookup_cfa_1 (cfi, &next_cfa);
12100 last_cfa = next_cfa;
12101 last_label = start_label;
12103 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
12104 switch (cfi->dw_cfi_opc)
12106 case DW_CFA_set_loc:
12107 case DW_CFA_advance_loc1:
12108 case DW_CFA_advance_loc2:
12109 case DW_CFA_advance_loc4:
12110 if (!cfa_equal_p (&last_cfa, &next_cfa))
12112 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12113 start_label, last_label, section,
12116 list_tail = &(*list_tail)->dw_loc_next;
12117 last_cfa = next_cfa;
12118 start_label = last_label;
12120 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
12123 case DW_CFA_advance_loc:
12124 /* The encoding is complex enough that we should never emit this. */
12125 case DW_CFA_remember_state:
12126 case DW_CFA_restore_state:
12127 /* We don't handle these two in this function. It would be possible
12128 if it were to be required. */
12129 gcc_unreachable ();
12132 lookup_cfa_1 (cfi, &next_cfa);
12136 if (!cfa_equal_p (&last_cfa, &next_cfa))
12138 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12139 start_label, last_label, section,
12141 list_tail = &(*list_tail)->dw_loc_next;
12142 start_label = last_label;
12144 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
12145 start_label, fde->dw_fde_end, section,
12151 /* Compute a displacement from the "steady-state frame pointer" to the
12152 frame base (often the same as the CFA), and store it in
12153 frame_pointer_fb_offset. OFFSET is added to the displacement
12154 before the latter is negated. */
12157 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
12161 #ifdef FRAME_POINTER_CFA_OFFSET
12162 reg = frame_pointer_rtx;
12163 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
12165 reg = arg_pointer_rtx;
12166 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
12169 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
12170 if (GET_CODE (elim) == PLUS)
12172 offset += INTVAL (XEXP (elim, 1));
12173 elim = XEXP (elim, 0);
12176 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12177 && (elim == hard_frame_pointer_rtx
12178 || elim == stack_pointer_rtx))
12179 || elim == (frame_pointer_needed
12180 ? hard_frame_pointer_rtx
12181 : stack_pointer_rtx));
12183 frame_pointer_fb_offset = -offset;
12186 /* Generate a DW_AT_name attribute given some string value to be included as
12187 the value of the attribute. */
12190 add_name_attribute (dw_die_ref die, const char *name_string)
12192 if (name_string != NULL && *name_string != 0)
12194 if (demangle_name_func)
12195 name_string = (*demangle_name_func) (name_string);
12197 add_AT_string (die, DW_AT_name, name_string);
12201 /* Generate a DW_AT_comp_dir attribute for DIE. */
12204 add_comp_dir_attribute (dw_die_ref die)
12206 const char *wd = get_src_pwd ();
12208 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
12211 /* Given a tree node describing an array bound (either lower or upper) output
12212 a representation for that bound. */
12215 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
12217 switch (TREE_CODE (bound))
12222 /* All fixed-bounds are represented by INTEGER_CST nodes. */
12224 if (! host_integerp (bound, 0)
12225 || (bound_attr == DW_AT_lower_bound
12226 && (((is_c_family () || is_java ()) && integer_zerop (bound))
12227 || (is_fortran () && integer_onep (bound)))))
12228 /* Use the default. */
12231 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
12235 case VIEW_CONVERT_EXPR:
12236 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
12246 dw_die_ref decl_die = lookup_decl_die (bound);
12247 dw_loc_descr_ref loc;
12249 /* ??? Can this happen, or should the variable have been bound
12250 first? Probably it can, since I imagine that we try to create
12251 the types of parameters in the order in which they exist in
12252 the list, and won't have created a forward reference to a
12253 later parameter. */
12254 if (decl_die != NULL)
12255 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12258 loc = loc_descriptor_from_tree_1 (bound, 0);
12259 add_AT_location_description (subrange_die, bound_attr, loc);
12266 /* Otherwise try to create a stack operation procedure to
12267 evaluate the value of the array bound. */
12269 dw_die_ref ctx, decl_die;
12270 dw_loc_descr_ref loc;
12272 loc = loc_descriptor_from_tree (bound);
12276 if (current_function_decl == 0)
12277 ctx = comp_unit_die;
12279 ctx = lookup_decl_die (current_function_decl);
12281 decl_die = new_die (DW_TAG_variable, ctx, bound);
12282 add_AT_flag (decl_die, DW_AT_artificial, 1);
12283 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
12284 add_AT_loc (decl_die, DW_AT_location, loc);
12286 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12292 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
12293 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
12294 Note that the block of subscript information for an array type also
12295 includes information about the element type of the given array type. */
12298 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
12300 unsigned dimension_number;
12302 dw_die_ref subrange_die;
12304 for (dimension_number = 0;
12305 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
12306 type = TREE_TYPE (type), dimension_number++)
12308 tree domain = TYPE_DOMAIN (type);
12310 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
12313 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
12314 and (in GNU C only) variable bounds. Handle all three forms
12316 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
12319 /* We have an array type with specified bounds. */
12320 lower = TYPE_MIN_VALUE (domain);
12321 upper = TYPE_MAX_VALUE (domain);
12323 /* Define the index type. */
12324 if (TREE_TYPE (domain))
12326 /* ??? This is probably an Ada unnamed subrange type. Ignore the
12327 TREE_TYPE field. We can't emit debug info for this
12328 because it is an unnamed integral type. */
12329 if (TREE_CODE (domain) == INTEGER_TYPE
12330 && TYPE_NAME (domain) == NULL_TREE
12331 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
12332 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
12335 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
12339 /* ??? If upper is NULL, the array has unspecified length,
12340 but it does have a lower bound. This happens with Fortran
12342 Since the debugger is definitely going to need to know N
12343 to produce useful results, go ahead and output the lower
12344 bound solo, and hope the debugger can cope. */
12346 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
12348 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
12351 /* Otherwise we have an array type with an unspecified length. The
12352 DWARF-2 spec does not say how to handle this; let's just leave out the
12358 add_byte_size_attribute (dw_die_ref die, tree tree_node)
12362 switch (TREE_CODE (tree_node))
12367 case ENUMERAL_TYPE:
12370 case QUAL_UNION_TYPE:
12371 size = int_size_in_bytes (tree_node);
12374 /* For a data member of a struct or union, the DW_AT_byte_size is
12375 generally given as the number of bytes normally allocated for an
12376 object of the *declared* type of the member itself. This is true
12377 even for bit-fields. */
12378 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
12381 gcc_unreachable ();
12384 /* Note that `size' might be -1 when we get to this point. If it is, that
12385 indicates that the byte size of the entity in question is variable. We
12386 have no good way of expressing this fact in Dwarf at the present time,
12387 so just let the -1 pass on through. */
12388 add_AT_unsigned (die, DW_AT_byte_size, size);
12391 /* For a FIELD_DECL node which represents a bit-field, output an attribute
12392 which specifies the distance in bits from the highest order bit of the
12393 "containing object" for the bit-field to the highest order bit of the
12396 For any given bit-field, the "containing object" is a hypothetical object
12397 (of some integral or enum type) within which the given bit-field lives. The
12398 type of this hypothetical "containing object" is always the same as the
12399 declared type of the individual bit-field itself. The determination of the
12400 exact location of the "containing object" for a bit-field is rather
12401 complicated. It's handled by the `field_byte_offset' function (above).
12403 Note that it is the size (in bytes) of the hypothetical "containing object"
12404 which will be given in the DW_AT_byte_size attribute for this bit-field.
12405 (See `byte_size_attribute' above). */
12408 add_bit_offset_attribute (dw_die_ref die, tree decl)
12410 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
12411 tree type = DECL_BIT_FIELD_TYPE (decl);
12412 HOST_WIDE_INT bitpos_int;
12413 HOST_WIDE_INT highest_order_object_bit_offset;
12414 HOST_WIDE_INT highest_order_field_bit_offset;
12415 HOST_WIDE_INT unsigned bit_offset;
12417 /* Must be a field and a bit field. */
12418 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
12420 /* We can't yet handle bit-fields whose offsets are variable, so if we
12421 encounter such things, just return without generating any attribute
12422 whatsoever. Likewise for variable or too large size. */
12423 if (! host_integerp (bit_position (decl), 0)
12424 || ! host_integerp (DECL_SIZE (decl), 1))
12427 bitpos_int = int_bit_position (decl);
12429 /* Note that the bit offset is always the distance (in bits) from the
12430 highest-order bit of the "containing object" to the highest-order bit of
12431 the bit-field itself. Since the "high-order end" of any object or field
12432 is different on big-endian and little-endian machines, the computation
12433 below must take account of these differences. */
12434 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
12435 highest_order_field_bit_offset = bitpos_int;
12437 if (! BYTES_BIG_ENDIAN)
12439 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
12440 highest_order_object_bit_offset += simple_type_size_in_bits (type);
12444 = (! BYTES_BIG_ENDIAN
12445 ? highest_order_object_bit_offset - highest_order_field_bit_offset
12446 : highest_order_field_bit_offset - highest_order_object_bit_offset);
12448 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
12451 /* For a FIELD_DECL node which represents a bit field, output an attribute
12452 which specifies the length in bits of the given field. */
12455 add_bit_size_attribute (dw_die_ref die, tree decl)
12457 /* Must be a field and a bit field. */
12458 gcc_assert (TREE_CODE (decl) == FIELD_DECL
12459 && DECL_BIT_FIELD_TYPE (decl));
12461 if (host_integerp (DECL_SIZE (decl), 1))
12462 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
12465 /* If the compiled language is ANSI C, then add a 'prototyped'
12466 attribute, if arg types are given for the parameters of a function. */
12469 add_prototyped_attribute (dw_die_ref die, tree func_type)
12471 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
12472 && TYPE_ARG_TYPES (func_type) != NULL)
12473 add_AT_flag (die, DW_AT_prototyped, 1);
12476 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
12477 by looking in either the type declaration or object declaration
12480 static inline dw_die_ref
12481 add_abstract_origin_attribute (dw_die_ref die, tree origin)
12483 dw_die_ref origin_die = NULL;
12485 if (TREE_CODE (origin) != FUNCTION_DECL)
12487 /* We may have gotten separated from the block for the inlined
12488 function, if we're in an exception handler or some such; make
12489 sure that the abstract function has been written out.
12491 Doing this for nested functions is wrong, however; functions are
12492 distinct units, and our context might not even be inline. */
12496 fn = TYPE_STUB_DECL (fn);
12498 fn = decl_function_context (fn);
12500 dwarf2out_abstract_function (fn);
12503 if (DECL_P (origin))
12504 origin_die = lookup_decl_die (origin);
12505 else if (TYPE_P (origin))
12506 origin_die = lookup_type_die (origin);
12508 /* XXX: Functions that are never lowered don't always have correct block
12509 trees (in the case of java, they simply have no block tree, in some other
12510 languages). For these functions, there is nothing we can really do to
12511 output correct debug info for inlined functions in all cases. Rather
12512 than die, we'll just produce deficient debug info now, in that we will
12513 have variables without a proper abstract origin. In the future, when all
12514 functions are lowered, we should re-add a gcc_assert (origin_die)
12518 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
12522 /* We do not currently support the pure_virtual attribute. */
12525 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
12527 if (DECL_VINDEX (func_decl))
12529 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12531 if (host_integerp (DECL_VINDEX (func_decl), 0))
12532 add_AT_loc (die, DW_AT_vtable_elem_location,
12533 new_loc_descr (DW_OP_constu,
12534 tree_low_cst (DECL_VINDEX (func_decl), 0),
12537 /* GNU extension: Record what type this method came from originally. */
12538 if (debug_info_level > DINFO_LEVEL_TERSE)
12539 add_AT_die_ref (die, DW_AT_containing_type,
12540 lookup_type_die (DECL_CONTEXT (func_decl)));
12544 /* Add source coordinate attributes for the given decl. */
12547 add_src_coords_attributes (dw_die_ref die, tree decl)
12549 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12551 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
12552 add_AT_unsigned (die, DW_AT_decl_line, s.line);
12555 /* Add a DW_AT_name attribute and source coordinate attribute for the
12556 given decl, but only if it actually has a name. */
12559 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
12563 decl_name = DECL_NAME (decl);
12564 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
12566 add_name_attribute (die, dwarf2_name (decl, 0));
12567 if (! DECL_ARTIFICIAL (decl))
12568 add_src_coords_attributes (die, decl);
12570 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
12571 && TREE_PUBLIC (decl)
12572 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
12573 && !DECL_ABSTRACT (decl)
12574 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
12576 add_AT_string (die, DW_AT_MIPS_linkage_name,
12577 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
12580 #ifdef VMS_DEBUGGING_INFO
12581 /* Get the function's name, as described by its RTL. This may be different
12582 from the DECL_NAME name used in the source file. */
12583 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
12585 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
12586 XEXP (DECL_RTL (decl), 0));
12587 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
12592 /* Push a new declaration scope. */
12595 push_decl_scope (tree scope)
12597 VEC_safe_push (tree, gc, decl_scope_table, scope);
12600 /* Pop a declaration scope. */
12603 pop_decl_scope (void)
12605 VEC_pop (tree, decl_scope_table);
12608 /* Return the DIE for the scope that immediately contains this type.
12609 Non-named types get global scope. Named types nested in other
12610 types get their containing scope if it's open, or global scope
12611 otherwise. All other types (i.e. function-local named types) get
12612 the current active scope. */
12615 scope_die_for (tree t, dw_die_ref context_die)
12617 dw_die_ref scope_die = NULL;
12618 tree containing_scope;
12621 /* Non-types always go in the current scope. */
12622 gcc_assert (TYPE_P (t));
12624 containing_scope = TYPE_CONTEXT (t);
12626 /* Use the containing namespace if it was passed in (for a declaration). */
12627 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
12629 if (context_die == lookup_decl_die (containing_scope))
12632 containing_scope = NULL_TREE;
12635 /* Ignore function type "scopes" from the C frontend. They mean that
12636 a tagged type is local to a parmlist of a function declarator, but
12637 that isn't useful to DWARF. */
12638 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
12639 containing_scope = NULL_TREE;
12641 if (containing_scope == NULL_TREE)
12642 scope_die = comp_unit_die;
12643 else if (TYPE_P (containing_scope))
12645 /* For types, we can just look up the appropriate DIE. But
12646 first we check to see if we're in the middle of emitting it
12647 so we know where the new DIE should go. */
12648 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
12649 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
12654 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
12655 || TREE_ASM_WRITTEN (containing_scope));
12657 /* If none of the current dies are suitable, we get file scope. */
12658 scope_die = comp_unit_die;
12661 scope_die = lookup_type_die (containing_scope);
12664 scope_die = context_die;
12669 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
12672 local_scope_p (dw_die_ref context_die)
12674 for (; context_die; context_die = context_die->die_parent)
12675 if (context_die->die_tag == DW_TAG_inlined_subroutine
12676 || context_die->die_tag == DW_TAG_subprogram)
12682 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
12683 whether or not to treat a DIE in this context as a declaration. */
12686 class_or_namespace_scope_p (dw_die_ref context_die)
12688 return (context_die
12689 && (context_die->die_tag == DW_TAG_structure_type
12690 || context_die->die_tag == DW_TAG_class_type
12691 || context_die->die_tag == DW_TAG_interface_type
12692 || context_die->die_tag == DW_TAG_union_type
12693 || context_die->die_tag == DW_TAG_namespace));
12696 /* Many forms of DIEs require a "type description" attribute. This
12697 routine locates the proper "type descriptor" die for the type given
12698 by 'type', and adds a DW_AT_type attribute below the given die. */
12701 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
12702 int decl_volatile, dw_die_ref context_die)
12704 enum tree_code code = TREE_CODE (type);
12705 dw_die_ref type_die = NULL;
12707 /* ??? If this type is an unnamed subrange type of an integral, floating-point
12708 or fixed-point type, use the inner type. This is because we have no
12709 support for unnamed types in base_type_die. This can happen if this is
12710 an Ada subrange type. Correct solution is emit a subrange type die. */
12711 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
12712 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
12713 type = TREE_TYPE (type), code = TREE_CODE (type);
12715 if (code == ERROR_MARK
12716 /* Handle a special case. For functions whose return type is void, we
12717 generate *no* type attribute. (Note that no object may have type
12718 `void', so this only applies to function return types). */
12719 || code == VOID_TYPE)
12722 type_die = modified_type_die (type,
12723 decl_const || TYPE_READONLY (type),
12724 decl_volatile || TYPE_VOLATILE (type),
12727 if (type_die != NULL)
12728 add_AT_die_ref (object_die, DW_AT_type, type_die);
12731 /* Given an object die, add the calling convention attribute for the
12732 function call type. */
12734 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
12736 enum dwarf_calling_convention value = DW_CC_normal;
12738 value = targetm.dwarf_calling_convention (TREE_TYPE (decl));
12740 /* DWARF doesn't provide a way to identify a program's source-level
12741 entry point. DW_AT_calling_convention attributes are only meant
12742 to describe functions' calling conventions. However, lacking a
12743 better way to signal the Fortran main program, we use this for the
12744 time being, following existing custom. */
12746 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
12747 value = DW_CC_program;
12749 /* Only add the attribute if the backend requests it, and
12750 is not DW_CC_normal. */
12751 if (value && (value != DW_CC_normal))
12752 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
12755 /* Given a tree pointer to a struct, class, union, or enum type node, return
12756 a pointer to the (string) tag name for the given type, or zero if the type
12757 was declared without a tag. */
12759 static const char *
12760 type_tag (const_tree type)
12762 const char *name = 0;
12764 if (TYPE_NAME (type) != 0)
12768 /* Find the IDENTIFIER_NODE for the type name. */
12769 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
12770 t = TYPE_NAME (type);
12772 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
12773 a TYPE_DECL node, regardless of whether or not a `typedef' was
12775 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12776 && ! DECL_IGNORED_P (TYPE_NAME (type)))
12778 /* We want to be extra verbose. Don't call dwarf_name if
12779 DECL_NAME isn't set. The default hook for decl_printable_name
12780 doesn't like that, and in this context it's correct to return
12781 0, instead of "<anonymous>" or the like. */
12782 if (DECL_NAME (TYPE_NAME (type)))
12783 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
12786 /* Now get the name as a string, or invent one. */
12787 if (!name && t != 0)
12788 name = IDENTIFIER_POINTER (t);
12791 return (name == 0 || *name == '\0') ? 0 : name;
12794 /* Return the type associated with a data member, make a special check
12795 for bit field types. */
12798 member_declared_type (const_tree member)
12800 return (DECL_BIT_FIELD_TYPE (member)
12801 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
12804 /* Get the decl's label, as described by its RTL. This may be different
12805 from the DECL_NAME name used in the source file. */
12808 static const char *
12809 decl_start_label (tree decl)
12812 const char *fnname;
12814 x = DECL_RTL (decl);
12815 gcc_assert (MEM_P (x));
12818 gcc_assert (GET_CODE (x) == SYMBOL_REF);
12820 fnname = XSTR (x, 0);
12825 /* These routines generate the internal representation of the DIE's for
12826 the compilation unit. Debugging information is collected by walking
12827 the declaration trees passed in from dwarf2out_decl(). */
12830 gen_array_type_die (tree type, dw_die_ref context_die)
12832 dw_die_ref scope_die = scope_die_for (type, context_die);
12833 dw_die_ref array_die;
12835 /* GNU compilers represent multidimensional array types as sequences of one
12836 dimensional array types whose element types are themselves array types.
12837 We sometimes squish that down to a single array_type DIE with multiple
12838 subscripts in the Dwarf debugging info. The draft Dwarf specification
12839 say that we are allowed to do this kind of compression in C, because
12840 there is no difference between an array of arrays and a multidimensional
12841 array. We don't do this for Ada to remain as close as possible to the
12842 actual representation, which is especially important against the language
12843 flexibilty wrt arrays of variable size. */
12845 bool collapse_nested_arrays = !is_ada ();
12848 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
12849 DW_TAG_string_type doesn't have DW_AT_type attribute). */
12850 if (TYPE_STRING_FLAG (type)
12851 && TREE_CODE (type) == ARRAY_TYPE
12853 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
12855 HOST_WIDE_INT size;
12857 array_die = new_die (DW_TAG_string_type, scope_die, type);
12858 add_name_attribute (array_die, type_tag (type));
12859 equate_type_number_to_die (type, array_die);
12860 size = int_size_in_bytes (type);
12862 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12863 else if (TYPE_DOMAIN (type) != NULL_TREE
12864 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
12865 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12867 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
12868 dw_loc_descr_ref loc = loc_descriptor_from_tree (szdecl);
12870 size = int_size_in_bytes (TREE_TYPE (szdecl));
12871 if (loc && size > 0)
12873 add_AT_loc (array_die, DW_AT_string_length, loc);
12874 if (size != DWARF2_ADDR_SIZE)
12875 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12881 /* ??? The SGI dwarf reader fails for array of array of enum types
12882 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
12883 array type comes before the outer array type. We thus call gen_type_die
12884 before we new_die and must prevent nested array types collapsing for this
12887 #ifdef MIPS_DEBUGGING_INFO
12888 gen_type_die (TREE_TYPE (type), context_die);
12889 collapse_nested_arrays = false;
12892 array_die = new_die (DW_TAG_array_type, scope_die, type);
12893 add_name_attribute (array_die, type_tag (type));
12894 equate_type_number_to_die (type, array_die);
12896 if (TREE_CODE (type) == VECTOR_TYPE)
12898 /* The frontend feeds us a representation for the vector as a struct
12899 containing an array. Pull out the array type. */
12900 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
12901 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
12904 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
12906 && TREE_CODE (type) == ARRAY_TYPE
12907 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
12908 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
12909 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
12912 /* We default the array ordering. SDB will probably do
12913 the right things even if DW_AT_ordering is not present. It's not even
12914 an issue until we start to get into multidimensional arrays anyway. If
12915 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
12916 then we'll have to put the DW_AT_ordering attribute back in. (But if
12917 and when we find out that we need to put these in, we will only do so
12918 for multidimensional arrays. */
12919 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
12922 #ifdef MIPS_DEBUGGING_INFO
12923 /* The SGI compilers handle arrays of unknown bound by setting
12924 AT_declaration and not emitting any subrange DIEs. */
12925 if (! TYPE_DOMAIN (type))
12926 add_AT_flag (array_die, DW_AT_declaration, 1);
12929 add_subscript_info (array_die, type, collapse_nested_arrays);
12931 /* Add representation of the type of the elements of this array type and
12932 emit the corresponding DIE if we haven't done it already. */
12933 element_type = TREE_TYPE (type);
12934 if (collapse_nested_arrays)
12935 while (TREE_CODE (element_type) == ARRAY_TYPE)
12937 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
12939 element_type = TREE_TYPE (element_type);
12942 #ifndef MIPS_DEBUGGING_INFO
12943 gen_type_die (element_type, context_die);
12946 add_type_attribute (array_die, element_type, 0, 0, context_die);
12948 if (get_AT (array_die, DW_AT_name))
12949 add_pubtype (type, array_die);
12952 static dw_loc_descr_ref
12953 descr_info_loc (tree val, tree base_decl)
12955 HOST_WIDE_INT size;
12956 dw_loc_descr_ref loc, loc2;
12957 enum dwarf_location_atom op;
12959 if (val == base_decl)
12960 return new_loc_descr (DW_OP_push_object_address, 0, 0);
12962 switch (TREE_CODE (val))
12965 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12967 return loc_descriptor_from_tree_1 (val, 0);
12969 if (host_integerp (val, 0))
12970 return int_loc_descriptor (tree_low_cst (val, 0));
12973 size = int_size_in_bytes (TREE_TYPE (val));
12976 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12979 if (size == DWARF2_ADDR_SIZE)
12980 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
12982 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
12984 case POINTER_PLUS_EXPR:
12986 if (host_integerp (TREE_OPERAND (val, 1), 1)
12987 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
12990 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12993 add_loc_descr (&loc,
12994 new_loc_descr (DW_OP_plus_uconst,
12995 tree_low_cst (TREE_OPERAND (val, 1),
13002 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13005 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
13008 add_loc_descr (&loc, loc2);
13009 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
13031 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
13032 tree val, tree base_decl)
13034 dw_loc_descr_ref loc;
13036 if (host_integerp (val, 0))
13038 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
13042 loc = descr_info_loc (val, base_decl);
13046 add_AT_loc (die, attr, loc);
13049 /* This routine generates DIE for array with hidden descriptor, details
13050 are filled into *info by a langhook. */
13053 gen_descr_array_type_die (tree type, struct array_descr_info *info,
13054 dw_die_ref context_die)
13056 dw_die_ref scope_die = scope_die_for (type, context_die);
13057 dw_die_ref array_die;
13060 array_die = new_die (DW_TAG_array_type, scope_die, type);
13061 add_name_attribute (array_die, type_tag (type));
13062 equate_type_number_to_die (type, array_die);
13064 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
13066 && info->ndimensions >= 2)
13067 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
13069 if (info->data_location)
13070 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
13072 if (info->associated)
13073 add_descr_info_field (array_die, DW_AT_associated, info->associated,
13075 if (info->allocated)
13076 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
13079 for (dim = 0; dim < info->ndimensions; dim++)
13081 dw_die_ref subrange_die
13082 = new_die (DW_TAG_subrange_type, array_die, NULL);
13084 if (info->dimen[dim].lower_bound)
13086 /* If it is the default value, omit it. */
13087 if ((is_c_family () || is_java ())
13088 && integer_zerop (info->dimen[dim].lower_bound))
13090 else if (is_fortran ()
13091 && integer_onep (info->dimen[dim].lower_bound))
13094 add_descr_info_field (subrange_die, DW_AT_lower_bound,
13095 info->dimen[dim].lower_bound,
13098 if (info->dimen[dim].upper_bound)
13099 add_descr_info_field (subrange_die, DW_AT_upper_bound,
13100 info->dimen[dim].upper_bound,
13102 if (info->dimen[dim].stride)
13103 add_descr_info_field (subrange_die, DW_AT_byte_stride,
13104 info->dimen[dim].stride,
13108 gen_type_die (info->element_type, context_die);
13109 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
13111 if (get_AT (array_die, DW_AT_name))
13112 add_pubtype (type, array_die);
13117 gen_entry_point_die (tree decl, dw_die_ref context_die)
13119 tree origin = decl_ultimate_origin (decl);
13120 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
13122 if (origin != NULL)
13123 add_abstract_origin_attribute (decl_die, origin);
13126 add_name_and_src_coords_attributes (decl_die, decl);
13127 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
13128 0, 0, context_die);
13131 if (DECL_ABSTRACT (decl))
13132 equate_decl_number_to_die (decl, decl_die);
13134 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
13138 /* Walk through the list of incomplete types again, trying once more to
13139 emit full debugging info for them. */
13142 retry_incomplete_types (void)
13146 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
13147 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
13150 /* Determine what tag to use for a record type. */
13152 static enum dwarf_tag
13153 record_type_tag (tree type)
13155 if (! lang_hooks.types.classify_record)
13156 return DW_TAG_structure_type;
13158 switch (lang_hooks.types.classify_record (type))
13160 case RECORD_IS_STRUCT:
13161 return DW_TAG_structure_type;
13163 case RECORD_IS_CLASS:
13164 return DW_TAG_class_type;
13166 case RECORD_IS_INTERFACE:
13167 return DW_TAG_interface_type;
13170 gcc_unreachable ();
13174 /* Generate a DIE to represent an enumeration type. Note that these DIEs
13175 include all of the information about the enumeration values also. Each
13176 enumerated type name/value is listed as a child of the enumerated type
13180 gen_enumeration_type_die (tree type, dw_die_ref context_die)
13182 dw_die_ref type_die = lookup_type_die (type);
13184 if (type_die == NULL)
13186 type_die = new_die (DW_TAG_enumeration_type,
13187 scope_die_for (type, context_die), type);
13188 equate_type_number_to_die (type, type_die);
13189 add_name_attribute (type_die, type_tag (type));
13191 else if (! TYPE_SIZE (type))
13194 remove_AT (type_die, DW_AT_declaration);
13196 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
13197 given enum type is incomplete, do not generate the DW_AT_byte_size
13198 attribute or the DW_AT_element_list attribute. */
13199 if (TYPE_SIZE (type))
13203 TREE_ASM_WRITTEN (type) = 1;
13204 add_byte_size_attribute (type_die, type);
13205 if (TYPE_STUB_DECL (type) != NULL_TREE)
13206 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
13208 /* If the first reference to this type was as the return type of an
13209 inline function, then it may not have a parent. Fix this now. */
13210 if (type_die->die_parent == NULL)
13211 add_child_die (scope_die_for (type, context_die), type_die);
13213 for (link = TYPE_VALUES (type);
13214 link != NULL; link = TREE_CHAIN (link))
13216 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
13217 tree value = TREE_VALUE (link);
13219 add_name_attribute (enum_die,
13220 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
13222 if (TREE_CODE (value) == CONST_DECL)
13223 value = DECL_INITIAL (value);
13225 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
13226 /* DWARF2 does not provide a way of indicating whether or
13227 not enumeration constants are signed or unsigned. GDB
13228 always assumes the values are signed, so we output all
13229 values as if they were signed. That means that
13230 enumeration constants with very large unsigned values
13231 will appear to have negative values in the debugger. */
13232 add_AT_int (enum_die, DW_AT_const_value,
13233 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
13237 add_AT_flag (type_die, DW_AT_declaration, 1);
13239 if (get_AT (type_die, DW_AT_name))
13240 add_pubtype (type, type_die);
13245 /* Generate a DIE to represent either a real live formal parameter decl or to
13246 represent just the type of some formal parameter position in some function
13249 Note that this routine is a bit unusual because its argument may be a
13250 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
13251 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
13252 node. If it's the former then this function is being called to output a
13253 DIE to represent a formal parameter object (or some inlining thereof). If
13254 it's the latter, then this function is only being called to output a
13255 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
13256 argument type of some subprogram type. */
13259 gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
13261 tree node_or_origin = node ? node : origin;
13262 dw_die_ref parm_die
13263 = new_die (DW_TAG_formal_parameter, context_die, node);
13265 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
13267 case tcc_declaration:
13269 origin = decl_ultimate_origin (node);
13270 if (origin != NULL)
13271 add_abstract_origin_attribute (parm_die, origin);
13274 tree type = TREE_TYPE (node);
13275 add_name_and_src_coords_attributes (parm_die, node);
13276 if (DECL_BY_REFERENCE (node))
13277 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
13280 add_type_attribute (parm_die, type,
13281 TREE_READONLY (node),
13282 TREE_THIS_VOLATILE (node),
13284 if (DECL_ARTIFICIAL (node))
13285 add_AT_flag (parm_die, DW_AT_artificial, 1);
13289 equate_decl_number_to_die (node, parm_die);
13290 if (! DECL_ABSTRACT (node_or_origin))
13291 add_location_or_const_value_attribute (parm_die, node_or_origin,
13297 /* We were called with some kind of a ..._TYPE node. */
13298 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
13302 gcc_unreachable ();
13308 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
13309 at the end of an (ANSI prototyped) formal parameters list. */
13312 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
13314 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
13317 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
13318 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
13319 parameters as specified in some function type specification (except for
13320 those which appear as part of a function *definition*). */
13323 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
13326 tree formal_type = NULL;
13327 tree first_parm_type;
13330 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
13332 arg = DECL_ARGUMENTS (function_or_method_type);
13333 function_or_method_type = TREE_TYPE (function_or_method_type);
13338 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
13340 /* Make our first pass over the list of formal parameter types and output a
13341 DW_TAG_formal_parameter DIE for each one. */
13342 for (link = first_parm_type; link; )
13344 dw_die_ref parm_die;
13346 formal_type = TREE_VALUE (link);
13347 if (formal_type == void_type_node)
13350 /* Output a (nameless) DIE to represent the formal parameter itself. */
13351 parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
13352 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
13353 && link == first_parm_type)
13354 || (arg && DECL_ARTIFICIAL (arg)))
13355 add_AT_flag (parm_die, DW_AT_artificial, 1);
13357 link = TREE_CHAIN (link);
13359 arg = TREE_CHAIN (arg);
13362 /* If this function type has an ellipsis, add a
13363 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
13364 if (formal_type != void_type_node)
13365 gen_unspecified_parameters_die (function_or_method_type, context_die);
13367 /* Make our second (and final) pass over the list of formal parameter types
13368 and output DIEs to represent those types (as necessary). */
13369 for (link = TYPE_ARG_TYPES (function_or_method_type);
13370 link && TREE_VALUE (link);
13371 link = TREE_CHAIN (link))
13372 gen_type_die (TREE_VALUE (link), context_die);
13375 /* We want to generate the DIE for TYPE so that we can generate the
13376 die for MEMBER, which has been defined; we will need to refer back
13377 to the member declaration nested within TYPE. If we're trying to
13378 generate minimal debug info for TYPE, processing TYPE won't do the
13379 trick; we need to attach the member declaration by hand. */
13382 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
13384 gen_type_die (type, context_die);
13386 /* If we're trying to avoid duplicate debug info, we may not have
13387 emitted the member decl for this function. Emit it now. */
13388 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
13389 && ! lookup_decl_die (member))
13391 dw_die_ref type_die;
13392 gcc_assert (!decl_ultimate_origin (member));
13394 push_decl_scope (type);
13395 type_die = lookup_type_die (type);
13396 if (TREE_CODE (member) == FUNCTION_DECL)
13397 gen_subprogram_die (member, type_die);
13398 else if (TREE_CODE (member) == FIELD_DECL)
13400 /* Ignore the nameless fields that are used to skip bits but handle
13401 C++ anonymous unions and structs. */
13402 if (DECL_NAME (member) != NULL_TREE
13403 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
13404 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
13406 gen_type_die (member_declared_type (member), type_die);
13407 gen_field_die (member, type_die);
13411 gen_variable_die (member, NULL_TREE, type_die);
13417 /* Generate the DWARF2 info for the "abstract" instance of a function which we
13418 may later generate inlined and/or out-of-line instances of. */
13421 dwarf2out_abstract_function (tree decl)
13423 dw_die_ref old_die;
13426 int was_abstract = DECL_ABSTRACT (decl);
13428 /* Make sure we have the actual abstract inline, not a clone. */
13429 decl = DECL_ORIGIN (decl);
13431 old_die = lookup_decl_die (decl);
13432 if (old_die && get_AT (old_die, DW_AT_inline))
13433 /* We've already generated the abstract instance. */
13436 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
13437 we don't get confused by DECL_ABSTRACT. */
13438 if (debug_info_level > DINFO_LEVEL_TERSE)
13440 context = decl_class_context (decl);
13442 gen_type_die_for_member
13443 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
13446 /* Pretend we've just finished compiling this function. */
13447 save_fn = current_function_decl;
13448 current_function_decl = decl;
13449 push_cfun (DECL_STRUCT_FUNCTION (decl));
13451 set_decl_abstract_flags (decl, 1);
13452 dwarf2out_decl (decl);
13453 if (! was_abstract)
13454 set_decl_abstract_flags (decl, 0);
13456 current_function_decl = save_fn;
13460 /* Helper function of premark_used_types() which gets called through
13461 htab_traverse_resize().
13463 Marks the DIE of a given type in *SLOT as perennial, so it never gets
13464 marked as unused by prune_unused_types. */
13466 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
13471 type = (tree) *slot;
13472 die = lookup_type_die (type);
13474 die->die_perennial_p = 1;
13478 /* Mark all members of used_types_hash as perennial. */
13480 premark_used_types (void)
13482 if (cfun && cfun->used_types_hash)
13483 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
13486 /* Generate a DIE to represent a declared function (either file-scope or
13490 gen_subprogram_die (tree decl, dw_die_ref context_die)
13492 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
13493 tree origin = decl_ultimate_origin (decl);
13494 dw_die_ref subr_die;
13497 dw_die_ref old_die = lookup_decl_die (decl);
13498 int declaration = (current_function_decl != decl
13499 || class_or_namespace_scope_p (context_die));
13501 premark_used_types ();
13503 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
13504 started to generate the abstract instance of an inline, decided to output
13505 its containing class, and proceeded to emit the declaration of the inline
13506 from the member list for the class. If so, DECLARATION takes priority;
13507 we'll get back to the abstract instance when done with the class. */
13509 /* The class-scope declaration DIE must be the primary DIE. */
13510 if (origin && declaration && class_or_namespace_scope_p (context_die))
13513 gcc_assert (!old_die);
13516 /* Now that the C++ front end lazily declares artificial member fns, we
13517 might need to retrofit the declaration into its class. */
13518 if (!declaration && !origin && !old_die
13519 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
13520 && !class_or_namespace_scope_p (context_die)
13521 && debug_info_level > DINFO_LEVEL_TERSE)
13522 old_die = force_decl_die (decl);
13524 if (origin != NULL)
13526 gcc_assert (!declaration || local_scope_p (context_die));
13528 /* Fixup die_parent for the abstract instance of a nested
13529 inline function. */
13530 if (old_die && old_die->die_parent == NULL)
13531 add_child_die (context_die, old_die);
13533 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13534 add_abstract_origin_attribute (subr_die, origin);
13538 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
13539 struct dwarf_file_data * file_index = lookup_filename (s.file);
13541 if (!get_AT_flag (old_die, DW_AT_declaration)
13542 /* We can have a normal definition following an inline one in the
13543 case of redefinition of GNU C extern inlines.
13544 It seems reasonable to use AT_specification in this case. */
13545 && !get_AT (old_die, DW_AT_inline))
13547 /* Detect and ignore this case, where we are trying to output
13548 something we have already output. */
13552 /* If the definition comes from the same place as the declaration,
13553 maybe use the old DIE. We always want the DIE for this function
13554 that has the *_pc attributes to be under comp_unit_die so the
13555 debugger can find it. We also need to do this for abstract
13556 instances of inlines, since the spec requires the out-of-line copy
13557 to have the same parent. For local class methods, this doesn't
13558 apply; we just use the old DIE. */
13559 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
13560 && (DECL_ARTIFICIAL (decl)
13561 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
13562 && (get_AT_unsigned (old_die, DW_AT_decl_line)
13563 == (unsigned) s.line))))
13565 subr_die = old_die;
13567 /* Clear out the declaration attribute and the formal parameters.
13568 Do not remove all children, because it is possible that this
13569 declaration die was forced using force_decl_die(). In such
13570 cases die that forced declaration die (e.g. TAG_imported_module)
13571 is one of the children that we do not want to remove. */
13572 remove_AT (subr_die, DW_AT_declaration);
13573 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
13577 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13578 add_AT_specification (subr_die, old_die);
13579 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
13580 add_AT_file (subr_die, DW_AT_decl_file, file_index);
13581 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
13582 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
13587 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13589 if (TREE_PUBLIC (decl))
13590 add_AT_flag (subr_die, DW_AT_external, 1);
13592 add_name_and_src_coords_attributes (subr_die, decl);
13593 if (debug_info_level > DINFO_LEVEL_TERSE)
13595 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
13596 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
13597 0, 0, context_die);
13600 add_pure_or_virtual_attribute (subr_die, decl);
13601 if (DECL_ARTIFICIAL (decl))
13602 add_AT_flag (subr_die, DW_AT_artificial, 1);
13604 if (TREE_PROTECTED (decl))
13605 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
13606 else if (TREE_PRIVATE (decl))
13607 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
13612 if (!old_die || !get_AT (old_die, DW_AT_inline))
13614 add_AT_flag (subr_die, DW_AT_declaration, 1);
13616 /* If this is an explicit function declaration then generate
13617 a DW_AT_explicit attribute. */
13618 if (lang_hooks.decls.function_decl_explicit_p (decl))
13619 add_AT_flag (subr_die, DW_AT_explicit, 1);
13621 /* The first time we see a member function, it is in the context of
13622 the class to which it belongs. We make sure of this by emitting
13623 the class first. The next time is the definition, which is
13624 handled above. The two may come from the same source text.
13626 Note that force_decl_die() forces function declaration die. It is
13627 later reused to represent definition. */
13628 equate_decl_number_to_die (decl, subr_die);
13631 else if (DECL_ABSTRACT (decl))
13633 if (DECL_DECLARED_INLINE_P (decl))
13635 if (cgraph_function_possibly_inlined_p (decl))
13636 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
13638 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
13642 if (cgraph_function_possibly_inlined_p (decl))
13643 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
13645 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
13648 if (DECL_DECLARED_INLINE_P (decl)
13649 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
13650 add_AT_flag (subr_die, DW_AT_artificial, 1);
13652 equate_decl_number_to_die (decl, subr_die);
13654 else if (!DECL_EXTERNAL (decl))
13656 HOST_WIDE_INT cfa_fb_offset;
13658 if (!old_die || !get_AT (old_die, DW_AT_inline))
13659 equate_decl_number_to_die (decl, subr_die);
13661 if (!flag_reorder_blocks_and_partition)
13663 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
13664 current_function_funcdef_no);
13665 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
13666 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
13667 current_function_funcdef_no);
13668 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
13670 add_pubname (decl, subr_die);
13671 add_arange (decl, subr_die);
13674 { /* Do nothing for now; maybe need to duplicate die, one for
13675 hot section and one for cold section, then use the hot/cold
13676 section begin/end labels to generate the aranges... */
13678 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
13679 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
13680 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
13681 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
13683 add_pubname (decl, subr_die);
13684 add_arange (decl, subr_die);
13685 add_arange (decl, subr_die);
13689 #ifdef MIPS_DEBUGGING_INFO
13690 /* Add a reference to the FDE for this routine. */
13691 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
13694 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
13696 /* We define the "frame base" as the function's CFA. This is more
13697 convenient for several reasons: (1) It's stable across the prologue
13698 and epilogue, which makes it better than just a frame pointer,
13699 (2) With dwarf3, there exists a one-byte encoding that allows us
13700 to reference the .debug_frame data by proxy, but failing that,
13701 (3) We can at least reuse the code inspection and interpretation
13702 code that determines the CFA position at various points in the
13704 /* ??? Use some command-line or configury switch to enable the use
13705 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
13706 consumers that understand it; fall back to "pure" dwarf2 and
13707 convert the CFA data into a location list. */
13709 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
13710 if (list->dw_loc_next)
13711 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
13713 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
13716 /* Compute a displacement from the "steady-state frame pointer" to
13717 the CFA. The former is what all stack slots and argument slots
13718 will reference in the rtl; the later is what we've told the
13719 debugger about. We'll need to adjust all frame_base references
13720 by this displacement. */
13721 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
13723 if (cfun->static_chain_decl)
13724 add_AT_location_description (subr_die, DW_AT_static_link,
13725 loc_descriptor_from_tree (cfun->static_chain_decl));
13728 /* Now output descriptions of the arguments for this function. This gets
13729 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
13730 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
13731 `...' at the end of the formal parameter list. In order to find out if
13732 there was a trailing ellipsis or not, we must instead look at the type
13733 associated with the FUNCTION_DECL. This will be a node of type
13734 FUNCTION_TYPE. If the chain of type nodes hanging off of this
13735 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
13736 an ellipsis at the end. */
13738 /* In the case where we are describing a mere function declaration, all we
13739 need to do here (and all we *can* do here) is to describe the *types* of
13740 its formal parameters. */
13741 if (debug_info_level <= DINFO_LEVEL_TERSE)
13743 else if (declaration)
13744 gen_formal_types_die (decl, subr_die);
13747 /* Generate DIEs to represent all known formal parameters. */
13748 tree arg_decls = DECL_ARGUMENTS (decl);
13751 /* When generating DIEs, generate the unspecified_parameters DIE
13752 instead if we come across the arg "__builtin_va_alist" */
13753 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
13754 if (TREE_CODE (parm) == PARM_DECL)
13756 if (DECL_NAME (parm)
13757 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
13758 "__builtin_va_alist"))
13759 gen_unspecified_parameters_die (parm, subr_die);
13761 gen_decl_die (parm, NULL, subr_die);
13764 /* Decide whether we need an unspecified_parameters DIE at the end.
13765 There are 2 more cases to do this for: 1) the ansi ... declaration -
13766 this is detectable when the end of the arg list is not a
13767 void_type_node 2) an unprototyped function declaration (not a
13768 definition). This just means that we have no info about the
13769 parameters at all. */
13770 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
13771 if (fn_arg_types != NULL)
13773 /* This is the prototyped case, check for.... */
13774 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
13775 gen_unspecified_parameters_die (decl, subr_die);
13777 else if (DECL_INITIAL (decl) == NULL_TREE)
13778 gen_unspecified_parameters_die (decl, subr_die);
13781 /* Output Dwarf info for all of the stuff within the body of the function
13782 (if it has one - it may be just a declaration). */
13783 outer_scope = DECL_INITIAL (decl);
13785 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
13786 a function. This BLOCK actually represents the outermost binding contour
13787 for the function, i.e. the contour in which the function's formal
13788 parameters and labels get declared. Curiously, it appears that the front
13789 end doesn't actually put the PARM_DECL nodes for the current function onto
13790 the BLOCK_VARS list for this outer scope, but are strung off of the
13791 DECL_ARGUMENTS list for the function instead.
13793 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
13794 the LABEL_DECL nodes for the function however, and we output DWARF info
13795 for those in decls_for_scope. Just within the `outer_scope' there will be
13796 a BLOCK node representing the function's outermost pair of curly braces,
13797 and any blocks used for the base and member initializers of a C++
13798 constructor function. */
13799 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
13801 /* Emit a DW_TAG_variable DIE for a named return value. */
13802 if (DECL_NAME (DECL_RESULT (decl)))
13803 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
13805 current_function_has_inlines = 0;
13806 decls_for_scope (outer_scope, subr_die, 0);
13808 #if 0 && defined (MIPS_DEBUGGING_INFO)
13809 if (current_function_has_inlines)
13811 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
13812 if (! comp_unit_has_inlines)
13814 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
13815 comp_unit_has_inlines = 1;
13820 /* Add the calling convention attribute if requested. */
13821 add_calling_convention_attribute (subr_die, decl);
13825 /* Returns a hash value for X (which really is a die_struct). */
13828 common_block_die_table_hash (const void *x)
13830 const_dw_die_ref d = (const_dw_die_ref) x;
13831 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
13834 /* Return nonzero if decl_id and die_parent of die_struct X is the same
13835 as decl_id and die_parent of die_struct Y. */
13838 common_block_die_table_eq (const void *x, const void *y)
13840 const_dw_die_ref d = (const_dw_die_ref) x;
13841 const_dw_die_ref e = (const_dw_die_ref) y;
13842 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
13845 /* Generate a DIE to represent a declared data object.
13846 Either DECL or ORIGIN must be non-null. */
13849 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
13853 tree decl_or_origin = decl ? decl : origin;
13854 dw_die_ref var_die;
13855 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
13856 dw_die_ref origin_die;
13857 int declaration = (DECL_EXTERNAL (decl_or_origin)
13858 /* If DECL is COMDAT and has not actually been
13859 emitted, we cannot take its address; there
13860 might end up being no definition anywhere in
13861 the program. For example, consider the C++
13865 struct S { static const int i = 7; };
13870 int f() { return S<int>::i; }
13872 Here, S<int>::i is not DECL_EXTERNAL, but no
13873 definition is required, so the compiler will
13874 not emit a definition. */
13875 || (TREE_CODE (decl_or_origin) == VAR_DECL
13876 && DECL_COMDAT (decl_or_origin)
13877 && !TREE_ASM_WRITTEN (decl_or_origin))
13878 || class_or_namespace_scope_p (context_die));
13881 origin = decl_ultimate_origin (decl);
13883 com_decl = fortran_common (decl_or_origin, &off);
13885 /* Symbol in common gets emitted as a child of the common block, in the form
13886 of a data member. */
13890 dw_die_ref com_die;
13891 dw_loc_descr_ref loc;
13892 die_node com_die_arg;
13894 var_die = lookup_decl_die (decl_or_origin);
13897 if (get_AT (var_die, DW_AT_location) == NULL)
13899 loc = loc_descriptor_from_tree (com_decl);
13904 /* Optimize the common case. */
13905 if (loc->dw_loc_opc == DW_OP_addr
13906 && loc->dw_loc_next == NULL
13907 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr)
13909 loc->dw_loc_oprnd1.v.val_addr
13910 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
13912 add_loc_descr (&loc,
13913 new_loc_descr (DW_OP_plus_uconst,
13916 add_AT_loc (var_die, DW_AT_location, loc);
13917 remove_AT (var_die, DW_AT_declaration);
13923 if (common_block_die_table == NULL)
13924 common_block_die_table
13925 = htab_create_ggc (10, common_block_die_table_hash,
13926 common_block_die_table_eq, NULL);
13928 field = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
13929 com_die_arg.decl_id = DECL_UID (com_decl);
13930 com_die_arg.die_parent = context_die;
13931 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
13932 loc = loc_descriptor_from_tree (com_decl);
13933 if (com_die == NULL)
13936 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
13939 com_die = new_die (DW_TAG_common_block, context_die, decl);
13940 add_name_and_src_coords_attributes (com_die, com_decl);
13943 add_AT_loc (com_die, DW_AT_location, loc);
13944 /* Avoid sharing the same loc descriptor between
13945 DW_TAG_common_block and DW_TAG_variable. */
13946 loc = loc_descriptor_from_tree (com_decl);
13948 else if (DECL_EXTERNAL (decl))
13949 add_AT_flag (com_die, DW_AT_declaration, 1);
13950 add_pubname_string (cnam, com_die); /* ??? needed? */
13951 com_die->decl_id = DECL_UID (com_decl);
13952 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
13953 *slot = (void *) com_die;
13955 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
13957 add_AT_loc (com_die, DW_AT_location, loc);
13958 loc = loc_descriptor_from_tree (com_decl);
13959 remove_AT (com_die, DW_AT_declaration);
13961 var_die = new_die (DW_TAG_variable, com_die, decl);
13962 add_name_and_src_coords_attributes (var_die, decl);
13963 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
13964 TREE_THIS_VOLATILE (decl), context_die);
13965 add_AT_flag (var_die, DW_AT_external, 1);
13970 /* Optimize the common case. */
13971 if (loc->dw_loc_opc == DW_OP_addr
13972 && loc->dw_loc_next == NULL
13973 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
13974 loc->dw_loc_oprnd1.v.val_addr
13975 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
13977 add_loc_descr (&loc, new_loc_descr (DW_OP_plus_uconst,
13980 add_AT_loc (var_die, DW_AT_location, loc);
13982 else if (DECL_EXTERNAL (decl))
13983 add_AT_flag (var_die, DW_AT_declaration, 1);
13984 equate_decl_number_to_die (decl, var_die);
13988 /* If the compiler emitted a definition for the DECL declaration
13989 and if we already emitted a DIE for it, don't emit a second
13990 DIE for it again. */
13993 && old_die->die_parent == context_die)
13996 var_die = new_die (DW_TAG_variable, context_die, decl);
13999 if (origin != NULL)
14000 origin_die = add_abstract_origin_attribute (var_die, origin);
14002 /* Loop unrolling can create multiple blocks that refer to the same
14003 static variable, so we must test for the DW_AT_declaration flag.
14005 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
14006 copy decls and set the DECL_ABSTRACT flag on them instead of
14009 ??? Duplicated blocks have been rewritten to use .debug_ranges.
14011 ??? The declare_in_namespace support causes us to get two DIEs for one
14012 variable, both of which are declarations. We want to avoid considering
14013 one to be a specification, so we must test that this DIE is not a
14015 else if (old_die && TREE_STATIC (decl) && ! declaration
14016 && get_AT_flag (old_die, DW_AT_declaration) == 1)
14018 /* This is a definition of a C++ class level static. */
14019 add_AT_specification (var_die, old_die);
14020 if (DECL_NAME (decl))
14022 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
14023 struct dwarf_file_data * file_index = lookup_filename (s.file);
14025 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
14026 add_AT_file (var_die, DW_AT_decl_file, file_index);
14028 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
14029 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
14034 tree type = TREE_TYPE (decl);
14036 add_name_and_src_coords_attributes (var_die, decl);
14037 if ((TREE_CODE (decl) == PARM_DECL
14038 || TREE_CODE (decl) == RESULT_DECL)
14039 && DECL_BY_REFERENCE (decl))
14040 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
14042 add_type_attribute (var_die, type, TREE_READONLY (decl),
14043 TREE_THIS_VOLATILE (decl), context_die);
14045 if (TREE_PUBLIC (decl))
14046 add_AT_flag (var_die, DW_AT_external, 1);
14048 if (DECL_ARTIFICIAL (decl))
14049 add_AT_flag (var_die, DW_AT_artificial, 1);
14051 if (TREE_PROTECTED (decl))
14052 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
14053 else if (TREE_PRIVATE (decl))
14054 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
14058 add_AT_flag (var_die, DW_AT_declaration, 1);
14060 if (decl && (DECL_ABSTRACT (decl) || declaration))
14061 equate_decl_number_to_die (decl, var_die);
14064 && (! DECL_ABSTRACT (decl_or_origin)
14065 /* Local static vars are shared between all clones/inlines,
14066 so emit DW_AT_location on the abstract DIE if DECL_RTL is
14068 || (TREE_CODE (decl_or_origin) == VAR_DECL
14069 && TREE_STATIC (decl_or_origin)
14070 && DECL_RTL_SET_P (decl_or_origin)))
14071 /* When abstract origin already has DW_AT_location attribute, no need
14072 to add it again. */
14073 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
14075 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
14076 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
14077 defer_location (decl_or_origin, var_die);
14079 add_location_or_const_value_attribute (var_die,
14082 add_pubname (decl_or_origin, var_die);
14085 tree_add_const_value_attribute (var_die, decl_or_origin);
14088 /* Generate a DIE to represent a named constant. */
14091 gen_const_die (tree decl, dw_die_ref context_die)
14093 dw_die_ref const_die;
14094 tree type = TREE_TYPE (decl);
14096 const_die = new_die (DW_TAG_constant, context_die, decl);
14097 add_name_and_src_coords_attributes (const_die, decl);
14098 add_type_attribute (const_die, type, 1, 0, context_die);
14099 if (TREE_PUBLIC (decl))
14100 add_AT_flag (const_die, DW_AT_external, 1);
14101 if (DECL_ARTIFICIAL (decl))
14102 add_AT_flag (const_die, DW_AT_artificial, 1);
14103 tree_add_const_value_attribute (const_die, decl);
14106 /* Generate a DIE to represent a label identifier. */
14109 gen_label_die (tree decl, dw_die_ref context_die)
14111 tree origin = decl_ultimate_origin (decl);
14112 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
14114 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14116 if (origin != NULL)
14117 add_abstract_origin_attribute (lbl_die, origin);
14119 add_name_and_src_coords_attributes (lbl_die, decl);
14121 if (DECL_ABSTRACT (decl))
14122 equate_decl_number_to_die (decl, lbl_die);
14125 insn = DECL_RTL_IF_SET (decl);
14127 /* Deleted labels are programmer specified labels which have been
14128 eliminated because of various optimizations. We still emit them
14129 here so that it is possible to put breakpoints on them. */
14133 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
14135 /* When optimization is enabled (via -O) some parts of the compiler
14136 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
14137 represent source-level labels which were explicitly declared by
14138 the user. This really shouldn't be happening though, so catch
14139 it if it ever does happen. */
14140 gcc_assert (!INSN_DELETED_P (insn));
14142 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
14143 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
14148 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
14149 attributes to the DIE for a block STMT, to describe where the inlined
14150 function was called from. This is similar to add_src_coords_attributes. */
14153 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
14155 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
14157 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
14158 add_AT_unsigned (die, DW_AT_call_line, s.line);
14162 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
14163 Add low_pc and high_pc attributes to the DIE for a block STMT. */
14166 add_high_low_attributes (tree stmt, dw_die_ref die)
14168 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14170 if (BLOCK_FRAGMENT_CHAIN (stmt))
14174 if (inlined_function_outer_scope_p (stmt))
14176 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14177 BLOCK_NUMBER (stmt));
14178 add_AT_lbl_id (die, DW_AT_entry_pc, label);
14181 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
14183 chain = BLOCK_FRAGMENT_CHAIN (stmt);
14186 add_ranges (chain);
14187 chain = BLOCK_FRAGMENT_CHAIN (chain);
14194 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14195 BLOCK_NUMBER (stmt));
14196 add_AT_lbl_id (die, DW_AT_low_pc, label);
14197 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
14198 BLOCK_NUMBER (stmt));
14199 add_AT_lbl_id (die, DW_AT_high_pc, label);
14203 /* Generate a DIE for a lexical block. */
14206 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
14208 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
14210 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
14211 add_high_low_attributes (stmt, stmt_die);
14213 decls_for_scope (stmt, stmt_die, depth);
14216 /* Generate a DIE for an inlined subprogram. */
14219 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
14221 tree decl = block_ultimate_origin (stmt);
14223 /* Emit info for the abstract instance first, if we haven't yet. We
14224 must emit this even if the block is abstract, otherwise when we
14225 emit the block below (or elsewhere), we may end up trying to emit
14226 a die whose origin die hasn't been emitted, and crashing. */
14227 dwarf2out_abstract_function (decl);
14229 if (! BLOCK_ABSTRACT (stmt))
14231 dw_die_ref subr_die
14232 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
14234 add_abstract_origin_attribute (subr_die, decl);
14235 if (TREE_ASM_WRITTEN (stmt))
14236 add_high_low_attributes (stmt, subr_die);
14237 add_call_src_coords_attributes (stmt, subr_die);
14239 decls_for_scope (stmt, subr_die, depth);
14240 current_function_has_inlines = 1;
14243 /* We may get here if we're the outer block of function A that was
14244 inlined into function B that was inlined into function C. When
14245 generating debugging info for C, dwarf2out_abstract_function(B)
14246 would mark all inlined blocks as abstract, including this one.
14247 So, we wouldn't (and shouldn't) expect labels to be generated
14248 for this one. Instead, just emit debugging info for
14249 declarations within the block. This is particularly important
14250 in the case of initializers of arguments passed from B to us:
14251 if they're statement expressions containing declarations, we
14252 wouldn't generate dies for their abstract variables, and then,
14253 when generating dies for the real variables, we'd die (pun
14255 gen_lexical_block_die (stmt, context_die, depth);
14258 /* Generate a DIE for a field in a record, or structure. */
14261 gen_field_die (tree decl, dw_die_ref context_die)
14263 dw_die_ref decl_die;
14265 if (TREE_TYPE (decl) == error_mark_node)
14268 decl_die = new_die (DW_TAG_member, context_die, decl);
14269 add_name_and_src_coords_attributes (decl_die, decl);
14270 add_type_attribute (decl_die, member_declared_type (decl),
14271 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
14274 if (DECL_BIT_FIELD_TYPE (decl))
14276 add_byte_size_attribute (decl_die, decl);
14277 add_bit_size_attribute (decl_die, decl);
14278 add_bit_offset_attribute (decl_die, decl);
14281 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
14282 add_data_member_location_attribute (decl_die, decl);
14284 if (DECL_ARTIFICIAL (decl))
14285 add_AT_flag (decl_die, DW_AT_artificial, 1);
14287 if (TREE_PROTECTED (decl))
14288 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
14289 else if (TREE_PRIVATE (decl))
14290 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
14292 /* Equate decl number to die, so that we can look up this decl later on. */
14293 equate_decl_number_to_die (decl, decl_die);
14297 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14298 Use modified_type_die instead.
14299 We keep this code here just in case these types of DIEs may be needed to
14300 represent certain things in other languages (e.g. Pascal) someday. */
14303 gen_pointer_type_die (tree type, dw_die_ref context_die)
14306 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
14308 equate_type_number_to_die (type, ptr_die);
14309 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14310 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14313 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14314 Use modified_type_die instead.
14315 We keep this code here just in case these types of DIEs may be needed to
14316 represent certain things in other languages (e.g. Pascal) someday. */
14319 gen_reference_type_die (tree type, dw_die_ref context_die)
14322 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
14324 equate_type_number_to_die (type, ref_die);
14325 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
14326 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14330 /* Generate a DIE for a pointer to a member type. */
14333 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
14336 = new_die (DW_TAG_ptr_to_member_type,
14337 scope_die_for (type, context_die), type);
14339 equate_type_number_to_die (type, ptr_die);
14340 add_AT_die_ref (ptr_die, DW_AT_containing_type,
14341 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
14342 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14345 /* Generate the DIE for the compilation unit. */
14348 gen_compile_unit_die (const char *filename)
14351 char producer[250];
14352 const char *language_string = lang_hooks.name;
14355 die = new_die (DW_TAG_compile_unit, NULL, NULL);
14359 add_name_attribute (die, filename);
14360 /* Don't add cwd for <built-in>. */
14361 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
14362 add_comp_dir_attribute (die);
14365 sprintf (producer, "%s %s", language_string, version_string);
14367 #ifdef MIPS_DEBUGGING_INFO
14368 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
14369 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
14370 not appear in the producer string, the debugger reaches the conclusion
14371 that the object file is stripped and has no debugging information.
14372 To get the MIPS/SGI debugger to believe that there is debugging
14373 information in the object file, we add a -g to the producer string. */
14374 if (debug_info_level > DINFO_LEVEL_TERSE)
14375 strcat (producer, " -g");
14378 add_AT_string (die, DW_AT_producer, producer);
14380 if (strcmp (language_string, "GNU C++") == 0)
14381 language = DW_LANG_C_plus_plus;
14382 else if (strcmp (language_string, "GNU Ada") == 0)
14383 language = DW_LANG_Ada95;
14384 else if (strcmp (language_string, "GNU F77") == 0)
14385 language = DW_LANG_Fortran77;
14386 else if (strcmp (language_string, "GNU Fortran") == 0)
14387 language = DW_LANG_Fortran95;
14388 else if (strcmp (language_string, "GNU Pascal") == 0)
14389 language = DW_LANG_Pascal83;
14390 else if (strcmp (language_string, "GNU Java") == 0)
14391 language = DW_LANG_Java;
14392 else if (strcmp (language_string, "GNU Objective-C") == 0)
14393 language = DW_LANG_ObjC;
14394 else if (strcmp (language_string, "GNU Objective-C++") == 0)
14395 language = DW_LANG_ObjC_plus_plus;
14397 language = DW_LANG_C89;
14399 add_AT_unsigned (die, DW_AT_language, language);
14403 /* Generate the DIE for a base class. */
14406 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
14408 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
14410 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
14411 add_data_member_location_attribute (die, binfo);
14413 if (BINFO_VIRTUAL_P (binfo))
14414 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
14416 if (access == access_public_node)
14417 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
14418 else if (access == access_protected_node)
14419 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
14422 /* Generate a DIE for a class member. */
14425 gen_member_die (tree type, dw_die_ref context_die)
14428 tree binfo = TYPE_BINFO (type);
14431 /* If this is not an incomplete type, output descriptions of each of its
14432 members. Note that as we output the DIEs necessary to represent the
14433 members of this record or union type, we will also be trying to output
14434 DIEs to represent the *types* of those members. However the `type'
14435 function (above) will specifically avoid generating type DIEs for member
14436 types *within* the list of member DIEs for this (containing) type except
14437 for those types (of members) which are explicitly marked as also being
14438 members of this (containing) type themselves. The g++ front- end can
14439 force any given type to be treated as a member of some other (containing)
14440 type by setting the TYPE_CONTEXT of the given (member) type to point to
14441 the TREE node representing the appropriate (containing) type. */
14443 /* First output info about the base classes. */
14446 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
14450 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
14451 gen_inheritance_die (base,
14452 (accesses ? VEC_index (tree, accesses, i)
14453 : access_public_node), context_die);
14456 /* Now output info about the data members and type members. */
14457 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
14459 /* If we thought we were generating minimal debug info for TYPE
14460 and then changed our minds, some of the member declarations
14461 may have already been defined. Don't define them again, but
14462 do put them in the right order. */
14464 child = lookup_decl_die (member);
14466 splice_child_die (context_die, child);
14468 gen_decl_die (member, NULL, context_die);
14471 /* Now output info about the function members (if any). */
14472 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
14474 /* Don't include clones in the member list. */
14475 if (DECL_ABSTRACT_ORIGIN (member))
14478 child = lookup_decl_die (member);
14480 splice_child_die (context_die, child);
14482 gen_decl_die (member, NULL, context_die);
14486 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
14487 is set, we pretend that the type was never defined, so we only get the
14488 member DIEs needed by later specification DIEs. */
14491 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
14492 enum debug_info_usage usage)
14494 dw_die_ref type_die = lookup_type_die (type);
14495 dw_die_ref scope_die = 0;
14497 int complete = (TYPE_SIZE (type)
14498 && (! TYPE_STUB_DECL (type)
14499 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
14500 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
14501 complete = complete && should_emit_struct_debug (type, usage);
14503 if (type_die && ! complete)
14506 if (TYPE_CONTEXT (type) != NULL_TREE
14507 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14508 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
14511 scope_die = scope_die_for (type, context_die);
14513 if (! type_die || (nested && scope_die == comp_unit_die))
14514 /* First occurrence of type or toplevel definition of nested class. */
14516 dw_die_ref old_die = type_die;
14518 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
14519 ? record_type_tag (type) : DW_TAG_union_type,
14521 equate_type_number_to_die (type, type_die);
14523 add_AT_specification (type_die, old_die);
14525 add_name_attribute (type_die, type_tag (type));
14528 remove_AT (type_die, DW_AT_declaration);
14530 /* If this type has been completed, then give it a byte_size attribute and
14531 then give a list of members. */
14532 if (complete && !ns_decl)
14534 /* Prevent infinite recursion in cases where the type of some member of
14535 this type is expressed in terms of this type itself. */
14536 TREE_ASM_WRITTEN (type) = 1;
14537 add_byte_size_attribute (type_die, type);
14538 if (TYPE_STUB_DECL (type) != NULL_TREE)
14539 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
14541 /* If the first reference to this type was as the return type of an
14542 inline function, then it may not have a parent. Fix this now. */
14543 if (type_die->die_parent == NULL)
14544 add_child_die (scope_die, type_die);
14546 push_decl_scope (type);
14547 gen_member_die (type, type_die);
14550 /* GNU extension: Record what type our vtable lives in. */
14551 if (TYPE_VFIELD (type))
14553 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
14555 gen_type_die (vtype, context_die);
14556 add_AT_die_ref (type_die, DW_AT_containing_type,
14557 lookup_type_die (vtype));
14562 add_AT_flag (type_die, DW_AT_declaration, 1);
14564 /* We don't need to do this for function-local types. */
14565 if (TYPE_STUB_DECL (type)
14566 && ! decl_function_context (TYPE_STUB_DECL (type)))
14567 VEC_safe_push (tree, gc, incomplete_types, type);
14570 if (get_AT (type_die, DW_AT_name))
14571 add_pubtype (type, type_die);
14574 /* Generate a DIE for a subroutine _type_. */
14577 gen_subroutine_type_die (tree type, dw_die_ref context_die)
14579 tree return_type = TREE_TYPE (type);
14580 dw_die_ref subr_die
14581 = new_die (DW_TAG_subroutine_type,
14582 scope_die_for (type, context_die), type);
14584 equate_type_number_to_die (type, subr_die);
14585 add_prototyped_attribute (subr_die, type);
14586 add_type_attribute (subr_die, return_type, 0, 0, context_die);
14587 gen_formal_types_die (type, subr_die);
14589 if (get_AT (subr_die, DW_AT_name))
14590 add_pubtype (type, subr_die);
14593 /* Generate a DIE for a type definition. */
14596 gen_typedef_die (tree decl, dw_die_ref context_die)
14598 dw_die_ref type_die;
14601 if (TREE_ASM_WRITTEN (decl))
14604 TREE_ASM_WRITTEN (decl) = 1;
14605 type_die = new_die (DW_TAG_typedef, context_die, decl);
14606 origin = decl_ultimate_origin (decl);
14607 if (origin != NULL)
14608 add_abstract_origin_attribute (type_die, origin);
14613 add_name_and_src_coords_attributes (type_die, decl);
14614 if (DECL_ORIGINAL_TYPE (decl))
14616 type = DECL_ORIGINAL_TYPE (decl);
14618 gcc_assert (type != TREE_TYPE (decl));
14619 equate_type_number_to_die (TREE_TYPE (decl), type_die);
14622 type = TREE_TYPE (decl);
14624 add_type_attribute (type_die, type, TREE_READONLY (decl),
14625 TREE_THIS_VOLATILE (decl), context_die);
14628 if (DECL_ABSTRACT (decl))
14629 equate_decl_number_to_die (decl, type_die);
14631 if (get_AT (type_die, DW_AT_name))
14632 add_pubtype (decl, type_die);
14635 /* Generate a type description DIE. */
14638 gen_type_die_with_usage (tree type, dw_die_ref context_die,
14639 enum debug_info_usage usage)
14642 struct array_descr_info info;
14644 if (type == NULL_TREE || type == error_mark_node)
14647 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
14648 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
14650 if (TREE_ASM_WRITTEN (type))
14653 /* Prevent broken recursion; we can't hand off to the same type. */
14654 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
14656 TREE_ASM_WRITTEN (type) = 1;
14657 gen_decl_die (TYPE_NAME (type), NULL, context_die);
14661 /* If this is an array type with hidden descriptor, handle it first. */
14662 if (!TREE_ASM_WRITTEN (type)
14663 && lang_hooks.types.get_array_descr_info
14664 && lang_hooks.types.get_array_descr_info (type, &info))
14666 gen_descr_array_type_die (type, &info, context_die);
14667 TREE_ASM_WRITTEN (type) = 1;
14671 /* We are going to output a DIE to represent the unqualified version
14672 of this type (i.e. without any const or volatile qualifiers) so
14673 get the main variant (i.e. the unqualified version) of this type
14674 now. (Vectors are special because the debugging info is in the
14675 cloned type itself). */
14676 if (TREE_CODE (type) != VECTOR_TYPE)
14677 type = type_main_variant (type);
14679 if (TREE_ASM_WRITTEN (type))
14682 switch (TREE_CODE (type))
14688 case REFERENCE_TYPE:
14689 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
14690 ensures that the gen_type_die recursion will terminate even if the
14691 type is recursive. Recursive types are possible in Ada. */
14692 /* ??? We could perhaps do this for all types before the switch
14694 TREE_ASM_WRITTEN (type) = 1;
14696 /* For these types, all that is required is that we output a DIE (or a
14697 set of DIEs) to represent the "basis" type. */
14698 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14699 DINFO_USAGE_IND_USE);
14703 /* This code is used for C++ pointer-to-data-member types.
14704 Output a description of the relevant class type. */
14705 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
14706 DINFO_USAGE_IND_USE);
14708 /* Output a description of the type of the object pointed to. */
14709 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14710 DINFO_USAGE_IND_USE);
14712 /* Now output a DIE to represent this pointer-to-data-member type
14714 gen_ptr_to_mbr_type_die (type, context_die);
14717 case FUNCTION_TYPE:
14718 /* Force out return type (in case it wasn't forced out already). */
14719 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14720 DINFO_USAGE_DIR_USE);
14721 gen_subroutine_type_die (type, context_die);
14725 /* Force out return type (in case it wasn't forced out already). */
14726 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14727 DINFO_USAGE_DIR_USE);
14728 gen_subroutine_type_die (type, context_die);
14732 gen_array_type_die (type, context_die);
14736 gen_array_type_die (type, context_die);
14739 case ENUMERAL_TYPE:
14742 case QUAL_UNION_TYPE:
14743 /* If this is a nested type whose containing class hasn't been written
14744 out yet, writing it out will cover this one, too. This does not apply
14745 to instantiations of member class templates; they need to be added to
14746 the containing class as they are generated. FIXME: This hurts the
14747 idea of combining type decls from multiple TUs, since we can't predict
14748 what set of template instantiations we'll get. */
14749 if (TYPE_CONTEXT (type)
14750 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14751 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
14753 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
14755 if (TREE_ASM_WRITTEN (type))
14758 /* If that failed, attach ourselves to the stub. */
14759 push_decl_scope (TYPE_CONTEXT (type));
14760 context_die = lookup_type_die (TYPE_CONTEXT (type));
14765 context_die = declare_in_namespace (type, context_die);
14769 if (TREE_CODE (type) == ENUMERAL_TYPE)
14771 /* This might have been written out by the call to
14772 declare_in_namespace. */
14773 if (!TREE_ASM_WRITTEN (type))
14774 gen_enumeration_type_die (type, context_die);
14777 gen_struct_or_union_type_die (type, context_die, usage);
14782 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
14783 it up if it is ever completed. gen_*_type_die will set it for us
14784 when appropriate. */
14790 case FIXED_POINT_TYPE:
14793 /* No DIEs needed for fundamental types. */
14797 /* No Dwarf representation currently defined. */
14801 gcc_unreachable ();
14804 TREE_ASM_WRITTEN (type) = 1;
14808 gen_type_die (tree type, dw_die_ref context_die)
14810 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
14813 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
14814 things which are local to the given block. */
14817 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
14819 int must_output_die = 0;
14822 /* Ignore blocks that are NULL. */
14823 if (stmt == NULL_TREE)
14826 inlined_func = inlined_function_outer_scope_p (stmt);
14828 /* If the block is one fragment of a non-contiguous block, do not
14829 process the variables, since they will have been done by the
14830 origin block. Do process subblocks. */
14831 if (BLOCK_FRAGMENT_ORIGIN (stmt))
14835 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
14836 gen_block_die (sub, context_die, depth + 1);
14841 /* Determine if we need to output any Dwarf DIEs at all to represent this
14844 /* The outer scopes for inlinings *must* always be represented. We
14845 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
14846 must_output_die = 1;
14849 /* Determine if this block directly contains any "significant"
14850 local declarations which we will need to output DIEs for. */
14851 if (debug_info_level > DINFO_LEVEL_TERSE)
14852 /* We are not in terse mode so *any* local declaration counts
14853 as being a "significant" one. */
14854 must_output_die = ((BLOCK_VARS (stmt) != NULL
14855 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
14856 && (TREE_USED (stmt)
14857 || TREE_ASM_WRITTEN (stmt)
14858 || BLOCK_ABSTRACT (stmt)));
14859 else if ((TREE_USED (stmt)
14860 || TREE_ASM_WRITTEN (stmt)
14861 || BLOCK_ABSTRACT (stmt))
14862 && !dwarf2out_ignore_block (stmt))
14863 must_output_die = 1;
14866 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
14867 DIE for any block which contains no significant local declarations at
14868 all. Rather, in such cases we just call `decls_for_scope' so that any
14869 needed Dwarf info for any sub-blocks will get properly generated. Note
14870 that in terse mode, our definition of what constitutes a "significant"
14871 local declaration gets restricted to include only inlined function
14872 instances and local (nested) function definitions. */
14873 if (must_output_die)
14876 gen_inlined_subroutine_die (stmt, context_die, depth);
14878 gen_lexical_block_die (stmt, context_die, depth);
14881 decls_for_scope (stmt, context_die, depth);
14884 /* Process variable DECL (or variable with origin ORIGIN) within
14885 block STMT and add it to CONTEXT_DIE. */
14887 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
14890 tree decl_or_origin = decl ? decl : origin;
14891 tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
14893 if (ultimate_origin)
14894 origin = ultimate_origin;
14896 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
14897 die = lookup_decl_die (decl_or_origin);
14898 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
14899 && TYPE_DECL_IS_STUB (decl_or_origin))
14900 die = lookup_type_die (TREE_TYPE (decl_or_origin));
14904 if (die != NULL && die->die_parent == NULL)
14905 add_child_die (context_die, die);
14906 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
14907 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
14908 stmt, context_die);
14910 gen_decl_die (decl, origin, context_die);
14913 /* Generate all of the decls declared within a given scope and (recursively)
14914 all of its sub-blocks. */
14917 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
14923 /* Ignore NULL blocks. */
14924 if (stmt == NULL_TREE)
14927 /* Output the DIEs to represent all of the data objects and typedefs
14928 declared directly within this block but not within any nested
14929 sub-blocks. Also, nested function and tag DIEs have been
14930 generated with a parent of NULL; fix that up now. */
14931 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
14932 process_scope_var (stmt, decl, NULL_TREE, context_die);
14933 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
14934 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
14937 /* If we're at -g1, we're not interested in subblocks. */
14938 if (debug_info_level <= DINFO_LEVEL_TERSE)
14941 /* Output the DIEs to represent all sub-blocks (and the items declared
14942 therein) of this block. */
14943 for (subblocks = BLOCK_SUBBLOCKS (stmt);
14945 subblocks = BLOCK_CHAIN (subblocks))
14946 gen_block_die (subblocks, context_die, depth + 1);
14949 /* Is this a typedef we can avoid emitting? */
14952 is_redundant_typedef (const_tree decl)
14954 if (TYPE_DECL_IS_STUB (decl))
14957 if (DECL_ARTIFICIAL (decl)
14958 && DECL_CONTEXT (decl)
14959 && is_tagged_type (DECL_CONTEXT (decl))
14960 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
14961 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
14962 /* Also ignore the artificial member typedef for the class name. */
14968 /* Returns the DIE for a context. */
14970 static inline dw_die_ref
14971 get_context_die (tree context)
14975 /* Find die that represents this context. */
14976 if (TYPE_P (context))
14977 return force_type_die (context);
14979 return force_decl_die (context);
14981 return comp_unit_die;
14984 /* Returns the DIE for decl. A DIE will always be returned. */
14987 force_decl_die (tree decl)
14989 dw_die_ref decl_die;
14990 unsigned saved_external_flag;
14991 tree save_fn = NULL_TREE;
14992 decl_die = lookup_decl_die (decl);
14995 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
14997 decl_die = lookup_decl_die (decl);
15001 switch (TREE_CODE (decl))
15003 case FUNCTION_DECL:
15004 /* Clear current_function_decl, so that gen_subprogram_die thinks
15005 that this is a declaration. At this point, we just want to force
15006 declaration die. */
15007 save_fn = current_function_decl;
15008 current_function_decl = NULL_TREE;
15009 gen_subprogram_die (decl, context_die);
15010 current_function_decl = save_fn;
15014 /* Set external flag to force declaration die. Restore it after
15015 gen_decl_die() call. */
15016 saved_external_flag = DECL_EXTERNAL (decl);
15017 DECL_EXTERNAL (decl) = 1;
15018 gen_decl_die (decl, NULL, context_die);
15019 DECL_EXTERNAL (decl) = saved_external_flag;
15022 case NAMESPACE_DECL:
15023 dwarf2out_decl (decl);
15027 gcc_unreachable ();
15030 /* We should be able to find the DIE now. */
15032 decl_die = lookup_decl_die (decl);
15033 gcc_assert (decl_die);
15039 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
15040 always returned. */
15043 force_type_die (tree type)
15045 dw_die_ref type_die;
15047 type_die = lookup_type_die (type);
15050 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
15052 type_die = modified_type_die (type, TYPE_READONLY (type),
15053 TYPE_VOLATILE (type), context_die);
15054 gcc_assert (type_die);
15059 /* Force out any required namespaces to be able to output DECL,
15060 and return the new context_die for it, if it's changed. */
15063 setup_namespace_context (tree thing, dw_die_ref context_die)
15065 tree context = (DECL_P (thing)
15066 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
15067 if (context && TREE_CODE (context) == NAMESPACE_DECL)
15068 /* Force out the namespace. */
15069 context_die = force_decl_die (context);
15071 return context_die;
15074 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
15075 type) within its namespace, if appropriate.
15077 For compatibility with older debuggers, namespace DIEs only contain
15078 declarations; all definitions are emitted at CU scope. */
15081 declare_in_namespace (tree thing, dw_die_ref context_die)
15083 dw_die_ref ns_context;
15085 if (debug_info_level <= DINFO_LEVEL_TERSE)
15086 return context_die;
15088 /* If this decl is from an inlined function, then don't try to emit it in its
15089 namespace, as we will get confused. It would have already been emitted
15090 when the abstract instance of the inline function was emitted anyways. */
15091 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
15092 return context_die;
15094 ns_context = setup_namespace_context (thing, context_die);
15096 if (ns_context != context_die)
15100 if (DECL_P (thing))
15101 gen_decl_die (thing, NULL, ns_context);
15103 gen_type_die (thing, ns_context);
15105 return context_die;
15108 /* Generate a DIE for a namespace or namespace alias. */
15111 gen_namespace_die (tree decl, dw_die_ref context_die)
15113 dw_die_ref namespace_die;
15115 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
15116 they are an alias of. */
15117 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
15119 /* Output a real namespace or module. */
15120 context_die = setup_namespace_context (decl, comp_unit_die);
15121 namespace_die = new_die (is_fortran ()
15122 ? DW_TAG_module : DW_TAG_namespace,
15123 context_die, decl);
15124 /* For Fortran modules defined in different CU don't add src coords. */
15125 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
15126 add_name_attribute (namespace_die, dwarf2_name (decl, 0));
15128 add_name_and_src_coords_attributes (namespace_die, decl);
15129 if (DECL_EXTERNAL (decl))
15130 add_AT_flag (namespace_die, DW_AT_declaration, 1);
15131 equate_decl_number_to_die (decl, namespace_die);
15135 /* Output a namespace alias. */
15137 /* Force out the namespace we are an alias of, if necessary. */
15138 dw_die_ref origin_die
15139 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
15141 if (DECL_CONTEXT (decl) == NULL_TREE
15142 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
15143 context_die = setup_namespace_context (decl, comp_unit_die);
15144 /* Now create the namespace alias DIE. */
15145 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
15146 add_name_and_src_coords_attributes (namespace_die, decl);
15147 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
15148 equate_decl_number_to_die (decl, namespace_die);
15152 /* Generate Dwarf debug information for a decl described by DECL. */
15155 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
15157 tree decl_or_origin = decl ? decl : origin;
15158 tree class_origin = NULL;
15160 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
15163 switch (TREE_CODE (decl_or_origin))
15169 if (!is_fortran ())
15171 /* The individual enumerators of an enum type get output when we output
15172 the Dwarf representation of the relevant enum type itself. */
15176 /* Emit its type. */
15177 gen_type_die (TREE_TYPE (decl), context_die);
15179 /* And its containing namespace. */
15180 context_die = declare_in_namespace (decl, context_die);
15182 gen_const_die (decl, context_die);
15185 case FUNCTION_DECL:
15186 /* Don't output any DIEs to represent mere function declarations,
15187 unless they are class members or explicit block externs. */
15188 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
15189 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
15190 && (current_function_decl == NULL_TREE
15191 || DECL_ARTIFICIAL (decl_or_origin)))
15196 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
15197 on local redeclarations of global functions. That seems broken. */
15198 if (current_function_decl != decl)
15199 /* This is only a declaration. */;
15202 /* If we're emitting a clone, emit info for the abstract instance. */
15203 if (origin || DECL_ORIGIN (decl) != decl)
15204 dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
15206 /* If we're emitting an out-of-line copy of an inline function,
15207 emit info for the abstract instance and set up to refer to it. */
15208 else if (cgraph_function_possibly_inlined_p (decl)
15209 && ! DECL_ABSTRACT (decl)
15210 && ! class_or_namespace_scope_p (context_die)
15211 /* dwarf2out_abstract_function won't emit a die if this is just
15212 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
15213 that case, because that works only if we have a die. */
15214 && DECL_INITIAL (decl) != NULL_TREE)
15216 dwarf2out_abstract_function (decl);
15217 set_decl_origin_self (decl);
15220 /* Otherwise we're emitting the primary DIE for this decl. */
15221 else if (debug_info_level > DINFO_LEVEL_TERSE)
15223 /* Before we describe the FUNCTION_DECL itself, make sure that we
15224 have described its return type. */
15225 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
15227 /* And its virtual context. */
15228 if (DECL_VINDEX (decl) != NULL_TREE)
15229 gen_type_die (DECL_CONTEXT (decl), context_die);
15231 /* And its containing type. */
15233 origin = decl_class_context (decl);
15234 if (origin != NULL_TREE)
15235 gen_type_die_for_member (origin, decl, context_die);
15237 /* And its containing namespace. */
15238 context_die = declare_in_namespace (decl, context_die);
15241 /* Now output a DIE to represent the function itself. */
15243 gen_subprogram_die (decl, context_die);
15247 /* If we are in terse mode, don't generate any DIEs to represent any
15248 actual typedefs. */
15249 if (debug_info_level <= DINFO_LEVEL_TERSE)
15252 /* In the special case of a TYPE_DECL node representing the declaration
15253 of some type tag, if the given TYPE_DECL is marked as having been
15254 instantiated from some other (original) TYPE_DECL node (e.g. one which
15255 was generated within the original definition of an inline function) we
15256 used to generate a special (abbreviated) DW_TAG_structure_type,
15257 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
15258 should be actually referencing those DIEs, as variable DIEs with that
15259 type would be emitted already in the abstract origin, so it was always
15260 removed during unused type prunning. Don't add anything in this
15262 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
15265 if (is_redundant_typedef (decl))
15266 gen_type_die (TREE_TYPE (decl), context_die);
15268 /* Output a DIE to represent the typedef itself. */
15269 gen_typedef_die (decl, context_die);
15273 if (debug_info_level >= DINFO_LEVEL_NORMAL)
15274 gen_label_die (decl, context_die);
15279 /* If we are in terse mode, don't generate any DIEs to represent any
15280 variable declarations or definitions. */
15281 if (debug_info_level <= DINFO_LEVEL_TERSE)
15284 /* Output any DIEs that are needed to specify the type of this data
15286 if (TREE_CODE (decl_or_origin) == RESULT_DECL
15287 && DECL_BY_REFERENCE (decl_or_origin))
15288 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15290 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15292 /* And its containing type. */
15293 class_origin = decl_class_context (decl_or_origin);
15294 if (class_origin != NULL_TREE)
15295 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
15297 /* And its containing namespace. */
15298 context_die = declare_in_namespace (decl_or_origin, context_die);
15300 /* Now output the DIE to represent the data object itself. This gets
15301 complicated because of the possibility that the VAR_DECL really
15302 represents an inlined instance of a formal parameter for an inline
15305 origin = decl_ultimate_origin (decl);
15306 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
15307 gen_formal_parameter_die (decl, origin, context_die);
15309 gen_variable_die (decl, origin, context_die);
15313 /* Ignore the nameless fields that are used to skip bits but handle C++
15314 anonymous unions and structs. */
15315 if (DECL_NAME (decl) != NULL_TREE
15316 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
15317 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
15319 gen_type_die (member_declared_type (decl), context_die);
15320 gen_field_die (decl, context_die);
15325 if (DECL_BY_REFERENCE (decl_or_origin))
15326 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15328 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15329 gen_formal_parameter_die (decl, origin, context_die);
15332 case NAMESPACE_DECL:
15333 case IMPORTED_DECL:
15334 gen_namespace_die (decl, context_die);
15338 /* Probably some frontend-internal decl. Assume we don't care. */
15339 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
15344 /* Output debug information for global decl DECL. Called from toplev.c after
15345 compilation proper has finished. */
15348 dwarf2out_global_decl (tree decl)
15350 /* Output DWARF2 information for file-scope tentative data object
15351 declarations, file-scope (extern) function declarations (which
15352 had no corresponding body) and file-scope tagged type declarations
15353 and definitions which have not yet been forced out. */
15354 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
15355 dwarf2out_decl (decl);
15358 /* Output debug information for type decl DECL. Called from toplev.c
15359 and from language front ends (to record built-in types). */
15361 dwarf2out_type_decl (tree decl, int local)
15364 dwarf2out_decl (decl);
15367 /* Output debug information for imported module or decl DECL.
15368 NAME is non-NULL name in the lexical block if the decl has been renamed.
15369 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
15370 that DECL belongs to.
15371 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
15373 dwarf2out_imported_module_or_decl_1 (tree decl,
15375 tree lexical_block,
15376 dw_die_ref lexical_block_die)
15378 expanded_location xloc;
15379 dw_die_ref imported_die = NULL;
15380 dw_die_ref at_import_die;
15382 if (TREE_CODE (decl) == IMPORTED_DECL)
15384 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
15385 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
15389 xloc = expand_location (input_location);
15391 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
15393 if (is_base_type (TREE_TYPE (decl)))
15394 at_import_die = base_type_die (TREE_TYPE (decl));
15396 at_import_die = force_type_die (TREE_TYPE (decl));
15397 /* For namespace N { typedef void T; } using N::T; base_type_die
15398 returns NULL, but DW_TAG_imported_declaration requires
15399 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
15400 if (!at_import_die)
15402 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
15403 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
15404 at_import_die = lookup_type_die (TREE_TYPE (decl));
15405 gcc_assert (at_import_die);
15410 at_import_die = lookup_decl_die (decl);
15411 if (!at_import_die)
15413 /* If we're trying to avoid duplicate debug info, we may not have
15414 emitted the member decl for this field. Emit it now. */
15415 if (TREE_CODE (decl) == FIELD_DECL)
15417 tree type = DECL_CONTEXT (decl);
15419 if (TYPE_CONTEXT (type)
15420 && TYPE_P (TYPE_CONTEXT (type))
15421 && !should_emit_struct_debug (TYPE_CONTEXT (type),
15422 DINFO_USAGE_DIR_USE))
15424 gen_type_die_for_member (type, decl,
15425 get_context_die (TYPE_CONTEXT (type)));
15427 at_import_die = force_decl_die (decl);
15431 if (TREE_CODE (decl) == NAMESPACE_DECL)
15432 imported_die = new_die (DW_TAG_imported_module,
15436 imported_die = new_die (DW_TAG_imported_declaration,
15440 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
15441 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
15443 add_AT_string (imported_die, DW_AT_name,
15444 IDENTIFIER_POINTER (name));
15445 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
15448 /* Output debug information for imported module or decl DECL.
15449 NAME is non-NULL name in context if the decl has been renamed.
15450 CHILD is true if decl is one of the renamed decls as part of
15451 importing whole module. */
15454 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
15457 /* dw_die_ref at_import_die; */
15458 dw_die_ref scope_die;
15460 if (debug_info_level <= DINFO_LEVEL_TERSE)
15465 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
15466 We need decl DIE for reference and scope die. First, get DIE for the decl
15469 /* Get the scope die for decl context. Use comp_unit_die for global module
15470 or decl. If die is not found for non globals, force new die. */
15472 && TYPE_P (context)
15473 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
15475 scope_die = get_context_die (context);
15479 gcc_assert (scope_die->die_child);
15480 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
15481 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
15482 scope_die = scope_die->die_child;
15485 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
15486 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
15490 /* Write the debugging output for DECL. */
15493 dwarf2out_decl (tree decl)
15495 dw_die_ref context_die = comp_unit_die;
15497 switch (TREE_CODE (decl))
15502 case FUNCTION_DECL:
15503 /* What we would really like to do here is to filter out all mere
15504 file-scope declarations of file-scope functions which are never
15505 referenced later within this translation unit (and keep all of ones
15506 that *are* referenced later on) but we aren't clairvoyant, so we have
15507 no idea which functions will be referenced in the future (i.e. later
15508 on within the current translation unit). So here we just ignore all
15509 file-scope function declarations which are not also definitions. If
15510 and when the debugger needs to know something about these functions,
15511 it will have to hunt around and find the DWARF information associated
15512 with the definition of the function.
15514 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
15515 nodes represent definitions and which ones represent mere
15516 declarations. We have to check DECL_INITIAL instead. That's because
15517 the C front-end supports some weird semantics for "extern inline"
15518 function definitions. These can get inlined within the current
15519 translation unit (and thus, we need to generate Dwarf info for their
15520 abstract instances so that the Dwarf info for the concrete inlined
15521 instances can have something to refer to) but the compiler never
15522 generates any out-of-lines instances of such things (despite the fact
15523 that they *are* definitions).
15525 The important point is that the C front-end marks these "extern
15526 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
15527 them anyway. Note that the C++ front-end also plays some similar games
15528 for inline function definitions appearing within include files which
15529 also contain `#pragma interface' pragmas. */
15530 if (DECL_INITIAL (decl) == NULL_TREE)
15533 /* If we're a nested function, initially use a parent of NULL; if we're
15534 a plain function, this will be fixed up in decls_for_scope. If
15535 we're a method, it will be ignored, since we already have a DIE. */
15536 if (decl_function_context (decl)
15537 /* But if we're in terse mode, we don't care about scope. */
15538 && debug_info_level > DINFO_LEVEL_TERSE)
15539 context_die = NULL;
15543 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
15544 declaration and if the declaration was never even referenced from
15545 within this entire compilation unit. We suppress these DIEs in
15546 order to save space in the .debug section (by eliminating entries
15547 which are probably useless). Note that we must not suppress
15548 block-local extern declarations (whether used or not) because that
15549 would screw-up the debugger's name lookup mechanism and cause it to
15550 miss things which really ought to be in scope at a given point. */
15551 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
15554 /* For local statics lookup proper context die. */
15555 if (TREE_STATIC (decl) && decl_function_context (decl))
15556 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15558 /* If we are in terse mode, don't generate any DIEs to represent any
15559 variable declarations or definitions. */
15560 if (debug_info_level <= DINFO_LEVEL_TERSE)
15565 if (debug_info_level <= DINFO_LEVEL_TERSE)
15567 if (!is_fortran ())
15569 if (TREE_STATIC (decl) && decl_function_context (decl))
15570 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15573 case NAMESPACE_DECL:
15574 case IMPORTED_DECL:
15575 if (debug_info_level <= DINFO_LEVEL_TERSE)
15577 if (lookup_decl_die (decl) != NULL)
15582 /* Don't emit stubs for types unless they are needed by other DIEs. */
15583 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
15586 /* Don't bother trying to generate any DIEs to represent any of the
15587 normal built-in types for the language we are compiling. */
15588 if (DECL_IS_BUILTIN (decl))
15590 /* OK, we need to generate one for `bool' so GDB knows what type
15591 comparisons have. */
15593 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
15594 && ! DECL_IGNORED_P (decl))
15595 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
15600 /* If we are in terse mode, don't generate any DIEs for types. */
15601 if (debug_info_level <= DINFO_LEVEL_TERSE)
15604 /* If we're a function-scope tag, initially use a parent of NULL;
15605 this will be fixed up in decls_for_scope. */
15606 if (decl_function_context (decl))
15607 context_die = NULL;
15615 gen_decl_die (decl, NULL, context_die);
15618 /* Output a marker (i.e. a label) for the beginning of the generated code for
15619 a lexical block. */
15622 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
15623 unsigned int blocknum)
15625 switch_to_section (current_function_section ());
15626 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
15629 /* Output a marker (i.e. a label) for the end of the generated code for a
15633 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
15635 switch_to_section (current_function_section ());
15636 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
15639 /* Returns nonzero if it is appropriate not to emit any debugging
15640 information for BLOCK, because it doesn't contain any instructions.
15642 Don't allow this for blocks with nested functions or local classes
15643 as we would end up with orphans, and in the presence of scheduling
15644 we may end up calling them anyway. */
15647 dwarf2out_ignore_block (const_tree block)
15652 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
15653 if (TREE_CODE (decl) == FUNCTION_DECL
15654 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15656 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
15658 decl = BLOCK_NONLOCALIZED_VAR (block, i);
15659 if (TREE_CODE (decl) == FUNCTION_DECL
15660 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15667 /* Hash table routines for file_hash. */
15670 file_table_eq (const void *p1_p, const void *p2_p)
15672 const struct dwarf_file_data *const p1 =
15673 (const struct dwarf_file_data *) p1_p;
15674 const char *const p2 = (const char *) p2_p;
15675 return strcmp (p1->filename, p2) == 0;
15679 file_table_hash (const void *p_p)
15681 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
15682 return htab_hash_string (p->filename);
15685 /* Lookup FILE_NAME (in the list of filenames that we know about here in
15686 dwarf2out.c) and return its "index". The index of each (known) filename is
15687 just a unique number which is associated with only that one filename. We
15688 need such numbers for the sake of generating labels (in the .debug_sfnames
15689 section) and references to those files numbers (in the .debug_srcinfo
15690 and.debug_macinfo sections). If the filename given as an argument is not
15691 found in our current list, add it to the list and assign it the next
15692 available unique index number. In order to speed up searches, we remember
15693 the index of the filename was looked up last. This handles the majority of
15696 static struct dwarf_file_data *
15697 lookup_filename (const char *file_name)
15700 struct dwarf_file_data * created;
15702 /* Check to see if the file name that was searched on the previous
15703 call matches this file name. If so, return the index. */
15704 if (file_table_last_lookup
15705 && (file_name == file_table_last_lookup->filename
15706 || strcmp (file_table_last_lookup->filename, file_name) == 0))
15707 return file_table_last_lookup;
15709 /* Didn't match the previous lookup, search the table. */
15710 slot = htab_find_slot_with_hash (file_table, file_name,
15711 htab_hash_string (file_name), INSERT);
15713 return (struct dwarf_file_data *) *slot;
15715 created = GGC_NEW (struct dwarf_file_data);
15716 created->filename = file_name;
15717 created->emitted_number = 0;
15722 /* If the assembler will construct the file table, then translate the compiler
15723 internal file table number into the assembler file table number, and emit
15724 a .file directive if we haven't already emitted one yet. The file table
15725 numbers are different because we prune debug info for unused variables and
15726 types, which may include filenames. */
15729 maybe_emit_file (struct dwarf_file_data * fd)
15731 if (! fd->emitted_number)
15733 if (last_emitted_file)
15734 fd->emitted_number = last_emitted_file->emitted_number + 1;
15736 fd->emitted_number = 1;
15737 last_emitted_file = fd;
15739 if (DWARF2_ASM_LINE_DEBUG_INFO)
15741 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
15742 output_quoted_string (asm_out_file,
15743 remap_debug_filename (fd->filename));
15744 fputc ('\n', asm_out_file);
15748 return fd->emitted_number;
15751 /* Called by the final INSN scan whenever we see a var location. We
15752 use it to drop labels in the right places, and throw the location in
15753 our lookup table. */
15756 dwarf2out_var_location (rtx loc_note)
15758 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
15759 struct var_loc_node *newloc;
15761 static rtx last_insn;
15762 static const char *last_label;
15765 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
15767 prev_insn = PREV_INSN (loc_note);
15769 newloc = GGC_CNEW (struct var_loc_node);
15770 /* If the insn we processed last time is the previous insn
15771 and it is also a var location note, use the label we emitted
15773 if (last_insn != NULL_RTX
15774 && last_insn == prev_insn
15775 && NOTE_P (prev_insn)
15776 && NOTE_KIND (prev_insn) == NOTE_INSN_VAR_LOCATION)
15778 newloc->label = last_label;
15782 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
15783 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
15785 newloc->label = ggc_strdup (loclabel);
15787 newloc->var_loc_note = loc_note;
15788 newloc->next = NULL;
15790 if (cfun && in_cold_section_p)
15791 newloc->section_label = crtl->subsections.cold_section_label;
15793 newloc->section_label = text_section_label;
15795 last_insn = loc_note;
15796 last_label = newloc->label;
15797 decl = NOTE_VAR_LOCATION_DECL (loc_note);
15798 add_var_loc_to_decl (decl, newloc);
15801 /* We need to reset the locations at the beginning of each
15802 function. We can't do this in the end_function hook, because the
15803 declarations that use the locations won't have been output when
15804 that hook is called. Also compute have_multiple_function_sections here. */
15807 dwarf2out_begin_function (tree fun)
15809 htab_empty (decl_loc_table);
15811 if (function_section (fun) != text_section)
15812 have_multiple_function_sections = true;
15814 dwarf2out_note_section_used ();
15817 /* Output a label to mark the beginning of a source code line entry
15818 and record information relating to this source line, in
15819 'line_info_table' for later output of the .debug_line section. */
15822 dwarf2out_source_line (unsigned int line, const char *filename)
15824 if (debug_info_level >= DINFO_LEVEL_NORMAL
15827 int file_num = maybe_emit_file (lookup_filename (filename));
15829 switch_to_section (current_function_section ());
15831 /* If requested, emit something human-readable. */
15832 if (flag_debug_asm)
15833 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
15836 if (DWARF2_ASM_LINE_DEBUG_INFO)
15838 /* Emit the .loc directive understood by GNU as. */
15839 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
15841 /* Indicate that line number info exists. */
15842 line_info_table_in_use++;
15844 else if (function_section (current_function_decl) != text_section)
15846 dw_separate_line_info_ref line_info;
15847 targetm.asm_out.internal_label (asm_out_file,
15848 SEPARATE_LINE_CODE_LABEL,
15849 separate_line_info_table_in_use);
15851 /* Expand the line info table if necessary. */
15852 if (separate_line_info_table_in_use
15853 == separate_line_info_table_allocated)
15855 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15856 separate_line_info_table
15857 = GGC_RESIZEVEC (dw_separate_line_info_entry,
15858 separate_line_info_table,
15859 separate_line_info_table_allocated);
15860 memset (separate_line_info_table
15861 + separate_line_info_table_in_use,
15863 (LINE_INFO_TABLE_INCREMENT
15864 * sizeof (dw_separate_line_info_entry)));
15867 /* Add the new entry at the end of the line_info_table. */
15869 = &separate_line_info_table[separate_line_info_table_in_use++];
15870 line_info->dw_file_num = file_num;
15871 line_info->dw_line_num = line;
15872 line_info->function = current_function_funcdef_no;
15876 dw_line_info_ref line_info;
15878 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
15879 line_info_table_in_use);
15881 /* Expand the line info table if necessary. */
15882 if (line_info_table_in_use == line_info_table_allocated)
15884 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15886 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
15887 line_info_table_allocated);
15888 memset (line_info_table + line_info_table_in_use, 0,
15889 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
15892 /* Add the new entry at the end of the line_info_table. */
15893 line_info = &line_info_table[line_info_table_in_use++];
15894 line_info->dw_file_num = file_num;
15895 line_info->dw_line_num = line;
15900 /* Record the beginning of a new source file. */
15903 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
15905 if (flag_eliminate_dwarf2_dups)
15907 /* Record the beginning of the file for break_out_includes. */
15908 dw_die_ref bincl_die;
15910 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
15911 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
15914 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15916 int file_num = maybe_emit_file (lookup_filename (filename));
15918 switch_to_section (debug_macinfo_section);
15919 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
15920 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
15923 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
15927 /* Record the end of a source file. */
15930 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
15932 if (flag_eliminate_dwarf2_dups)
15933 /* Record the end of the file for break_out_includes. */
15934 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
15936 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15938 switch_to_section (debug_macinfo_section);
15939 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
15943 /* Called from debug_define in toplev.c. The `buffer' parameter contains
15944 the tail part of the directive line, i.e. the part which is past the
15945 initial whitespace, #, whitespace, directive-name, whitespace part. */
15948 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
15949 const char *buffer ATTRIBUTE_UNUSED)
15951 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15953 switch_to_section (debug_macinfo_section);
15954 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
15955 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
15956 dw2_asm_output_nstring (buffer, -1, "The macro");
15960 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
15961 the tail part of the directive line, i.e. the part which is past the
15962 initial whitespace, #, whitespace, directive-name, whitespace part. */
15965 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
15966 const char *buffer ATTRIBUTE_UNUSED)
15968 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15970 switch_to_section (debug_macinfo_section);
15971 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
15972 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
15973 dw2_asm_output_nstring (buffer, -1, "The macro");
15977 /* Set up for Dwarf output at the start of compilation. */
15980 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
15982 /* Allocate the file_table. */
15983 file_table = htab_create_ggc (50, file_table_hash,
15984 file_table_eq, NULL);
15986 /* Allocate the decl_die_table. */
15987 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
15988 decl_die_table_eq, NULL);
15990 /* Allocate the decl_loc_table. */
15991 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
15992 decl_loc_table_eq, NULL);
15994 /* Allocate the initial hunk of the decl_scope_table. */
15995 decl_scope_table = VEC_alloc (tree, gc, 256);
15997 /* Allocate the initial hunk of the abbrev_die_table. */
15998 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
15999 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
16000 /* Zero-th entry is allocated, but unused. */
16001 abbrev_die_table_in_use = 1;
16003 /* Allocate the initial hunk of the line_info_table. */
16004 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
16005 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
16007 /* Zero-th entry is allocated, but unused. */
16008 line_info_table_in_use = 1;
16010 /* Allocate the pubtypes and pubnames vectors. */
16011 pubname_table = VEC_alloc (pubname_entry, gc, 32);
16012 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
16014 /* Generate the initial DIE for the .debug section. Note that the (string)
16015 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
16016 will (typically) be a relative pathname and that this pathname should be
16017 taken as being relative to the directory from which the compiler was
16018 invoked when the given (base) source file was compiled. We will fill
16019 in this value in dwarf2out_finish. */
16020 comp_unit_die = gen_compile_unit_die (NULL);
16022 incomplete_types = VEC_alloc (tree, gc, 64);
16024 used_rtx_array = VEC_alloc (rtx, gc, 32);
16026 debug_info_section = get_section (DEBUG_INFO_SECTION,
16027 SECTION_DEBUG, NULL);
16028 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
16029 SECTION_DEBUG, NULL);
16030 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
16031 SECTION_DEBUG, NULL);
16032 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
16033 SECTION_DEBUG, NULL);
16034 debug_line_section = get_section (DEBUG_LINE_SECTION,
16035 SECTION_DEBUG, NULL);
16036 debug_loc_section = get_section (DEBUG_LOC_SECTION,
16037 SECTION_DEBUG, NULL);
16038 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
16039 SECTION_DEBUG, NULL);
16040 #ifdef DEBUG_PUBTYPES_SECTION
16041 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
16042 SECTION_DEBUG, NULL);
16044 debug_str_section = get_section (DEBUG_STR_SECTION,
16045 DEBUG_STR_SECTION_FLAGS, NULL);
16046 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
16047 SECTION_DEBUG, NULL);
16048 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
16049 SECTION_DEBUG, NULL);
16051 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
16052 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
16053 DEBUG_ABBREV_SECTION_LABEL, 0);
16054 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
16055 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
16056 COLD_TEXT_SECTION_LABEL, 0);
16057 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
16059 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
16060 DEBUG_INFO_SECTION_LABEL, 0);
16061 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
16062 DEBUG_LINE_SECTION_LABEL, 0);
16063 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
16064 DEBUG_RANGES_SECTION_LABEL, 0);
16065 switch_to_section (debug_abbrev_section);
16066 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
16067 switch_to_section (debug_info_section);
16068 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
16069 switch_to_section (debug_line_section);
16070 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
16072 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16074 switch_to_section (debug_macinfo_section);
16075 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
16076 DEBUG_MACINFO_SECTION_LABEL, 0);
16077 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
16080 switch_to_section (text_section);
16081 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
16082 if (flag_reorder_blocks_and_partition)
16084 cold_text_section = unlikely_text_section ();
16085 switch_to_section (cold_text_section);
16086 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
16090 /* A helper function for dwarf2out_finish called through
16091 ht_forall. Emit one queued .debug_str string. */
16094 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
16096 struct indirect_string_node *node = (struct indirect_string_node *) *h;
16098 if (node->form == DW_FORM_strp)
16100 switch_to_section (debug_str_section);
16101 ASM_OUTPUT_LABEL (asm_out_file, node->label);
16102 assemble_string (node->str, strlen (node->str) + 1);
16108 #if ENABLE_ASSERT_CHECKING
16109 /* Verify that all marks are clear. */
16112 verify_marks_clear (dw_die_ref die)
16116 gcc_assert (! die->die_mark);
16117 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
16119 #endif /* ENABLE_ASSERT_CHECKING */
16121 /* Clear the marks for a die and its children.
16122 Be cool if the mark isn't set. */
16125 prune_unmark_dies (dw_die_ref die)
16131 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
16134 /* Given DIE that we're marking as used, find any other dies
16135 it references as attributes and mark them as used. */
16138 prune_unused_types_walk_attribs (dw_die_ref die)
16143 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16145 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
16147 /* A reference to another DIE.
16148 Make sure that it will get emitted. */
16149 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
16151 /* Set the string's refcount to 0 so that prune_unused_types_mark
16152 accounts properly for it. */
16153 if (AT_class (a) == dw_val_class_str)
16154 a->dw_attr_val.v.val_str->refcount = 0;
16159 /* Mark DIE as being used. If DOKIDS is true, then walk down
16160 to DIE's children. */
16163 prune_unused_types_mark (dw_die_ref die, int dokids)
16167 if (die->die_mark == 0)
16169 /* We haven't done this node yet. Mark it as used. */
16172 /* We also have to mark its parents as used.
16173 (But we don't want to mark our parents' kids due to this.) */
16174 if (die->die_parent)
16175 prune_unused_types_mark (die->die_parent, 0);
16177 /* Mark any referenced nodes. */
16178 prune_unused_types_walk_attribs (die);
16180 /* If this node is a specification,
16181 also mark the definition, if it exists. */
16182 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
16183 prune_unused_types_mark (die->die_definition, 1);
16186 if (dokids && die->die_mark != 2)
16188 /* We need to walk the children, but haven't done so yet.
16189 Remember that we've walked the kids. */
16192 /* If this is an array type, we need to make sure our
16193 kids get marked, even if they're types. */
16194 if (die->die_tag == DW_TAG_array_type)
16195 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
16197 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16201 /* For local classes, look if any static member functions were emitted
16202 and if so, mark them. */
16205 prune_unused_types_walk_local_classes (dw_die_ref die)
16209 if (die->die_mark == 2)
16212 switch (die->die_tag)
16214 case DW_TAG_structure_type:
16215 case DW_TAG_union_type:
16216 case DW_TAG_class_type:
16219 case DW_TAG_subprogram:
16220 if (!get_AT_flag (die, DW_AT_declaration)
16221 || die->die_definition != NULL)
16222 prune_unused_types_mark (die, 1);
16229 /* Mark children. */
16230 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
16233 /* Walk the tree DIE and mark types that we actually use. */
16236 prune_unused_types_walk (dw_die_ref die)
16240 /* Don't do anything if this node is already marked and
16241 children have been marked as well. */
16242 if (die->die_mark == 2)
16245 switch (die->die_tag)
16247 case DW_TAG_structure_type:
16248 case DW_TAG_union_type:
16249 case DW_TAG_class_type:
16250 if (die->die_perennial_p)
16253 for (c = die->die_parent; c; c = c->die_parent)
16254 if (c->die_tag == DW_TAG_subprogram)
16257 /* Finding used static member functions inside of classes
16258 is needed just for local classes, because for other classes
16259 static member function DIEs with DW_AT_specification
16260 are emitted outside of the DW_TAG_*_type. If we ever change
16261 it, we'd need to call this even for non-local classes. */
16263 prune_unused_types_walk_local_classes (die);
16265 /* It's a type node --- don't mark it. */
16268 case DW_TAG_const_type:
16269 case DW_TAG_packed_type:
16270 case DW_TAG_pointer_type:
16271 case DW_TAG_reference_type:
16272 case DW_TAG_volatile_type:
16273 case DW_TAG_typedef:
16274 case DW_TAG_array_type:
16275 case DW_TAG_interface_type:
16276 case DW_TAG_friend:
16277 case DW_TAG_variant_part:
16278 case DW_TAG_enumeration_type:
16279 case DW_TAG_subroutine_type:
16280 case DW_TAG_string_type:
16281 case DW_TAG_set_type:
16282 case DW_TAG_subrange_type:
16283 case DW_TAG_ptr_to_member_type:
16284 case DW_TAG_file_type:
16285 if (die->die_perennial_p)
16288 /* It's a type node --- don't mark it. */
16292 /* Mark everything else. */
16296 if (die->die_mark == 0)
16300 /* Now, mark any dies referenced from here. */
16301 prune_unused_types_walk_attribs (die);
16306 /* Mark children. */
16307 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16310 /* Increment the string counts on strings referred to from DIE's
16314 prune_unused_types_update_strings (dw_die_ref die)
16319 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16320 if (AT_class (a) == dw_val_class_str)
16322 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
16324 /* Avoid unnecessarily putting strings that are used less than
16325 twice in the hash table. */
16327 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
16330 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
16331 htab_hash_string (s->str),
16333 gcc_assert (*slot == NULL);
16339 /* Remove from the tree DIE any dies that aren't marked. */
16342 prune_unused_types_prune (dw_die_ref die)
16346 gcc_assert (die->die_mark);
16347 prune_unused_types_update_strings (die);
16349 if (! die->die_child)
16352 c = die->die_child;
16354 dw_die_ref prev = c;
16355 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
16356 if (c == die->die_child)
16358 /* No marked children between 'prev' and the end of the list. */
16360 /* No marked children at all. */
16361 die->die_child = NULL;
16364 prev->die_sib = c->die_sib;
16365 die->die_child = prev;
16370 if (c != prev->die_sib)
16372 prune_unused_types_prune (c);
16373 } while (c != die->die_child);
16377 /* Remove dies representing declarations that we never use. */
16380 prune_unused_types (void)
16383 limbo_die_node *node;
16386 #if ENABLE_ASSERT_CHECKING
16387 /* All the marks should already be clear. */
16388 verify_marks_clear (comp_unit_die);
16389 for (node = limbo_die_list; node; node = node->next)
16390 verify_marks_clear (node->die);
16391 #endif /* ENABLE_ASSERT_CHECKING */
16393 /* Set the mark on nodes that are actually used. */
16394 prune_unused_types_walk (comp_unit_die);
16395 for (node = limbo_die_list; node; node = node->next)
16396 prune_unused_types_walk (node->die);
16398 /* Also set the mark on nodes referenced from the
16399 pubname_table or arange_table. */
16400 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
16401 prune_unused_types_mark (pub->die, 1);
16402 for (i = 0; i < arange_table_in_use; i++)
16403 prune_unused_types_mark (arange_table[i], 1);
16405 /* Get rid of nodes that aren't marked; and update the string counts. */
16406 if (debug_str_hash)
16407 htab_empty (debug_str_hash);
16408 prune_unused_types_prune (comp_unit_die);
16409 for (node = limbo_die_list; node; node = node->next)
16410 prune_unused_types_prune (node->die);
16412 /* Leave the marks clear. */
16413 prune_unmark_dies (comp_unit_die);
16414 for (node = limbo_die_list; node; node = node->next)
16415 prune_unmark_dies (node->die);
16418 /* Set the parameter to true if there are any relative pathnames in
16421 file_table_relative_p (void ** slot, void *param)
16423 bool *p = (bool *) param;
16424 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
16425 if (!IS_ABSOLUTE_PATH (d->filename))
16433 /* Output stuff that dwarf requires at the end of every file,
16434 and generate the DWARF-2 debugging info. */
16437 dwarf2out_finish (const char *filename)
16439 limbo_die_node *node, *next_node;
16440 dw_die_ref die = 0;
16443 /* Add the name for the main input file now. We delayed this from
16444 dwarf2out_init to avoid complications with PCH. */
16445 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
16446 if (!IS_ABSOLUTE_PATH (filename))
16447 add_comp_dir_attribute (comp_unit_die);
16448 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
16451 htab_traverse (file_table, file_table_relative_p, &p);
16453 add_comp_dir_attribute (comp_unit_die);
16456 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
16458 add_location_or_const_value_attribute (
16459 VEC_index (deferred_locations, deferred_locations_list, i)->die,
16460 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
16464 /* Traverse the limbo die list, and add parent/child links. The only
16465 dies without parents that should be here are concrete instances of
16466 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
16467 For concrete instances, we can get the parent die from the abstract
16469 for (node = limbo_die_list; node; node = next_node)
16471 next_node = node->next;
16474 if (die->die_parent == NULL)
16476 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
16479 add_child_die (origin->die_parent, die);
16480 else if (die == comp_unit_die)
16482 else if (errorcount > 0 || sorrycount > 0)
16483 /* It's OK to be confused by errors in the input. */
16484 add_child_die (comp_unit_die, die);
16487 /* In certain situations, the lexical block containing a
16488 nested function can be optimized away, which results
16489 in the nested function die being orphaned. Likewise
16490 with the return type of that nested function. Force
16491 this to be a child of the containing function.
16493 It may happen that even the containing function got fully
16494 inlined and optimized out. In that case we are lost and
16495 assign the empty child. This should not be big issue as
16496 the function is likely unreachable too. */
16497 tree context = NULL_TREE;
16499 gcc_assert (node->created_for);
16501 if (DECL_P (node->created_for))
16502 context = DECL_CONTEXT (node->created_for);
16503 else if (TYPE_P (node->created_for))
16504 context = TYPE_CONTEXT (node->created_for);
16506 gcc_assert (context
16507 && (TREE_CODE (context) == FUNCTION_DECL
16508 || TREE_CODE (context) == NAMESPACE_DECL));
16510 origin = lookup_decl_die (context);
16512 add_child_die (origin, die);
16514 add_child_die (comp_unit_die, die);
16519 limbo_die_list = NULL;
16521 /* Walk through the list of incomplete types again, trying once more to
16522 emit full debugging info for them. */
16523 retry_incomplete_types ();
16525 if (flag_eliminate_unused_debug_types)
16526 prune_unused_types ();
16528 /* Generate separate CUs for each of the include files we've seen.
16529 They will go into limbo_die_list. */
16530 if (flag_eliminate_dwarf2_dups)
16531 break_out_includes (comp_unit_die);
16533 /* Traverse the DIE's and add add sibling attributes to those DIE's
16534 that have children. */
16535 add_sibling_attributes (comp_unit_die);
16536 for (node = limbo_die_list; node; node = node->next)
16537 add_sibling_attributes (node->die);
16539 /* Output a terminator label for the .text section. */
16540 switch_to_section (text_section);
16541 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
16542 if (flag_reorder_blocks_and_partition)
16544 switch_to_section (unlikely_text_section ());
16545 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
16548 /* We can only use the low/high_pc attributes if all of the code was
16550 if (!have_multiple_function_sections)
16552 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
16553 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
16558 unsigned fde_idx = 0;
16560 /* We need to give .debug_loc and .debug_ranges an appropriate
16561 "base address". Use zero so that these addresses become
16562 absolute. Historically, we've emitted the unexpected
16563 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
16564 Emit both to give time for other tools to adapt. */
16565 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
16566 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
16568 add_AT_range_list (comp_unit_die, DW_AT_ranges,
16569 add_ranges_by_labels (text_section_label,
16571 if (flag_reorder_blocks_and_partition)
16572 add_ranges_by_labels (cold_text_section_label,
16575 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
16577 dw_fde_ref fde = &fde_table[fde_idx];
16579 if (fde->dw_fde_switched_sections)
16581 add_ranges_by_labels (fde->dw_fde_hot_section_label,
16582 fde->dw_fde_hot_section_end_label);
16583 add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
16584 fde->dw_fde_unlikely_section_end_label);
16587 add_ranges_by_labels (fde->dw_fde_begin,
16594 /* Output location list section if necessary. */
16595 if (have_location_lists)
16597 /* Output the location lists info. */
16598 switch_to_section (debug_loc_section);
16599 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
16600 DEBUG_LOC_SECTION_LABEL, 0);
16601 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
16602 output_location_lists (die);
16605 if (debug_info_level >= DINFO_LEVEL_NORMAL)
16606 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
16607 debug_line_section_label);
16609 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16610 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
16612 /* Output all of the compilation units. We put the main one last so that
16613 the offsets are available to output_pubnames. */
16614 for (node = limbo_die_list; node; node = node->next)
16615 output_comp_unit (node->die, 0);
16617 /* Output the main compilation unit if non-empty or if .debug_macinfo
16618 has been emitted. */
16619 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
16621 /* Output the abbreviation table. */
16622 switch_to_section (debug_abbrev_section);
16623 output_abbrev_section ();
16625 /* Output public names table if necessary. */
16626 if (!VEC_empty (pubname_entry, pubname_table))
16628 switch_to_section (debug_pubnames_section);
16629 output_pubnames (pubname_table);
16632 #ifdef DEBUG_PUBTYPES_SECTION
16633 /* Output public types table if necessary. */
16634 if (!VEC_empty (pubname_entry, pubtype_table))
16636 switch_to_section (debug_pubtypes_section);
16637 output_pubnames (pubtype_table);
16641 /* Output the address range information. We only put functions in the arange
16642 table, so don't write it out if we don't have any. */
16643 if (fde_table_in_use)
16645 switch_to_section (debug_aranges_section);
16649 /* Output ranges section if necessary. */
16650 if (ranges_table_in_use)
16652 switch_to_section (debug_ranges_section);
16653 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
16657 /* Output the source line correspondence table. We must do this
16658 even if there is no line information. Otherwise, on an empty
16659 translation unit, we will generate a present, but empty,
16660 .debug_info section. IRIX 6.5 `nm' will then complain when
16661 examining the file. This is done late so that any filenames
16662 used by the debug_info section are marked as 'used'. */
16663 if (! DWARF2_ASM_LINE_DEBUG_INFO)
16665 switch_to_section (debug_line_section);
16666 output_line_info ();
16669 /* Have to end the macro section. */
16670 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16672 switch_to_section (debug_macinfo_section);
16673 dw2_asm_output_data (1, 0, "End compilation unit");
16676 /* If we emitted any DW_FORM_strp form attribute, output the string
16678 if (debug_str_hash)
16679 htab_traverse (debug_str_hash, output_indirect_string, NULL);
16683 /* This should never be used, but its address is needed for comparisons. */
16684 const struct gcc_debug_hooks dwarf2_debug_hooks;
16686 #endif /* DWARF2_DEBUGGING_INFO */
16688 #include "gt-dwarf2out.h"