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 = TREE_NOTHROW (current_function_decl);
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_frame_base:
5603 return "DW_AT_frame_base";
5605 return "DW_AT_friend";
5606 case DW_AT_identifier_case:
5607 return "DW_AT_identifier_case";
5608 case DW_AT_macro_info:
5609 return "DW_AT_macro_info";
5610 case DW_AT_namelist_items:
5611 return "DW_AT_namelist_items";
5612 case DW_AT_priority:
5613 return "DW_AT_priority";
5615 return "DW_AT_segment";
5616 case DW_AT_specification:
5617 return "DW_AT_specification";
5618 case DW_AT_static_link:
5619 return "DW_AT_static_link";
5621 return "DW_AT_type";
5622 case DW_AT_use_location:
5623 return "DW_AT_use_location";
5624 case DW_AT_variable_parameter:
5625 return "DW_AT_variable_parameter";
5626 case DW_AT_virtuality:
5627 return "DW_AT_virtuality";
5628 case DW_AT_vtable_elem_location:
5629 return "DW_AT_vtable_elem_location";
5631 case DW_AT_allocated:
5632 return "DW_AT_allocated";
5633 case DW_AT_associated:
5634 return "DW_AT_associated";
5635 case DW_AT_data_location:
5636 return "DW_AT_data_location";
5637 case DW_AT_byte_stride:
5638 return "DW_AT_byte_stride";
5639 case DW_AT_entry_pc:
5640 return "DW_AT_entry_pc";
5641 case DW_AT_use_UTF8:
5642 return "DW_AT_use_UTF8";
5643 case DW_AT_extension:
5644 return "DW_AT_extension";
5646 return "DW_AT_ranges";
5647 case DW_AT_trampoline:
5648 return "DW_AT_trampoline";
5649 case DW_AT_call_column:
5650 return "DW_AT_call_column";
5651 case DW_AT_call_file:
5652 return "DW_AT_call_file";
5653 case DW_AT_call_line:
5654 return "DW_AT_call_line";
5656 case DW_AT_MIPS_fde:
5657 return "DW_AT_MIPS_fde";
5658 case DW_AT_MIPS_loop_begin:
5659 return "DW_AT_MIPS_loop_begin";
5660 case DW_AT_MIPS_tail_loop_begin:
5661 return "DW_AT_MIPS_tail_loop_begin";
5662 case DW_AT_MIPS_epilog_begin:
5663 return "DW_AT_MIPS_epilog_begin";
5664 case DW_AT_MIPS_loop_unroll_factor:
5665 return "DW_AT_MIPS_loop_unroll_factor";
5666 case DW_AT_MIPS_software_pipeline_depth:
5667 return "DW_AT_MIPS_software_pipeline_depth";
5668 case DW_AT_MIPS_linkage_name:
5669 return "DW_AT_MIPS_linkage_name";
5670 case DW_AT_MIPS_stride:
5671 return "DW_AT_MIPS_stride";
5672 case DW_AT_MIPS_abstract_name:
5673 return "DW_AT_MIPS_abstract_name";
5674 case DW_AT_MIPS_clone_origin:
5675 return "DW_AT_MIPS_clone_origin";
5676 case DW_AT_MIPS_has_inlines:
5677 return "DW_AT_MIPS_has_inlines";
5679 case DW_AT_sf_names:
5680 return "DW_AT_sf_names";
5681 case DW_AT_src_info:
5682 return "DW_AT_src_info";
5683 case DW_AT_mac_info:
5684 return "DW_AT_mac_info";
5685 case DW_AT_src_coords:
5686 return "DW_AT_src_coords";
5687 case DW_AT_body_begin:
5688 return "DW_AT_body_begin";
5689 case DW_AT_body_end:
5690 return "DW_AT_body_end";
5691 case DW_AT_GNU_vector:
5692 return "DW_AT_GNU_vector";
5694 case DW_AT_VMS_rtnbeg_pd_address:
5695 return "DW_AT_VMS_rtnbeg_pd_address";
5698 return "DW_AT_<unknown>";
5702 /* Convert a DWARF value form code into its string name. */
5705 dwarf_form_name (unsigned int form)
5710 return "DW_FORM_addr";
5711 case DW_FORM_block2:
5712 return "DW_FORM_block2";
5713 case DW_FORM_block4:
5714 return "DW_FORM_block4";
5716 return "DW_FORM_data2";
5718 return "DW_FORM_data4";
5720 return "DW_FORM_data8";
5721 case DW_FORM_string:
5722 return "DW_FORM_string";
5724 return "DW_FORM_block";
5725 case DW_FORM_block1:
5726 return "DW_FORM_block1";
5728 return "DW_FORM_data1";
5730 return "DW_FORM_flag";
5732 return "DW_FORM_sdata";
5734 return "DW_FORM_strp";
5736 return "DW_FORM_udata";
5737 case DW_FORM_ref_addr:
5738 return "DW_FORM_ref_addr";
5740 return "DW_FORM_ref1";
5742 return "DW_FORM_ref2";
5744 return "DW_FORM_ref4";
5746 return "DW_FORM_ref8";
5747 case DW_FORM_ref_udata:
5748 return "DW_FORM_ref_udata";
5749 case DW_FORM_indirect:
5750 return "DW_FORM_indirect";
5752 return "DW_FORM_<unknown>";
5756 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
5757 instance of an inlined instance of a decl which is local to an inline
5758 function, so we have to trace all of the way back through the origin chain
5759 to find out what sort of node actually served as the original seed for the
5763 decl_ultimate_origin (const_tree decl)
5765 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
5768 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
5769 nodes in the function to point to themselves; ignore that if
5770 we're trying to output the abstract instance of this function. */
5771 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
5774 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
5775 most distant ancestor, this should never happen. */
5776 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
5778 return DECL_ABSTRACT_ORIGIN (decl);
5781 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
5782 of a virtual function may refer to a base class, so we check the 'this'
5786 decl_class_context (tree decl)
5788 tree context = NULL_TREE;
5790 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
5791 context = DECL_CONTEXT (decl);
5793 context = TYPE_MAIN_VARIANT
5794 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
5796 if (context && !TYPE_P (context))
5797 context = NULL_TREE;
5802 /* Add an attribute/value pair to a DIE. */
5805 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
5807 /* Maybe this should be an assert? */
5811 if (die->die_attr == NULL)
5812 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
5813 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
5816 static inline enum dw_val_class
5817 AT_class (dw_attr_ref a)
5819 return a->dw_attr_val.val_class;
5822 /* Add a flag value attribute to a DIE. */
5825 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
5829 attr.dw_attr = attr_kind;
5830 attr.dw_attr_val.val_class = dw_val_class_flag;
5831 attr.dw_attr_val.v.val_flag = flag;
5832 add_dwarf_attr (die, &attr);
5835 static inline unsigned
5836 AT_flag (dw_attr_ref a)
5838 gcc_assert (a && AT_class (a) == dw_val_class_flag);
5839 return a->dw_attr_val.v.val_flag;
5842 /* Add a signed integer attribute value to a DIE. */
5845 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
5849 attr.dw_attr = attr_kind;
5850 attr.dw_attr_val.val_class = dw_val_class_const;
5851 attr.dw_attr_val.v.val_int = int_val;
5852 add_dwarf_attr (die, &attr);
5855 static inline HOST_WIDE_INT
5856 AT_int (dw_attr_ref a)
5858 gcc_assert (a && AT_class (a) == dw_val_class_const);
5859 return a->dw_attr_val.v.val_int;
5862 /* Add an unsigned integer attribute value to a DIE. */
5865 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
5866 unsigned HOST_WIDE_INT unsigned_val)
5870 attr.dw_attr = attr_kind;
5871 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
5872 attr.dw_attr_val.v.val_unsigned = unsigned_val;
5873 add_dwarf_attr (die, &attr);
5876 static inline unsigned HOST_WIDE_INT
5877 AT_unsigned (dw_attr_ref a)
5879 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
5880 return a->dw_attr_val.v.val_unsigned;
5883 /* Add an unsigned double integer attribute value to a DIE. */
5886 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
5887 long unsigned int val_hi, long unsigned int val_low)
5891 attr.dw_attr = attr_kind;
5892 attr.dw_attr_val.val_class = dw_val_class_long_long;
5893 attr.dw_attr_val.v.val_long_long.hi = val_hi;
5894 attr.dw_attr_val.v.val_long_long.low = val_low;
5895 add_dwarf_attr (die, &attr);
5898 /* Add a floating point attribute value to a DIE and return it. */
5901 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
5902 unsigned int length, unsigned int elt_size, unsigned char *array)
5906 attr.dw_attr = attr_kind;
5907 attr.dw_attr_val.val_class = dw_val_class_vec;
5908 attr.dw_attr_val.v.val_vec.length = length;
5909 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
5910 attr.dw_attr_val.v.val_vec.array = array;
5911 add_dwarf_attr (die, &attr);
5914 /* Hash and equality functions for debug_str_hash. */
5917 debug_str_do_hash (const void *x)
5919 return htab_hash_string (((const struct indirect_string_node *)x)->str);
5923 debug_str_eq (const void *x1, const void *x2)
5925 return strcmp ((((const struct indirect_string_node *)x1)->str),
5926 (const char *)x2) == 0;
5929 /* Add a string attribute value to a DIE. */
5932 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5935 struct indirect_string_node *node;
5938 if (! debug_str_hash)
5939 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5940 debug_str_eq, NULL);
5942 slot = htab_find_slot_with_hash (debug_str_hash, str,
5943 htab_hash_string (str), INSERT);
5946 node = (struct indirect_string_node *)
5947 ggc_alloc_cleared (sizeof (struct indirect_string_node));
5948 node->str = ggc_strdup (str);
5952 node = (struct indirect_string_node *) *slot;
5956 attr.dw_attr = attr_kind;
5957 attr.dw_attr_val.val_class = dw_val_class_str;
5958 attr.dw_attr_val.v.val_str = node;
5959 add_dwarf_attr (die, &attr);
5962 static inline const char *
5963 AT_string (dw_attr_ref a)
5965 gcc_assert (a && AT_class (a) == dw_val_class_str);
5966 return a->dw_attr_val.v.val_str->str;
5969 /* Find out whether a string should be output inline in DIE
5970 or out-of-line in .debug_str section. */
5973 AT_string_form (dw_attr_ref a)
5975 struct indirect_string_node *node;
5979 gcc_assert (a && AT_class (a) == dw_val_class_str);
5981 node = a->dw_attr_val.v.val_str;
5985 len = strlen (node->str) + 1;
5987 /* If the string is shorter or equal to the size of the reference, it is
5988 always better to put it inline. */
5989 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5990 return node->form = DW_FORM_string;
5992 /* If we cannot expect the linker to merge strings in .debug_str
5993 section, only put it into .debug_str if it is worth even in this
5995 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
5996 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5997 return node->form = DW_FORM_string;
5999 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
6000 ++dw2_string_counter;
6001 node->label = xstrdup (label);
6003 return node->form = DW_FORM_strp;
6006 /* Add a DIE reference attribute value to a DIE. */
6009 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
6013 attr.dw_attr = attr_kind;
6014 attr.dw_attr_val.val_class = dw_val_class_die_ref;
6015 attr.dw_attr_val.v.val_die_ref.die = targ_die;
6016 attr.dw_attr_val.v.val_die_ref.external = 0;
6017 add_dwarf_attr (die, &attr);
6020 /* Add an AT_specification attribute to a DIE, and also make the back
6021 pointer from the specification to the definition. */
6024 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
6026 add_AT_die_ref (die, DW_AT_specification, targ_die);
6027 gcc_assert (!targ_die->die_definition);
6028 targ_die->die_definition = die;
6031 static inline dw_die_ref
6032 AT_ref (dw_attr_ref a)
6034 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6035 return a->dw_attr_val.v.val_die_ref.die;
6039 AT_ref_external (dw_attr_ref a)
6041 if (a && AT_class (a) == dw_val_class_die_ref)
6042 return a->dw_attr_val.v.val_die_ref.external;
6048 set_AT_ref_external (dw_attr_ref a, int i)
6050 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6051 a->dw_attr_val.v.val_die_ref.external = i;
6054 /* Add an FDE reference attribute value to a DIE. */
6057 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
6061 attr.dw_attr = attr_kind;
6062 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
6063 attr.dw_attr_val.v.val_fde_index = targ_fde;
6064 add_dwarf_attr (die, &attr);
6067 /* Add a location description attribute value to a DIE. */
6070 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
6074 attr.dw_attr = attr_kind;
6075 attr.dw_attr_val.val_class = dw_val_class_loc;
6076 attr.dw_attr_val.v.val_loc = loc;
6077 add_dwarf_attr (die, &attr);
6080 static inline dw_loc_descr_ref
6081 AT_loc (dw_attr_ref a)
6083 gcc_assert (a && AT_class (a) == dw_val_class_loc);
6084 return a->dw_attr_val.v.val_loc;
6088 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
6092 attr.dw_attr = attr_kind;
6093 attr.dw_attr_val.val_class = dw_val_class_loc_list;
6094 attr.dw_attr_val.v.val_loc_list = loc_list;
6095 add_dwarf_attr (die, &attr);
6096 have_location_lists = true;
6099 static inline dw_loc_list_ref
6100 AT_loc_list (dw_attr_ref a)
6102 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
6103 return a->dw_attr_val.v.val_loc_list;
6106 /* Add an address constant attribute value to a DIE. */
6109 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
6113 attr.dw_attr = attr_kind;
6114 attr.dw_attr_val.val_class = dw_val_class_addr;
6115 attr.dw_attr_val.v.val_addr = addr;
6116 add_dwarf_attr (die, &attr);
6119 /* Get the RTX from to an address DIE attribute. */
6122 AT_addr (dw_attr_ref a)
6124 gcc_assert (a && AT_class (a) == dw_val_class_addr);
6125 return a->dw_attr_val.v.val_addr;
6128 /* Add a file attribute value to a DIE. */
6131 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
6132 struct dwarf_file_data *fd)
6136 attr.dw_attr = attr_kind;
6137 attr.dw_attr_val.val_class = dw_val_class_file;
6138 attr.dw_attr_val.v.val_file = fd;
6139 add_dwarf_attr (die, &attr);
6142 /* Get the dwarf_file_data from a file DIE attribute. */
6144 static inline struct dwarf_file_data *
6145 AT_file (dw_attr_ref a)
6147 gcc_assert (a && AT_class (a) == dw_val_class_file);
6148 return a->dw_attr_val.v.val_file;
6151 /* Add a label identifier attribute value to a DIE. */
6154 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
6158 attr.dw_attr = attr_kind;
6159 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
6160 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
6161 add_dwarf_attr (die, &attr);
6164 /* Add a section offset attribute value to a DIE, an offset into the
6165 debug_line section. */
6168 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6173 attr.dw_attr = attr_kind;
6174 attr.dw_attr_val.val_class = dw_val_class_lineptr;
6175 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6176 add_dwarf_attr (die, &attr);
6179 /* Add a section offset attribute value to a DIE, an offset into the
6180 debug_macinfo section. */
6183 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6188 attr.dw_attr = attr_kind;
6189 attr.dw_attr_val.val_class = dw_val_class_macptr;
6190 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6191 add_dwarf_attr (die, &attr);
6194 /* Add an offset attribute value to a DIE. */
6197 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
6198 unsigned HOST_WIDE_INT offset)
6202 attr.dw_attr = attr_kind;
6203 attr.dw_attr_val.val_class = dw_val_class_offset;
6204 attr.dw_attr_val.v.val_offset = offset;
6205 add_dwarf_attr (die, &attr);
6208 /* Add an range_list attribute value to a DIE. */
6211 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
6212 long unsigned int offset)
6216 attr.dw_attr = attr_kind;
6217 attr.dw_attr_val.val_class = dw_val_class_range_list;
6218 attr.dw_attr_val.v.val_offset = offset;
6219 add_dwarf_attr (die, &attr);
6222 static inline const char *
6223 AT_lbl (dw_attr_ref a)
6225 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
6226 || AT_class (a) == dw_val_class_lineptr
6227 || AT_class (a) == dw_val_class_macptr));
6228 return a->dw_attr_val.v.val_lbl_id;
6231 /* Get the attribute of type attr_kind. */
6234 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6238 dw_die_ref spec = NULL;
6243 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6244 if (a->dw_attr == attr_kind)
6246 else if (a->dw_attr == DW_AT_specification
6247 || a->dw_attr == DW_AT_abstract_origin)
6251 return get_AT (spec, attr_kind);
6256 /* Return the "low pc" attribute value, typically associated with a subprogram
6257 DIE. Return null if the "low pc" attribute is either not present, or if it
6258 cannot be represented as an assembler label identifier. */
6260 static inline const char *
6261 get_AT_low_pc (dw_die_ref die)
6263 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
6265 return a ? AT_lbl (a) : NULL;
6268 /* Return the "high pc" attribute value, typically associated with a subprogram
6269 DIE. Return null if the "high pc" attribute is either not present, or if it
6270 cannot be represented as an assembler label identifier. */
6272 static inline const char *
6273 get_AT_hi_pc (dw_die_ref die)
6275 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
6277 return a ? AT_lbl (a) : NULL;
6280 /* Return the value of the string attribute designated by ATTR_KIND, or
6281 NULL if it is not present. */
6283 static inline const char *
6284 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
6286 dw_attr_ref a = get_AT (die, attr_kind);
6288 return a ? AT_string (a) : NULL;
6291 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
6292 if it is not present. */
6295 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
6297 dw_attr_ref a = get_AT (die, attr_kind);
6299 return a ? AT_flag (a) : 0;
6302 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
6303 if it is not present. */
6305 static inline unsigned
6306 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
6308 dw_attr_ref a = get_AT (die, attr_kind);
6310 return a ? AT_unsigned (a) : 0;
6313 static inline dw_die_ref
6314 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
6316 dw_attr_ref a = get_AT (die, attr_kind);
6318 return a ? AT_ref (a) : NULL;
6321 static inline struct dwarf_file_data *
6322 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
6324 dw_attr_ref a = get_AT (die, attr_kind);
6326 return a ? AT_file (a) : NULL;
6329 /* Return TRUE if the language is C or C++. */
6334 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6336 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
6337 || lang == DW_LANG_C99
6338 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
6341 /* Return TRUE if the language is C++. */
6346 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6348 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
6351 /* Return TRUE if the language is Fortran. */
6356 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6358 return (lang == DW_LANG_Fortran77
6359 || lang == DW_LANG_Fortran90
6360 || lang == DW_LANG_Fortran95);
6363 /* Return TRUE if the language is Java. */
6368 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6370 return lang == DW_LANG_Java;
6373 /* Return TRUE if the language is Ada. */
6378 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6380 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
6383 /* Remove the specified attribute if present. */
6386 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6394 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6395 if (a->dw_attr == attr_kind)
6397 if (AT_class (a) == dw_val_class_str)
6398 if (a->dw_attr_val.v.val_str->refcount)
6399 a->dw_attr_val.v.val_str->refcount--;
6401 /* VEC_ordered_remove should help reduce the number of abbrevs
6403 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
6408 /* Remove CHILD from its parent. PREV must have the property that
6409 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
6412 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
6414 gcc_assert (child->die_parent == prev->die_parent);
6415 gcc_assert (prev->die_sib == child);
6418 gcc_assert (child->die_parent->die_child == child);
6422 prev->die_sib = child->die_sib;
6423 if (child->die_parent->die_child == child)
6424 child->die_parent->die_child = prev;
6427 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
6431 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
6437 dw_die_ref prev = c;
6439 while (c->die_tag == tag)
6441 remove_child_with_prev (c, prev);
6442 /* Might have removed every child. */
6443 if (c == c->die_sib)
6447 } while (c != die->die_child);
6450 /* Add a CHILD_DIE as the last child of DIE. */
6453 add_child_die (dw_die_ref die, dw_die_ref child_die)
6455 /* FIXME this should probably be an assert. */
6456 if (! die || ! child_die)
6458 gcc_assert (die != child_die);
6460 child_die->die_parent = die;
6463 child_die->die_sib = die->die_child->die_sib;
6464 die->die_child->die_sib = child_die;
6467 child_die->die_sib = child_die;
6468 die->die_child = child_die;
6471 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
6472 is the specification, to the end of PARENT's list of children.
6473 This is done by removing and re-adding it. */
6476 splice_child_die (dw_die_ref parent, dw_die_ref child)
6480 /* We want the declaration DIE from inside the class, not the
6481 specification DIE at toplevel. */
6482 if (child->die_parent != parent)
6484 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
6490 gcc_assert (child->die_parent == parent
6491 || (child->die_parent
6492 == get_AT_ref (parent, DW_AT_specification)));
6494 for (p = child->die_parent->die_child; ; p = p->die_sib)
6495 if (p->die_sib == child)
6497 remove_child_with_prev (child, p);
6501 add_child_die (parent, child);
6504 /* Return a pointer to a newly created DIE node. */
6506 static inline dw_die_ref
6507 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
6509 dw_die_ref die = GGC_CNEW (die_node);
6511 die->die_tag = tag_value;
6513 if (parent_die != NULL)
6514 add_child_die (parent_die, die);
6517 limbo_die_node *limbo_node;
6519 limbo_node = GGC_CNEW (limbo_die_node);
6520 limbo_node->die = die;
6521 limbo_node->created_for = t;
6522 limbo_node->next = limbo_die_list;
6523 limbo_die_list = limbo_node;
6529 /* Return the DIE associated with the given type specifier. */
6531 static inline dw_die_ref
6532 lookup_type_die (tree type)
6534 return TYPE_SYMTAB_DIE (type);
6537 /* Equate a DIE to a given type specifier. */
6540 equate_type_number_to_die (tree type, dw_die_ref type_die)
6542 TYPE_SYMTAB_DIE (type) = type_die;
6545 /* Returns a hash value for X (which really is a die_struct). */
6548 decl_die_table_hash (const void *x)
6550 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
6553 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
6556 decl_die_table_eq (const void *x, const void *y)
6558 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
6561 /* Return the DIE associated with a given declaration. */
6563 static inline dw_die_ref
6564 lookup_decl_die (tree decl)
6566 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
6569 /* Returns a hash value for X (which really is a var_loc_list). */
6572 decl_loc_table_hash (const void *x)
6574 return (hashval_t) ((const var_loc_list *) x)->decl_id;
6577 /* Return nonzero if decl_id of var_loc_list X is the same as
6581 decl_loc_table_eq (const void *x, const void *y)
6583 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
6586 /* Return the var_loc list associated with a given declaration. */
6588 static inline var_loc_list *
6589 lookup_decl_loc (const_tree decl)
6591 return (var_loc_list *)
6592 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
6595 /* Equate a DIE to a particular declaration. */
6598 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
6600 unsigned int decl_id = DECL_UID (decl);
6603 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
6605 decl_die->decl_id = decl_id;
6608 /* Add a variable location node to the linked list for DECL. */
6611 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
6613 unsigned int decl_id = DECL_UID (decl);
6617 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
6620 temp = GGC_CNEW (var_loc_list);
6621 temp->decl_id = decl_id;
6625 temp = (var_loc_list *) *slot;
6629 /* If the current location is the same as the end of the list,
6630 and either both or neither of the locations is uninitialized,
6631 we have nothing to do. */
6632 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
6633 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
6634 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6635 != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
6636 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6637 == VAR_INIT_STATUS_UNINITIALIZED)
6638 || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
6639 == VAR_INIT_STATUS_UNINITIALIZED))))
6641 /* Add LOC to the end of list and update LAST. */
6642 temp->last->next = loc;
6646 /* Do not add empty location to the beginning of the list. */
6647 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
6654 /* Keep track of the number of spaces used to indent the
6655 output of the debugging routines that print the structure of
6656 the DIE internal representation. */
6657 static int print_indent;
6659 /* Indent the line the number of spaces given by print_indent. */
6662 print_spaces (FILE *outfile)
6664 fprintf (outfile, "%*s", print_indent, "");
6667 /* Print the information associated with a given DIE, and its children.
6668 This routine is a debugging aid only. */
6671 print_die (dw_die_ref die, FILE *outfile)
6677 print_spaces (outfile);
6678 fprintf (outfile, "DIE %4ld: %s\n",
6679 die->die_offset, dwarf_tag_name (die->die_tag));
6680 print_spaces (outfile);
6681 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
6682 fprintf (outfile, " offset: %ld\n", die->die_offset);
6684 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6686 print_spaces (outfile);
6687 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
6689 switch (AT_class (a))
6691 case dw_val_class_addr:
6692 fprintf (outfile, "address");
6694 case dw_val_class_offset:
6695 fprintf (outfile, "offset");
6697 case dw_val_class_loc:
6698 fprintf (outfile, "location descriptor");
6700 case dw_val_class_loc_list:
6701 fprintf (outfile, "location list -> label:%s",
6702 AT_loc_list (a)->ll_symbol);
6704 case dw_val_class_range_list:
6705 fprintf (outfile, "range list");
6707 case dw_val_class_const:
6708 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
6710 case dw_val_class_unsigned_const:
6711 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
6713 case dw_val_class_long_long:
6714 fprintf (outfile, "constant (%lu,%lu)",
6715 a->dw_attr_val.v.val_long_long.hi,
6716 a->dw_attr_val.v.val_long_long.low);
6718 case dw_val_class_vec:
6719 fprintf (outfile, "floating-point or vector constant");
6721 case dw_val_class_flag:
6722 fprintf (outfile, "%u", AT_flag (a));
6724 case dw_val_class_die_ref:
6725 if (AT_ref (a) != NULL)
6727 if (AT_ref (a)->die_symbol)
6728 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
6730 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
6733 fprintf (outfile, "die -> <null>");
6735 case dw_val_class_lbl_id:
6736 case dw_val_class_lineptr:
6737 case dw_val_class_macptr:
6738 fprintf (outfile, "label: %s", AT_lbl (a));
6740 case dw_val_class_str:
6741 if (AT_string (a) != NULL)
6742 fprintf (outfile, "\"%s\"", AT_string (a));
6744 fprintf (outfile, "<null>");
6746 case dw_val_class_file:
6747 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
6748 AT_file (a)->emitted_number);
6754 fprintf (outfile, "\n");
6757 if (die->die_child != NULL)
6760 FOR_EACH_CHILD (die, c, print_die (c, outfile));
6763 if (print_indent == 0)
6764 fprintf (outfile, "\n");
6767 /* Print the contents of the source code line number correspondence table.
6768 This routine is a debugging aid only. */
6771 print_dwarf_line_table (FILE *outfile)
6774 dw_line_info_ref line_info;
6776 fprintf (outfile, "\n\nDWARF source line information\n");
6777 for (i = 1; i < line_info_table_in_use; i++)
6779 line_info = &line_info_table[i];
6780 fprintf (outfile, "%5d: %4ld %6ld\n", i,
6781 line_info->dw_file_num,
6782 line_info->dw_line_num);
6785 fprintf (outfile, "\n\n");
6788 /* Print the information collected for a given DIE. */
6791 debug_dwarf_die (dw_die_ref die)
6793 print_die (die, stderr);
6796 /* Print all DWARF information collected for the compilation unit.
6797 This routine is a debugging aid only. */
6803 print_die (comp_unit_die, stderr);
6804 if (! DWARF2_ASM_LINE_DEBUG_INFO)
6805 print_dwarf_line_table (stderr);
6808 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
6809 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
6810 DIE that marks the start of the DIEs for this include file. */
6813 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
6815 const char *filename = get_AT_string (bincl_die, DW_AT_name);
6816 dw_die_ref new_unit = gen_compile_unit_die (filename);
6818 new_unit->die_sib = old_unit;
6822 /* Close an include-file CU and reopen the enclosing one. */
6825 pop_compile_unit (dw_die_ref old_unit)
6827 dw_die_ref new_unit = old_unit->die_sib;
6829 old_unit->die_sib = NULL;
6833 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6834 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6836 /* Calculate the checksum of a location expression. */
6839 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
6841 CHECKSUM (loc->dw_loc_opc);
6842 CHECKSUM (loc->dw_loc_oprnd1);
6843 CHECKSUM (loc->dw_loc_oprnd2);
6846 /* Calculate the checksum of an attribute. */
6849 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
6851 dw_loc_descr_ref loc;
6854 CHECKSUM (at->dw_attr);
6856 /* We don't care that this was compiled with a different compiler
6857 snapshot; if the output is the same, that's what matters. */
6858 if (at->dw_attr == DW_AT_producer)
6861 switch (AT_class (at))
6863 case dw_val_class_const:
6864 CHECKSUM (at->dw_attr_val.v.val_int);
6866 case dw_val_class_unsigned_const:
6867 CHECKSUM (at->dw_attr_val.v.val_unsigned);
6869 case dw_val_class_long_long:
6870 CHECKSUM (at->dw_attr_val.v.val_long_long);
6872 case dw_val_class_vec:
6873 CHECKSUM (at->dw_attr_val.v.val_vec);
6875 case dw_val_class_flag:
6876 CHECKSUM (at->dw_attr_val.v.val_flag);
6878 case dw_val_class_str:
6879 CHECKSUM_STRING (AT_string (at));
6882 case dw_val_class_addr:
6884 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6885 CHECKSUM_STRING (XSTR (r, 0));
6888 case dw_val_class_offset:
6889 CHECKSUM (at->dw_attr_val.v.val_offset);
6892 case dw_val_class_loc:
6893 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6894 loc_checksum (loc, ctx);
6897 case dw_val_class_die_ref:
6898 die_checksum (AT_ref (at), ctx, mark);
6901 case dw_val_class_fde_ref:
6902 case dw_val_class_lbl_id:
6903 case dw_val_class_lineptr:
6904 case dw_val_class_macptr:
6907 case dw_val_class_file:
6908 CHECKSUM_STRING (AT_file (at)->filename);
6916 /* Calculate the checksum of a DIE. */
6919 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6925 /* To avoid infinite recursion. */
6928 CHECKSUM (die->die_mark);
6931 die->die_mark = ++(*mark);
6933 CHECKSUM (die->die_tag);
6935 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6936 attr_checksum (a, ctx, mark);
6938 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6942 #undef CHECKSUM_STRING
6944 /* Do the location expressions look same? */
6946 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6948 return loc1->dw_loc_opc == loc2->dw_loc_opc
6949 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6950 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6953 /* Do the values look the same? */
6955 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6957 dw_loc_descr_ref loc1, loc2;
6960 if (v1->val_class != v2->val_class)
6963 switch (v1->val_class)
6965 case dw_val_class_const:
6966 return v1->v.val_int == v2->v.val_int;
6967 case dw_val_class_unsigned_const:
6968 return v1->v.val_unsigned == v2->v.val_unsigned;
6969 case dw_val_class_long_long:
6970 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6971 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6972 case dw_val_class_vec:
6973 if (v1->v.val_vec.length != v2->v.val_vec.length
6974 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6976 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6977 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6980 case dw_val_class_flag:
6981 return v1->v.val_flag == v2->v.val_flag;
6982 case dw_val_class_str:
6983 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6985 case dw_val_class_addr:
6986 r1 = v1->v.val_addr;
6987 r2 = v2->v.val_addr;
6988 if (GET_CODE (r1) != GET_CODE (r2))
6990 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6991 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6993 case dw_val_class_offset:
6994 return v1->v.val_offset == v2->v.val_offset;
6996 case dw_val_class_loc:
6997 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6999 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7000 if (!same_loc_p (loc1, loc2, mark))
7002 return !loc1 && !loc2;
7004 case dw_val_class_die_ref:
7005 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7007 case dw_val_class_fde_ref:
7008 case dw_val_class_lbl_id:
7009 case dw_val_class_lineptr:
7010 case dw_val_class_macptr:
7013 case dw_val_class_file:
7014 return v1->v.val_file == v2->v.val_file;
7021 /* Do the attributes look the same? */
7024 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
7026 if (at1->dw_attr != at2->dw_attr)
7029 /* We don't care that this was compiled with a different compiler
7030 snapshot; if the output is the same, that's what matters. */
7031 if (at1->dw_attr == DW_AT_producer)
7034 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7037 /* Do the dies look the same? */
7040 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7046 /* To avoid infinite recursion. */
7048 return die1->die_mark == die2->die_mark;
7049 die1->die_mark = die2->die_mark = ++(*mark);
7051 if (die1->die_tag != die2->die_tag)
7054 if (VEC_length (dw_attr_node, die1->die_attr)
7055 != VEC_length (dw_attr_node, die2->die_attr))
7058 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
7059 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
7062 c1 = die1->die_child;
7063 c2 = die2->die_child;
7072 if (!same_die_p (c1, c2, mark))
7076 if (c1 == die1->die_child)
7078 if (c2 == die2->die_child)
7088 /* Do the dies look the same? Wrapper around same_die_p. */
7091 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
7094 int ret = same_die_p (die1, die2, &mark);
7096 unmark_all_dies (die1);
7097 unmark_all_dies (die2);
7102 /* The prefix to attach to symbols on DIEs in the current comdat debug
7104 static char *comdat_symbol_id;
7106 /* The index of the current symbol within the current comdat CU. */
7107 static unsigned int comdat_symbol_number;
7109 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7110 children, and set comdat_symbol_id accordingly. */
7113 compute_section_prefix (dw_die_ref unit_die)
7115 const char *die_name = get_AT_string (unit_die, DW_AT_name);
7116 const char *base = die_name ? lbasename (die_name) : "anonymous";
7117 char *name = XALLOCAVEC (char, strlen (base) + 64);
7120 unsigned char checksum[16];
7123 /* Compute the checksum of the DIE, then append part of it as hex digits to
7124 the name filename of the unit. */
7126 md5_init_ctx (&ctx);
7128 die_checksum (unit_die, &ctx, &mark);
7129 unmark_all_dies (unit_die);
7130 md5_finish_ctx (&ctx, checksum);
7132 sprintf (name, "%s.", base);
7133 clean_symbol_name (name);
7135 p = name + strlen (name);
7136 for (i = 0; i < 4; i++)
7138 sprintf (p, "%.2x", checksum[i]);
7142 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
7143 comdat_symbol_number = 0;
7146 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7149 is_type_die (dw_die_ref die)
7151 switch (die->die_tag)
7153 case DW_TAG_array_type:
7154 case DW_TAG_class_type:
7155 case DW_TAG_interface_type:
7156 case DW_TAG_enumeration_type:
7157 case DW_TAG_pointer_type:
7158 case DW_TAG_reference_type:
7159 case DW_TAG_string_type:
7160 case DW_TAG_structure_type:
7161 case DW_TAG_subroutine_type:
7162 case DW_TAG_union_type:
7163 case DW_TAG_ptr_to_member_type:
7164 case DW_TAG_set_type:
7165 case DW_TAG_subrange_type:
7166 case DW_TAG_base_type:
7167 case DW_TAG_const_type:
7168 case DW_TAG_file_type:
7169 case DW_TAG_packed_type:
7170 case DW_TAG_volatile_type:
7171 case DW_TAG_typedef:
7178 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7179 Basically, we want to choose the bits that are likely to be shared between
7180 compilations (types) and leave out the bits that are specific to individual
7181 compilations (functions). */
7184 is_comdat_die (dw_die_ref c)
7186 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7187 we do for stabs. The advantage is a greater likelihood of sharing between
7188 objects that don't include headers in the same order (and therefore would
7189 put the base types in a different comdat). jason 8/28/00 */
7191 if (c->die_tag == DW_TAG_base_type)
7194 if (c->die_tag == DW_TAG_pointer_type
7195 || c->die_tag == DW_TAG_reference_type
7196 || c->die_tag == DW_TAG_const_type
7197 || c->die_tag == DW_TAG_volatile_type)
7199 dw_die_ref t = get_AT_ref (c, DW_AT_type);
7201 return t ? is_comdat_die (t) : 0;
7204 return is_type_die (c);
7207 /* Returns 1 iff C is the sort of DIE that might be referred to from another
7208 compilation unit. */
7211 is_symbol_die (dw_die_ref c)
7213 return (is_type_die (c)
7214 || (get_AT (c, DW_AT_declaration)
7215 && !get_AT (c, DW_AT_specification))
7216 || c->die_tag == DW_TAG_namespace
7217 || c->die_tag == DW_TAG_module);
7221 gen_internal_sym (const char *prefix)
7225 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
7226 return xstrdup (buf);
7229 /* Assign symbols to all worthy DIEs under DIE. */
7232 assign_symbol_names (dw_die_ref die)
7236 if (is_symbol_die (die))
7238 if (comdat_symbol_id)
7240 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
7242 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
7243 comdat_symbol_id, comdat_symbol_number++);
7244 die->die_symbol = xstrdup (p);
7247 die->die_symbol = gen_internal_sym ("LDIE");
7250 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
7253 struct cu_hash_table_entry
7256 unsigned min_comdat_num, max_comdat_num;
7257 struct cu_hash_table_entry *next;
7260 /* Routines to manipulate hash table of CUs. */
7262 htab_cu_hash (const void *of)
7264 const struct cu_hash_table_entry *const entry =
7265 (const struct cu_hash_table_entry *) of;
7267 return htab_hash_string (entry->cu->die_symbol);
7271 htab_cu_eq (const void *of1, const void *of2)
7273 const struct cu_hash_table_entry *const entry1 =
7274 (const struct cu_hash_table_entry *) of1;
7275 const struct die_struct *const entry2 = (const struct die_struct *) of2;
7277 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
7281 htab_cu_del (void *what)
7283 struct cu_hash_table_entry *next,
7284 *entry = (struct cu_hash_table_entry *) what;
7294 /* Check whether we have already seen this CU and set up SYM_NUM
7297 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
7299 struct cu_hash_table_entry dummy;
7300 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
7302 dummy.max_comdat_num = 0;
7304 slot = (struct cu_hash_table_entry **)
7305 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7309 for (; entry; last = entry, entry = entry->next)
7311 if (same_die_p_wrap (cu, entry->cu))
7317 *sym_num = entry->min_comdat_num;
7321 entry = XCNEW (struct cu_hash_table_entry);
7323 entry->min_comdat_num = *sym_num = last->max_comdat_num;
7324 entry->next = *slot;
7330 /* Record SYM_NUM to record of CU in HTABLE. */
7332 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
7334 struct cu_hash_table_entry **slot, *entry;
7336 slot = (struct cu_hash_table_entry **)
7337 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7341 entry->max_comdat_num = sym_num;
7344 /* Traverse the DIE (which is always comp_unit_die), and set up
7345 additional compilation units for each of the include files we see
7346 bracketed by BINCL/EINCL. */
7349 break_out_includes (dw_die_ref die)
7352 dw_die_ref unit = NULL;
7353 limbo_die_node *node, **pnode;
7354 htab_t cu_hash_table;
7358 dw_die_ref prev = c;
7360 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
7361 || (unit && is_comdat_die (c)))
7363 dw_die_ref next = c->die_sib;
7365 /* This DIE is for a secondary CU; remove it from the main one. */
7366 remove_child_with_prev (c, prev);
7368 if (c->die_tag == DW_TAG_GNU_BINCL)
7369 unit = push_new_compile_unit (unit, c);
7370 else if (c->die_tag == DW_TAG_GNU_EINCL)
7371 unit = pop_compile_unit (unit);
7373 add_child_die (unit, c);
7375 if (c == die->die_child)
7378 } while (c != die->die_child);
7381 /* We can only use this in debugging, since the frontend doesn't check
7382 to make sure that we leave every include file we enter. */
7386 assign_symbol_names (die);
7387 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
7388 for (node = limbo_die_list, pnode = &limbo_die_list;
7394 compute_section_prefix (node->die);
7395 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
7396 &comdat_symbol_number);
7397 assign_symbol_names (node->die);
7399 *pnode = node->next;
7402 pnode = &node->next;
7403 record_comdat_symbol_number (node->die, cu_hash_table,
7404 comdat_symbol_number);
7407 htab_delete (cu_hash_table);
7410 /* Traverse the DIE and add a sibling attribute if it may have the
7411 effect of speeding up access to siblings. To save some space,
7412 avoid generating sibling attributes for DIE's without children. */
7415 add_sibling_attributes (dw_die_ref die)
7419 if (! die->die_child)
7422 if (die->die_parent && die != die->die_parent->die_child)
7423 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7425 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7428 /* Output all location lists for the DIE and its children. */
7431 output_location_lists (dw_die_ref die)
7437 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7438 if (AT_class (a) == dw_val_class_loc_list)
7439 output_loc_list (AT_loc_list (a));
7441 FOR_EACH_CHILD (die, c, output_location_lists (c));
7444 /* The format of each DIE (and its attribute value pairs) is encoded in an
7445 abbreviation table. This routine builds the abbreviation table and assigns
7446 a unique abbreviation id for each abbreviation entry. The children of each
7447 die are visited recursively. */
7450 build_abbrev_table (dw_die_ref die)
7452 unsigned long abbrev_id;
7453 unsigned int n_alloc;
7458 /* Scan the DIE references, and mark as external any that refer to
7459 DIEs from other CUs (i.e. those which are not marked). */
7460 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7461 if (AT_class (a) == dw_val_class_die_ref
7462 && AT_ref (a)->die_mark == 0)
7464 gcc_assert (AT_ref (a)->die_symbol);
7466 set_AT_ref_external (a, 1);
7469 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7471 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7472 dw_attr_ref die_a, abbrev_a;
7476 if (abbrev->die_tag != die->die_tag)
7478 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7481 if (VEC_length (dw_attr_node, abbrev->die_attr)
7482 != VEC_length (dw_attr_node, die->die_attr))
7485 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
7487 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
7488 if ((abbrev_a->dw_attr != die_a->dw_attr)
7489 || (value_format (abbrev_a) != value_format (die_a)))
7499 if (abbrev_id >= abbrev_die_table_in_use)
7501 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7503 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7504 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7507 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7508 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7509 abbrev_die_table_allocated = n_alloc;
7512 ++abbrev_die_table_in_use;
7513 abbrev_die_table[abbrev_id] = die;
7516 die->die_abbrev = abbrev_id;
7517 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
7520 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7523 constant_size (unsigned HOST_WIDE_INT value)
7530 log = floor_log2 (value);
7533 log = 1 << (floor_log2 (log) + 1);
7538 /* Return the size of a DIE as it is represented in the
7539 .debug_info section. */
7541 static unsigned long
7542 size_of_die (dw_die_ref die)
7544 unsigned long size = 0;
7548 size += size_of_uleb128 (die->die_abbrev);
7549 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7551 switch (AT_class (a))
7553 case dw_val_class_addr:
7554 size += DWARF2_ADDR_SIZE;
7556 case dw_val_class_offset:
7557 size += DWARF_OFFSET_SIZE;
7559 case dw_val_class_loc:
7561 unsigned long lsize = size_of_locs (AT_loc (a));
7564 size += constant_size (lsize);
7568 case dw_val_class_loc_list:
7569 size += DWARF_OFFSET_SIZE;
7571 case dw_val_class_range_list:
7572 size += DWARF_OFFSET_SIZE;
7574 case dw_val_class_const:
7575 size += size_of_sleb128 (AT_int (a));
7577 case dw_val_class_unsigned_const:
7578 size += constant_size (AT_unsigned (a));
7580 case dw_val_class_long_long:
7581 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
7583 case dw_val_class_vec:
7584 size += constant_size (a->dw_attr_val.v.val_vec.length
7585 * a->dw_attr_val.v.val_vec.elt_size)
7586 + a->dw_attr_val.v.val_vec.length
7587 * a->dw_attr_val.v.val_vec.elt_size; /* block */
7589 case dw_val_class_flag:
7592 case dw_val_class_die_ref:
7593 if (AT_ref_external (a))
7594 size += DWARF2_ADDR_SIZE;
7596 size += DWARF_OFFSET_SIZE;
7598 case dw_val_class_fde_ref:
7599 size += DWARF_OFFSET_SIZE;
7601 case dw_val_class_lbl_id:
7602 size += DWARF2_ADDR_SIZE;
7604 case dw_val_class_lineptr:
7605 case dw_val_class_macptr:
7606 size += DWARF_OFFSET_SIZE;
7608 case dw_val_class_str:
7609 if (AT_string_form (a) == DW_FORM_strp)
7610 size += DWARF_OFFSET_SIZE;
7612 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
7614 case dw_val_class_file:
7615 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
7625 /* Size the debugging information associated with a given DIE. Visits the
7626 DIE's children recursively. Updates the global variable next_die_offset, on
7627 each time through. Uses the current value of next_die_offset to update the
7628 die_offset field in each DIE. */
7631 calc_die_sizes (dw_die_ref die)
7635 die->die_offset = next_die_offset;
7636 next_die_offset += size_of_die (die);
7638 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
7640 if (die->die_child != NULL)
7641 /* Count the null byte used to terminate sibling lists. */
7642 next_die_offset += 1;
7645 /* Set the marks for a die and its children. We do this so
7646 that we know whether or not a reference needs to use FORM_ref_addr; only
7647 DIEs in the same CU will be marked. We used to clear out the offset
7648 and use that as the flag, but ran into ordering problems. */
7651 mark_dies (dw_die_ref die)
7655 gcc_assert (!die->die_mark);
7658 FOR_EACH_CHILD (die, c, mark_dies (c));
7661 /* Clear the marks for a die and its children. */
7664 unmark_dies (dw_die_ref die)
7668 gcc_assert (die->die_mark);
7671 FOR_EACH_CHILD (die, c, unmark_dies (c));
7674 /* Clear the marks for a die, its children and referred dies. */
7677 unmark_all_dies (dw_die_ref die)
7687 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
7689 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7690 if (AT_class (a) == dw_val_class_die_ref)
7691 unmark_all_dies (AT_ref (a));
7694 /* Return the size of the .debug_pubnames or .debug_pubtypes table
7695 generated for the compilation unit. */
7697 static unsigned long
7698 size_of_pubnames (VEC (pubname_entry, gc) * names)
7704 size = DWARF_PUBNAMES_HEADER_SIZE;
7705 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
7706 if (names != pubtype_table
7707 || p->die->die_offset != 0
7708 || !flag_eliminate_unused_debug_types)
7709 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
7711 size += DWARF_OFFSET_SIZE;
7715 /* Return the size of the information in the .debug_aranges section. */
7717 static unsigned long
7718 size_of_aranges (void)
7722 size = DWARF_ARANGES_HEADER_SIZE;
7724 /* Count the address/length pair for this compilation unit. */
7725 if (text_section_used)
7726 size += 2 * DWARF2_ADDR_SIZE;
7727 if (cold_text_section_used)
7728 size += 2 * DWARF2_ADDR_SIZE;
7729 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
7731 /* Count the two zero words used to terminated the address range table. */
7732 size += 2 * DWARF2_ADDR_SIZE;
7736 /* Select the encoding of an attribute value. */
7738 static enum dwarf_form
7739 value_format (dw_attr_ref a)
7741 switch (a->dw_attr_val.val_class)
7743 case dw_val_class_addr:
7744 return DW_FORM_addr;
7745 case dw_val_class_range_list:
7746 case dw_val_class_offset:
7747 case dw_val_class_loc_list:
7748 switch (DWARF_OFFSET_SIZE)
7751 return DW_FORM_data4;
7753 return DW_FORM_data8;
7757 case dw_val_class_loc:
7758 switch (constant_size (size_of_locs (AT_loc (a))))
7761 return DW_FORM_block1;
7763 return DW_FORM_block2;
7767 case dw_val_class_const:
7768 return DW_FORM_sdata;
7769 case dw_val_class_unsigned_const:
7770 switch (constant_size (AT_unsigned (a)))
7773 return DW_FORM_data1;
7775 return DW_FORM_data2;
7777 return DW_FORM_data4;
7779 return DW_FORM_data8;
7783 case dw_val_class_long_long:
7784 return DW_FORM_block1;
7785 case dw_val_class_vec:
7786 switch (constant_size (a->dw_attr_val.v.val_vec.length
7787 * a->dw_attr_val.v.val_vec.elt_size))
7790 return DW_FORM_block1;
7792 return DW_FORM_block2;
7794 return DW_FORM_block4;
7798 case dw_val_class_flag:
7799 return DW_FORM_flag;
7800 case dw_val_class_die_ref:
7801 if (AT_ref_external (a))
7802 return DW_FORM_ref_addr;
7805 case dw_val_class_fde_ref:
7806 return DW_FORM_data;
7807 case dw_val_class_lbl_id:
7808 return DW_FORM_addr;
7809 case dw_val_class_lineptr:
7810 case dw_val_class_macptr:
7811 return DW_FORM_data;
7812 case dw_val_class_str:
7813 return AT_string_form (a);
7814 case dw_val_class_file:
7815 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
7818 return DW_FORM_data1;
7820 return DW_FORM_data2;
7822 return DW_FORM_data4;
7832 /* Output the encoding of an attribute value. */
7835 output_value_format (dw_attr_ref a)
7837 enum dwarf_form form = value_format (a);
7839 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
7842 /* Output the .debug_abbrev section which defines the DIE abbreviation
7846 output_abbrev_section (void)
7848 unsigned long abbrev_id;
7850 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7852 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7856 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
7857 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
7858 dwarf_tag_name (abbrev->die_tag));
7860 if (abbrev->die_child != NULL)
7861 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
7863 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
7865 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
7868 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
7869 dwarf_attr_name (a_attr->dw_attr));
7870 output_value_format (a_attr);
7873 dw2_asm_output_data (1, 0, NULL);
7874 dw2_asm_output_data (1, 0, NULL);
7877 /* Terminate the table. */
7878 dw2_asm_output_data (1, 0, NULL);
7881 /* Output a symbol we can use to refer to this DIE from another CU. */
7884 output_die_symbol (dw_die_ref die)
7886 char *sym = die->die_symbol;
7891 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
7892 /* We make these global, not weak; if the target doesn't support
7893 .linkonce, it doesn't support combining the sections, so debugging
7895 targetm.asm_out.globalize_label (asm_out_file, sym);
7897 ASM_OUTPUT_LABEL (asm_out_file, sym);
7900 /* Return a new location list, given the begin and end range, and the
7901 expression. gensym tells us whether to generate a new internal symbol for
7902 this location list node, which is done for the head of the list only. */
7904 static inline dw_loc_list_ref
7905 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
7906 const char *section, unsigned int gensym)
7908 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
7910 retlist->begin = begin;
7912 retlist->expr = expr;
7913 retlist->section = section;
7915 retlist->ll_symbol = gen_internal_sym ("LLST");
7920 /* Add a location description expression to a location list. */
7923 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
7924 const char *begin, const char *end,
7925 const char *section)
7929 /* Find the end of the chain. */
7930 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
7933 /* Add a new location list node to the list. */
7934 *d = new_loc_list (descr, begin, end, section, 0);
7937 /* Output the location list given to us. */
7940 output_loc_list (dw_loc_list_ref list_head)
7942 dw_loc_list_ref curr = list_head;
7944 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7946 /* Walk the location list, and output each range + expression. */
7947 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7950 /* Don't output an entry that starts and ends at the same address. */
7951 if (strcmp (curr->begin, curr->end) == 0)
7953 if (!have_multiple_function_sections)
7955 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7956 "Location list begin address (%s)",
7957 list_head->ll_symbol);
7958 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7959 "Location list end address (%s)",
7960 list_head->ll_symbol);
7964 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7965 "Location list begin address (%s)",
7966 list_head->ll_symbol);
7967 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7968 "Location list end address (%s)",
7969 list_head->ll_symbol);
7971 size = size_of_locs (curr->expr);
7973 /* Output the block length for this list of location operations. */
7974 gcc_assert (size <= 0xffff);
7975 dw2_asm_output_data (2, size, "%s", "Location expression size");
7977 output_loc_sequence (curr->expr);
7980 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7981 "Location list terminator begin (%s)",
7982 list_head->ll_symbol);
7983 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7984 "Location list terminator end (%s)",
7985 list_head->ll_symbol);
7988 /* Output the DIE and its attributes. Called recursively to generate
7989 the definitions of each child DIE. */
7992 output_die (dw_die_ref die)
7999 /* If someone in another CU might refer to us, set up a symbol for
8000 them to point to. */
8001 if (die->die_symbol)
8002 output_die_symbol (die);
8004 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
8005 (unsigned long)die->die_offset,
8006 dwarf_tag_name (die->die_tag));
8008 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8010 const char *name = dwarf_attr_name (a->dw_attr);
8012 switch (AT_class (a))
8014 case dw_val_class_addr:
8015 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8018 case dw_val_class_offset:
8019 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8023 case dw_val_class_range_list:
8025 char *p = strchr (ranges_section_label, '\0');
8027 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8028 a->dw_attr_val.v.val_offset);
8029 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8030 debug_ranges_section, "%s", name);
8035 case dw_val_class_loc:
8036 size = size_of_locs (AT_loc (a));
8038 /* Output the block length for this list of location operations. */
8039 dw2_asm_output_data (constant_size (size), size, "%s", name);
8041 output_loc_sequence (AT_loc (a));
8044 case dw_val_class_const:
8045 /* ??? It would be slightly more efficient to use a scheme like is
8046 used for unsigned constants below, but gdb 4.x does not sign
8047 extend. Gdb 5.x does sign extend. */
8048 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8051 case dw_val_class_unsigned_const:
8052 dw2_asm_output_data (constant_size (AT_unsigned (a)),
8053 AT_unsigned (a), "%s", name);
8056 case dw_val_class_long_long:
8058 unsigned HOST_WIDE_INT first, second;
8060 dw2_asm_output_data (1,
8061 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8064 if (WORDS_BIG_ENDIAN)
8066 first = a->dw_attr_val.v.val_long_long.hi;
8067 second = a->dw_attr_val.v.val_long_long.low;
8071 first = a->dw_attr_val.v.val_long_long.low;
8072 second = a->dw_attr_val.v.val_long_long.hi;
8075 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8076 first, "long long constant");
8077 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8082 case dw_val_class_vec:
8084 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8085 unsigned int len = a->dw_attr_val.v.val_vec.length;
8089 dw2_asm_output_data (constant_size (len * elt_size),
8090 len * elt_size, "%s", name);
8091 if (elt_size > sizeof (HOST_WIDE_INT))
8096 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8099 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8100 "fp or vector constant word %u", i);
8104 case dw_val_class_flag:
8105 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8108 case dw_val_class_loc_list:
8110 char *sym = AT_loc_list (a)->ll_symbol;
8113 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8118 case dw_val_class_die_ref:
8119 if (AT_ref_external (a))
8121 char *sym = AT_ref (a)->die_symbol;
8124 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
8129 gcc_assert (AT_ref (a)->die_offset);
8130 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8135 case dw_val_class_fde_ref:
8139 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8140 a->dw_attr_val.v.val_fde_index * 2);
8141 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
8146 case dw_val_class_lbl_id:
8147 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8150 case dw_val_class_lineptr:
8151 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8152 debug_line_section, "%s", name);
8155 case dw_val_class_macptr:
8156 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8157 debug_macinfo_section, "%s", name);
8160 case dw_val_class_str:
8161 if (AT_string_form (a) == DW_FORM_strp)
8162 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
8163 a->dw_attr_val.v.val_str->label,
8165 "%s: \"%s\"", name, AT_string (a));
8167 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
8170 case dw_val_class_file:
8172 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
8174 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
8175 a->dw_attr_val.v.val_file->filename);
8184 FOR_EACH_CHILD (die, c, output_die (c));
8186 /* Add null byte to terminate sibling list. */
8187 if (die->die_child != NULL)
8188 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
8189 (unsigned long) die->die_offset);
8192 /* Output the compilation unit that appears at the beginning of the
8193 .debug_info section, and precedes the DIE descriptions. */
8196 output_compilation_unit_header (void)
8198 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8199 dw2_asm_output_data (4, 0xffffffff,
8200 "Initial length escape value indicating 64-bit DWARF extension");
8201 dw2_asm_output_data (DWARF_OFFSET_SIZE,
8202 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
8203 "Length of Compilation Unit Info");
8204 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
8205 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
8206 debug_abbrev_section,
8207 "Offset Into Abbrev. Section");
8208 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
8211 /* Output the compilation unit DIE and its children. */
8214 output_comp_unit (dw_die_ref die, int output_if_empty)
8216 const char *secname;
8219 /* Unless we are outputting main CU, we may throw away empty ones. */
8220 if (!output_if_empty && die->die_child == NULL)
8223 /* Even if there are no children of this DIE, we must output the information
8224 about the compilation unit. Otherwise, on an empty translation unit, we
8225 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8226 will then complain when examining the file. First mark all the DIEs in
8227 this CU so we know which get local refs. */
8230 build_abbrev_table (die);
8232 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8233 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8234 calc_die_sizes (die);
8236 oldsym = die->die_symbol;
8239 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
8241 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
8243 die->die_symbol = NULL;
8244 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
8247 switch_to_section (debug_info_section);
8249 /* Output debugging information. */
8250 output_compilation_unit_header ();
8253 /* Leave the marks on the main CU, so we can check them in
8258 die->die_symbol = oldsym;
8262 /* Return the DWARF2/3 pubname associated with a decl. */
8265 dwarf2_name (tree decl, int scope)
8267 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
8270 /* Add a new entry to .debug_pubnames if appropriate. */
8273 add_pubname_string (const char *str, dw_die_ref die)
8278 e.name = xstrdup (str);
8279 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
8283 add_pubname (tree decl, dw_die_ref die)
8286 if (TREE_PUBLIC (decl))
8287 add_pubname_string (dwarf2_name (decl, 1), die);
8290 /* Add a new entry to .debug_pubtypes if appropriate. */
8293 add_pubtype (tree decl, dw_die_ref die)
8298 if ((TREE_PUBLIC (decl)
8299 || die->die_parent == comp_unit_die)
8300 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
8305 if (TYPE_NAME (decl))
8307 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
8308 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
8309 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
8310 && DECL_NAME (TYPE_NAME (decl)))
8311 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
8313 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
8317 e.name = xstrdup (dwarf2_name (decl, 1));
8319 /* If we don't have a name for the type, there's no point in adding
8321 if (e.name && e.name[0] != '\0')
8322 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
8326 /* Output the public names table used to speed up access to externally
8327 visible names; or the public types table used to find type definitions. */
8330 output_pubnames (VEC (pubname_entry, gc) * names)
8333 unsigned long pubnames_length = size_of_pubnames (names);
8336 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8337 dw2_asm_output_data (4, 0xffffffff,
8338 "Initial length escape value indicating 64-bit DWARF extension");
8339 if (names == pubname_table)
8340 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8341 "Length of Public Names Info");
8343 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8344 "Length of Public Type Names Info");
8345 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8346 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8348 "Offset of Compilation Unit Info");
8349 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
8350 "Compilation Unit Length");
8352 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
8354 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8355 if (names == pubname_table)
8356 gcc_assert (pub->die->die_mark);
8358 if (names != pubtype_table
8359 || pub->die->die_offset != 0
8360 || !flag_eliminate_unused_debug_types)
8362 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
8365 dw2_asm_output_nstring (pub->name, -1, "external name");
8369 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
8372 /* Add a new entry to .debug_aranges if appropriate. */
8375 add_arange (tree decl, dw_die_ref die)
8377 if (! DECL_SECTION_NAME (decl))
8380 if (arange_table_in_use == arange_table_allocated)
8382 arange_table_allocated += ARANGE_TABLE_INCREMENT;
8383 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
8384 arange_table_allocated);
8385 memset (arange_table + arange_table_in_use, 0,
8386 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
8389 arange_table[arange_table_in_use++] = die;
8392 /* Output the information that goes into the .debug_aranges table.
8393 Namely, define the beginning and ending address range of the
8394 text section generated for this compilation unit. */
8397 output_aranges (void)
8400 unsigned long aranges_length = size_of_aranges ();
8402 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8403 dw2_asm_output_data (4, 0xffffffff,
8404 "Initial length escape value indicating 64-bit DWARF extension");
8405 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
8406 "Length of Address Ranges Info");
8407 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8408 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8410 "Offset of Compilation Unit Info");
8411 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
8412 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8414 /* We need to align to twice the pointer size here. */
8415 if (DWARF_ARANGES_PAD_SIZE)
8417 /* Pad using a 2 byte words so that padding is correct for any
8419 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8420 2 * DWARF2_ADDR_SIZE);
8421 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
8422 dw2_asm_output_data (2, 0, NULL);
8425 /* It is necessary not to output these entries if the sections were
8426 not used; if the sections were not used, the length will be 0 and
8427 the address may end up as 0 if the section is discarded by ld
8428 --gc-sections, leaving an invalid (0, 0) entry that can be
8429 confused with the terminator. */
8430 if (text_section_used)
8432 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
8433 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
8434 text_section_label, "Length");
8436 if (cold_text_section_used)
8438 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
8440 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
8441 cold_text_section_label, "Length");
8444 for (i = 0; i < arange_table_in_use; i++)
8446 dw_die_ref die = arange_table[i];
8448 /* We shouldn't see aranges for DIEs outside of the main CU. */
8449 gcc_assert (die->die_mark);
8451 if (die->die_tag == DW_TAG_subprogram)
8453 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
8455 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
8456 get_AT_low_pc (die), "Length");
8460 /* A static variable; extract the symbol from DW_AT_location.
8461 Note that this code isn't currently hit, as we only emit
8462 aranges for functions (jason 9/23/99). */
8463 dw_attr_ref a = get_AT (die, DW_AT_location);
8464 dw_loc_descr_ref loc;
8466 gcc_assert (a && AT_class (a) == dw_val_class_loc);
8469 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
8471 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
8472 loc->dw_loc_oprnd1.v.val_addr, "Address");
8473 dw2_asm_output_data (DWARF2_ADDR_SIZE,
8474 get_AT_unsigned (die, DW_AT_byte_size),
8479 /* Output the terminator words. */
8480 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8481 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8484 /* Add a new entry to .debug_ranges. Return the offset at which it
8488 add_ranges_num (int num)
8490 unsigned int in_use = ranges_table_in_use;
8492 if (in_use == ranges_table_allocated)
8494 ranges_table_allocated += RANGES_TABLE_INCREMENT;
8495 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
8496 ranges_table_allocated);
8497 memset (ranges_table + ranges_table_in_use, 0,
8498 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
8501 ranges_table[in_use].num = num;
8502 ranges_table_in_use = in_use + 1;
8504 return in_use * 2 * DWARF2_ADDR_SIZE;
8507 /* Add a new entry to .debug_ranges corresponding to a block, or a
8508 range terminator if BLOCK is NULL. */
8511 add_ranges (const_tree block)
8513 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
8516 /* Add a new entry to .debug_ranges corresponding to a pair of
8520 add_ranges_by_labels (const char *begin, const char *end)
8522 unsigned int in_use = ranges_by_label_in_use;
8524 if (in_use == ranges_by_label_allocated)
8526 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
8527 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
8529 ranges_by_label_allocated);
8530 memset (ranges_by_label + ranges_by_label_in_use, 0,
8531 RANGES_TABLE_INCREMENT
8532 * sizeof (struct dw_ranges_by_label_struct));
8535 ranges_by_label[in_use].begin = begin;
8536 ranges_by_label[in_use].end = end;
8537 ranges_by_label_in_use = in_use + 1;
8539 return add_ranges_num (-(int)in_use - 1);
8543 output_ranges (void)
8546 static const char *const start_fmt = "Offset 0x%x";
8547 const char *fmt = start_fmt;
8549 for (i = 0; i < ranges_table_in_use; i++)
8551 int block_num = ranges_table[i].num;
8555 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
8556 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
8558 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
8559 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
8561 /* If all code is in the text section, then the compilation
8562 unit base address defaults to DW_AT_low_pc, which is the
8563 base of the text section. */
8564 if (!have_multiple_function_sections)
8566 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
8568 fmt, i * 2 * DWARF2_ADDR_SIZE);
8569 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
8570 text_section_label, NULL);
8573 /* Otherwise, the compilation unit base address is zero,
8574 which allows us to use absolute addresses, and not worry
8575 about whether the target supports cross-section
8579 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
8580 fmt, i * 2 * DWARF2_ADDR_SIZE);
8581 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
8587 /* Negative block_num stands for an index into ranges_by_label. */
8588 else if (block_num < 0)
8590 int lab_idx = - block_num - 1;
8592 if (!have_multiple_function_sections)
8596 /* If we ever use add_ranges_by_labels () for a single
8597 function section, all we have to do is to take out
8599 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8600 ranges_by_label[lab_idx].begin,
8602 fmt, i * 2 * DWARF2_ADDR_SIZE);
8603 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8604 ranges_by_label[lab_idx].end,
8605 text_section_label, NULL);
8610 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8611 ranges_by_label[lab_idx].begin,
8612 fmt, i * 2 * DWARF2_ADDR_SIZE);
8613 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8614 ranges_by_label[lab_idx].end,
8620 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8621 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8627 /* Data structure containing information about input files. */
8630 const char *path; /* Complete file name. */
8631 const char *fname; /* File name part. */
8632 int length; /* Length of entire string. */
8633 struct dwarf_file_data * file_idx; /* Index in input file table. */
8634 int dir_idx; /* Index in directory table. */
8637 /* Data structure containing information about directories with source
8641 const char *path; /* Path including directory name. */
8642 int length; /* Path length. */
8643 int prefix; /* Index of directory entry which is a prefix. */
8644 int count; /* Number of files in this directory. */
8645 int dir_idx; /* Index of directory used as base. */
8648 /* Callback function for file_info comparison. We sort by looking at
8649 the directories in the path. */
8652 file_info_cmp (const void *p1, const void *p2)
8654 const struct file_info *const s1 = (const struct file_info *) p1;
8655 const struct file_info *const s2 = (const struct file_info *) p2;
8656 const unsigned char *cp1;
8657 const unsigned char *cp2;
8659 /* Take care of file names without directories. We need to make sure that
8660 we return consistent values to qsort since some will get confused if
8661 we return the same value when identical operands are passed in opposite
8662 orders. So if neither has a directory, return 0 and otherwise return
8663 1 or -1 depending on which one has the directory. */
8664 if ((s1->path == s1->fname || s2->path == s2->fname))
8665 return (s2->path == s2->fname) - (s1->path == s1->fname);
8667 cp1 = (const unsigned char *) s1->path;
8668 cp2 = (const unsigned char *) s2->path;
8674 /* Reached the end of the first path? If so, handle like above. */
8675 if ((cp1 == (const unsigned char *) s1->fname)
8676 || (cp2 == (const unsigned char *) s2->fname))
8677 return ((cp2 == (const unsigned char *) s2->fname)
8678 - (cp1 == (const unsigned char *) s1->fname));
8680 /* Character of current path component the same? */
8681 else if (*cp1 != *cp2)
8686 struct file_name_acquire_data
8688 struct file_info *files;
8693 /* Traversal function for the hash table. */
8696 file_name_acquire (void ** slot, void *data)
8698 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
8699 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
8700 struct file_info *fi;
8703 gcc_assert (fnad->max_files >= d->emitted_number);
8705 if (! d->emitted_number)
8708 gcc_assert (fnad->max_files != fnad->used_files);
8710 fi = fnad->files + fnad->used_files++;
8712 /* Skip all leading "./". */
8714 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
8717 /* Create a new array entry. */
8719 fi->length = strlen (f);
8722 /* Search for the file name part. */
8723 f = strrchr (f, DIR_SEPARATOR);
8724 #if defined (DIR_SEPARATOR_2)
8726 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
8730 if (f == NULL || f < g)
8736 fi->fname = f == NULL ? fi->path : f + 1;
8740 /* Output the directory table and the file name table. We try to minimize
8741 the total amount of memory needed. A heuristic is used to avoid large
8742 slowdowns with many input files. */
8745 output_file_names (void)
8747 struct file_name_acquire_data fnad;
8749 struct file_info *files;
8750 struct dir_info *dirs;
8759 if (!last_emitted_file)
8761 dw2_asm_output_data (1, 0, "End directory table");
8762 dw2_asm_output_data (1, 0, "End file name table");
8766 numfiles = last_emitted_file->emitted_number;
8768 /* Allocate the various arrays we need. */
8769 files = XALLOCAVEC (struct file_info, numfiles);
8770 dirs = XALLOCAVEC (struct dir_info, numfiles);
8773 fnad.used_files = 0;
8774 fnad.max_files = numfiles;
8775 htab_traverse (file_table, file_name_acquire, &fnad);
8776 gcc_assert (fnad.used_files == fnad.max_files);
8778 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
8780 /* Find all the different directories used. */
8781 dirs[0].path = files[0].path;
8782 dirs[0].length = files[0].fname - files[0].path;
8783 dirs[0].prefix = -1;
8785 dirs[0].dir_idx = 0;
8786 files[0].dir_idx = 0;
8789 for (i = 1; i < numfiles; i++)
8790 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
8791 && memcmp (dirs[ndirs - 1].path, files[i].path,
8792 dirs[ndirs - 1].length) == 0)
8794 /* Same directory as last entry. */
8795 files[i].dir_idx = ndirs - 1;
8796 ++dirs[ndirs - 1].count;
8802 /* This is a new directory. */
8803 dirs[ndirs].path = files[i].path;
8804 dirs[ndirs].length = files[i].fname - files[i].path;
8805 dirs[ndirs].count = 1;
8806 dirs[ndirs].dir_idx = ndirs;
8807 files[i].dir_idx = ndirs;
8809 /* Search for a prefix. */
8810 dirs[ndirs].prefix = -1;
8811 for (j = 0; j < ndirs; j++)
8812 if (dirs[j].length < dirs[ndirs].length
8813 && dirs[j].length > 1
8814 && (dirs[ndirs].prefix == -1
8815 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
8816 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
8817 dirs[ndirs].prefix = j;
8822 /* Now to the actual work. We have to find a subset of the directories which
8823 allow expressing the file name using references to the directory table
8824 with the least amount of characters. We do not do an exhaustive search
8825 where we would have to check out every combination of every single
8826 possible prefix. Instead we use a heuristic which provides nearly optimal
8827 results in most cases and never is much off. */
8828 saved = XALLOCAVEC (int, ndirs);
8829 savehere = XALLOCAVEC (int, ndirs);
8831 memset (saved, '\0', ndirs * sizeof (saved[0]));
8832 for (i = 0; i < ndirs; i++)
8837 /* We can always save some space for the current directory. But this
8838 does not mean it will be enough to justify adding the directory. */
8839 savehere[i] = dirs[i].length;
8840 total = (savehere[i] - saved[i]) * dirs[i].count;
8842 for (j = i + 1; j < ndirs; j++)
8845 if (saved[j] < dirs[i].length)
8847 /* Determine whether the dirs[i] path is a prefix of the
8852 while (k != -1 && k != (int) i)
8857 /* Yes it is. We can possibly save some memory by
8858 writing the filenames in dirs[j] relative to
8860 savehere[j] = dirs[i].length;
8861 total += (savehere[j] - saved[j]) * dirs[j].count;
8866 /* Check whether we can save enough to justify adding the dirs[i]
8868 if (total > dirs[i].length + 1)
8870 /* It's worthwhile adding. */
8871 for (j = i; j < ndirs; j++)
8872 if (savehere[j] > 0)
8874 /* Remember how much we saved for this directory so far. */
8875 saved[j] = savehere[j];
8877 /* Remember the prefix directory. */
8878 dirs[j].dir_idx = i;
8883 /* Emit the directory name table. */
8885 idx_offset = dirs[0].length > 0 ? 1 : 0;
8886 for (i = 1 - idx_offset; i < ndirs; i++)
8887 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
8888 "Directory Entry: 0x%x", i + idx_offset);
8890 dw2_asm_output_data (1, 0, "End directory table");
8892 /* We have to emit them in the order of emitted_number since that's
8893 used in the debug info generation. To do this efficiently we
8894 generate a back-mapping of the indices first. */
8895 backmap = XALLOCAVEC (int, numfiles);
8896 for (i = 0; i < numfiles; i++)
8897 backmap[files[i].file_idx->emitted_number - 1] = i;
8899 /* Now write all the file names. */
8900 for (i = 0; i < numfiles; i++)
8902 int file_idx = backmap[i];
8903 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
8905 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
8906 "File Entry: 0x%x", (unsigned) i + 1);
8908 /* Include directory index. */
8909 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
8911 /* Modification time. */
8912 dw2_asm_output_data_uleb128 (0, NULL);
8914 /* File length in bytes. */
8915 dw2_asm_output_data_uleb128 (0, NULL);
8918 dw2_asm_output_data (1, 0, "End file name table");
8922 /* Output the source line number correspondence information. This
8923 information goes into the .debug_line section. */
8926 output_line_info (void)
8928 char l1[20], l2[20], p1[20], p2[20];
8929 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8930 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8933 unsigned long lt_index;
8934 unsigned long current_line;
8937 unsigned long current_file;
8938 unsigned long function;
8940 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
8941 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
8942 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
8943 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
8945 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8946 dw2_asm_output_data (4, 0xffffffff,
8947 "Initial length escape value indicating 64-bit DWARF extension");
8948 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
8949 "Length of Source Line Info");
8950 ASM_OUTPUT_LABEL (asm_out_file, l1);
8952 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8953 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
8954 ASM_OUTPUT_LABEL (asm_out_file, p1);
8956 /* Define the architecture-dependent minimum instruction length (in
8957 bytes). In this implementation of DWARF, this field is used for
8958 information purposes only. Since GCC generates assembly language,
8959 we have no a priori knowledge of how many instruction bytes are
8960 generated for each source line, and therefore can use only the
8961 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
8962 commands. Accordingly, we fix this as `1', which is "correct
8963 enough" for all architectures, and don't let the target override. */
8964 dw2_asm_output_data (1, 1,
8965 "Minimum Instruction Length");
8967 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
8968 "Default is_stmt_start flag");
8969 dw2_asm_output_data (1, DWARF_LINE_BASE,
8970 "Line Base Value (Special Opcodes)");
8971 dw2_asm_output_data (1, DWARF_LINE_RANGE,
8972 "Line Range Value (Special Opcodes)");
8973 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
8974 "Special Opcode Base");
8976 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
8980 case DW_LNS_advance_pc:
8981 case DW_LNS_advance_line:
8982 case DW_LNS_set_file:
8983 case DW_LNS_set_column:
8984 case DW_LNS_fixed_advance_pc:
8992 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
8996 /* Write out the information about the files we use. */
8997 output_file_names ();
8998 ASM_OUTPUT_LABEL (asm_out_file, p2);
9000 /* We used to set the address register to the first location in the text
9001 section here, but that didn't accomplish anything since we already
9002 have a line note for the opening brace of the first function. */
9004 /* Generate the line number to PC correspondence table, encoded as
9005 a series of state machine operations. */
9009 if (cfun && in_cold_section_p)
9010 strcpy (prev_line_label, crtl->subsections.cold_section_label);
9012 strcpy (prev_line_label, text_section_label);
9013 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
9015 dw_line_info_ref line_info = &line_info_table[lt_index];
9018 /* Disable this optimization for now; GDB wants to see two line notes
9019 at the beginning of a function so it can find the end of the
9022 /* Don't emit anything for redundant notes. Just updating the
9023 address doesn't accomplish anything, because we already assume
9024 that anything after the last address is this line. */
9025 if (line_info->dw_line_num == current_line
9026 && line_info->dw_file_num == current_file)
9030 /* Emit debug info for the address of the current line.
9032 Unfortunately, we have little choice here currently, and must always
9033 use the most general form. GCC does not know the address delta
9034 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9035 attributes which will give an upper bound on the address range. We
9036 could perhaps use length attributes to determine when it is safe to
9037 use DW_LNS_fixed_advance_pc. */
9039 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
9042 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
9043 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9044 "DW_LNS_fixed_advance_pc");
9045 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9049 /* This can handle any delta. This takes
9050 4+DWARF2_ADDR_SIZE bytes. */
9051 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9052 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9053 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9054 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9057 strcpy (prev_line_label, line_label);
9059 /* Emit debug info for the source file of the current line, if
9060 different from the previous line. */
9061 if (line_info->dw_file_num != current_file)
9063 current_file = line_info->dw_file_num;
9064 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9065 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9068 /* Emit debug info for the current line number, choosing the encoding
9069 that uses the least amount of space. */
9070 if (line_info->dw_line_num != current_line)
9072 line_offset = line_info->dw_line_num - current_line;
9073 line_delta = line_offset - DWARF_LINE_BASE;
9074 current_line = line_info->dw_line_num;
9075 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9076 /* This can handle deltas from -10 to 234, using the current
9077 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
9079 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9080 "line %lu", current_line);
9083 /* This can handle any delta. This takes at least 4 bytes,
9084 depending on the value being encoded. */
9085 dw2_asm_output_data (1, DW_LNS_advance_line,
9086 "advance to line %lu", current_line);
9087 dw2_asm_output_data_sleb128 (line_offset, NULL);
9088 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9092 /* We still need to start a new row, so output a copy insn. */
9093 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9096 /* Emit debug info for the address of the end of the function. */
9099 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9100 "DW_LNS_fixed_advance_pc");
9101 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
9105 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9106 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9107 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9108 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
9111 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9112 dw2_asm_output_data_uleb128 (1, NULL);
9113 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9118 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
9120 dw_separate_line_info_ref line_info
9121 = &separate_line_info_table[lt_index];
9124 /* Don't emit anything for redundant notes. */
9125 if (line_info->dw_line_num == current_line
9126 && line_info->dw_file_num == current_file
9127 && line_info->function == function)
9131 /* Emit debug info for the address of the current line. If this is
9132 a new function, or the first line of a function, then we need
9133 to handle it differently. */
9134 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
9136 if (function != line_info->function)
9138 function = line_info->function;
9140 /* Set the address register to the first line in the function. */
9141 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9142 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9143 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9144 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9148 /* ??? See the DW_LNS_advance_pc comment above. */
9151 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9152 "DW_LNS_fixed_advance_pc");
9153 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9157 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9158 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9159 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9160 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9164 strcpy (prev_line_label, line_label);
9166 /* Emit debug info for the source file of the current line, if
9167 different from the previous line. */
9168 if (line_info->dw_file_num != current_file)
9170 current_file = line_info->dw_file_num;
9171 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9172 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9175 /* Emit debug info for the current line number, choosing the encoding
9176 that uses the least amount of space. */
9177 if (line_info->dw_line_num != current_line)
9179 line_offset = line_info->dw_line_num - current_line;
9180 line_delta = line_offset - DWARF_LINE_BASE;
9181 current_line = line_info->dw_line_num;
9182 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9183 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9184 "line %lu", current_line);
9187 dw2_asm_output_data (1, DW_LNS_advance_line,
9188 "advance to line %lu", current_line);
9189 dw2_asm_output_data_sleb128 (line_offset, NULL);
9190 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9194 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9202 /* If we're done with a function, end its sequence. */
9203 if (lt_index == separate_line_info_table_in_use
9204 || separate_line_info_table[lt_index].function != function)
9209 /* Emit debug info for the address of the end of the function. */
9210 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
9213 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9214 "DW_LNS_fixed_advance_pc");
9215 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9219 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9220 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9221 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9222 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9225 /* Output the marker for the end of this sequence. */
9226 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9227 dw2_asm_output_data_uleb128 (1, NULL);
9228 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9232 /* Output the marker for the end of the line number info. */
9233 ASM_OUTPUT_LABEL (asm_out_file, l2);
9236 /* Given a pointer to a tree node for some base type, return a pointer to
9237 a DIE that describes the given type.
9239 This routine must only be called for GCC type nodes that correspond to
9240 Dwarf base (fundamental) types. */
9243 base_type_die (tree type)
9245 dw_die_ref base_type_result;
9246 enum dwarf_type encoding;
9248 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
9251 switch (TREE_CODE (type))
9254 if (TYPE_STRING_FLAG (type))
9256 if (TYPE_UNSIGNED (type))
9257 encoding = DW_ATE_unsigned_char;
9259 encoding = DW_ATE_signed_char;
9261 else if (TYPE_UNSIGNED (type))
9262 encoding = DW_ATE_unsigned;
9264 encoding = DW_ATE_signed;
9268 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
9269 encoding = DW_ATE_decimal_float;
9271 encoding = DW_ATE_float;
9274 case FIXED_POINT_TYPE:
9275 if (TYPE_UNSIGNED (type))
9276 encoding = DW_ATE_unsigned_fixed;
9278 encoding = DW_ATE_signed_fixed;
9281 /* Dwarf2 doesn't know anything about complex ints, so use
9282 a user defined type for it. */
9284 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
9285 encoding = DW_ATE_complex_float;
9287 encoding = DW_ATE_lo_user;
9291 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9292 encoding = DW_ATE_boolean;
9296 /* No other TREE_CODEs are Dwarf fundamental types. */
9300 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
9302 /* This probably indicates a bug. */
9303 if (! TYPE_NAME (type))
9304 add_name_attribute (base_type_result, "__unknown__");
9306 add_AT_unsigned (base_type_result, DW_AT_byte_size,
9307 int_size_in_bytes (type));
9308 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
9310 return base_type_result;
9313 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9314 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9317 is_base_type (tree type)
9319 switch (TREE_CODE (type))
9325 case FIXED_POINT_TYPE:
9333 case QUAL_UNION_TYPE:
9338 case REFERENCE_TYPE:
9351 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9352 node, return the size in bits for the type if it is a constant, or else
9353 return the alignment for the type if the type's size is not constant, or
9354 else return BITS_PER_WORD if the type actually turns out to be an
9357 static inline unsigned HOST_WIDE_INT
9358 simple_type_size_in_bits (const_tree type)
9360 if (TREE_CODE (type) == ERROR_MARK)
9361 return BITS_PER_WORD;
9362 else if (TYPE_SIZE (type) == NULL_TREE)
9364 else if (host_integerp (TYPE_SIZE (type), 1))
9365 return tree_low_cst (TYPE_SIZE (type), 1);
9367 return TYPE_ALIGN (type);
9370 /* Return true if the debug information for the given type should be
9371 emitted as a subrange type. */
9374 is_subrange_type (const_tree type)
9376 tree subtype = TREE_TYPE (type);
9378 /* Subrange types are identified by the fact that they are integer
9379 types, and that they have a subtype which is either an integer type
9380 or an enumeral type. */
9382 if (TREE_CODE (type) != INTEGER_TYPE
9383 || subtype == NULL_TREE)
9386 if (TREE_CODE (subtype) != INTEGER_TYPE
9387 && TREE_CODE (subtype) != ENUMERAL_TYPE
9388 && TREE_CODE (subtype) != BOOLEAN_TYPE)
9391 if (TREE_CODE (type) == TREE_CODE (subtype)
9392 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
9393 && TYPE_MIN_VALUE (type) != NULL
9394 && TYPE_MIN_VALUE (subtype) != NULL
9395 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
9396 && TYPE_MAX_VALUE (type) != NULL
9397 && TYPE_MAX_VALUE (subtype) != NULL
9398 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
9400 /* The type and its subtype have the same representation. If in
9401 addition the two types also have the same name, then the given
9402 type is not a subrange type, but rather a plain base type. */
9403 /* FIXME: brobecker/2004-03-22:
9404 Sizetype INTEGER_CSTs nodes are canonicalized. It should
9405 therefore be sufficient to check the TYPE_SIZE node pointers
9406 rather than checking the actual size. Unfortunately, we have
9407 found some cases, such as in the Ada "integer" type, where
9408 this is not the case. Until this problem is solved, we need to
9409 keep checking the actual size. */
9410 tree type_name = TYPE_NAME (type);
9411 tree subtype_name = TYPE_NAME (subtype);
9413 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
9414 type_name = DECL_NAME (type_name);
9416 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
9417 subtype_name = DECL_NAME (subtype_name);
9419 if (type_name == subtype_name)
9426 /* Given a pointer to a tree node for a subrange type, return a pointer
9427 to a DIE that describes the given type. */
9430 subrange_type_die (tree type, dw_die_ref context_die)
9432 dw_die_ref subrange_die;
9433 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
9435 if (context_die == NULL)
9436 context_die = comp_unit_die;
9438 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
9440 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
9442 /* The size of the subrange type and its base type do not match,
9443 so we need to generate a size attribute for the subrange type. */
9444 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
9447 if (TYPE_MIN_VALUE (type) != NULL)
9448 add_bound_info (subrange_die, DW_AT_lower_bound,
9449 TYPE_MIN_VALUE (type));
9450 if (TYPE_MAX_VALUE (type) != NULL)
9451 add_bound_info (subrange_die, DW_AT_upper_bound,
9452 TYPE_MAX_VALUE (type));
9454 return subrange_die;
9457 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9458 entry that chains various modifiers in front of the given type. */
9461 modified_type_die (tree type, int is_const_type, int is_volatile_type,
9462 dw_die_ref context_die)
9464 enum tree_code code = TREE_CODE (type);
9465 dw_die_ref mod_type_die;
9466 dw_die_ref sub_die = NULL;
9467 tree item_type = NULL;
9468 tree qualified_type;
9471 if (code == ERROR_MARK)
9474 /* See if we already have the appropriately qualified variant of
9477 = get_qualified_type (type,
9478 ((is_const_type ? TYPE_QUAL_CONST : 0)
9479 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
9481 /* If we do, then we can just use its DIE, if it exists. */
9484 mod_type_die = lookup_type_die (qualified_type);
9486 return mod_type_die;
9489 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
9491 /* Handle C typedef types. */
9492 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
9494 tree dtype = TREE_TYPE (name);
9496 if (qualified_type == dtype)
9498 /* For a named type, use the typedef. */
9499 gen_type_die (qualified_type, context_die);
9500 return lookup_type_die (qualified_type);
9502 else if (is_const_type < TYPE_READONLY (dtype)
9503 || is_volatile_type < TYPE_VOLATILE (dtype)
9504 || (is_const_type <= TYPE_READONLY (dtype)
9505 && is_volatile_type <= TYPE_VOLATILE (dtype)
9506 && DECL_ORIGINAL_TYPE (name) != type))
9507 /* cv-unqualified version of named type. Just use the unnamed
9508 type to which it refers. */
9509 return modified_type_die (DECL_ORIGINAL_TYPE (name),
9510 is_const_type, is_volatile_type,
9512 /* Else cv-qualified version of named type; fall through. */
9517 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
9518 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
9520 else if (is_volatile_type)
9522 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
9523 sub_die = modified_type_die (type, 0, 0, context_die);
9525 else if (code == POINTER_TYPE)
9527 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
9528 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9529 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9530 item_type = TREE_TYPE (type);
9532 else if (code == REFERENCE_TYPE)
9534 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
9535 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9536 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9537 item_type = TREE_TYPE (type);
9539 else if (is_subrange_type (type))
9541 mod_type_die = subrange_type_die (type, context_die);
9542 item_type = TREE_TYPE (type);
9544 else if (is_base_type (type))
9545 mod_type_die = base_type_die (type);
9548 gen_type_die (type, context_die);
9550 /* We have to get the type_main_variant here (and pass that to the
9551 `lookup_type_die' routine) because the ..._TYPE node we have
9552 might simply be a *copy* of some original type node (where the
9553 copy was created to help us keep track of typedef names) and
9554 that copy might have a different TYPE_UID from the original
9556 if (TREE_CODE (type) != VECTOR_TYPE)
9557 return lookup_type_die (type_main_variant (type));
9559 /* Vectors have the debugging information in the type,
9560 not the main variant. */
9561 return lookup_type_die (type);
9564 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9565 don't output a DW_TAG_typedef, since there isn't one in the
9566 user's program; just attach a DW_AT_name to the type. */
9568 && (TREE_CODE (name) != TYPE_DECL
9569 || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
9571 if (TREE_CODE (name) == TYPE_DECL)
9572 /* Could just call add_name_and_src_coords_attributes here,
9573 but since this is a builtin type it doesn't have any
9574 useful source coordinates anyway. */
9575 name = DECL_NAME (name);
9576 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
9580 equate_type_number_to_die (qualified_type, mod_type_die);
9583 /* We must do this after the equate_type_number_to_die call, in case
9584 this is a recursive type. This ensures that the modified_type_die
9585 recursion will terminate even if the type is recursive. Recursive
9586 types are possible in Ada. */
9587 sub_die = modified_type_die (item_type,
9588 TYPE_READONLY (item_type),
9589 TYPE_VOLATILE (item_type),
9592 if (sub_die != NULL)
9593 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
9595 return mod_type_die;
9598 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
9599 an enumerated type. */
9602 type_is_enum (const_tree type)
9604 return TREE_CODE (type) == ENUMERAL_TYPE;
9607 /* Return the DBX register number described by a given RTL node. */
9610 dbx_reg_number (const_rtx rtl)
9612 unsigned regno = REGNO (rtl);
9614 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
9616 #ifdef LEAF_REG_REMAP
9617 if (current_function_uses_only_leaf_regs)
9619 int leaf_reg = LEAF_REG_REMAP (regno);
9621 regno = (unsigned) leaf_reg;
9625 return DBX_REGISTER_NUMBER (regno);
9628 /* Optionally add a DW_OP_piece term to a location description expression.
9629 DW_OP_piece is only added if the location description expression already
9630 doesn't end with DW_OP_piece. */
9633 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
9635 dw_loc_descr_ref loc;
9637 if (*list_head != NULL)
9639 /* Find the end of the chain. */
9640 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
9643 if (loc->dw_loc_opc != DW_OP_piece)
9644 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
9648 /* Return a location descriptor that designates a machine register or
9649 zero if there is none. */
9651 static dw_loc_descr_ref
9652 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
9656 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
9659 regs = targetm.dwarf_register_span (rtl);
9661 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
9662 return multiple_reg_loc_descriptor (rtl, regs, initialized);
9664 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
9667 /* Return a location descriptor that designates a machine register for
9668 a given hard register number. */
9670 static dw_loc_descr_ref
9671 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
9673 dw_loc_descr_ref reg_loc_descr = new_reg_loc_descr (regno, 0);
9675 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9676 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9678 return reg_loc_descr;
9681 /* Given an RTL of a register, return a location descriptor that
9682 designates a value that spans more than one register. */
9684 static dw_loc_descr_ref
9685 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
9686 enum var_init_status initialized)
9690 dw_loc_descr_ref loc_result = NULL;
9693 #ifdef LEAF_REG_REMAP
9694 if (current_function_uses_only_leaf_regs)
9696 int leaf_reg = LEAF_REG_REMAP (reg);
9698 reg = (unsigned) leaf_reg;
9701 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
9702 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
9704 /* Simple, contiguous registers. */
9705 if (regs == NULL_RTX)
9707 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
9714 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
9715 VAR_INIT_STATUS_INITIALIZED);
9716 add_loc_descr (&loc_result, t);
9717 add_loc_descr_op_piece (&loc_result, size);
9723 /* Now onto stupid register sets in non contiguous locations. */
9725 gcc_assert (GET_CODE (regs) == PARALLEL);
9727 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9730 for (i = 0; i < XVECLEN (regs, 0); ++i)
9734 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
9735 VAR_INIT_STATUS_INITIALIZED);
9736 add_loc_descr (&loc_result, t);
9737 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9738 add_loc_descr_op_piece (&loc_result, size);
9741 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9742 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9746 #endif /* DWARF2_DEBUGGING_INFO */
9748 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
9750 /* Return a location descriptor that designates a constant. */
9752 static dw_loc_descr_ref
9753 int_loc_descriptor (HOST_WIDE_INT i)
9755 enum dwarf_location_atom op;
9757 /* Pick the smallest representation of a constant, rather than just
9758 defaulting to the LEB encoding. */
9762 op = DW_OP_lit0 + i;
9765 else if (i <= 0xffff)
9767 else if (HOST_BITS_PER_WIDE_INT == 32
9777 else if (i >= -0x8000)
9779 else if (HOST_BITS_PER_WIDE_INT == 32
9780 || i >= -0x80000000)
9786 return new_loc_descr (op, i, 0);
9790 #ifdef DWARF2_DEBUGGING_INFO
9792 /* Return a location descriptor that designates a base+offset location. */
9794 static dw_loc_descr_ref
9795 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
9796 enum var_init_status initialized)
9799 dw_loc_descr_ref result;
9800 dw_fde_ref fde = current_fde ();
9802 /* We only use "frame base" when we're sure we're talking about the
9803 post-prologue local stack frame. We do this by *not* running
9804 register elimination until this point, and recognizing the special
9805 argument pointer and soft frame pointer rtx's. */
9806 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
9808 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
9812 if (GET_CODE (elim) == PLUS)
9814 offset += INTVAL (XEXP (elim, 1));
9815 elim = XEXP (elim, 0);
9817 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
9818 && (elim == hard_frame_pointer_rtx
9819 || elim == stack_pointer_rtx))
9820 || elim == (frame_pointer_needed
9821 ? hard_frame_pointer_rtx
9822 : stack_pointer_rtx));
9824 /* If drap register is used to align stack, use frame
9825 pointer + offset to access stack variables. If stack
9826 is aligned without drap, use stack pointer + offset to
9827 access stack variables. */
9828 if (crtl->stack_realign_tried
9829 && cfa.reg == HARD_FRAME_POINTER_REGNUM
9830 && reg == frame_pointer_rtx)
9833 = DWARF_FRAME_REGNUM (cfa.indirect
9834 ? HARD_FRAME_POINTER_REGNUM
9835 : STACK_POINTER_REGNUM);
9836 return new_reg_loc_descr (base_reg, offset);
9839 offset += frame_pointer_fb_offset;
9840 return new_loc_descr (DW_OP_fbreg, offset, 0);
9844 && fde->drap_reg != INVALID_REGNUM
9845 && (fde->drap_reg == REGNO (reg)
9846 || fde->vdrap_reg == REGNO (reg)))
9848 /* Use cfa+offset to represent the location of arguments passed
9849 on stack when drap is used to align stack. */
9850 return new_loc_descr (DW_OP_fbreg, offset, 0);
9853 regno = dbx_reg_number (reg);
9855 result = new_loc_descr (DW_OP_breg0 + regno, offset, 0);
9857 result = new_loc_descr (DW_OP_bregx, regno, offset);
9859 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9860 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9865 /* Return true if this RTL expression describes a base+offset calculation. */
9868 is_based_loc (const_rtx rtl)
9870 return (GET_CODE (rtl) == PLUS
9871 && ((REG_P (XEXP (rtl, 0))
9872 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
9873 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
9876 /* Return a descriptor that describes the concatenation of N locations
9877 used to form the address of a memory location. */
9879 static dw_loc_descr_ref
9880 concatn_mem_loc_descriptor (rtx concatn, enum machine_mode mode,
9881 enum var_init_status initialized)
9884 dw_loc_descr_ref cc_loc_result = NULL;
9885 unsigned int n = XVECLEN (concatn, 0);
9887 for (i = 0; i < n; ++i)
9889 dw_loc_descr_ref ref;
9890 rtx x = XVECEXP (concatn, 0, i);
9892 ref = mem_loc_descriptor (x, mode, VAR_INIT_STATUS_INITIALIZED);
9896 add_loc_descr (&cc_loc_result, ref);
9897 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9900 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9901 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9903 return cc_loc_result;
9906 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
9909 static dw_loc_descr_ref
9910 tls_mem_loc_descriptor (rtx mem)
9913 dw_loc_descr_ref loc_result, loc_result2;
9915 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
9918 base = get_base_address (MEM_EXPR (mem));
9920 || TREE_CODE (base) != VAR_DECL
9921 || !DECL_THREAD_LOCAL_P (base))
9924 loc_result = loc_descriptor_from_tree_1 (MEM_EXPR (mem), 2);
9925 if (loc_result == NULL)
9928 if (INTVAL (MEM_OFFSET (mem)))
9930 if (INTVAL (MEM_OFFSET (mem)) >= 0)
9931 add_loc_descr (&loc_result,
9932 new_loc_descr (DW_OP_plus_uconst,
9933 INTVAL (MEM_OFFSET (mem)), 0));
9936 loc_result2 = mem_loc_descriptor (MEM_OFFSET (mem), GET_MODE (mem),
9937 VAR_INIT_STATUS_INITIALIZED);
9938 if (loc_result2 == 0)
9940 add_loc_descr (&loc_result, loc_result2);
9941 add_loc_descr (&loc_result, new_loc_descr (DW_OP_plus, 0, 0));
9948 /* The following routine converts the RTL for a variable or parameter
9949 (resident in memory) into an equivalent Dwarf representation of a
9950 mechanism for getting the address of that same variable onto the top of a
9951 hypothetical "address evaluation" stack.
9953 When creating memory location descriptors, we are effectively transforming
9954 the RTL for a memory-resident object into its Dwarf postfix expression
9955 equivalent. This routine recursively descends an RTL tree, turning
9956 it into Dwarf postfix code as it goes.
9958 MODE is the mode of the memory reference, needed to handle some
9959 autoincrement addressing modes.
9961 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
9962 location list for RTL.
9964 Return 0 if we can't represent the location. */
9966 static dw_loc_descr_ref
9967 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
9968 enum var_init_status initialized)
9970 dw_loc_descr_ref mem_loc_result = NULL;
9971 enum dwarf_location_atom op;
9973 /* Note that for a dynamically sized array, the location we will generate a
9974 description of here will be the lowest numbered location which is
9975 actually within the array. That's *not* necessarily the same as the
9976 zeroth element of the array. */
9978 rtl = targetm.delegitimize_address (rtl);
9980 switch (GET_CODE (rtl))
9985 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
9986 just fall into the SUBREG code. */
9988 /* ... fall through ... */
9991 /* The case of a subreg may arise when we have a local (register)
9992 variable or a formal (register) parameter which doesn't quite fill
9993 up an entire register. For now, just assume that it is
9994 legitimate to make the Dwarf info refer to the whole register which
9995 contains the given subreg. */
9996 rtl = XEXP (rtl, 0);
9998 /* ... fall through ... */
10001 /* Whenever a register number forms a part of the description of the
10002 method for calculating the (dynamic) address of a memory resident
10003 object, DWARF rules require the register number be referred to as
10004 a "base register". This distinction is not based in any way upon
10005 what category of register the hardware believes the given register
10006 belongs to. This is strictly DWARF terminology we're dealing with
10007 here. Note that in cases where the location of a memory-resident
10008 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
10009 OP_CONST (0)) the actual DWARF location descriptor that we generate
10010 may just be OP_BASEREG (basereg). This may look deceptively like
10011 the object in question was allocated to a register (rather than in
10012 memory) so DWARF consumers need to be aware of the subtle
10013 distinction between OP_REG and OP_BASEREG. */
10014 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
10015 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
10016 else if (stack_realign_drap
10018 && crtl->args.internal_arg_pointer == rtl
10019 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
10021 /* If RTL is internal_arg_pointer, which has been optimized
10022 out, use DRAP instead. */
10023 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
10024 VAR_INIT_STATUS_INITIALIZED);
10029 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10030 VAR_INIT_STATUS_INITIALIZED);
10031 if (mem_loc_result == NULL)
10032 mem_loc_result = tls_mem_loc_descriptor (rtl);
10033 if (mem_loc_result != 0)
10034 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
10038 rtl = XEXP (rtl, 1);
10040 /* ... fall through ... */
10043 /* Some ports can transform a symbol ref into a label ref, because
10044 the symbol ref is too far away and has to be dumped into a constant
10048 /* Alternatively, the symbol in the constant pool might be referenced
10049 by a different symbol. */
10050 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
10053 rtx tmp = get_pool_constant_mark (rtl, &marked);
10055 if (GET_CODE (tmp) == SYMBOL_REF)
10058 if (CONSTANT_POOL_ADDRESS_P (tmp))
10059 get_pool_constant_mark (tmp, &marked);
10064 /* If all references to this pool constant were optimized away,
10065 it was not output and thus we can't represent it.
10066 FIXME: might try to use DW_OP_const_value here, though
10067 DW_OP_piece complicates it. */
10072 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
10073 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
10074 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
10075 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10079 /* Extract the PLUS expression nested inside and fall into
10080 PLUS code below. */
10081 rtl = XEXP (rtl, 1);
10086 /* Turn these into a PLUS expression and fall into the PLUS code
10088 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
10089 GEN_INT (GET_CODE (rtl) == PRE_INC
10090 ? GET_MODE_UNIT_SIZE (mode)
10091 : -GET_MODE_UNIT_SIZE (mode)));
10093 /* ... fall through ... */
10097 if (is_based_loc (rtl))
10098 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
10099 INTVAL (XEXP (rtl, 1)),
10100 VAR_INIT_STATUS_INITIALIZED);
10103 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
10104 VAR_INIT_STATUS_INITIALIZED);
10105 if (mem_loc_result == 0)
10108 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
10109 && INTVAL (XEXP (rtl, 1)) >= 0)
10110 add_loc_descr (&mem_loc_result,
10111 new_loc_descr (DW_OP_plus_uconst,
10112 INTVAL (XEXP (rtl, 1)), 0));
10115 dw_loc_descr_ref mem_loc_result2
10116 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10117 VAR_INIT_STATUS_INITIALIZED);
10118 if (mem_loc_result2 == 0)
10120 add_loc_descr (&mem_loc_result, mem_loc_result2);
10121 add_loc_descr (&mem_loc_result,
10122 new_loc_descr (DW_OP_plus, 0, 0));
10127 /* If a pseudo-reg is optimized away, it is possible for it to
10128 be replaced with a MEM containing a multiply or shift. */
10147 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
10148 VAR_INIT_STATUS_INITIALIZED);
10149 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10150 VAR_INIT_STATUS_INITIALIZED);
10152 if (op0 == 0 || op1 == 0)
10155 mem_loc_result = op0;
10156 add_loc_descr (&mem_loc_result, op1);
10157 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
10162 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
10166 mem_loc_result = concatn_mem_loc_descriptor (rtl, mode,
10167 VAR_INIT_STATUS_INITIALIZED);
10171 /* If delegitimize_address couldn't do anything with the UNSPEC, we
10172 can't express it in the debug info. This can happen e.g. with some
10177 gcc_unreachable ();
10180 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10181 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10183 return mem_loc_result;
10186 /* Return a descriptor that describes the concatenation of two locations.
10187 This is typically a complex variable. */
10189 static dw_loc_descr_ref
10190 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
10192 dw_loc_descr_ref cc_loc_result = NULL;
10193 dw_loc_descr_ref x0_ref = loc_descriptor (x0, VAR_INIT_STATUS_INITIALIZED);
10194 dw_loc_descr_ref x1_ref = loc_descriptor (x1, VAR_INIT_STATUS_INITIALIZED);
10196 if (x0_ref == 0 || x1_ref == 0)
10199 cc_loc_result = x0_ref;
10200 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
10202 add_loc_descr (&cc_loc_result, x1_ref);
10203 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
10205 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10206 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10208 return cc_loc_result;
10211 /* Return a descriptor that describes the concatenation of N
10214 static dw_loc_descr_ref
10215 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
10218 dw_loc_descr_ref cc_loc_result = NULL;
10219 unsigned int n = XVECLEN (concatn, 0);
10221 for (i = 0; i < n; ++i)
10223 dw_loc_descr_ref ref;
10224 rtx x = XVECEXP (concatn, 0, i);
10226 ref = loc_descriptor (x, VAR_INIT_STATUS_INITIALIZED);
10230 add_loc_descr (&cc_loc_result, ref);
10231 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
10234 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10235 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10237 return cc_loc_result;
10240 /* Output a proper Dwarf location descriptor for a variable or parameter
10241 which is either allocated in a register or in a memory location. For a
10242 register, we just generate an OP_REG and the register number. For a
10243 memory location we provide a Dwarf postfix expression describing how to
10244 generate the (dynamic) address of the object onto the address stack.
10246 If we don't know how to describe it, return 0. */
10248 static dw_loc_descr_ref
10249 loc_descriptor (rtx rtl, enum var_init_status initialized)
10251 dw_loc_descr_ref loc_result = NULL;
10253 switch (GET_CODE (rtl))
10256 /* The case of a subreg may arise when we have a local (register)
10257 variable or a formal (register) parameter which doesn't quite fill
10258 up an entire register. For now, just assume that it is
10259 legitimate to make the Dwarf info refer to the whole register which
10260 contains the given subreg. */
10261 rtl = SUBREG_REG (rtl);
10263 /* ... fall through ... */
10266 loc_result = reg_loc_descriptor (rtl, initialized);
10270 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10272 if (loc_result == NULL)
10273 loc_result = tls_mem_loc_descriptor (rtl);
10277 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
10282 loc_result = concatn_loc_descriptor (rtl, initialized);
10287 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
10289 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), initialized);
10293 rtl = XEXP (rtl, 1);
10298 rtvec par_elems = XVEC (rtl, 0);
10299 int num_elem = GET_NUM_ELEM (par_elems);
10300 enum machine_mode mode;
10303 /* Create the first one, so we have something to add to. */
10304 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
10306 if (loc_result == NULL)
10308 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
10309 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10310 for (i = 1; i < num_elem; i++)
10312 dw_loc_descr_ref temp;
10314 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
10318 add_loc_descr (&loc_result, temp);
10319 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
10320 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10326 gcc_unreachable ();
10332 /* Similar, but generate the descriptor from trees instead of rtl. This comes
10333 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
10334 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
10335 top-level invocation, and we require the address of LOC; is 0 if we require
10336 the value of LOC. */
10338 static dw_loc_descr_ref
10339 loc_descriptor_from_tree_1 (tree loc, int want_address)
10341 dw_loc_descr_ref ret, ret1;
10342 int have_address = 0;
10343 enum dwarf_location_atom op;
10345 /* ??? Most of the time we do not take proper care for sign/zero
10346 extending the values properly. Hopefully this won't be a real
10349 switch (TREE_CODE (loc))
10354 case PLACEHOLDER_EXPR:
10355 /* This case involves extracting fields from an object to determine the
10356 position of other fields. We don't try to encode this here. The
10357 only user of this is Ada, which encodes the needed information using
10358 the names of types. */
10364 case PREINCREMENT_EXPR:
10365 case PREDECREMENT_EXPR:
10366 case POSTINCREMENT_EXPR:
10367 case POSTDECREMENT_EXPR:
10368 /* There are no opcodes for these operations. */
10372 /* If we already want an address, there's nothing we can do. */
10376 /* Otherwise, process the argument and look for the address. */
10377 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
10380 if (DECL_THREAD_LOCAL_P (loc))
10384 unsigned second_op;
10386 if (targetm.have_tls)
10388 /* If this is not defined, we have no way to emit the
10390 if (!targetm.asm_out.output_dwarf_dtprel)
10393 /* The way DW_OP_GNU_push_tls_address is specified, we
10394 can only look up addresses of objects in the current
10396 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
10398 first_op = INTERNAL_DW_OP_tls_addr;
10399 second_op = DW_OP_GNU_push_tls_address;
10403 if (!targetm.emutls.debug_form_tls_address)
10405 loc = emutls_decl (loc);
10406 first_op = DW_OP_addr;
10407 second_op = DW_OP_form_tls_address;
10410 rtl = rtl_for_decl_location (loc);
10411 if (rtl == NULL_RTX)
10416 rtl = XEXP (rtl, 0);
10417 if (! CONSTANT_P (rtl))
10420 ret = new_loc_descr (first_op, 0, 0);
10421 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10422 ret->dw_loc_oprnd1.v.val_addr = rtl;
10424 ret1 = new_loc_descr (second_op, 0, 0);
10425 add_loc_descr (&ret, ret1);
10433 if (DECL_HAS_VALUE_EXPR_P (loc))
10434 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
10439 case FUNCTION_DECL:
10441 rtx rtl = rtl_for_decl_location (loc);
10443 if (rtl == NULL_RTX)
10445 else if (GET_CODE (rtl) == CONST_INT)
10447 HOST_WIDE_INT val = INTVAL (rtl);
10448 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
10449 val &= GET_MODE_MASK (DECL_MODE (loc));
10450 ret = int_loc_descriptor (val);
10452 else if (GET_CODE (rtl) == CONST_STRING)
10454 else if (CONSTANT_P (rtl))
10456 ret = new_loc_descr (DW_OP_addr, 0, 0);
10457 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10458 ret->dw_loc_oprnd1.v.val_addr = rtl;
10462 enum machine_mode mode;
10464 /* Certain constructs can only be represented at top-level. */
10465 if (want_address == 2)
10466 return loc_descriptor (rtl, VAR_INIT_STATUS_INITIALIZED);
10468 mode = GET_MODE (rtl);
10471 rtl = XEXP (rtl, 0);
10474 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10480 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10484 case COMPOUND_EXPR:
10485 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
10488 case VIEW_CONVERT_EXPR:
10491 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
10493 case COMPONENT_REF:
10494 case BIT_FIELD_REF:
10496 case ARRAY_RANGE_REF:
10499 HOST_WIDE_INT bitsize, bitpos, bytepos;
10500 enum machine_mode mode;
10502 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
10504 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
10505 &unsignedp, &volatilep, false);
10510 ret = loc_descriptor_from_tree_1 (obj, 1);
10512 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
10515 if (offset != NULL_TREE)
10517 /* Variable offset. */
10518 ret1 = loc_descriptor_from_tree_1 (offset, 0);
10521 add_loc_descr (&ret, ret1);
10522 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10525 bytepos = bitpos / BITS_PER_UNIT;
10527 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
10528 else if (bytepos < 0)
10530 add_loc_descr (&ret, int_loc_descriptor (bytepos));
10531 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10539 if (host_integerp (loc, 0))
10540 ret = int_loc_descriptor (tree_low_cst (loc, 0));
10547 /* Get an RTL for this, if something has been emitted. */
10548 rtx rtl = lookup_constant_def (loc);
10549 enum machine_mode mode;
10551 if (!rtl || !MEM_P (rtl))
10553 mode = GET_MODE (rtl);
10554 rtl = XEXP (rtl, 0);
10555 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10560 case TRUTH_AND_EXPR:
10561 case TRUTH_ANDIF_EXPR:
10566 case TRUTH_XOR_EXPR:
10571 case TRUTH_OR_EXPR:
10572 case TRUTH_ORIF_EXPR:
10577 case FLOOR_DIV_EXPR:
10578 case CEIL_DIV_EXPR:
10579 case ROUND_DIV_EXPR:
10580 case TRUNC_DIV_EXPR:
10588 case FLOOR_MOD_EXPR:
10589 case CEIL_MOD_EXPR:
10590 case ROUND_MOD_EXPR:
10591 case TRUNC_MOD_EXPR:
10604 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
10607 case POINTER_PLUS_EXPR:
10609 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
10610 && host_integerp (TREE_OPERAND (loc, 1), 0))
10612 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10616 add_loc_descr (&ret,
10617 new_loc_descr (DW_OP_plus_uconst,
10618 tree_low_cst (TREE_OPERAND (loc, 1),
10628 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10635 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10642 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10649 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10664 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10665 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10666 if (ret == 0 || ret1 == 0)
10669 add_loc_descr (&ret, ret1);
10670 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10673 case TRUTH_NOT_EXPR:
10687 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10691 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10697 const enum tree_code code =
10698 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
10700 loc = build3 (COND_EXPR, TREE_TYPE (loc),
10701 build2 (code, integer_type_node,
10702 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
10703 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
10706 /* ... fall through ... */
10710 dw_loc_descr_ref lhs
10711 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10712 dw_loc_descr_ref rhs
10713 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
10714 dw_loc_descr_ref bra_node, jump_node, tmp;
10716 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10717 if (ret == 0 || lhs == 0 || rhs == 0)
10720 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
10721 add_loc_descr (&ret, bra_node);
10723 add_loc_descr (&ret, rhs);
10724 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
10725 add_loc_descr (&ret, jump_node);
10727 add_loc_descr (&ret, lhs);
10728 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10729 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
10731 /* ??? Need a node to point the skip at. Use a nop. */
10732 tmp = new_loc_descr (DW_OP_nop, 0, 0);
10733 add_loc_descr (&ret, tmp);
10734 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10735 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
10739 case FIX_TRUNC_EXPR:
10743 /* Leave front-end specific codes as simply unknown. This comes
10744 up, for instance, with the C STMT_EXPR. */
10745 if ((unsigned int) TREE_CODE (loc)
10746 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
10749 #ifdef ENABLE_CHECKING
10750 /* Otherwise this is a generic code; we should just lists all of
10751 these explicitly. We forgot one. */
10752 gcc_unreachable ();
10754 /* In a release build, we want to degrade gracefully: better to
10755 generate incomplete debugging information than to crash. */
10760 /* Show if we can't fill the request for an address. */
10761 if (want_address && !have_address)
10764 /* If we've got an address and don't want one, dereference. */
10765 if (!want_address && have_address && ret)
10767 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
10769 if (size > DWARF2_ADDR_SIZE || size == -1)
10771 else if (size == DWARF2_ADDR_SIZE)
10774 op = DW_OP_deref_size;
10776 add_loc_descr (&ret, new_loc_descr (op, size, 0));
10782 static inline dw_loc_descr_ref
10783 loc_descriptor_from_tree (tree loc)
10785 return loc_descriptor_from_tree_1 (loc, 2);
10788 /* Given a value, round it up to the lowest multiple of `boundary'
10789 which is not less than the value itself. */
10791 static inline HOST_WIDE_INT
10792 ceiling (HOST_WIDE_INT value, unsigned int boundary)
10794 return (((value + boundary - 1) / boundary) * boundary);
10797 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
10798 pointer to the declared type for the relevant field variable, or return
10799 `integer_type_node' if the given node turns out to be an
10800 ERROR_MARK node. */
10803 field_type (const_tree decl)
10807 if (TREE_CODE (decl) == ERROR_MARK)
10808 return integer_type_node;
10810 type = DECL_BIT_FIELD_TYPE (decl);
10811 if (type == NULL_TREE)
10812 type = TREE_TYPE (decl);
10817 /* Given a pointer to a tree node, return the alignment in bits for
10818 it, or else return BITS_PER_WORD if the node actually turns out to
10819 be an ERROR_MARK node. */
10821 static inline unsigned
10822 simple_type_align_in_bits (const_tree type)
10824 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
10827 static inline unsigned
10828 simple_decl_align_in_bits (const_tree decl)
10830 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
10833 /* Return the result of rounding T up to ALIGN. */
10835 static inline HOST_WIDE_INT
10836 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
10838 /* We must be careful if T is negative because HOST_WIDE_INT can be
10839 either "above" or "below" unsigned int as per the C promotion
10840 rules, depending on the host, thus making the signedness of the
10841 direct multiplication and division unpredictable. */
10842 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
10848 return (HOST_WIDE_INT) u;
10851 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
10852 lowest addressed byte of the "containing object" for the given FIELD_DECL,
10853 or return 0 if we are unable to determine what that offset is, either
10854 because the argument turns out to be a pointer to an ERROR_MARK node, or
10855 because the offset is actually variable. (We can't handle the latter case
10858 static HOST_WIDE_INT
10859 field_byte_offset (const_tree decl)
10861 HOST_WIDE_INT object_offset_in_bits;
10862 HOST_WIDE_INT bitpos_int;
10864 if (TREE_CODE (decl) == ERROR_MARK)
10867 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
10869 /* We cannot yet cope with fields whose positions are variable, so
10870 for now, when we see such things, we simply return 0. Someday, we may
10871 be able to handle such cases, but it will be damn difficult. */
10872 if (! host_integerp (bit_position (decl), 0))
10875 bitpos_int = int_bit_position (decl);
10877 #ifdef PCC_BITFIELD_TYPE_MATTERS
10878 if (PCC_BITFIELD_TYPE_MATTERS)
10881 tree field_size_tree;
10882 HOST_WIDE_INT deepest_bitpos;
10883 unsigned HOST_WIDE_INT field_size_in_bits;
10884 unsigned int type_align_in_bits;
10885 unsigned int decl_align_in_bits;
10886 unsigned HOST_WIDE_INT type_size_in_bits;
10888 type = field_type (decl);
10889 field_size_tree = DECL_SIZE (decl);
10891 /* The size could be unspecified if there was an error, or for
10892 a flexible array member. */
10893 if (! field_size_tree)
10894 field_size_tree = bitsize_zero_node;
10896 /* If we don't know the size of the field, pretend it's a full word. */
10897 if (host_integerp (field_size_tree, 1))
10898 field_size_in_bits = tree_low_cst (field_size_tree, 1);
10900 field_size_in_bits = BITS_PER_WORD;
10902 type_size_in_bits = simple_type_size_in_bits (type);
10903 type_align_in_bits = simple_type_align_in_bits (type);
10904 decl_align_in_bits = simple_decl_align_in_bits (decl);
10906 /* The GCC front-end doesn't make any attempt to keep track of the
10907 starting bit offset (relative to the start of the containing
10908 structure type) of the hypothetical "containing object" for a
10909 bit-field. Thus, when computing the byte offset value for the
10910 start of the "containing object" of a bit-field, we must deduce
10911 this information on our own. This can be rather tricky to do in
10912 some cases. For example, handling the following structure type
10913 definition when compiling for an i386/i486 target (which only
10914 aligns long long's to 32-bit boundaries) can be very tricky:
10916 struct S { int field1; long long field2:31; };
10918 Fortunately, there is a simple rule-of-thumb which can be used
10919 in such cases. When compiling for an i386/i486, GCC will
10920 allocate 8 bytes for the structure shown above. It decides to
10921 do this based upon one simple rule for bit-field allocation.
10922 GCC allocates each "containing object" for each bit-field at
10923 the first (i.e. lowest addressed) legitimate alignment boundary
10924 (based upon the required minimum alignment for the declared
10925 type of the field) which it can possibly use, subject to the
10926 condition that there is still enough available space remaining
10927 in the containing object (when allocated at the selected point)
10928 to fully accommodate all of the bits of the bit-field itself.
10930 This simple rule makes it obvious why GCC allocates 8 bytes for
10931 each object of the structure type shown above. When looking
10932 for a place to allocate the "containing object" for `field2',
10933 the compiler simply tries to allocate a 64-bit "containing
10934 object" at each successive 32-bit boundary (starting at zero)
10935 until it finds a place to allocate that 64- bit field such that
10936 at least 31 contiguous (and previously unallocated) bits remain
10937 within that selected 64 bit field. (As it turns out, for the
10938 example above, the compiler finds it is OK to allocate the
10939 "containing object" 64-bit field at bit-offset zero within the
10942 Here we attempt to work backwards from the limited set of facts
10943 we're given, and we try to deduce from those facts, where GCC
10944 must have believed that the containing object started (within
10945 the structure type). The value we deduce is then used (by the
10946 callers of this routine) to generate DW_AT_location and
10947 DW_AT_bit_offset attributes for fields (both bit-fields and, in
10948 the case of DW_AT_location, regular fields as well). */
10950 /* Figure out the bit-distance from the start of the structure to
10951 the "deepest" bit of the bit-field. */
10952 deepest_bitpos = bitpos_int + field_size_in_bits;
10954 /* This is the tricky part. Use some fancy footwork to deduce
10955 where the lowest addressed bit of the containing object must
10957 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10959 /* Round up to type_align by default. This works best for
10961 object_offset_in_bits
10962 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
10964 if (object_offset_in_bits > bitpos_int)
10966 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10968 /* Round up to decl_align instead. */
10969 object_offset_in_bits
10970 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
10975 object_offset_in_bits = bitpos_int;
10977 return object_offset_in_bits / BITS_PER_UNIT;
10980 /* The following routines define various Dwarf attributes and any data
10981 associated with them. */
10983 /* Add a location description attribute value to a DIE.
10985 This emits location attributes suitable for whole variables and
10986 whole parameters. Note that the location attributes for struct fields are
10987 generated by the routine `data_member_location_attribute' below. */
10990 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
10991 dw_loc_descr_ref descr)
10994 add_AT_loc (die, attr_kind, descr);
10997 /* Attach the specialized form of location attribute used for data members of
10998 struct and union types. In the special case of a FIELD_DECL node which
10999 represents a bit-field, the "offset" part of this special location
11000 descriptor must indicate the distance in bytes from the lowest-addressed
11001 byte of the containing struct or union type to the lowest-addressed byte of
11002 the "containing object" for the bit-field. (See the `field_byte_offset'
11005 For any given bit-field, the "containing object" is a hypothetical object
11006 (of some integral or enum type) within which the given bit-field lives. The
11007 type of this hypothetical "containing object" is always the same as the
11008 declared type of the individual bit-field itself (for GCC anyway... the
11009 DWARF spec doesn't actually mandate this). Note that it is the size (in
11010 bytes) of the hypothetical "containing object" which will be given in the
11011 DW_AT_byte_size attribute for this bit-field. (See the
11012 `byte_size_attribute' function below.) It is also used when calculating the
11013 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
11014 function below.) */
11017 add_data_member_location_attribute (dw_die_ref die, tree decl)
11019 HOST_WIDE_INT offset;
11020 dw_loc_descr_ref loc_descr = 0;
11022 if (TREE_CODE (decl) == TREE_BINFO)
11024 /* We're working on the TAG_inheritance for a base class. */
11025 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
11027 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
11028 aren't at a fixed offset from all (sub)objects of the same
11029 type. We need to extract the appropriate offset from our
11030 vtable. The following dwarf expression means
11032 BaseAddr = ObAddr + *((*ObAddr) - Offset)
11034 This is specific to the V3 ABI, of course. */
11036 dw_loc_descr_ref tmp;
11038 /* Make a copy of the object address. */
11039 tmp = new_loc_descr (DW_OP_dup, 0, 0);
11040 add_loc_descr (&loc_descr, tmp);
11042 /* Extract the vtable address. */
11043 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11044 add_loc_descr (&loc_descr, tmp);
11046 /* Calculate the address of the offset. */
11047 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
11048 gcc_assert (offset < 0);
11050 tmp = int_loc_descriptor (-offset);
11051 add_loc_descr (&loc_descr, tmp);
11052 tmp = new_loc_descr (DW_OP_minus, 0, 0);
11053 add_loc_descr (&loc_descr, tmp);
11055 /* Extract the offset. */
11056 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11057 add_loc_descr (&loc_descr, tmp);
11059 /* Add it to the object address. */
11060 tmp = new_loc_descr (DW_OP_plus, 0, 0);
11061 add_loc_descr (&loc_descr, tmp);
11064 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
11067 offset = field_byte_offset (decl);
11071 enum dwarf_location_atom op;
11073 /* The DWARF2 standard says that we should assume that the structure
11074 address is already on the stack, so we can specify a structure field
11075 address by using DW_OP_plus_uconst. */
11077 #ifdef MIPS_DEBUGGING_INFO
11078 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
11079 operator correctly. It works only if we leave the offset on the
11083 op = DW_OP_plus_uconst;
11086 loc_descr = new_loc_descr (op, offset, 0);
11089 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
11092 /* Writes integer values to dw_vec_const array. */
11095 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
11099 *dest++ = val & 0xff;
11105 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
11107 static HOST_WIDE_INT
11108 extract_int (const unsigned char *src, unsigned int size)
11110 HOST_WIDE_INT val = 0;
11116 val |= *--src & 0xff;
11122 /* Writes floating point values to dw_vec_const array. */
11125 insert_float (const_rtx rtl, unsigned char *array)
11127 REAL_VALUE_TYPE rv;
11131 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
11132 real_to_target (val, &rv, GET_MODE (rtl));
11134 /* real_to_target puts 32-bit pieces in each long. Pack them. */
11135 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
11137 insert_int (val[i], 4, array);
11142 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
11143 does not have a "location" either in memory or in a register. These
11144 things can arise in GNU C when a constant is passed as an actual parameter
11145 to an inlined function. They can also arise in C++ where declared
11146 constants do not necessarily get memory "homes". */
11149 add_const_value_attribute (dw_die_ref die, rtx rtl)
11151 switch (GET_CODE (rtl))
11155 HOST_WIDE_INT val = INTVAL (rtl);
11158 add_AT_int (die, DW_AT_const_value, val);
11160 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
11165 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
11166 floating-point constant. A CONST_DOUBLE is used whenever the
11167 constant requires more than one word in order to be adequately
11168 represented. We output CONST_DOUBLEs as blocks. */
11170 enum machine_mode mode = GET_MODE (rtl);
11172 if (SCALAR_FLOAT_MODE_P (mode))
11174 unsigned int length = GET_MODE_SIZE (mode);
11175 unsigned char *array = GGC_NEWVEC (unsigned char, length);
11177 insert_float (rtl, array);
11178 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
11182 /* ??? We really should be using HOST_WIDE_INT throughout. */
11183 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
11185 add_AT_long_long (die, DW_AT_const_value,
11186 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
11193 enum machine_mode mode = GET_MODE (rtl);
11194 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
11195 unsigned int length = CONST_VECTOR_NUNITS (rtl);
11196 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
11200 switch (GET_MODE_CLASS (mode))
11202 case MODE_VECTOR_INT:
11203 for (i = 0, p = array; i < length; i++, p += elt_size)
11205 rtx elt = CONST_VECTOR_ELT (rtl, i);
11206 HOST_WIDE_INT lo, hi;
11208 switch (GET_CODE (elt))
11216 lo = CONST_DOUBLE_LOW (elt);
11217 hi = CONST_DOUBLE_HIGH (elt);
11221 gcc_unreachable ();
11224 if (elt_size <= sizeof (HOST_WIDE_INT))
11225 insert_int (lo, elt_size, p);
11228 unsigned char *p0 = p;
11229 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
11231 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
11232 if (WORDS_BIG_ENDIAN)
11237 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
11238 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
11243 case MODE_VECTOR_FLOAT:
11244 for (i = 0, p = array; i < length; i++, p += elt_size)
11246 rtx elt = CONST_VECTOR_ELT (rtl, i);
11247 insert_float (elt, p);
11252 gcc_unreachable ();
11255 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
11260 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
11266 add_AT_addr (die, DW_AT_const_value, rtl);
11267 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11271 /* In cases where an inlined instance of an inline function is passed
11272 the address of an `auto' variable (which is local to the caller) we
11273 can get a situation where the DECL_RTL of the artificial local
11274 variable (for the inlining) which acts as a stand-in for the
11275 corresponding formal parameter (of the inline function) will look
11276 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
11277 exactly a compile-time constant expression, but it isn't the address
11278 of the (artificial) local variable either. Rather, it represents the
11279 *value* which the artificial local variable always has during its
11280 lifetime. We currently have no way to represent such quasi-constant
11281 values in Dwarf, so for now we just punt and generate nothing. */
11285 /* No other kinds of rtx should be possible here. */
11286 gcc_unreachable ();
11291 /* Determine whether the evaluation of EXPR references any variables
11292 or functions which aren't otherwise used (and therefore may not be
11295 reference_to_unused (tree * tp, int * walk_subtrees,
11296 void * data ATTRIBUTE_UNUSED)
11298 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
11299 *walk_subtrees = 0;
11301 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
11302 && ! TREE_ASM_WRITTEN (*tp))
11304 /* ??? The C++ FE emits debug information for using decls, so
11305 putting gcc_unreachable here falls over. See PR31899. For now
11306 be conservative. */
11307 else if (!cgraph_global_info_ready
11308 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
11310 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
11312 struct varpool_node *node = varpool_node (*tp);
11316 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
11317 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
11319 struct cgraph_node *node = cgraph_node (*tp);
11323 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
11329 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
11330 for use in a later add_const_value_attribute call. */
11333 rtl_for_decl_init (tree init, tree type)
11335 rtx rtl = NULL_RTX;
11337 /* If a variable is initialized with a string constant without embedded
11338 zeros, build CONST_STRING. */
11339 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
11341 tree enttype = TREE_TYPE (type);
11342 tree domain = TYPE_DOMAIN (type);
11343 enum machine_mode mode = TYPE_MODE (enttype);
11345 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
11347 && integer_zerop (TYPE_MIN_VALUE (domain))
11348 && compare_tree_int (TYPE_MAX_VALUE (domain),
11349 TREE_STRING_LENGTH (init) - 1) == 0
11350 && ((size_t) TREE_STRING_LENGTH (init)
11351 == strlen (TREE_STRING_POINTER (init)) + 1))
11352 rtl = gen_rtx_CONST_STRING (VOIDmode,
11353 ggc_strdup (TREE_STRING_POINTER (init)));
11355 /* Other aggregates, and complex values, could be represented using
11357 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
11359 /* Vectors only work if their mode is supported by the target.
11360 FIXME: generic vectors ought to work too. */
11361 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
11363 /* If the initializer is something that we know will expand into an
11364 immediate RTL constant, expand it now. We must be careful not to
11365 reference variables which won't be output. */
11366 else if (initializer_constant_valid_p (init, type)
11367 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
11369 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
11371 if (TREE_CODE (type) == VECTOR_TYPE)
11372 switch (TREE_CODE (init))
11377 if (TREE_CONSTANT (init))
11379 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
11380 bool constant_p = true;
11382 unsigned HOST_WIDE_INT ix;
11384 /* Even when ctor is constant, it might contain non-*_CST
11385 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
11386 belong into VECTOR_CST nodes. */
11387 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
11388 if (!CONSTANT_CLASS_P (value))
11390 constant_p = false;
11396 init = build_vector_from_ctor (type, elts);
11406 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
11408 /* If expand_expr returns a MEM, it wasn't immediate. */
11409 gcc_assert (!rtl || !MEM_P (rtl));
11415 /* Generate RTL for the variable DECL to represent its location. */
11418 rtl_for_decl_location (tree decl)
11422 /* Here we have to decide where we are going to say the parameter "lives"
11423 (as far as the debugger is concerned). We only have a couple of
11424 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
11426 DECL_RTL normally indicates where the parameter lives during most of the
11427 activation of the function. If optimization is enabled however, this
11428 could be either NULL or else a pseudo-reg. Both of those cases indicate
11429 that the parameter doesn't really live anywhere (as far as the code
11430 generation parts of GCC are concerned) during most of the function's
11431 activation. That will happen (for example) if the parameter is never
11432 referenced within the function.
11434 We could just generate a location descriptor here for all non-NULL
11435 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
11436 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
11437 where DECL_RTL is NULL or is a pseudo-reg.
11439 Note however that we can only get away with using DECL_INCOMING_RTL as
11440 a backup substitute for DECL_RTL in certain limited cases. In cases
11441 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
11442 we can be sure that the parameter was passed using the same type as it is
11443 declared to have within the function, and that its DECL_INCOMING_RTL
11444 points us to a place where a value of that type is passed.
11446 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
11447 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
11448 because in these cases DECL_INCOMING_RTL points us to a value of some
11449 type which is *different* from the type of the parameter itself. Thus,
11450 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
11451 such cases, the debugger would end up (for example) trying to fetch a
11452 `float' from a place which actually contains the first part of a
11453 `double'. That would lead to really incorrect and confusing
11454 output at debug-time.
11456 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
11457 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
11458 are a couple of exceptions however. On little-endian machines we can
11459 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
11460 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
11461 an integral type that is smaller than TREE_TYPE (decl). These cases arise
11462 when (on a little-endian machine) a non-prototyped function has a
11463 parameter declared to be of type `short' or `char'. In such cases,
11464 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
11465 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
11466 passed `int' value. If the debugger then uses that address to fetch
11467 a `short' or a `char' (on a little-endian machine) the result will be
11468 the correct data, so we allow for such exceptional cases below.
11470 Note that our goal here is to describe the place where the given formal
11471 parameter lives during most of the function's activation (i.e. between the
11472 end of the prologue and the start of the epilogue). We'll do that as best
11473 as we can. Note however that if the given formal parameter is modified
11474 sometime during the execution of the function, then a stack backtrace (at
11475 debug-time) will show the function as having been called with the *new*
11476 value rather than the value which was originally passed in. This happens
11477 rarely enough that it is not a major problem, but it *is* a problem, and
11478 I'd like to fix it.
11480 A future version of dwarf2out.c may generate two additional attributes for
11481 any given DW_TAG_formal_parameter DIE which will describe the "passed
11482 type" and the "passed location" for the given formal parameter in addition
11483 to the attributes we now generate to indicate the "declared type" and the
11484 "active location" for each parameter. This additional set of attributes
11485 could be used by debuggers for stack backtraces. Separately, note that
11486 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
11487 This happens (for example) for inlined-instances of inline function formal
11488 parameters which are never referenced. This really shouldn't be
11489 happening. All PARM_DECL nodes should get valid non-NULL
11490 DECL_INCOMING_RTL values. FIXME. */
11492 /* Use DECL_RTL as the "location" unless we find something better. */
11493 rtl = DECL_RTL_IF_SET (decl);
11495 /* When generating abstract instances, ignore everything except
11496 constants, symbols living in memory, and symbols living in
11497 fixed registers. */
11498 if (! reload_completed)
11501 && (CONSTANT_P (rtl)
11503 && CONSTANT_P (XEXP (rtl, 0)))
11505 && TREE_CODE (decl) == VAR_DECL
11506 && TREE_STATIC (decl))))
11508 rtl = targetm.delegitimize_address (rtl);
11513 else if (TREE_CODE (decl) == PARM_DECL)
11515 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
11517 tree declared_type = TREE_TYPE (decl);
11518 tree passed_type = DECL_ARG_TYPE (decl);
11519 enum machine_mode dmode = TYPE_MODE (declared_type);
11520 enum machine_mode pmode = TYPE_MODE (passed_type);
11522 /* This decl represents a formal parameter which was optimized out.
11523 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
11524 all cases where (rtl == NULL_RTX) just below. */
11525 if (dmode == pmode)
11526 rtl = DECL_INCOMING_RTL (decl);
11527 else if (SCALAR_INT_MODE_P (dmode)
11528 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
11529 && DECL_INCOMING_RTL (decl))
11531 rtx inc = DECL_INCOMING_RTL (decl);
11534 else if (MEM_P (inc))
11536 if (BYTES_BIG_ENDIAN)
11537 rtl = adjust_address_nv (inc, dmode,
11538 GET_MODE_SIZE (pmode)
11539 - GET_MODE_SIZE (dmode));
11546 /* If the parm was passed in registers, but lives on the stack, then
11547 make a big endian correction if the mode of the type of the
11548 parameter is not the same as the mode of the rtl. */
11549 /* ??? This is the same series of checks that are made in dbxout.c before
11550 we reach the big endian correction code there. It isn't clear if all
11551 of these checks are necessary here, but keeping them all is the safe
11553 else if (MEM_P (rtl)
11554 && XEXP (rtl, 0) != const0_rtx
11555 && ! CONSTANT_P (XEXP (rtl, 0))
11556 /* Not passed in memory. */
11557 && !MEM_P (DECL_INCOMING_RTL (decl))
11558 /* Not passed by invisible reference. */
11559 && (!REG_P (XEXP (rtl, 0))
11560 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
11561 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
11562 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
11563 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
11566 /* Big endian correction check. */
11567 && BYTES_BIG_ENDIAN
11568 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
11569 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
11572 int offset = (UNITS_PER_WORD
11573 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
11575 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11576 plus_constant (XEXP (rtl, 0), offset));
11579 else if (TREE_CODE (decl) == VAR_DECL
11582 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
11583 && BYTES_BIG_ENDIAN)
11585 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
11586 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
11588 /* If a variable is declared "register" yet is smaller than
11589 a register, then if we store the variable to memory, it
11590 looks like we're storing a register-sized value, when in
11591 fact we are not. We need to adjust the offset of the
11592 storage location to reflect the actual value's bytes,
11593 else gdb will not be able to display it. */
11595 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11596 plus_constant (XEXP (rtl, 0), rsize-dsize));
11599 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
11600 and will have been substituted directly into all expressions that use it.
11601 C does not have such a concept, but C++ and other languages do. */
11602 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
11603 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
11606 rtl = targetm.delegitimize_address (rtl);
11608 /* If we don't look past the constant pool, we risk emitting a
11609 reference to a constant pool entry that isn't referenced from
11610 code, and thus is not emitted. */
11612 rtl = avoid_constant_pool_reference (rtl);
11617 /* We need to figure out what section we should use as the base for the
11618 address ranges where a given location is valid.
11619 1. If this particular DECL has a section associated with it, use that.
11620 2. If this function has a section associated with it, use that.
11621 3. Otherwise, use the text section.
11622 XXX: If you split a variable across multiple sections, we won't notice. */
11624 static const char *
11625 secname_for_decl (const_tree decl)
11627 const char *secname;
11629 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
11631 tree sectree = DECL_SECTION_NAME (decl);
11632 secname = TREE_STRING_POINTER (sectree);
11634 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
11636 tree sectree = DECL_SECTION_NAME (current_function_decl);
11637 secname = TREE_STRING_POINTER (sectree);
11639 else if (cfun && in_cold_section_p)
11640 secname = crtl->subsections.cold_section_label;
11642 secname = text_section_label;
11647 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
11648 returned. If so, the decl for the COMMON block is returned, and the
11649 value is the offset into the common block for the symbol. */
11652 fortran_common (tree decl, HOST_WIDE_INT *value)
11654 tree val_expr, cvar;
11655 enum machine_mode mode;
11656 HOST_WIDE_INT bitsize, bitpos;
11658 int volatilep = 0, unsignedp = 0;
11660 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
11661 it does not have a value (the offset into the common area), or if it
11662 is thread local (as opposed to global) then it isn't common, and shouldn't
11663 be handled as such. */
11664 if (TREE_CODE (decl) != VAR_DECL
11665 || !TREE_PUBLIC (decl)
11666 || !TREE_STATIC (decl)
11667 || !DECL_HAS_VALUE_EXPR_P (decl)
11671 val_expr = DECL_VALUE_EXPR (decl);
11672 if (TREE_CODE (val_expr) != COMPONENT_REF)
11675 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
11676 &mode, &unsignedp, &volatilep, true);
11678 if (cvar == NULL_TREE
11679 || TREE_CODE (cvar) != VAR_DECL
11680 || DECL_ARTIFICIAL (cvar)
11681 || !TREE_PUBLIC (cvar))
11685 if (offset != NULL)
11687 if (!host_integerp (offset, 0))
11689 *value = tree_low_cst (offset, 0);
11692 *value += bitpos / BITS_PER_UNIT;
11697 /* Dereference a location expression LOC if DECL is passed by invisible
11700 static dw_loc_descr_ref
11701 loc_by_reference (dw_loc_descr_ref loc, tree decl)
11703 HOST_WIDE_INT size;
11704 enum dwarf_location_atom op;
11709 if ((TREE_CODE (decl) != PARM_DECL && TREE_CODE (decl) != RESULT_DECL)
11710 || !DECL_BY_REFERENCE (decl))
11713 size = int_size_in_bytes (TREE_TYPE (decl));
11714 if (size > DWARF2_ADDR_SIZE || size == -1)
11716 else if (size == DWARF2_ADDR_SIZE)
11719 op = DW_OP_deref_size;
11720 add_loc_descr (&loc, new_loc_descr (op, size, 0));
11724 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
11725 data attribute for a variable or a parameter. We generate the
11726 DW_AT_const_value attribute only in those cases where the given variable
11727 or parameter does not have a true "location" either in memory or in a
11728 register. This can happen (for example) when a constant is passed as an
11729 actual argument in a call to an inline function. (It's possible that
11730 these things can crop up in other ways also.) Note that one type of
11731 constant value which can be passed into an inlined function is a constant
11732 pointer. This can happen for example if an actual argument in an inlined
11733 function call evaluates to a compile-time constant address. */
11736 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
11737 enum dwarf_attribute attr)
11740 dw_loc_descr_ref descr;
11741 var_loc_list *loc_list;
11742 struct var_loc_node *node;
11743 if (TREE_CODE (decl) == ERROR_MARK)
11746 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
11747 || TREE_CODE (decl) == RESULT_DECL);
11749 /* See if we possibly have multiple locations for this variable. */
11750 loc_list = lookup_decl_loc (decl);
11752 /* If it truly has multiple locations, the first and last node will
11754 if (loc_list && loc_list->first != loc_list->last)
11756 const char *endname, *secname;
11757 dw_loc_list_ref list;
11759 enum var_init_status initialized;
11761 /* Now that we know what section we are using for a base,
11762 actually construct the list of locations.
11763 The first location information is what is passed to the
11764 function that creates the location list, and the remaining
11765 locations just get added on to that list.
11766 Note that we only know the start address for a location
11767 (IE location changes), so to build the range, we use
11768 the range [current location start, next location start].
11769 This means we have to special case the last node, and generate
11770 a range of [last location start, end of function label]. */
11772 node = loc_list->first;
11773 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11774 secname = secname_for_decl (decl);
11776 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
11777 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11779 initialized = VAR_INIT_STATUS_INITIALIZED;
11781 descr = loc_by_reference (loc_descriptor (varloc, initialized), decl);
11782 list = new_loc_list (descr, node->label, node->next->label, secname, 1);
11785 for (; node->next; node = node->next)
11786 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11788 /* The variable has a location between NODE->LABEL and
11789 NODE->NEXT->LABEL. */
11790 enum var_init_status initialized =
11791 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11792 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11793 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11795 add_loc_descr_to_loc_list (&list, descr,
11796 node->label, node->next->label, secname);
11799 /* If the variable has a location at the last label
11800 it keeps its location until the end of function. */
11801 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11803 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11804 enum var_init_status initialized =
11805 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11807 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11808 if (!current_function_decl)
11809 endname = text_end_label;
11812 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11813 current_function_funcdef_no);
11814 endname = ggc_strdup (label_id);
11816 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11818 add_loc_descr_to_loc_list (&list, descr,
11819 node->label, endname, secname);
11822 /* Finally, add the location list to the DIE, and we are done. */
11823 add_AT_loc_list (die, attr, list);
11827 /* Try to get some constant RTL for this decl, and use that as the value of
11830 rtl = rtl_for_decl_location (decl);
11831 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
11833 add_const_value_attribute (die, rtl);
11837 /* If we have tried to generate the location otherwise, and it
11838 didn't work out (we wouldn't be here if we did), and we have a one entry
11839 location list, try generating a location from that. */
11840 if (loc_list && loc_list->first)
11842 enum var_init_status status;
11843 node = loc_list->first;
11844 status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11845 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note), status);
11848 descr = loc_by_reference (descr, decl);
11849 add_AT_location_description (die, attr, descr);
11854 /* We couldn't get any rtl, so try directly generating the location
11855 description from the tree. */
11856 descr = loc_descriptor_from_tree (decl);
11859 descr = loc_by_reference (descr, decl);
11860 add_AT_location_description (die, attr, descr);
11863 /* None of that worked, so it must not really have a location;
11864 try adding a constant value attribute from the DECL_INITIAL. */
11865 tree_add_const_value_attribute (die, decl);
11868 /* Add VARIABLE and DIE into deferred locations list. */
11871 defer_location (tree variable, dw_die_ref die)
11873 deferred_locations entry;
11874 entry.variable = variable;
11876 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
11879 /* Helper function for tree_add_const_value_attribute. Natively encode
11880 initializer INIT into an array. Return true if successful. */
11883 native_encode_initializer (tree init, unsigned char *array, int size)
11887 if (init == NULL_TREE)
11891 switch (TREE_CODE (init))
11894 type = TREE_TYPE (init);
11895 if (TREE_CODE (type) == ARRAY_TYPE)
11897 tree enttype = TREE_TYPE (type);
11898 enum machine_mode mode = TYPE_MODE (enttype);
11900 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
11902 if (int_size_in_bytes (type) != size)
11904 if (size > TREE_STRING_LENGTH (init))
11906 memcpy (array, TREE_STRING_POINTER (init),
11907 TREE_STRING_LENGTH (init));
11908 memset (array + TREE_STRING_LENGTH (init),
11909 '\0', size - TREE_STRING_LENGTH (init));
11912 memcpy (array, TREE_STRING_POINTER (init), size);
11917 type = TREE_TYPE (init);
11918 if (int_size_in_bytes (type) != size)
11920 if (TREE_CODE (type) == ARRAY_TYPE)
11922 HOST_WIDE_INT min_index;
11923 unsigned HOST_WIDE_INT cnt;
11924 int curpos = 0, fieldsize;
11925 constructor_elt *ce;
11927 if (TYPE_DOMAIN (type) == NULL_TREE
11928 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
11931 fieldsize = int_size_in_bytes (TREE_TYPE (type));
11932 if (fieldsize <= 0)
11935 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
11936 memset (array, '\0', size);
11938 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
11941 tree val = ce->value;
11942 tree index = ce->index;
11944 if (index && TREE_CODE (index) == RANGE_EXPR)
11945 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
11948 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
11953 if (!native_encode_initializer (val, array + pos, fieldsize))
11956 curpos = pos + fieldsize;
11957 if (index && TREE_CODE (index) == RANGE_EXPR)
11959 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
11960 - tree_low_cst (TREE_OPERAND (index, 0), 0);
11964 memcpy (array + curpos, array + pos, fieldsize);
11965 curpos += fieldsize;
11968 gcc_assert (curpos <= size);
11972 else if (TREE_CODE (type) == RECORD_TYPE
11973 || TREE_CODE (type) == UNION_TYPE)
11975 tree field = NULL_TREE;
11976 unsigned HOST_WIDE_INT cnt;
11977 constructor_elt *ce;
11979 if (int_size_in_bytes (type) != size)
11982 if (TREE_CODE (type) == RECORD_TYPE)
11983 field = TYPE_FIELDS (type);
11986 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
11987 cnt++, field = field ? TREE_CHAIN (field) : 0)
11989 tree val = ce->value;
11990 int pos, fieldsize;
11992 if (ce->index != 0)
11998 if (field == NULL_TREE || DECL_BIT_FIELD (field))
12001 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
12002 && TYPE_DOMAIN (TREE_TYPE (field))
12003 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
12005 else if (DECL_SIZE_UNIT (field) == NULL_TREE
12006 || !host_integerp (DECL_SIZE_UNIT (field), 0))
12008 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
12009 pos = int_byte_position (field);
12010 gcc_assert (pos + fieldsize <= size);
12012 && !native_encode_initializer (val, array + pos, fieldsize))
12018 case VIEW_CONVERT_EXPR:
12019 case NON_LVALUE_EXPR:
12020 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
12022 return native_encode_expr (init, array, size) == size;
12026 /* If we don't have a copy of this variable in memory for some reason (such
12027 as a C++ member constant that doesn't have an out-of-line definition),
12028 we should tell the debugger about the constant value. */
12031 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
12034 tree type = TREE_TYPE (decl);
12037 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
12040 init = DECL_INITIAL (decl);
12041 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
12046 rtl = rtl_for_decl_init (init, type);
12048 add_const_value_attribute (var_die, rtl);
12049 /* If the host and target are sane, try harder. */
12050 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
12051 && initializer_constant_valid_p (init, type))
12053 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
12054 if (size > 0 && (int) size == size)
12056 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
12058 if (native_encode_initializer (init, array, size))
12059 add_AT_vec (var_die, DW_AT_const_value, size, 1, array);
12064 /* Convert the CFI instructions for the current function into a
12065 location list. This is used for DW_AT_frame_base when we targeting
12066 a dwarf2 consumer that does not support the dwarf3
12067 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
12070 static dw_loc_list_ref
12071 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
12074 dw_loc_list_ref list, *list_tail;
12076 dw_cfa_location last_cfa, next_cfa;
12077 const char *start_label, *last_label, *section;
12079 fde = current_fde ();
12080 gcc_assert (fde != NULL);
12082 section = secname_for_decl (current_function_decl);
12086 next_cfa.reg = INVALID_REGNUM;
12087 next_cfa.offset = 0;
12088 next_cfa.indirect = 0;
12089 next_cfa.base_offset = 0;
12091 start_label = fde->dw_fde_begin;
12093 /* ??? Bald assumption that the CIE opcode list does not contain
12094 advance opcodes. */
12095 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
12096 lookup_cfa_1 (cfi, &next_cfa);
12098 last_cfa = next_cfa;
12099 last_label = start_label;
12101 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
12102 switch (cfi->dw_cfi_opc)
12104 case DW_CFA_set_loc:
12105 case DW_CFA_advance_loc1:
12106 case DW_CFA_advance_loc2:
12107 case DW_CFA_advance_loc4:
12108 if (!cfa_equal_p (&last_cfa, &next_cfa))
12110 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12111 start_label, last_label, section,
12114 list_tail = &(*list_tail)->dw_loc_next;
12115 last_cfa = next_cfa;
12116 start_label = last_label;
12118 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
12121 case DW_CFA_advance_loc:
12122 /* The encoding is complex enough that we should never emit this. */
12123 case DW_CFA_remember_state:
12124 case DW_CFA_restore_state:
12125 /* We don't handle these two in this function. It would be possible
12126 if it were to be required. */
12127 gcc_unreachable ();
12130 lookup_cfa_1 (cfi, &next_cfa);
12134 if (!cfa_equal_p (&last_cfa, &next_cfa))
12136 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12137 start_label, last_label, section,
12139 list_tail = &(*list_tail)->dw_loc_next;
12140 start_label = last_label;
12142 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
12143 start_label, fde->dw_fde_end, section,
12149 /* Compute a displacement from the "steady-state frame pointer" to the
12150 frame base (often the same as the CFA), and store it in
12151 frame_pointer_fb_offset. OFFSET is added to the displacement
12152 before the latter is negated. */
12155 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
12159 #ifdef FRAME_POINTER_CFA_OFFSET
12160 reg = frame_pointer_rtx;
12161 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
12163 reg = arg_pointer_rtx;
12164 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
12167 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
12168 if (GET_CODE (elim) == PLUS)
12170 offset += INTVAL (XEXP (elim, 1));
12171 elim = XEXP (elim, 0);
12174 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12175 && (elim == hard_frame_pointer_rtx
12176 || elim == stack_pointer_rtx))
12177 || elim == (frame_pointer_needed
12178 ? hard_frame_pointer_rtx
12179 : stack_pointer_rtx));
12181 frame_pointer_fb_offset = -offset;
12184 /* Generate a DW_AT_name attribute given some string value to be included as
12185 the value of the attribute. */
12188 add_name_attribute (dw_die_ref die, const char *name_string)
12190 if (name_string != NULL && *name_string != 0)
12192 if (demangle_name_func)
12193 name_string = (*demangle_name_func) (name_string);
12195 add_AT_string (die, DW_AT_name, name_string);
12199 /* Generate a DW_AT_comp_dir attribute for DIE. */
12202 add_comp_dir_attribute (dw_die_ref die)
12204 const char *wd = get_src_pwd ();
12206 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
12209 /* Given a tree node describing an array bound (either lower or upper) output
12210 a representation for that bound. */
12213 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
12215 switch (TREE_CODE (bound))
12220 /* All fixed-bounds are represented by INTEGER_CST nodes. */
12222 if (! host_integerp (bound, 0)
12223 || (bound_attr == DW_AT_lower_bound
12224 && (((is_c_family () || is_java ()) && integer_zerop (bound))
12225 || (is_fortran () && integer_onep (bound)))))
12226 /* Use the default. */
12229 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
12233 case VIEW_CONVERT_EXPR:
12234 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
12244 dw_die_ref decl_die = lookup_decl_die (bound);
12245 dw_loc_descr_ref loc;
12247 /* ??? Can this happen, or should the variable have been bound
12248 first? Probably it can, since I imagine that we try to create
12249 the types of parameters in the order in which they exist in
12250 the list, and won't have created a forward reference to a
12251 later parameter. */
12252 if (decl_die != NULL)
12253 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12256 loc = loc_descriptor_from_tree_1 (bound, 0);
12257 add_AT_location_description (subrange_die, bound_attr, loc);
12264 /* Otherwise try to create a stack operation procedure to
12265 evaluate the value of the array bound. */
12267 dw_die_ref ctx, decl_die;
12268 dw_loc_descr_ref loc;
12270 loc = loc_descriptor_from_tree (bound);
12274 if (current_function_decl == 0)
12275 ctx = comp_unit_die;
12277 ctx = lookup_decl_die (current_function_decl);
12279 decl_die = new_die (DW_TAG_variable, ctx, bound);
12280 add_AT_flag (decl_die, DW_AT_artificial, 1);
12281 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
12282 add_AT_loc (decl_die, DW_AT_location, loc);
12284 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12290 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
12291 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
12292 Note that the block of subscript information for an array type also
12293 includes information about the element type of the given array type. */
12296 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
12298 unsigned dimension_number;
12300 dw_die_ref subrange_die;
12302 for (dimension_number = 0;
12303 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
12304 type = TREE_TYPE (type), dimension_number++)
12306 tree domain = TYPE_DOMAIN (type);
12308 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
12311 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
12312 and (in GNU C only) variable bounds. Handle all three forms
12314 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
12317 /* We have an array type with specified bounds. */
12318 lower = TYPE_MIN_VALUE (domain);
12319 upper = TYPE_MAX_VALUE (domain);
12321 /* Define the index type. */
12322 if (TREE_TYPE (domain))
12324 /* ??? This is probably an Ada unnamed subrange type. Ignore the
12325 TREE_TYPE field. We can't emit debug info for this
12326 because it is an unnamed integral type. */
12327 if (TREE_CODE (domain) == INTEGER_TYPE
12328 && TYPE_NAME (domain) == NULL_TREE
12329 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
12330 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
12333 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
12337 /* ??? If upper is NULL, the array has unspecified length,
12338 but it does have a lower bound. This happens with Fortran
12340 Since the debugger is definitely going to need to know N
12341 to produce useful results, go ahead and output the lower
12342 bound solo, and hope the debugger can cope. */
12344 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
12346 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
12349 /* Otherwise we have an array type with an unspecified length. The
12350 DWARF-2 spec does not say how to handle this; let's just leave out the
12356 add_byte_size_attribute (dw_die_ref die, tree tree_node)
12360 switch (TREE_CODE (tree_node))
12365 case ENUMERAL_TYPE:
12368 case QUAL_UNION_TYPE:
12369 size = int_size_in_bytes (tree_node);
12372 /* For a data member of a struct or union, the DW_AT_byte_size is
12373 generally given as the number of bytes normally allocated for an
12374 object of the *declared* type of the member itself. This is true
12375 even for bit-fields. */
12376 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
12379 gcc_unreachable ();
12382 /* Note that `size' might be -1 when we get to this point. If it is, that
12383 indicates that the byte size of the entity in question is variable. We
12384 have no good way of expressing this fact in Dwarf at the present time,
12385 so just let the -1 pass on through. */
12386 add_AT_unsigned (die, DW_AT_byte_size, size);
12389 /* For a FIELD_DECL node which represents a bit-field, output an attribute
12390 which specifies the distance in bits from the highest order bit of the
12391 "containing object" for the bit-field to the highest order bit of the
12394 For any given bit-field, the "containing object" is a hypothetical object
12395 (of some integral or enum type) within which the given bit-field lives. The
12396 type of this hypothetical "containing object" is always the same as the
12397 declared type of the individual bit-field itself. The determination of the
12398 exact location of the "containing object" for a bit-field is rather
12399 complicated. It's handled by the `field_byte_offset' function (above).
12401 Note that it is the size (in bytes) of the hypothetical "containing object"
12402 which will be given in the DW_AT_byte_size attribute for this bit-field.
12403 (See `byte_size_attribute' above). */
12406 add_bit_offset_attribute (dw_die_ref die, tree decl)
12408 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
12409 tree type = DECL_BIT_FIELD_TYPE (decl);
12410 HOST_WIDE_INT bitpos_int;
12411 HOST_WIDE_INT highest_order_object_bit_offset;
12412 HOST_WIDE_INT highest_order_field_bit_offset;
12413 HOST_WIDE_INT unsigned bit_offset;
12415 /* Must be a field and a bit field. */
12416 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
12418 /* We can't yet handle bit-fields whose offsets are variable, so if we
12419 encounter such things, just return without generating any attribute
12420 whatsoever. Likewise for variable or too large size. */
12421 if (! host_integerp (bit_position (decl), 0)
12422 || ! host_integerp (DECL_SIZE (decl), 1))
12425 bitpos_int = int_bit_position (decl);
12427 /* Note that the bit offset is always the distance (in bits) from the
12428 highest-order bit of the "containing object" to the highest-order bit of
12429 the bit-field itself. Since the "high-order end" of any object or field
12430 is different on big-endian and little-endian machines, the computation
12431 below must take account of these differences. */
12432 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
12433 highest_order_field_bit_offset = bitpos_int;
12435 if (! BYTES_BIG_ENDIAN)
12437 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
12438 highest_order_object_bit_offset += simple_type_size_in_bits (type);
12442 = (! BYTES_BIG_ENDIAN
12443 ? highest_order_object_bit_offset - highest_order_field_bit_offset
12444 : highest_order_field_bit_offset - highest_order_object_bit_offset);
12446 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
12449 /* For a FIELD_DECL node which represents a bit field, output an attribute
12450 which specifies the length in bits of the given field. */
12453 add_bit_size_attribute (dw_die_ref die, tree decl)
12455 /* Must be a field and a bit field. */
12456 gcc_assert (TREE_CODE (decl) == FIELD_DECL
12457 && DECL_BIT_FIELD_TYPE (decl));
12459 if (host_integerp (DECL_SIZE (decl), 1))
12460 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
12463 /* If the compiled language is ANSI C, then add a 'prototyped'
12464 attribute, if arg types are given for the parameters of a function. */
12467 add_prototyped_attribute (dw_die_ref die, tree func_type)
12469 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
12470 && TYPE_ARG_TYPES (func_type) != NULL)
12471 add_AT_flag (die, DW_AT_prototyped, 1);
12474 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
12475 by looking in either the type declaration or object declaration
12478 static inline dw_die_ref
12479 add_abstract_origin_attribute (dw_die_ref die, tree origin)
12481 dw_die_ref origin_die = NULL;
12483 if (TREE_CODE (origin) != FUNCTION_DECL)
12485 /* We may have gotten separated from the block for the inlined
12486 function, if we're in an exception handler or some such; make
12487 sure that the abstract function has been written out.
12489 Doing this for nested functions is wrong, however; functions are
12490 distinct units, and our context might not even be inline. */
12494 fn = TYPE_STUB_DECL (fn);
12496 fn = decl_function_context (fn);
12498 dwarf2out_abstract_function (fn);
12501 if (DECL_P (origin))
12502 origin_die = lookup_decl_die (origin);
12503 else if (TYPE_P (origin))
12504 origin_die = lookup_type_die (origin);
12506 /* XXX: Functions that are never lowered don't always have correct block
12507 trees (in the case of java, they simply have no block tree, in some other
12508 languages). For these functions, there is nothing we can really do to
12509 output correct debug info for inlined functions in all cases. Rather
12510 than die, we'll just produce deficient debug info now, in that we will
12511 have variables without a proper abstract origin. In the future, when all
12512 functions are lowered, we should re-add a gcc_assert (origin_die)
12516 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
12520 /* We do not currently support the pure_virtual attribute. */
12523 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
12525 if (DECL_VINDEX (func_decl))
12527 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12529 if (host_integerp (DECL_VINDEX (func_decl), 0))
12530 add_AT_loc (die, DW_AT_vtable_elem_location,
12531 new_loc_descr (DW_OP_constu,
12532 tree_low_cst (DECL_VINDEX (func_decl), 0),
12535 /* GNU extension: Record what type this method came from originally. */
12536 if (debug_info_level > DINFO_LEVEL_TERSE)
12537 add_AT_die_ref (die, DW_AT_containing_type,
12538 lookup_type_die (DECL_CONTEXT (func_decl)));
12542 /* Add source coordinate attributes for the given decl. */
12545 add_src_coords_attributes (dw_die_ref die, tree decl)
12547 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12549 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
12550 add_AT_unsigned (die, DW_AT_decl_line, s.line);
12553 /* Add a DW_AT_name attribute and source coordinate attribute for the
12554 given decl, but only if it actually has a name. */
12557 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
12561 decl_name = DECL_NAME (decl);
12562 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
12564 add_name_attribute (die, dwarf2_name (decl, 0));
12565 if (! DECL_ARTIFICIAL (decl))
12566 add_src_coords_attributes (die, decl);
12568 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
12569 && TREE_PUBLIC (decl)
12570 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
12571 && !DECL_ABSTRACT (decl)
12572 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
12574 add_AT_string (die, DW_AT_MIPS_linkage_name,
12575 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
12578 #ifdef VMS_DEBUGGING_INFO
12579 /* Get the function's name, as described by its RTL. This may be different
12580 from the DECL_NAME name used in the source file. */
12581 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
12583 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
12584 XEXP (DECL_RTL (decl), 0));
12585 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
12590 /* Push a new declaration scope. */
12593 push_decl_scope (tree scope)
12595 VEC_safe_push (tree, gc, decl_scope_table, scope);
12598 /* Pop a declaration scope. */
12601 pop_decl_scope (void)
12603 VEC_pop (tree, decl_scope_table);
12606 /* Return the DIE for the scope that immediately contains this type.
12607 Non-named types get global scope. Named types nested in other
12608 types get their containing scope if it's open, or global scope
12609 otherwise. All other types (i.e. function-local named types) get
12610 the current active scope. */
12613 scope_die_for (tree t, dw_die_ref context_die)
12615 dw_die_ref scope_die = NULL;
12616 tree containing_scope;
12619 /* Non-types always go in the current scope. */
12620 gcc_assert (TYPE_P (t));
12622 containing_scope = TYPE_CONTEXT (t);
12624 /* Use the containing namespace if it was passed in (for a declaration). */
12625 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
12627 if (context_die == lookup_decl_die (containing_scope))
12630 containing_scope = NULL_TREE;
12633 /* Ignore function type "scopes" from the C frontend. They mean that
12634 a tagged type is local to a parmlist of a function declarator, but
12635 that isn't useful to DWARF. */
12636 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
12637 containing_scope = NULL_TREE;
12639 if (containing_scope == NULL_TREE)
12640 scope_die = comp_unit_die;
12641 else if (TYPE_P (containing_scope))
12643 /* For types, we can just look up the appropriate DIE. But
12644 first we check to see if we're in the middle of emitting it
12645 so we know where the new DIE should go. */
12646 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
12647 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
12652 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
12653 || TREE_ASM_WRITTEN (containing_scope));
12655 /* If none of the current dies are suitable, we get file scope. */
12656 scope_die = comp_unit_die;
12659 scope_die = lookup_type_die (containing_scope);
12662 scope_die = context_die;
12667 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
12670 local_scope_p (dw_die_ref context_die)
12672 for (; context_die; context_die = context_die->die_parent)
12673 if (context_die->die_tag == DW_TAG_inlined_subroutine
12674 || context_die->die_tag == DW_TAG_subprogram)
12680 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
12681 whether or not to treat a DIE in this context as a declaration. */
12684 class_or_namespace_scope_p (dw_die_ref context_die)
12686 return (context_die
12687 && (context_die->die_tag == DW_TAG_structure_type
12688 || context_die->die_tag == DW_TAG_class_type
12689 || context_die->die_tag == DW_TAG_interface_type
12690 || context_die->die_tag == DW_TAG_union_type
12691 || context_die->die_tag == DW_TAG_namespace));
12694 /* Many forms of DIEs require a "type description" attribute. This
12695 routine locates the proper "type descriptor" die for the type given
12696 by 'type', and adds a DW_AT_type attribute below the given die. */
12699 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
12700 int decl_volatile, dw_die_ref context_die)
12702 enum tree_code code = TREE_CODE (type);
12703 dw_die_ref type_die = NULL;
12705 /* ??? If this type is an unnamed subrange type of an integral, floating-point
12706 or fixed-point type, use the inner type. This is because we have no
12707 support for unnamed types in base_type_die. This can happen if this is
12708 an Ada subrange type. Correct solution is emit a subrange type die. */
12709 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
12710 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
12711 type = TREE_TYPE (type), code = TREE_CODE (type);
12713 if (code == ERROR_MARK
12714 /* Handle a special case. For functions whose return type is void, we
12715 generate *no* type attribute. (Note that no object may have type
12716 `void', so this only applies to function return types). */
12717 || code == VOID_TYPE)
12720 type_die = modified_type_die (type,
12721 decl_const || TYPE_READONLY (type),
12722 decl_volatile || TYPE_VOLATILE (type),
12725 if (type_die != NULL)
12726 add_AT_die_ref (object_die, DW_AT_type, type_die);
12729 /* Given an object die, add the calling convention attribute for the
12730 function call type. */
12732 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
12734 enum dwarf_calling_convention value = DW_CC_normal;
12736 value = targetm.dwarf_calling_convention (TREE_TYPE (decl));
12738 /* DWARF doesn't provide a way to identify a program's source-level
12739 entry point. DW_AT_calling_convention attributes are only meant
12740 to describe functions' calling conventions. However, lacking a
12741 better way to signal the Fortran main program, we use this for the
12742 time being, following existing custom. */
12744 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
12745 value = DW_CC_program;
12747 /* Only add the attribute if the backend requests it, and
12748 is not DW_CC_normal. */
12749 if (value && (value != DW_CC_normal))
12750 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
12753 /* Given a tree pointer to a struct, class, union, or enum type node, return
12754 a pointer to the (string) tag name for the given type, or zero if the type
12755 was declared without a tag. */
12757 static const char *
12758 type_tag (const_tree type)
12760 const char *name = 0;
12762 if (TYPE_NAME (type) != 0)
12766 /* Find the IDENTIFIER_NODE for the type name. */
12767 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
12768 t = TYPE_NAME (type);
12770 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
12771 a TYPE_DECL node, regardless of whether or not a `typedef' was
12773 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12774 && ! DECL_IGNORED_P (TYPE_NAME (type)))
12776 /* We want to be extra verbose. Don't call dwarf_name if
12777 DECL_NAME isn't set. The default hook for decl_printable_name
12778 doesn't like that, and in this context it's correct to return
12779 0, instead of "<anonymous>" or the like. */
12780 if (DECL_NAME (TYPE_NAME (type)))
12781 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
12784 /* Now get the name as a string, or invent one. */
12785 if (!name && t != 0)
12786 name = IDENTIFIER_POINTER (t);
12789 return (name == 0 || *name == '\0') ? 0 : name;
12792 /* Return the type associated with a data member, make a special check
12793 for bit field types. */
12796 member_declared_type (const_tree member)
12798 return (DECL_BIT_FIELD_TYPE (member)
12799 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
12802 /* Get the decl's label, as described by its RTL. This may be different
12803 from the DECL_NAME name used in the source file. */
12806 static const char *
12807 decl_start_label (tree decl)
12810 const char *fnname;
12812 x = DECL_RTL (decl);
12813 gcc_assert (MEM_P (x));
12816 gcc_assert (GET_CODE (x) == SYMBOL_REF);
12818 fnname = XSTR (x, 0);
12823 /* These routines generate the internal representation of the DIE's for
12824 the compilation unit. Debugging information is collected by walking
12825 the declaration trees passed in from dwarf2out_decl(). */
12828 gen_array_type_die (tree type, dw_die_ref context_die)
12830 dw_die_ref scope_die = scope_die_for (type, context_die);
12831 dw_die_ref array_die;
12833 /* GNU compilers represent multidimensional array types as sequences of one
12834 dimensional array types whose element types are themselves array types.
12835 We sometimes squish that down to a single array_type DIE with multiple
12836 subscripts in the Dwarf debugging info. The draft Dwarf specification
12837 say that we are allowed to do this kind of compression in C, because
12838 there is no difference between an array of arrays and a multidimensional
12839 array. We don't do this for Ada to remain as close as possible to the
12840 actual representation, which is especially important against the language
12841 flexibilty wrt arrays of variable size. */
12843 bool collapse_nested_arrays = !is_ada ();
12846 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
12847 DW_TAG_string_type doesn't have DW_AT_type attribute). */
12848 if (TYPE_STRING_FLAG (type)
12849 && TREE_CODE (type) == ARRAY_TYPE
12851 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
12853 HOST_WIDE_INT size;
12855 array_die = new_die (DW_TAG_string_type, scope_die, type);
12856 add_name_attribute (array_die, type_tag (type));
12857 equate_type_number_to_die (type, array_die);
12858 size = int_size_in_bytes (type);
12860 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12861 else if (TYPE_DOMAIN (type) != NULL_TREE
12862 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
12863 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12865 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
12866 dw_loc_descr_ref loc = loc_descriptor_from_tree (szdecl);
12868 size = int_size_in_bytes (TREE_TYPE (szdecl));
12869 if (loc && size > 0)
12871 add_AT_loc (array_die, DW_AT_string_length, loc);
12872 if (size != DWARF2_ADDR_SIZE)
12873 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12879 /* ??? The SGI dwarf reader fails for array of array of enum types
12880 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
12881 array type comes before the outer array type. We thus call gen_type_die
12882 before we new_die and must prevent nested array types collapsing for this
12885 #ifdef MIPS_DEBUGGING_INFO
12886 gen_type_die (TREE_TYPE (type), context_die);
12887 collapse_nested_arrays = false;
12890 array_die = new_die (DW_TAG_array_type, scope_die, type);
12891 add_name_attribute (array_die, type_tag (type));
12892 equate_type_number_to_die (type, array_die);
12894 if (TREE_CODE (type) == VECTOR_TYPE)
12896 /* The frontend feeds us a representation for the vector as a struct
12897 containing an array. Pull out the array type. */
12898 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
12899 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
12902 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
12904 && TREE_CODE (type) == ARRAY_TYPE
12905 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
12906 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
12907 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
12910 /* We default the array ordering. SDB will probably do
12911 the right things even if DW_AT_ordering is not present. It's not even
12912 an issue until we start to get into multidimensional arrays anyway. If
12913 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
12914 then we'll have to put the DW_AT_ordering attribute back in. (But if
12915 and when we find out that we need to put these in, we will only do so
12916 for multidimensional arrays. */
12917 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
12920 #ifdef MIPS_DEBUGGING_INFO
12921 /* The SGI compilers handle arrays of unknown bound by setting
12922 AT_declaration and not emitting any subrange DIEs. */
12923 if (! TYPE_DOMAIN (type))
12924 add_AT_flag (array_die, DW_AT_declaration, 1);
12927 add_subscript_info (array_die, type, collapse_nested_arrays);
12929 /* Add representation of the type of the elements of this array type and
12930 emit the corresponding DIE if we haven't done it already. */
12931 element_type = TREE_TYPE (type);
12932 if (collapse_nested_arrays)
12933 while (TREE_CODE (element_type) == ARRAY_TYPE)
12935 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
12937 element_type = TREE_TYPE (element_type);
12940 #ifndef MIPS_DEBUGGING_INFO
12941 gen_type_die (element_type, context_die);
12944 add_type_attribute (array_die, element_type, 0, 0, context_die);
12946 if (get_AT (array_die, DW_AT_name))
12947 add_pubtype (type, array_die);
12950 static dw_loc_descr_ref
12951 descr_info_loc (tree val, tree base_decl)
12953 HOST_WIDE_INT size;
12954 dw_loc_descr_ref loc, loc2;
12955 enum dwarf_location_atom op;
12957 if (val == base_decl)
12958 return new_loc_descr (DW_OP_push_object_address, 0, 0);
12960 switch (TREE_CODE (val))
12963 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12965 return loc_descriptor_from_tree_1 (val, 0);
12967 if (host_integerp (val, 0))
12968 return int_loc_descriptor (tree_low_cst (val, 0));
12971 size = int_size_in_bytes (TREE_TYPE (val));
12974 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12977 if (size == DWARF2_ADDR_SIZE)
12978 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
12980 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
12982 case POINTER_PLUS_EXPR:
12984 if (host_integerp (TREE_OPERAND (val, 1), 1)
12985 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
12988 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12991 add_loc_descr (&loc,
12992 new_loc_descr (DW_OP_plus_uconst,
12993 tree_low_cst (TREE_OPERAND (val, 1),
13000 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13003 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
13006 add_loc_descr (&loc, loc2);
13007 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
13029 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
13030 tree val, tree base_decl)
13032 dw_loc_descr_ref loc;
13034 if (host_integerp (val, 0))
13036 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
13040 loc = descr_info_loc (val, base_decl);
13044 add_AT_loc (die, attr, loc);
13047 /* This routine generates DIE for array with hidden descriptor, details
13048 are filled into *info by a langhook. */
13051 gen_descr_array_type_die (tree type, struct array_descr_info *info,
13052 dw_die_ref context_die)
13054 dw_die_ref scope_die = scope_die_for (type, context_die);
13055 dw_die_ref array_die;
13058 array_die = new_die (DW_TAG_array_type, scope_die, type);
13059 add_name_attribute (array_die, type_tag (type));
13060 equate_type_number_to_die (type, array_die);
13062 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
13064 && info->ndimensions >= 2)
13065 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
13067 if (info->data_location)
13068 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
13070 if (info->associated)
13071 add_descr_info_field (array_die, DW_AT_associated, info->associated,
13073 if (info->allocated)
13074 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
13077 for (dim = 0; dim < info->ndimensions; dim++)
13079 dw_die_ref subrange_die
13080 = new_die (DW_TAG_subrange_type, array_die, NULL);
13082 if (info->dimen[dim].lower_bound)
13084 /* If it is the default value, omit it. */
13085 if ((is_c_family () || is_java ())
13086 && integer_zerop (info->dimen[dim].lower_bound))
13088 else if (is_fortran ()
13089 && integer_onep (info->dimen[dim].lower_bound))
13092 add_descr_info_field (subrange_die, DW_AT_lower_bound,
13093 info->dimen[dim].lower_bound,
13096 if (info->dimen[dim].upper_bound)
13097 add_descr_info_field (subrange_die, DW_AT_upper_bound,
13098 info->dimen[dim].upper_bound,
13100 if (info->dimen[dim].stride)
13101 add_descr_info_field (subrange_die, DW_AT_byte_stride,
13102 info->dimen[dim].stride,
13106 gen_type_die (info->element_type, context_die);
13107 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
13109 if (get_AT (array_die, DW_AT_name))
13110 add_pubtype (type, array_die);
13115 gen_entry_point_die (tree decl, dw_die_ref context_die)
13117 tree origin = decl_ultimate_origin (decl);
13118 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
13120 if (origin != NULL)
13121 add_abstract_origin_attribute (decl_die, origin);
13124 add_name_and_src_coords_attributes (decl_die, decl);
13125 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
13126 0, 0, context_die);
13129 if (DECL_ABSTRACT (decl))
13130 equate_decl_number_to_die (decl, decl_die);
13132 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
13136 /* Walk through the list of incomplete types again, trying once more to
13137 emit full debugging info for them. */
13140 retry_incomplete_types (void)
13144 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
13145 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
13148 /* Determine what tag to use for a record type. */
13150 static enum dwarf_tag
13151 record_type_tag (tree type)
13153 if (! lang_hooks.types.classify_record)
13154 return DW_TAG_structure_type;
13156 switch (lang_hooks.types.classify_record (type))
13158 case RECORD_IS_STRUCT:
13159 return DW_TAG_structure_type;
13161 case RECORD_IS_CLASS:
13162 return DW_TAG_class_type;
13164 case RECORD_IS_INTERFACE:
13165 return DW_TAG_interface_type;
13168 gcc_unreachable ();
13172 /* Generate a DIE to represent an enumeration type. Note that these DIEs
13173 include all of the information about the enumeration values also. Each
13174 enumerated type name/value is listed as a child of the enumerated type
13178 gen_enumeration_type_die (tree type, dw_die_ref context_die)
13180 dw_die_ref type_die = lookup_type_die (type);
13182 if (type_die == NULL)
13184 type_die = new_die (DW_TAG_enumeration_type,
13185 scope_die_for (type, context_die), type);
13186 equate_type_number_to_die (type, type_die);
13187 add_name_attribute (type_die, type_tag (type));
13189 else if (! TYPE_SIZE (type))
13192 remove_AT (type_die, DW_AT_declaration);
13194 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
13195 given enum type is incomplete, do not generate the DW_AT_byte_size
13196 attribute or the DW_AT_element_list attribute. */
13197 if (TYPE_SIZE (type))
13201 TREE_ASM_WRITTEN (type) = 1;
13202 add_byte_size_attribute (type_die, type);
13203 if (TYPE_STUB_DECL (type) != NULL_TREE)
13204 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
13206 /* If the first reference to this type was as the return type of an
13207 inline function, then it may not have a parent. Fix this now. */
13208 if (type_die->die_parent == NULL)
13209 add_child_die (scope_die_for (type, context_die), type_die);
13211 for (link = TYPE_VALUES (type);
13212 link != NULL; link = TREE_CHAIN (link))
13214 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
13215 tree value = TREE_VALUE (link);
13217 add_name_attribute (enum_die,
13218 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
13220 if (TREE_CODE (value) == CONST_DECL)
13221 value = DECL_INITIAL (value);
13223 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
13224 /* DWARF2 does not provide a way of indicating whether or
13225 not enumeration constants are signed or unsigned. GDB
13226 always assumes the values are signed, so we output all
13227 values as if they were signed. That means that
13228 enumeration constants with very large unsigned values
13229 will appear to have negative values in the debugger. */
13230 add_AT_int (enum_die, DW_AT_const_value,
13231 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
13235 add_AT_flag (type_die, DW_AT_declaration, 1);
13237 if (get_AT (type_die, DW_AT_name))
13238 add_pubtype (type, type_die);
13243 /* Generate a DIE to represent either a real live formal parameter decl or to
13244 represent just the type of some formal parameter position in some function
13247 Note that this routine is a bit unusual because its argument may be a
13248 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
13249 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
13250 node. If it's the former then this function is being called to output a
13251 DIE to represent a formal parameter object (or some inlining thereof). If
13252 it's the latter, then this function is only being called to output a
13253 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
13254 argument type of some subprogram type. */
13257 gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
13259 tree node_or_origin = node ? node : origin;
13260 dw_die_ref parm_die
13261 = new_die (DW_TAG_formal_parameter, context_die, node);
13263 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
13265 case tcc_declaration:
13267 origin = decl_ultimate_origin (node);
13268 if (origin != NULL)
13269 add_abstract_origin_attribute (parm_die, origin);
13272 tree type = TREE_TYPE (node);
13273 add_name_and_src_coords_attributes (parm_die, node);
13274 if (DECL_BY_REFERENCE (node))
13275 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
13278 add_type_attribute (parm_die, type,
13279 TREE_READONLY (node),
13280 TREE_THIS_VOLATILE (node),
13282 if (DECL_ARTIFICIAL (node))
13283 add_AT_flag (parm_die, DW_AT_artificial, 1);
13287 equate_decl_number_to_die (node, parm_die);
13288 if (! DECL_ABSTRACT (node_or_origin))
13289 add_location_or_const_value_attribute (parm_die, node_or_origin,
13295 /* We were called with some kind of a ..._TYPE node. */
13296 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
13300 gcc_unreachable ();
13306 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
13307 at the end of an (ANSI prototyped) formal parameters list. */
13310 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
13312 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
13315 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
13316 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
13317 parameters as specified in some function type specification (except for
13318 those which appear as part of a function *definition*). */
13321 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
13324 tree formal_type = NULL;
13325 tree first_parm_type;
13328 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
13330 arg = DECL_ARGUMENTS (function_or_method_type);
13331 function_or_method_type = TREE_TYPE (function_or_method_type);
13336 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
13338 /* Make our first pass over the list of formal parameter types and output a
13339 DW_TAG_formal_parameter DIE for each one. */
13340 for (link = first_parm_type; link; )
13342 dw_die_ref parm_die;
13344 formal_type = TREE_VALUE (link);
13345 if (formal_type == void_type_node)
13348 /* Output a (nameless) DIE to represent the formal parameter itself. */
13349 parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
13350 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
13351 && link == first_parm_type)
13352 || (arg && DECL_ARTIFICIAL (arg)))
13353 add_AT_flag (parm_die, DW_AT_artificial, 1);
13355 link = TREE_CHAIN (link);
13357 arg = TREE_CHAIN (arg);
13360 /* If this function type has an ellipsis, add a
13361 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
13362 if (formal_type != void_type_node)
13363 gen_unspecified_parameters_die (function_or_method_type, context_die);
13365 /* Make our second (and final) pass over the list of formal parameter types
13366 and output DIEs to represent those types (as necessary). */
13367 for (link = TYPE_ARG_TYPES (function_or_method_type);
13368 link && TREE_VALUE (link);
13369 link = TREE_CHAIN (link))
13370 gen_type_die (TREE_VALUE (link), context_die);
13373 /* We want to generate the DIE for TYPE so that we can generate the
13374 die for MEMBER, which has been defined; we will need to refer back
13375 to the member declaration nested within TYPE. If we're trying to
13376 generate minimal debug info for TYPE, processing TYPE won't do the
13377 trick; we need to attach the member declaration by hand. */
13380 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
13382 gen_type_die (type, context_die);
13384 /* If we're trying to avoid duplicate debug info, we may not have
13385 emitted the member decl for this function. Emit it now. */
13386 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
13387 && ! lookup_decl_die (member))
13389 dw_die_ref type_die;
13390 gcc_assert (!decl_ultimate_origin (member));
13392 push_decl_scope (type);
13393 type_die = lookup_type_die (type);
13394 if (TREE_CODE (member) == FUNCTION_DECL)
13395 gen_subprogram_die (member, type_die);
13396 else if (TREE_CODE (member) == FIELD_DECL)
13398 /* Ignore the nameless fields that are used to skip bits but handle
13399 C++ anonymous unions and structs. */
13400 if (DECL_NAME (member) != NULL_TREE
13401 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
13402 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
13404 gen_type_die (member_declared_type (member), type_die);
13405 gen_field_die (member, type_die);
13409 gen_variable_die (member, NULL_TREE, type_die);
13415 /* Generate the DWARF2 info for the "abstract" instance of a function which we
13416 may later generate inlined and/or out-of-line instances of. */
13419 dwarf2out_abstract_function (tree decl)
13421 dw_die_ref old_die;
13424 int was_abstract = DECL_ABSTRACT (decl);
13426 /* Make sure we have the actual abstract inline, not a clone. */
13427 decl = DECL_ORIGIN (decl);
13429 old_die = lookup_decl_die (decl);
13430 if (old_die && get_AT (old_die, DW_AT_inline))
13431 /* We've already generated the abstract instance. */
13434 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
13435 we don't get confused by DECL_ABSTRACT. */
13436 if (debug_info_level > DINFO_LEVEL_TERSE)
13438 context = decl_class_context (decl);
13440 gen_type_die_for_member
13441 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
13444 /* Pretend we've just finished compiling this function. */
13445 save_fn = current_function_decl;
13446 current_function_decl = decl;
13447 push_cfun (DECL_STRUCT_FUNCTION (decl));
13449 set_decl_abstract_flags (decl, 1);
13450 dwarf2out_decl (decl);
13451 if (! was_abstract)
13452 set_decl_abstract_flags (decl, 0);
13454 current_function_decl = save_fn;
13458 /* Helper function of premark_used_types() which gets called through
13459 htab_traverse_resize().
13461 Marks the DIE of a given type in *SLOT as perennial, so it never gets
13462 marked as unused by prune_unused_types. */
13464 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
13469 type = (tree) *slot;
13470 die = lookup_type_die (type);
13472 die->die_perennial_p = 1;
13476 /* Mark all members of used_types_hash as perennial. */
13478 premark_used_types (void)
13480 if (cfun && cfun->used_types_hash)
13481 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
13484 /* Generate a DIE to represent a declared function (either file-scope or
13488 gen_subprogram_die (tree decl, dw_die_ref context_die)
13490 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
13491 tree origin = decl_ultimate_origin (decl);
13492 dw_die_ref subr_die;
13495 dw_die_ref old_die = lookup_decl_die (decl);
13496 int declaration = (current_function_decl != decl
13497 || class_or_namespace_scope_p (context_die));
13499 premark_used_types ();
13501 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
13502 started to generate the abstract instance of an inline, decided to output
13503 its containing class, and proceeded to emit the declaration of the inline
13504 from the member list for the class. If so, DECLARATION takes priority;
13505 we'll get back to the abstract instance when done with the class. */
13507 /* The class-scope declaration DIE must be the primary DIE. */
13508 if (origin && declaration && class_or_namespace_scope_p (context_die))
13511 gcc_assert (!old_die);
13514 /* Now that the C++ front end lazily declares artificial member fns, we
13515 might need to retrofit the declaration into its class. */
13516 if (!declaration && !origin && !old_die
13517 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
13518 && !class_or_namespace_scope_p (context_die)
13519 && debug_info_level > DINFO_LEVEL_TERSE)
13520 old_die = force_decl_die (decl);
13522 if (origin != NULL)
13524 gcc_assert (!declaration || local_scope_p (context_die));
13526 /* Fixup die_parent for the abstract instance of a nested
13527 inline function. */
13528 if (old_die && old_die->die_parent == NULL)
13529 add_child_die (context_die, old_die);
13531 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13532 add_abstract_origin_attribute (subr_die, origin);
13536 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
13537 struct dwarf_file_data * file_index = lookup_filename (s.file);
13539 if (!get_AT_flag (old_die, DW_AT_declaration)
13540 /* We can have a normal definition following an inline one in the
13541 case of redefinition of GNU C extern inlines.
13542 It seems reasonable to use AT_specification in this case. */
13543 && !get_AT (old_die, DW_AT_inline))
13545 /* Detect and ignore this case, where we are trying to output
13546 something we have already output. */
13550 /* If the definition comes from the same place as the declaration,
13551 maybe use the old DIE. We always want the DIE for this function
13552 that has the *_pc attributes to be under comp_unit_die so the
13553 debugger can find it. We also need to do this for abstract
13554 instances of inlines, since the spec requires the out-of-line copy
13555 to have the same parent. For local class methods, this doesn't
13556 apply; we just use the old DIE. */
13557 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
13558 && (DECL_ARTIFICIAL (decl)
13559 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
13560 && (get_AT_unsigned (old_die, DW_AT_decl_line)
13561 == (unsigned) s.line))))
13563 subr_die = old_die;
13565 /* Clear out the declaration attribute and the formal parameters.
13566 Do not remove all children, because it is possible that this
13567 declaration die was forced using force_decl_die(). In such
13568 cases die that forced declaration die (e.g. TAG_imported_module)
13569 is one of the children that we do not want to remove. */
13570 remove_AT (subr_die, DW_AT_declaration);
13571 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
13575 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13576 add_AT_specification (subr_die, old_die);
13577 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
13578 add_AT_file (subr_die, DW_AT_decl_file, file_index);
13579 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
13580 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
13585 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13587 if (TREE_PUBLIC (decl))
13588 add_AT_flag (subr_die, DW_AT_external, 1);
13590 add_name_and_src_coords_attributes (subr_die, decl);
13591 if (debug_info_level > DINFO_LEVEL_TERSE)
13593 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
13594 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
13595 0, 0, context_die);
13598 add_pure_or_virtual_attribute (subr_die, decl);
13599 if (DECL_ARTIFICIAL (decl))
13600 add_AT_flag (subr_die, DW_AT_artificial, 1);
13602 if (TREE_PROTECTED (decl))
13603 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
13604 else if (TREE_PRIVATE (decl))
13605 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
13610 if (!old_die || !get_AT (old_die, DW_AT_inline))
13612 add_AT_flag (subr_die, DW_AT_declaration, 1);
13614 /* The first time we see a member function, it is in the context of
13615 the class to which it belongs. We make sure of this by emitting
13616 the class first. The next time is the definition, which is
13617 handled above. The two may come from the same source text.
13619 Note that force_decl_die() forces function declaration die. It is
13620 later reused to represent definition. */
13621 equate_decl_number_to_die (decl, subr_die);
13624 else if (DECL_ABSTRACT (decl))
13626 if (DECL_DECLARED_INLINE_P (decl))
13628 if (cgraph_function_possibly_inlined_p (decl))
13629 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
13631 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
13635 if (cgraph_function_possibly_inlined_p (decl))
13636 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
13638 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
13641 if (DECL_DECLARED_INLINE_P (decl)
13642 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
13643 add_AT_flag (subr_die, DW_AT_artificial, 1);
13645 equate_decl_number_to_die (decl, subr_die);
13647 else if (!DECL_EXTERNAL (decl))
13649 HOST_WIDE_INT cfa_fb_offset;
13651 if (!old_die || !get_AT (old_die, DW_AT_inline))
13652 equate_decl_number_to_die (decl, subr_die);
13654 if (!flag_reorder_blocks_and_partition)
13656 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
13657 current_function_funcdef_no);
13658 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
13659 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
13660 current_function_funcdef_no);
13661 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
13663 add_pubname (decl, subr_die);
13664 add_arange (decl, subr_die);
13667 { /* Do nothing for now; maybe need to duplicate die, one for
13668 hot section and one for cold section, then use the hot/cold
13669 section begin/end labels to generate the aranges... */
13671 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
13672 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
13673 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
13674 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
13676 add_pubname (decl, subr_die);
13677 add_arange (decl, subr_die);
13678 add_arange (decl, subr_die);
13682 #ifdef MIPS_DEBUGGING_INFO
13683 /* Add a reference to the FDE for this routine. */
13684 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
13687 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
13689 /* We define the "frame base" as the function's CFA. This is more
13690 convenient for several reasons: (1) It's stable across the prologue
13691 and epilogue, which makes it better than just a frame pointer,
13692 (2) With dwarf3, there exists a one-byte encoding that allows us
13693 to reference the .debug_frame data by proxy, but failing that,
13694 (3) We can at least reuse the code inspection and interpretation
13695 code that determines the CFA position at various points in the
13697 /* ??? Use some command-line or configury switch to enable the use
13698 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
13699 consumers that understand it; fall back to "pure" dwarf2 and
13700 convert the CFA data into a location list. */
13702 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
13703 if (list->dw_loc_next)
13704 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
13706 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
13709 /* Compute a displacement from the "steady-state frame pointer" to
13710 the CFA. The former is what all stack slots and argument slots
13711 will reference in the rtl; the later is what we've told the
13712 debugger about. We'll need to adjust all frame_base references
13713 by this displacement. */
13714 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
13716 if (cfun->static_chain_decl)
13717 add_AT_location_description (subr_die, DW_AT_static_link,
13718 loc_descriptor_from_tree (cfun->static_chain_decl));
13721 /* Now output descriptions of the arguments for this function. This gets
13722 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
13723 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
13724 `...' at the end of the formal parameter list. In order to find out if
13725 there was a trailing ellipsis or not, we must instead look at the type
13726 associated with the FUNCTION_DECL. This will be a node of type
13727 FUNCTION_TYPE. If the chain of type nodes hanging off of this
13728 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
13729 an ellipsis at the end. */
13731 /* In the case where we are describing a mere function declaration, all we
13732 need to do here (and all we *can* do here) is to describe the *types* of
13733 its formal parameters. */
13734 if (debug_info_level <= DINFO_LEVEL_TERSE)
13736 else if (declaration)
13737 gen_formal_types_die (decl, subr_die);
13740 /* Generate DIEs to represent all known formal parameters. */
13741 tree arg_decls = DECL_ARGUMENTS (decl);
13744 /* When generating DIEs, generate the unspecified_parameters DIE
13745 instead if we come across the arg "__builtin_va_alist" */
13746 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
13747 if (TREE_CODE (parm) == PARM_DECL)
13749 if (DECL_NAME (parm)
13750 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
13751 "__builtin_va_alist"))
13752 gen_unspecified_parameters_die (parm, subr_die);
13754 gen_decl_die (parm, NULL, subr_die);
13757 /* Decide whether we need an unspecified_parameters DIE at the end.
13758 There are 2 more cases to do this for: 1) the ansi ... declaration -
13759 this is detectable when the end of the arg list is not a
13760 void_type_node 2) an unprototyped function declaration (not a
13761 definition). This just means that we have no info about the
13762 parameters at all. */
13763 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
13764 if (fn_arg_types != NULL)
13766 /* This is the prototyped case, check for.... */
13767 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
13768 gen_unspecified_parameters_die (decl, subr_die);
13770 else if (DECL_INITIAL (decl) == NULL_TREE)
13771 gen_unspecified_parameters_die (decl, subr_die);
13774 /* Output Dwarf info for all of the stuff within the body of the function
13775 (if it has one - it may be just a declaration). */
13776 outer_scope = DECL_INITIAL (decl);
13778 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
13779 a function. This BLOCK actually represents the outermost binding contour
13780 for the function, i.e. the contour in which the function's formal
13781 parameters and labels get declared. Curiously, it appears that the front
13782 end doesn't actually put the PARM_DECL nodes for the current function onto
13783 the BLOCK_VARS list for this outer scope, but are strung off of the
13784 DECL_ARGUMENTS list for the function instead.
13786 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
13787 the LABEL_DECL nodes for the function however, and we output DWARF info
13788 for those in decls_for_scope. Just within the `outer_scope' there will be
13789 a BLOCK node representing the function's outermost pair of curly braces,
13790 and any blocks used for the base and member initializers of a C++
13791 constructor function. */
13792 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
13794 /* Emit a DW_TAG_variable DIE for a named return value. */
13795 if (DECL_NAME (DECL_RESULT (decl)))
13796 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
13798 current_function_has_inlines = 0;
13799 decls_for_scope (outer_scope, subr_die, 0);
13801 #if 0 && defined (MIPS_DEBUGGING_INFO)
13802 if (current_function_has_inlines)
13804 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
13805 if (! comp_unit_has_inlines)
13807 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
13808 comp_unit_has_inlines = 1;
13813 /* Add the calling convention attribute if requested. */
13814 add_calling_convention_attribute (subr_die, decl);
13818 /* Returns a hash value for X (which really is a die_struct). */
13821 common_block_die_table_hash (const void *x)
13823 const_dw_die_ref d = (const_dw_die_ref) x;
13824 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
13827 /* Return nonzero if decl_id and die_parent of die_struct X is the same
13828 as decl_id and die_parent of die_struct Y. */
13831 common_block_die_table_eq (const void *x, const void *y)
13833 const_dw_die_ref d = (const_dw_die_ref) x;
13834 const_dw_die_ref e = (const_dw_die_ref) y;
13835 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
13838 /* Generate a DIE to represent a declared data object.
13839 Either DECL or ORIGIN must be non-null. */
13842 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
13846 tree decl_or_origin = decl ? decl : origin;
13847 dw_die_ref var_die;
13848 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
13849 dw_die_ref origin_die;
13850 int declaration = (DECL_EXTERNAL (decl_or_origin)
13851 /* If DECL is COMDAT and has not actually been
13852 emitted, we cannot take its address; there
13853 might end up being no definition anywhere in
13854 the program. For example, consider the C++
13858 struct S { static const int i = 7; };
13863 int f() { return S<int>::i; }
13865 Here, S<int>::i is not DECL_EXTERNAL, but no
13866 definition is required, so the compiler will
13867 not emit a definition. */
13868 || (TREE_CODE (decl_or_origin) == VAR_DECL
13869 && DECL_COMDAT (decl_or_origin)
13870 && !TREE_ASM_WRITTEN (decl_or_origin))
13871 || class_or_namespace_scope_p (context_die));
13874 origin = decl_ultimate_origin (decl);
13876 com_decl = fortran_common (decl_or_origin, &off);
13878 /* Symbol in common gets emitted as a child of the common block, in the form
13879 of a data member. */
13883 dw_die_ref com_die;
13884 dw_loc_descr_ref loc;
13885 die_node com_die_arg;
13887 var_die = lookup_decl_die (decl_or_origin);
13890 if (get_AT (var_die, DW_AT_location) == NULL)
13892 loc = loc_descriptor_from_tree (com_decl);
13897 /* Optimize the common case. */
13898 if (loc->dw_loc_opc == DW_OP_addr
13899 && loc->dw_loc_next == NULL
13900 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr)
13902 loc->dw_loc_oprnd1.v.val_addr
13903 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
13905 add_loc_descr (&loc,
13906 new_loc_descr (DW_OP_plus_uconst,
13909 add_AT_loc (var_die, DW_AT_location, loc);
13910 remove_AT (var_die, DW_AT_declaration);
13916 if (common_block_die_table == NULL)
13917 common_block_die_table
13918 = htab_create_ggc (10, common_block_die_table_hash,
13919 common_block_die_table_eq, NULL);
13921 field = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
13922 com_die_arg.decl_id = DECL_UID (com_decl);
13923 com_die_arg.die_parent = context_die;
13924 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
13925 loc = loc_descriptor_from_tree (com_decl);
13926 if (com_die == NULL)
13929 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
13932 com_die = new_die (DW_TAG_common_block, context_die, decl);
13933 add_name_and_src_coords_attributes (com_die, com_decl);
13936 add_AT_loc (com_die, DW_AT_location, loc);
13937 /* Avoid sharing the same loc descriptor between
13938 DW_TAG_common_block and DW_TAG_variable. */
13939 loc = loc_descriptor_from_tree (com_decl);
13941 else if (DECL_EXTERNAL (decl))
13942 add_AT_flag (com_die, DW_AT_declaration, 1);
13943 add_pubname_string (cnam, com_die); /* ??? needed? */
13944 com_die->decl_id = DECL_UID (com_decl);
13945 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
13946 *slot = (void *) com_die;
13948 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
13950 add_AT_loc (com_die, DW_AT_location, loc);
13951 loc = loc_descriptor_from_tree (com_decl);
13952 remove_AT (com_die, DW_AT_declaration);
13954 var_die = new_die (DW_TAG_variable, com_die, decl);
13955 add_name_and_src_coords_attributes (var_die, decl);
13956 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
13957 TREE_THIS_VOLATILE (decl), context_die);
13958 add_AT_flag (var_die, DW_AT_external, 1);
13963 /* Optimize the common case. */
13964 if (loc->dw_loc_opc == DW_OP_addr
13965 && loc->dw_loc_next == NULL
13966 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
13967 loc->dw_loc_oprnd1.v.val_addr
13968 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
13970 add_loc_descr (&loc, new_loc_descr (DW_OP_plus_uconst,
13973 add_AT_loc (var_die, DW_AT_location, loc);
13975 else if (DECL_EXTERNAL (decl))
13976 add_AT_flag (var_die, DW_AT_declaration, 1);
13977 equate_decl_number_to_die (decl, var_die);
13981 /* If the compiler emitted a definition for the DECL declaration
13982 and if we already emitted a DIE for it, don't emit a second
13983 DIE for it again. */
13986 && old_die->die_parent == context_die)
13989 var_die = new_die (DW_TAG_variable, context_die, decl);
13992 if (origin != NULL)
13993 origin_die = add_abstract_origin_attribute (var_die, origin);
13995 /* Loop unrolling can create multiple blocks that refer to the same
13996 static variable, so we must test for the DW_AT_declaration flag.
13998 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
13999 copy decls and set the DECL_ABSTRACT flag on them instead of
14002 ??? Duplicated blocks have been rewritten to use .debug_ranges.
14004 ??? The declare_in_namespace support causes us to get two DIEs for one
14005 variable, both of which are declarations. We want to avoid considering
14006 one to be a specification, so we must test that this DIE is not a
14008 else if (old_die && TREE_STATIC (decl) && ! declaration
14009 && get_AT_flag (old_die, DW_AT_declaration) == 1)
14011 /* This is a definition of a C++ class level static. */
14012 add_AT_specification (var_die, old_die);
14013 if (DECL_NAME (decl))
14015 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
14016 struct dwarf_file_data * file_index = lookup_filename (s.file);
14018 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
14019 add_AT_file (var_die, DW_AT_decl_file, file_index);
14021 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
14022 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
14027 tree type = TREE_TYPE (decl);
14029 add_name_and_src_coords_attributes (var_die, decl);
14030 if ((TREE_CODE (decl) == PARM_DECL
14031 || TREE_CODE (decl) == RESULT_DECL)
14032 && DECL_BY_REFERENCE (decl))
14033 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
14035 add_type_attribute (var_die, type, TREE_READONLY (decl),
14036 TREE_THIS_VOLATILE (decl), context_die);
14038 if (TREE_PUBLIC (decl))
14039 add_AT_flag (var_die, DW_AT_external, 1);
14041 if (DECL_ARTIFICIAL (decl))
14042 add_AT_flag (var_die, DW_AT_artificial, 1);
14044 if (TREE_PROTECTED (decl))
14045 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
14046 else if (TREE_PRIVATE (decl))
14047 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
14051 add_AT_flag (var_die, DW_AT_declaration, 1);
14053 if (decl && (DECL_ABSTRACT (decl) || declaration))
14054 equate_decl_number_to_die (decl, var_die);
14057 && (! DECL_ABSTRACT (decl_or_origin)
14058 /* Local static vars are shared between all clones/inlines,
14059 so emit DW_AT_location on the abstract DIE if DECL_RTL is
14061 || (TREE_CODE (decl_or_origin) == VAR_DECL
14062 && TREE_STATIC (decl_or_origin)
14063 && DECL_RTL_SET_P (decl_or_origin)))
14064 /* When abstract origin already has DW_AT_location attribute, no need
14065 to add it again. */
14066 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
14068 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
14069 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
14070 defer_location (decl_or_origin, var_die);
14072 add_location_or_const_value_attribute (var_die,
14075 add_pubname (decl_or_origin, var_die);
14078 tree_add_const_value_attribute (var_die, decl_or_origin);
14081 /* Generate a DIE to represent a named constant. */
14084 gen_const_die (tree decl, dw_die_ref context_die)
14086 dw_die_ref const_die;
14087 tree type = TREE_TYPE (decl);
14089 const_die = new_die (DW_TAG_constant, context_die, decl);
14090 add_name_and_src_coords_attributes (const_die, decl);
14091 add_type_attribute (const_die, type, 1, 0, context_die);
14092 if (TREE_PUBLIC (decl))
14093 add_AT_flag (const_die, DW_AT_external, 1);
14094 if (DECL_ARTIFICIAL (decl))
14095 add_AT_flag (const_die, DW_AT_artificial, 1);
14096 tree_add_const_value_attribute (const_die, decl);
14099 /* Generate a DIE to represent a label identifier. */
14102 gen_label_die (tree decl, dw_die_ref context_die)
14104 tree origin = decl_ultimate_origin (decl);
14105 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
14107 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14109 if (origin != NULL)
14110 add_abstract_origin_attribute (lbl_die, origin);
14112 add_name_and_src_coords_attributes (lbl_die, decl);
14114 if (DECL_ABSTRACT (decl))
14115 equate_decl_number_to_die (decl, lbl_die);
14118 insn = DECL_RTL_IF_SET (decl);
14120 /* Deleted labels are programmer specified labels which have been
14121 eliminated because of various optimizations. We still emit them
14122 here so that it is possible to put breakpoints on them. */
14126 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
14128 /* When optimization is enabled (via -O) some parts of the compiler
14129 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
14130 represent source-level labels which were explicitly declared by
14131 the user. This really shouldn't be happening though, so catch
14132 it if it ever does happen. */
14133 gcc_assert (!INSN_DELETED_P (insn));
14135 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
14136 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
14141 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
14142 attributes to the DIE for a block STMT, to describe where the inlined
14143 function was called from. This is similar to add_src_coords_attributes. */
14146 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
14148 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
14150 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
14151 add_AT_unsigned (die, DW_AT_call_line, s.line);
14155 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
14156 Add low_pc and high_pc attributes to the DIE for a block STMT. */
14159 add_high_low_attributes (tree stmt, dw_die_ref die)
14161 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14163 if (BLOCK_FRAGMENT_CHAIN (stmt))
14167 if (inlined_function_outer_scope_p (stmt))
14169 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14170 BLOCK_NUMBER (stmt));
14171 add_AT_lbl_id (die, DW_AT_entry_pc, label);
14174 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
14176 chain = BLOCK_FRAGMENT_CHAIN (stmt);
14179 add_ranges (chain);
14180 chain = BLOCK_FRAGMENT_CHAIN (chain);
14187 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14188 BLOCK_NUMBER (stmt));
14189 add_AT_lbl_id (die, DW_AT_low_pc, label);
14190 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
14191 BLOCK_NUMBER (stmt));
14192 add_AT_lbl_id (die, DW_AT_high_pc, label);
14196 /* Generate a DIE for a lexical block. */
14199 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
14201 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
14203 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
14204 add_high_low_attributes (stmt, stmt_die);
14206 decls_for_scope (stmt, stmt_die, depth);
14209 /* Generate a DIE for an inlined subprogram. */
14212 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
14214 tree decl = block_ultimate_origin (stmt);
14216 /* Emit info for the abstract instance first, if we haven't yet. We
14217 must emit this even if the block is abstract, otherwise when we
14218 emit the block below (or elsewhere), we may end up trying to emit
14219 a die whose origin die hasn't been emitted, and crashing. */
14220 dwarf2out_abstract_function (decl);
14222 if (! BLOCK_ABSTRACT (stmt))
14224 dw_die_ref subr_die
14225 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
14227 add_abstract_origin_attribute (subr_die, decl);
14228 if (TREE_ASM_WRITTEN (stmt))
14229 add_high_low_attributes (stmt, subr_die);
14230 add_call_src_coords_attributes (stmt, subr_die);
14232 decls_for_scope (stmt, subr_die, depth);
14233 current_function_has_inlines = 1;
14236 /* We may get here if we're the outer block of function A that was
14237 inlined into function B that was inlined into function C. When
14238 generating debugging info for C, dwarf2out_abstract_function(B)
14239 would mark all inlined blocks as abstract, including this one.
14240 So, we wouldn't (and shouldn't) expect labels to be generated
14241 for this one. Instead, just emit debugging info for
14242 declarations within the block. This is particularly important
14243 in the case of initializers of arguments passed from B to us:
14244 if they're statement expressions containing declarations, we
14245 wouldn't generate dies for their abstract variables, and then,
14246 when generating dies for the real variables, we'd die (pun
14248 gen_lexical_block_die (stmt, context_die, depth);
14251 /* Generate a DIE for a field in a record, or structure. */
14254 gen_field_die (tree decl, dw_die_ref context_die)
14256 dw_die_ref decl_die;
14258 if (TREE_TYPE (decl) == error_mark_node)
14261 decl_die = new_die (DW_TAG_member, context_die, decl);
14262 add_name_and_src_coords_attributes (decl_die, decl);
14263 add_type_attribute (decl_die, member_declared_type (decl),
14264 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
14267 if (DECL_BIT_FIELD_TYPE (decl))
14269 add_byte_size_attribute (decl_die, decl);
14270 add_bit_size_attribute (decl_die, decl);
14271 add_bit_offset_attribute (decl_die, decl);
14274 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
14275 add_data_member_location_attribute (decl_die, decl);
14277 if (DECL_ARTIFICIAL (decl))
14278 add_AT_flag (decl_die, DW_AT_artificial, 1);
14280 if (TREE_PROTECTED (decl))
14281 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
14282 else if (TREE_PRIVATE (decl))
14283 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
14285 /* Equate decl number to die, so that we can look up this decl later on. */
14286 equate_decl_number_to_die (decl, decl_die);
14290 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14291 Use modified_type_die instead.
14292 We keep this code here just in case these types of DIEs may be needed to
14293 represent certain things in other languages (e.g. Pascal) someday. */
14296 gen_pointer_type_die (tree type, dw_die_ref context_die)
14299 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
14301 equate_type_number_to_die (type, ptr_die);
14302 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14303 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14306 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14307 Use modified_type_die instead.
14308 We keep this code here just in case these types of DIEs may be needed to
14309 represent certain things in other languages (e.g. Pascal) someday. */
14312 gen_reference_type_die (tree type, dw_die_ref context_die)
14315 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
14317 equate_type_number_to_die (type, ref_die);
14318 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
14319 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14323 /* Generate a DIE for a pointer to a member type. */
14326 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
14329 = new_die (DW_TAG_ptr_to_member_type,
14330 scope_die_for (type, context_die), type);
14332 equate_type_number_to_die (type, ptr_die);
14333 add_AT_die_ref (ptr_die, DW_AT_containing_type,
14334 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
14335 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14338 /* Generate the DIE for the compilation unit. */
14341 gen_compile_unit_die (const char *filename)
14344 char producer[250];
14345 const char *language_string = lang_hooks.name;
14348 die = new_die (DW_TAG_compile_unit, NULL, NULL);
14352 add_name_attribute (die, filename);
14353 /* Don't add cwd for <built-in>. */
14354 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
14355 add_comp_dir_attribute (die);
14358 sprintf (producer, "%s %s", language_string, version_string);
14360 #ifdef MIPS_DEBUGGING_INFO
14361 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
14362 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
14363 not appear in the producer string, the debugger reaches the conclusion
14364 that the object file is stripped and has no debugging information.
14365 To get the MIPS/SGI debugger to believe that there is debugging
14366 information in the object file, we add a -g to the producer string. */
14367 if (debug_info_level > DINFO_LEVEL_TERSE)
14368 strcat (producer, " -g");
14371 add_AT_string (die, DW_AT_producer, producer);
14373 if (strcmp (language_string, "GNU C++") == 0)
14374 language = DW_LANG_C_plus_plus;
14375 else if (strcmp (language_string, "GNU Ada") == 0)
14376 language = DW_LANG_Ada95;
14377 else if (strcmp (language_string, "GNU F77") == 0)
14378 language = DW_LANG_Fortran77;
14379 else if (strcmp (language_string, "GNU Fortran") == 0)
14380 language = DW_LANG_Fortran95;
14381 else if (strcmp (language_string, "GNU Pascal") == 0)
14382 language = DW_LANG_Pascal83;
14383 else if (strcmp (language_string, "GNU Java") == 0)
14384 language = DW_LANG_Java;
14385 else if (strcmp (language_string, "GNU Objective-C") == 0)
14386 language = DW_LANG_ObjC;
14387 else if (strcmp (language_string, "GNU Objective-C++") == 0)
14388 language = DW_LANG_ObjC_plus_plus;
14390 language = DW_LANG_C89;
14392 add_AT_unsigned (die, DW_AT_language, language);
14396 /* Generate the DIE for a base class. */
14399 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
14401 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
14403 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
14404 add_data_member_location_attribute (die, binfo);
14406 if (BINFO_VIRTUAL_P (binfo))
14407 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
14409 if (access == access_public_node)
14410 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
14411 else if (access == access_protected_node)
14412 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
14415 /* Generate a DIE for a class member. */
14418 gen_member_die (tree type, dw_die_ref context_die)
14421 tree binfo = TYPE_BINFO (type);
14424 /* If this is not an incomplete type, output descriptions of each of its
14425 members. Note that as we output the DIEs necessary to represent the
14426 members of this record or union type, we will also be trying to output
14427 DIEs to represent the *types* of those members. However the `type'
14428 function (above) will specifically avoid generating type DIEs for member
14429 types *within* the list of member DIEs for this (containing) type except
14430 for those types (of members) which are explicitly marked as also being
14431 members of this (containing) type themselves. The g++ front- end can
14432 force any given type to be treated as a member of some other (containing)
14433 type by setting the TYPE_CONTEXT of the given (member) type to point to
14434 the TREE node representing the appropriate (containing) type. */
14436 /* First output info about the base classes. */
14439 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
14443 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
14444 gen_inheritance_die (base,
14445 (accesses ? VEC_index (tree, accesses, i)
14446 : access_public_node), context_die);
14449 /* Now output info about the data members and type members. */
14450 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
14452 /* If we thought we were generating minimal debug info for TYPE
14453 and then changed our minds, some of the member declarations
14454 may have already been defined. Don't define them again, but
14455 do put them in the right order. */
14457 child = lookup_decl_die (member);
14459 splice_child_die (context_die, child);
14461 gen_decl_die (member, NULL, context_die);
14464 /* Now output info about the function members (if any). */
14465 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
14467 /* Don't include clones in the member list. */
14468 if (DECL_ABSTRACT_ORIGIN (member))
14471 child = lookup_decl_die (member);
14473 splice_child_die (context_die, child);
14475 gen_decl_die (member, NULL, context_die);
14479 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
14480 is set, we pretend that the type was never defined, so we only get the
14481 member DIEs needed by later specification DIEs. */
14484 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
14485 enum debug_info_usage usage)
14487 dw_die_ref type_die = lookup_type_die (type);
14488 dw_die_ref scope_die = 0;
14490 int complete = (TYPE_SIZE (type)
14491 && (! TYPE_STUB_DECL (type)
14492 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
14493 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
14494 complete = complete && should_emit_struct_debug (type, usage);
14496 if (type_die && ! complete)
14499 if (TYPE_CONTEXT (type) != NULL_TREE
14500 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14501 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
14504 scope_die = scope_die_for (type, context_die);
14506 if (! type_die || (nested && scope_die == comp_unit_die))
14507 /* First occurrence of type or toplevel definition of nested class. */
14509 dw_die_ref old_die = type_die;
14511 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
14512 ? record_type_tag (type) : DW_TAG_union_type,
14514 equate_type_number_to_die (type, type_die);
14516 add_AT_specification (type_die, old_die);
14518 add_name_attribute (type_die, type_tag (type));
14521 remove_AT (type_die, DW_AT_declaration);
14523 /* If this type has been completed, then give it a byte_size attribute and
14524 then give a list of members. */
14525 if (complete && !ns_decl)
14527 /* Prevent infinite recursion in cases where the type of some member of
14528 this type is expressed in terms of this type itself. */
14529 TREE_ASM_WRITTEN (type) = 1;
14530 add_byte_size_attribute (type_die, type);
14531 if (TYPE_STUB_DECL (type) != NULL_TREE)
14532 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
14534 /* If the first reference to this type was as the return type of an
14535 inline function, then it may not have a parent. Fix this now. */
14536 if (type_die->die_parent == NULL)
14537 add_child_die (scope_die, type_die);
14539 push_decl_scope (type);
14540 gen_member_die (type, type_die);
14543 /* GNU extension: Record what type our vtable lives in. */
14544 if (TYPE_VFIELD (type))
14546 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
14548 gen_type_die (vtype, context_die);
14549 add_AT_die_ref (type_die, DW_AT_containing_type,
14550 lookup_type_die (vtype));
14555 add_AT_flag (type_die, DW_AT_declaration, 1);
14557 /* We don't need to do this for function-local types. */
14558 if (TYPE_STUB_DECL (type)
14559 && ! decl_function_context (TYPE_STUB_DECL (type)))
14560 VEC_safe_push (tree, gc, incomplete_types, type);
14563 if (get_AT (type_die, DW_AT_name))
14564 add_pubtype (type, type_die);
14567 /* Generate a DIE for a subroutine _type_. */
14570 gen_subroutine_type_die (tree type, dw_die_ref context_die)
14572 tree return_type = TREE_TYPE (type);
14573 dw_die_ref subr_die
14574 = new_die (DW_TAG_subroutine_type,
14575 scope_die_for (type, context_die), type);
14577 equate_type_number_to_die (type, subr_die);
14578 add_prototyped_attribute (subr_die, type);
14579 add_type_attribute (subr_die, return_type, 0, 0, context_die);
14580 gen_formal_types_die (type, subr_die);
14582 if (get_AT (subr_die, DW_AT_name))
14583 add_pubtype (type, subr_die);
14586 /* Generate a DIE for a type definition. */
14589 gen_typedef_die (tree decl, dw_die_ref context_die)
14591 dw_die_ref type_die;
14594 if (TREE_ASM_WRITTEN (decl))
14597 TREE_ASM_WRITTEN (decl) = 1;
14598 type_die = new_die (DW_TAG_typedef, context_die, decl);
14599 origin = decl_ultimate_origin (decl);
14600 if (origin != NULL)
14601 add_abstract_origin_attribute (type_die, origin);
14606 add_name_and_src_coords_attributes (type_die, decl);
14607 if (DECL_ORIGINAL_TYPE (decl))
14609 type = DECL_ORIGINAL_TYPE (decl);
14611 gcc_assert (type != TREE_TYPE (decl));
14612 equate_type_number_to_die (TREE_TYPE (decl), type_die);
14615 type = TREE_TYPE (decl);
14617 add_type_attribute (type_die, type, TREE_READONLY (decl),
14618 TREE_THIS_VOLATILE (decl), context_die);
14621 if (DECL_ABSTRACT (decl))
14622 equate_decl_number_to_die (decl, type_die);
14624 if (get_AT (type_die, DW_AT_name))
14625 add_pubtype (decl, type_die);
14628 /* Generate a type description DIE. */
14631 gen_type_die_with_usage (tree type, dw_die_ref context_die,
14632 enum debug_info_usage usage)
14635 struct array_descr_info info;
14637 if (type == NULL_TREE || type == error_mark_node)
14640 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
14641 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
14643 if (TREE_ASM_WRITTEN (type))
14646 /* Prevent broken recursion; we can't hand off to the same type. */
14647 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
14649 TREE_ASM_WRITTEN (type) = 1;
14650 gen_decl_die (TYPE_NAME (type), NULL, context_die);
14654 /* If this is an array type with hidden descriptor, handle it first. */
14655 if (!TREE_ASM_WRITTEN (type)
14656 && lang_hooks.types.get_array_descr_info
14657 && lang_hooks.types.get_array_descr_info (type, &info))
14659 gen_descr_array_type_die (type, &info, context_die);
14660 TREE_ASM_WRITTEN (type) = 1;
14664 /* We are going to output a DIE to represent the unqualified version
14665 of this type (i.e. without any const or volatile qualifiers) so
14666 get the main variant (i.e. the unqualified version) of this type
14667 now. (Vectors are special because the debugging info is in the
14668 cloned type itself). */
14669 if (TREE_CODE (type) != VECTOR_TYPE)
14670 type = type_main_variant (type);
14672 if (TREE_ASM_WRITTEN (type))
14675 switch (TREE_CODE (type))
14681 case REFERENCE_TYPE:
14682 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
14683 ensures that the gen_type_die recursion will terminate even if the
14684 type is recursive. Recursive types are possible in Ada. */
14685 /* ??? We could perhaps do this for all types before the switch
14687 TREE_ASM_WRITTEN (type) = 1;
14689 /* For these types, all that is required is that we output a DIE (or a
14690 set of DIEs) to represent the "basis" type. */
14691 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14692 DINFO_USAGE_IND_USE);
14696 /* This code is used for C++ pointer-to-data-member types.
14697 Output a description of the relevant class type. */
14698 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
14699 DINFO_USAGE_IND_USE);
14701 /* Output a description of the type of the object pointed to. */
14702 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14703 DINFO_USAGE_IND_USE);
14705 /* Now output a DIE to represent this pointer-to-data-member type
14707 gen_ptr_to_mbr_type_die (type, context_die);
14710 case FUNCTION_TYPE:
14711 /* Force out return type (in case it wasn't forced out already). */
14712 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14713 DINFO_USAGE_DIR_USE);
14714 gen_subroutine_type_die (type, context_die);
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 gen_array_type_die (type, context_die);
14729 gen_array_type_die (type, context_die);
14732 case ENUMERAL_TYPE:
14735 case QUAL_UNION_TYPE:
14736 /* If this is a nested type whose containing class hasn't been written
14737 out yet, writing it out will cover this one, too. This does not apply
14738 to instantiations of member class templates; they need to be added to
14739 the containing class as they are generated. FIXME: This hurts the
14740 idea of combining type decls from multiple TUs, since we can't predict
14741 what set of template instantiations we'll get. */
14742 if (TYPE_CONTEXT (type)
14743 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14744 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
14746 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
14748 if (TREE_ASM_WRITTEN (type))
14751 /* If that failed, attach ourselves to the stub. */
14752 push_decl_scope (TYPE_CONTEXT (type));
14753 context_die = lookup_type_die (TYPE_CONTEXT (type));
14758 context_die = declare_in_namespace (type, context_die);
14762 if (TREE_CODE (type) == ENUMERAL_TYPE)
14764 /* This might have been written out by the call to
14765 declare_in_namespace. */
14766 if (!TREE_ASM_WRITTEN (type))
14767 gen_enumeration_type_die (type, context_die);
14770 gen_struct_or_union_type_die (type, context_die, usage);
14775 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
14776 it up if it is ever completed. gen_*_type_die will set it for us
14777 when appropriate. */
14783 case FIXED_POINT_TYPE:
14786 /* No DIEs needed for fundamental types. */
14790 /* No Dwarf representation currently defined. */
14794 gcc_unreachable ();
14797 TREE_ASM_WRITTEN (type) = 1;
14801 gen_type_die (tree type, dw_die_ref context_die)
14803 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
14806 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
14807 things which are local to the given block. */
14810 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
14812 int must_output_die = 0;
14815 /* Ignore blocks that are NULL. */
14816 if (stmt == NULL_TREE)
14819 inlined_func = inlined_function_outer_scope_p (stmt);
14821 /* If the block is one fragment of a non-contiguous block, do not
14822 process the variables, since they will have been done by the
14823 origin block. Do process subblocks. */
14824 if (BLOCK_FRAGMENT_ORIGIN (stmt))
14828 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
14829 gen_block_die (sub, context_die, depth + 1);
14834 /* Determine if we need to output any Dwarf DIEs at all to represent this
14837 /* The outer scopes for inlinings *must* always be represented. We
14838 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
14839 must_output_die = 1;
14842 /* Determine if this block directly contains any "significant"
14843 local declarations which we will need to output DIEs for. */
14844 if (debug_info_level > DINFO_LEVEL_TERSE)
14845 /* We are not in terse mode so *any* local declaration counts
14846 as being a "significant" one. */
14847 must_output_die = ((BLOCK_VARS (stmt) != NULL
14848 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
14849 && (TREE_USED (stmt)
14850 || TREE_ASM_WRITTEN (stmt)
14851 || BLOCK_ABSTRACT (stmt)));
14852 else if ((TREE_USED (stmt)
14853 || TREE_ASM_WRITTEN (stmt)
14854 || BLOCK_ABSTRACT (stmt))
14855 && !dwarf2out_ignore_block (stmt))
14856 must_output_die = 1;
14859 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
14860 DIE for any block which contains no significant local declarations at
14861 all. Rather, in such cases we just call `decls_for_scope' so that any
14862 needed Dwarf info for any sub-blocks will get properly generated. Note
14863 that in terse mode, our definition of what constitutes a "significant"
14864 local declaration gets restricted to include only inlined function
14865 instances and local (nested) function definitions. */
14866 if (must_output_die)
14869 gen_inlined_subroutine_die (stmt, context_die, depth);
14871 gen_lexical_block_die (stmt, context_die, depth);
14874 decls_for_scope (stmt, context_die, depth);
14877 /* Process variable DECL (or variable with origin ORIGIN) within
14878 block STMT and add it to CONTEXT_DIE. */
14880 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
14883 tree decl_or_origin = decl ? decl : origin;
14884 tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
14886 if (ultimate_origin)
14887 origin = ultimate_origin;
14889 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
14890 die = lookup_decl_die (decl_or_origin);
14891 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
14892 && TYPE_DECL_IS_STUB (decl_or_origin))
14893 die = lookup_type_die (TREE_TYPE (decl_or_origin));
14897 if (die != NULL && die->die_parent == NULL)
14898 add_child_die (context_die, die);
14899 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
14900 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
14901 stmt, context_die);
14903 gen_decl_die (decl, origin, context_die);
14906 /* Generate all of the decls declared within a given scope and (recursively)
14907 all of its sub-blocks. */
14910 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
14916 /* Ignore NULL blocks. */
14917 if (stmt == NULL_TREE)
14920 /* Output the DIEs to represent all of the data objects and typedefs
14921 declared directly within this block but not within any nested
14922 sub-blocks. Also, nested function and tag DIEs have been
14923 generated with a parent of NULL; fix that up now. */
14924 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
14925 process_scope_var (stmt, decl, NULL_TREE, context_die);
14926 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
14927 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
14930 /* If we're at -g1, we're not interested in subblocks. */
14931 if (debug_info_level <= DINFO_LEVEL_TERSE)
14934 /* Output the DIEs to represent all sub-blocks (and the items declared
14935 therein) of this block. */
14936 for (subblocks = BLOCK_SUBBLOCKS (stmt);
14938 subblocks = BLOCK_CHAIN (subblocks))
14939 gen_block_die (subblocks, context_die, depth + 1);
14942 /* Is this a typedef we can avoid emitting? */
14945 is_redundant_typedef (const_tree decl)
14947 if (TYPE_DECL_IS_STUB (decl))
14950 if (DECL_ARTIFICIAL (decl)
14951 && DECL_CONTEXT (decl)
14952 && is_tagged_type (DECL_CONTEXT (decl))
14953 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
14954 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
14955 /* Also ignore the artificial member typedef for the class name. */
14961 /* Returns the DIE for a context. */
14963 static inline dw_die_ref
14964 get_context_die (tree context)
14968 /* Find die that represents this context. */
14969 if (TYPE_P (context))
14970 return force_type_die (context);
14972 return force_decl_die (context);
14974 return comp_unit_die;
14977 /* Returns the DIE for decl. A DIE will always be returned. */
14980 force_decl_die (tree decl)
14982 dw_die_ref decl_die;
14983 unsigned saved_external_flag;
14984 tree save_fn = NULL_TREE;
14985 decl_die = lookup_decl_die (decl);
14988 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
14990 decl_die = lookup_decl_die (decl);
14994 switch (TREE_CODE (decl))
14996 case FUNCTION_DECL:
14997 /* Clear current_function_decl, so that gen_subprogram_die thinks
14998 that this is a declaration. At this point, we just want to force
14999 declaration die. */
15000 save_fn = current_function_decl;
15001 current_function_decl = NULL_TREE;
15002 gen_subprogram_die (decl, context_die);
15003 current_function_decl = save_fn;
15007 /* Set external flag to force declaration die. Restore it after
15008 gen_decl_die() call. */
15009 saved_external_flag = DECL_EXTERNAL (decl);
15010 DECL_EXTERNAL (decl) = 1;
15011 gen_decl_die (decl, NULL, context_die);
15012 DECL_EXTERNAL (decl) = saved_external_flag;
15015 case NAMESPACE_DECL:
15016 dwarf2out_decl (decl);
15020 gcc_unreachable ();
15023 /* We should be able to find the DIE now. */
15025 decl_die = lookup_decl_die (decl);
15026 gcc_assert (decl_die);
15032 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
15033 always returned. */
15036 force_type_die (tree type)
15038 dw_die_ref type_die;
15040 type_die = lookup_type_die (type);
15043 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
15045 type_die = modified_type_die (type, TYPE_READONLY (type),
15046 TYPE_VOLATILE (type), context_die);
15047 gcc_assert (type_die);
15052 /* Force out any required namespaces to be able to output DECL,
15053 and return the new context_die for it, if it's changed. */
15056 setup_namespace_context (tree thing, dw_die_ref context_die)
15058 tree context = (DECL_P (thing)
15059 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
15060 if (context && TREE_CODE (context) == NAMESPACE_DECL)
15061 /* Force out the namespace. */
15062 context_die = force_decl_die (context);
15064 return context_die;
15067 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
15068 type) within its namespace, if appropriate.
15070 For compatibility with older debuggers, namespace DIEs only contain
15071 declarations; all definitions are emitted at CU scope. */
15074 declare_in_namespace (tree thing, dw_die_ref context_die)
15076 dw_die_ref ns_context;
15078 if (debug_info_level <= DINFO_LEVEL_TERSE)
15079 return context_die;
15081 /* If this decl is from an inlined function, then don't try to emit it in its
15082 namespace, as we will get confused. It would have already been emitted
15083 when the abstract instance of the inline function was emitted anyways. */
15084 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
15085 return context_die;
15087 ns_context = setup_namespace_context (thing, context_die);
15089 if (ns_context != context_die)
15093 if (DECL_P (thing))
15094 gen_decl_die (thing, NULL, ns_context);
15096 gen_type_die (thing, ns_context);
15098 return context_die;
15101 /* Generate a DIE for a namespace or namespace alias. */
15104 gen_namespace_die (tree decl, dw_die_ref context_die)
15106 dw_die_ref namespace_die;
15108 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
15109 they are an alias of. */
15110 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
15112 /* Output a real namespace or module. */
15113 context_die = setup_namespace_context (decl, comp_unit_die);
15114 namespace_die = new_die (is_fortran ()
15115 ? DW_TAG_module : DW_TAG_namespace,
15116 context_die, decl);
15117 /* For Fortran modules defined in different CU don't add src coords. */
15118 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
15119 add_name_attribute (namespace_die, dwarf2_name (decl, 0));
15121 add_name_and_src_coords_attributes (namespace_die, decl);
15122 if (DECL_EXTERNAL (decl))
15123 add_AT_flag (namespace_die, DW_AT_declaration, 1);
15124 equate_decl_number_to_die (decl, namespace_die);
15128 /* Output a namespace alias. */
15130 /* Force out the namespace we are an alias of, if necessary. */
15131 dw_die_ref origin_die
15132 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
15134 if (DECL_CONTEXT (decl) == NULL_TREE
15135 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
15136 context_die = setup_namespace_context (decl, comp_unit_die);
15137 /* Now create the namespace alias DIE. */
15138 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
15139 add_name_and_src_coords_attributes (namespace_die, decl);
15140 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
15141 equate_decl_number_to_die (decl, namespace_die);
15145 /* Generate Dwarf debug information for a decl described by DECL. */
15148 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
15150 tree decl_or_origin = decl ? decl : origin;
15151 tree class_origin = NULL;
15153 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
15156 switch (TREE_CODE (decl_or_origin))
15162 if (!is_fortran ())
15164 /* The individual enumerators of an enum type get output when we output
15165 the Dwarf representation of the relevant enum type itself. */
15169 /* Emit its type. */
15170 gen_type_die (TREE_TYPE (decl), context_die);
15172 /* And its containing namespace. */
15173 context_die = declare_in_namespace (decl, context_die);
15175 gen_const_die (decl, context_die);
15178 case FUNCTION_DECL:
15179 /* Don't output any DIEs to represent mere function declarations,
15180 unless they are class members or explicit block externs. */
15181 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
15182 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
15183 && (current_function_decl == NULL_TREE
15184 || DECL_ARTIFICIAL (decl_or_origin)))
15189 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
15190 on local redeclarations of global functions. That seems broken. */
15191 if (current_function_decl != decl)
15192 /* This is only a declaration. */;
15195 /* If we're emitting a clone, emit info for the abstract instance. */
15196 if (origin || DECL_ORIGIN (decl) != decl)
15197 dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
15199 /* If we're emitting an out-of-line copy of an inline function,
15200 emit info for the abstract instance and set up to refer to it. */
15201 else if (cgraph_function_possibly_inlined_p (decl)
15202 && ! DECL_ABSTRACT (decl)
15203 && ! class_or_namespace_scope_p (context_die)
15204 /* dwarf2out_abstract_function won't emit a die if this is just
15205 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
15206 that case, because that works only if we have a die. */
15207 && DECL_INITIAL (decl) != NULL_TREE)
15209 dwarf2out_abstract_function (decl);
15210 set_decl_origin_self (decl);
15213 /* Otherwise we're emitting the primary DIE for this decl. */
15214 else if (debug_info_level > DINFO_LEVEL_TERSE)
15216 /* Before we describe the FUNCTION_DECL itself, make sure that we
15217 have described its return type. */
15218 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
15220 /* And its virtual context. */
15221 if (DECL_VINDEX (decl) != NULL_TREE)
15222 gen_type_die (DECL_CONTEXT (decl), context_die);
15224 /* And its containing type. */
15226 origin = decl_class_context (decl);
15227 if (origin != NULL_TREE)
15228 gen_type_die_for_member (origin, decl, context_die);
15230 /* And its containing namespace. */
15231 context_die = declare_in_namespace (decl, context_die);
15234 /* Now output a DIE to represent the function itself. */
15236 gen_subprogram_die (decl, context_die);
15240 /* If we are in terse mode, don't generate any DIEs to represent any
15241 actual typedefs. */
15242 if (debug_info_level <= DINFO_LEVEL_TERSE)
15245 /* In the special case of a TYPE_DECL node representing the declaration
15246 of some type tag, if the given TYPE_DECL is marked as having been
15247 instantiated from some other (original) TYPE_DECL node (e.g. one which
15248 was generated within the original definition of an inline function) we
15249 used to generate a special (abbreviated) DW_TAG_structure_type,
15250 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
15251 should be actually referencing those DIEs, as variable DIEs with that
15252 type would be emitted already in the abstract origin, so it was always
15253 removed during unused type prunning. Don't add anything in this
15255 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
15258 if (is_redundant_typedef (decl))
15259 gen_type_die (TREE_TYPE (decl), context_die);
15261 /* Output a DIE to represent the typedef itself. */
15262 gen_typedef_die (decl, context_die);
15266 if (debug_info_level >= DINFO_LEVEL_NORMAL)
15267 gen_label_die (decl, context_die);
15272 /* If we are in terse mode, don't generate any DIEs to represent any
15273 variable declarations or definitions. */
15274 if (debug_info_level <= DINFO_LEVEL_TERSE)
15277 /* Output any DIEs that are needed to specify the type of this data
15279 if (TREE_CODE (decl_or_origin) == RESULT_DECL
15280 && DECL_BY_REFERENCE (decl_or_origin))
15281 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15283 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15285 /* And its containing type. */
15286 class_origin = decl_class_context (decl_or_origin);
15287 if (class_origin != NULL_TREE)
15288 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
15290 /* And its containing namespace. */
15291 context_die = declare_in_namespace (decl_or_origin, context_die);
15293 /* Now output the DIE to represent the data object itself. This gets
15294 complicated because of the possibility that the VAR_DECL really
15295 represents an inlined instance of a formal parameter for an inline
15298 origin = decl_ultimate_origin (decl);
15299 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
15300 gen_formal_parameter_die (decl, origin, context_die);
15302 gen_variable_die (decl, origin, context_die);
15306 /* Ignore the nameless fields that are used to skip bits but handle C++
15307 anonymous unions and structs. */
15308 if (DECL_NAME (decl) != NULL_TREE
15309 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
15310 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
15312 gen_type_die (member_declared_type (decl), context_die);
15313 gen_field_die (decl, context_die);
15318 if (DECL_BY_REFERENCE (decl_or_origin))
15319 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15321 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15322 gen_formal_parameter_die (decl, origin, context_die);
15325 case NAMESPACE_DECL:
15326 case IMPORTED_DECL:
15327 gen_namespace_die (decl, context_die);
15331 /* Probably some frontend-internal decl. Assume we don't care. */
15332 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
15337 /* Output debug information for global decl DECL. Called from toplev.c after
15338 compilation proper has finished. */
15341 dwarf2out_global_decl (tree decl)
15343 /* Output DWARF2 information for file-scope tentative data object
15344 declarations, file-scope (extern) function declarations (which
15345 had no corresponding body) and file-scope tagged type declarations
15346 and definitions which have not yet been forced out. */
15347 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
15348 dwarf2out_decl (decl);
15351 /* Output debug information for type decl DECL. Called from toplev.c
15352 and from language front ends (to record built-in types). */
15354 dwarf2out_type_decl (tree decl, int local)
15357 dwarf2out_decl (decl);
15360 /* Output debug information for imported module or decl DECL.
15361 NAME is non-NULL name in the lexical block if the decl has been renamed.
15362 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
15363 that DECL belongs to.
15364 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
15366 dwarf2out_imported_module_or_decl_1 (tree decl,
15368 tree lexical_block,
15369 dw_die_ref lexical_block_die)
15371 expanded_location xloc;
15372 dw_die_ref imported_die = NULL;
15373 dw_die_ref at_import_die;
15375 if (TREE_CODE (decl) == IMPORTED_DECL)
15377 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
15378 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
15382 xloc = expand_location (input_location);
15384 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
15386 if (is_base_type (TREE_TYPE (decl)))
15387 at_import_die = base_type_die (TREE_TYPE (decl));
15389 at_import_die = force_type_die (TREE_TYPE (decl));
15390 /* For namespace N { typedef void T; } using N::T; base_type_die
15391 returns NULL, but DW_TAG_imported_declaration requires
15392 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
15393 if (!at_import_die)
15395 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
15396 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
15397 at_import_die = lookup_type_die (TREE_TYPE (decl));
15398 gcc_assert (at_import_die);
15403 at_import_die = lookup_decl_die (decl);
15404 if (!at_import_die)
15406 /* If we're trying to avoid duplicate debug info, we may not have
15407 emitted the member decl for this field. Emit it now. */
15408 if (TREE_CODE (decl) == FIELD_DECL)
15410 tree type = DECL_CONTEXT (decl);
15412 if (TYPE_CONTEXT (type)
15413 && TYPE_P (TYPE_CONTEXT (type))
15414 && !should_emit_struct_debug (TYPE_CONTEXT (type),
15415 DINFO_USAGE_DIR_USE))
15417 gen_type_die_for_member (type, decl,
15418 get_context_die (TYPE_CONTEXT (type)));
15420 at_import_die = force_decl_die (decl);
15424 if (TREE_CODE (decl) == NAMESPACE_DECL)
15425 imported_die = new_die (DW_TAG_imported_module,
15429 imported_die = new_die (DW_TAG_imported_declaration,
15433 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
15434 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
15436 add_AT_string (imported_die, DW_AT_name,
15437 IDENTIFIER_POINTER (name));
15438 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
15441 /* Output debug information for imported module or decl DECL.
15442 NAME is non-NULL name in context if the decl has been renamed.
15443 CHILD is true if decl is one of the renamed decls as part of
15444 importing whole module. */
15447 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
15450 /* dw_die_ref at_import_die; */
15451 dw_die_ref scope_die;
15453 if (debug_info_level <= DINFO_LEVEL_TERSE)
15458 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
15459 We need decl DIE for reference and scope die. First, get DIE for the decl
15462 /* Get the scope die for decl context. Use comp_unit_die for global module
15463 or decl. If die is not found for non globals, force new die. */
15465 && TYPE_P (context)
15466 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
15468 scope_die = get_context_die (context);
15472 gcc_assert (scope_die->die_child);
15473 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
15474 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
15475 scope_die = scope_die->die_child;
15478 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
15479 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
15483 /* Write the debugging output for DECL. */
15486 dwarf2out_decl (tree decl)
15488 dw_die_ref context_die = comp_unit_die;
15490 switch (TREE_CODE (decl))
15495 case FUNCTION_DECL:
15496 /* What we would really like to do here is to filter out all mere
15497 file-scope declarations of file-scope functions which are never
15498 referenced later within this translation unit (and keep all of ones
15499 that *are* referenced later on) but we aren't clairvoyant, so we have
15500 no idea which functions will be referenced in the future (i.e. later
15501 on within the current translation unit). So here we just ignore all
15502 file-scope function declarations which are not also definitions. If
15503 and when the debugger needs to know something about these functions,
15504 it will have to hunt around and find the DWARF information associated
15505 with the definition of the function.
15507 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
15508 nodes represent definitions and which ones represent mere
15509 declarations. We have to check DECL_INITIAL instead. That's because
15510 the C front-end supports some weird semantics for "extern inline"
15511 function definitions. These can get inlined within the current
15512 translation unit (and thus, we need to generate Dwarf info for their
15513 abstract instances so that the Dwarf info for the concrete inlined
15514 instances can have something to refer to) but the compiler never
15515 generates any out-of-lines instances of such things (despite the fact
15516 that they *are* definitions).
15518 The important point is that the C front-end marks these "extern
15519 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
15520 them anyway. Note that the C++ front-end also plays some similar games
15521 for inline function definitions appearing within include files which
15522 also contain `#pragma interface' pragmas. */
15523 if (DECL_INITIAL (decl) == NULL_TREE)
15526 /* If we're a nested function, initially use a parent of NULL; if we're
15527 a plain function, this will be fixed up in decls_for_scope. If
15528 we're a method, it will be ignored, since we already have a DIE. */
15529 if (decl_function_context (decl)
15530 /* But if we're in terse mode, we don't care about scope. */
15531 && debug_info_level > DINFO_LEVEL_TERSE)
15532 context_die = NULL;
15536 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
15537 declaration and if the declaration was never even referenced from
15538 within this entire compilation unit. We suppress these DIEs in
15539 order to save space in the .debug section (by eliminating entries
15540 which are probably useless). Note that we must not suppress
15541 block-local extern declarations (whether used or not) because that
15542 would screw-up the debugger's name lookup mechanism and cause it to
15543 miss things which really ought to be in scope at a given point. */
15544 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
15547 /* For local statics lookup proper context die. */
15548 if (TREE_STATIC (decl) && decl_function_context (decl))
15549 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15551 /* If we are in terse mode, don't generate any DIEs to represent any
15552 variable declarations or definitions. */
15553 if (debug_info_level <= DINFO_LEVEL_TERSE)
15558 if (debug_info_level <= DINFO_LEVEL_TERSE)
15560 if (!is_fortran ())
15562 if (TREE_STATIC (decl) && decl_function_context (decl))
15563 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15566 case NAMESPACE_DECL:
15567 case IMPORTED_DECL:
15568 if (debug_info_level <= DINFO_LEVEL_TERSE)
15570 if (lookup_decl_die (decl) != NULL)
15575 /* Don't emit stubs for types unless they are needed by other DIEs. */
15576 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
15579 /* Don't bother trying to generate any DIEs to represent any of the
15580 normal built-in types for the language we are compiling. */
15581 if (DECL_IS_BUILTIN (decl))
15583 /* OK, we need to generate one for `bool' so GDB knows what type
15584 comparisons have. */
15586 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
15587 && ! DECL_IGNORED_P (decl))
15588 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
15593 /* If we are in terse mode, don't generate any DIEs for types. */
15594 if (debug_info_level <= DINFO_LEVEL_TERSE)
15597 /* If we're a function-scope tag, initially use a parent of NULL;
15598 this will be fixed up in decls_for_scope. */
15599 if (decl_function_context (decl))
15600 context_die = NULL;
15608 gen_decl_die (decl, NULL, context_die);
15611 /* Output a marker (i.e. a label) for the beginning of the generated code for
15612 a lexical block. */
15615 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
15616 unsigned int blocknum)
15618 switch_to_section (current_function_section ());
15619 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
15622 /* Output a marker (i.e. a label) for the end of the generated code for a
15626 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
15628 switch_to_section (current_function_section ());
15629 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
15632 /* Returns nonzero if it is appropriate not to emit any debugging
15633 information for BLOCK, because it doesn't contain any instructions.
15635 Don't allow this for blocks with nested functions or local classes
15636 as we would end up with orphans, and in the presence of scheduling
15637 we may end up calling them anyway. */
15640 dwarf2out_ignore_block (const_tree block)
15645 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
15646 if (TREE_CODE (decl) == FUNCTION_DECL
15647 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15649 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
15651 decl = BLOCK_NONLOCALIZED_VAR (block, i);
15652 if (TREE_CODE (decl) == FUNCTION_DECL
15653 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15660 /* Hash table routines for file_hash. */
15663 file_table_eq (const void *p1_p, const void *p2_p)
15665 const struct dwarf_file_data *const p1 =
15666 (const struct dwarf_file_data *) p1_p;
15667 const char *const p2 = (const char *) p2_p;
15668 return strcmp (p1->filename, p2) == 0;
15672 file_table_hash (const void *p_p)
15674 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
15675 return htab_hash_string (p->filename);
15678 /* Lookup FILE_NAME (in the list of filenames that we know about here in
15679 dwarf2out.c) and return its "index". The index of each (known) filename is
15680 just a unique number which is associated with only that one filename. We
15681 need such numbers for the sake of generating labels (in the .debug_sfnames
15682 section) and references to those files numbers (in the .debug_srcinfo
15683 and.debug_macinfo sections). If the filename given as an argument is not
15684 found in our current list, add it to the list and assign it the next
15685 available unique index number. In order to speed up searches, we remember
15686 the index of the filename was looked up last. This handles the majority of
15689 static struct dwarf_file_data *
15690 lookup_filename (const char *file_name)
15693 struct dwarf_file_data * created;
15695 /* Check to see if the file name that was searched on the previous
15696 call matches this file name. If so, return the index. */
15697 if (file_table_last_lookup
15698 && (file_name == file_table_last_lookup->filename
15699 || strcmp (file_table_last_lookup->filename, file_name) == 0))
15700 return file_table_last_lookup;
15702 /* Didn't match the previous lookup, search the table. */
15703 slot = htab_find_slot_with_hash (file_table, file_name,
15704 htab_hash_string (file_name), INSERT);
15706 return (struct dwarf_file_data *) *slot;
15708 created = GGC_NEW (struct dwarf_file_data);
15709 created->filename = file_name;
15710 created->emitted_number = 0;
15715 /* If the assembler will construct the file table, then translate the compiler
15716 internal file table number into the assembler file table number, and emit
15717 a .file directive if we haven't already emitted one yet. The file table
15718 numbers are different because we prune debug info for unused variables and
15719 types, which may include filenames. */
15722 maybe_emit_file (struct dwarf_file_data * fd)
15724 if (! fd->emitted_number)
15726 if (last_emitted_file)
15727 fd->emitted_number = last_emitted_file->emitted_number + 1;
15729 fd->emitted_number = 1;
15730 last_emitted_file = fd;
15732 if (DWARF2_ASM_LINE_DEBUG_INFO)
15734 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
15735 output_quoted_string (asm_out_file,
15736 remap_debug_filename (fd->filename));
15737 fputc ('\n', asm_out_file);
15741 return fd->emitted_number;
15744 /* Called by the final INSN scan whenever we see a var location. We
15745 use it to drop labels in the right places, and throw the location in
15746 our lookup table. */
15749 dwarf2out_var_location (rtx loc_note)
15751 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
15752 struct var_loc_node *newloc;
15754 static rtx last_insn;
15755 static const char *last_label;
15758 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
15760 prev_insn = PREV_INSN (loc_note);
15762 newloc = GGC_CNEW (struct var_loc_node);
15763 /* If the insn we processed last time is the previous insn
15764 and it is also a var location note, use the label we emitted
15766 if (last_insn != NULL_RTX
15767 && last_insn == prev_insn
15768 && NOTE_P (prev_insn)
15769 && NOTE_KIND (prev_insn) == NOTE_INSN_VAR_LOCATION)
15771 newloc->label = last_label;
15775 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
15776 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
15778 newloc->label = ggc_strdup (loclabel);
15780 newloc->var_loc_note = loc_note;
15781 newloc->next = NULL;
15783 if (cfun && in_cold_section_p)
15784 newloc->section_label = crtl->subsections.cold_section_label;
15786 newloc->section_label = text_section_label;
15788 last_insn = loc_note;
15789 last_label = newloc->label;
15790 decl = NOTE_VAR_LOCATION_DECL (loc_note);
15791 add_var_loc_to_decl (decl, newloc);
15794 /* We need to reset the locations at the beginning of each
15795 function. We can't do this in the end_function hook, because the
15796 declarations that use the locations won't have been output when
15797 that hook is called. Also compute have_multiple_function_sections here. */
15800 dwarf2out_begin_function (tree fun)
15802 htab_empty (decl_loc_table);
15804 if (function_section (fun) != text_section)
15805 have_multiple_function_sections = true;
15807 dwarf2out_note_section_used ();
15810 /* Output a label to mark the beginning of a source code line entry
15811 and record information relating to this source line, in
15812 'line_info_table' for later output of the .debug_line section. */
15815 dwarf2out_source_line (unsigned int line, const char *filename)
15817 if (debug_info_level >= DINFO_LEVEL_NORMAL
15820 int file_num = maybe_emit_file (lookup_filename (filename));
15822 switch_to_section (current_function_section ());
15824 /* If requested, emit something human-readable. */
15825 if (flag_debug_asm)
15826 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
15829 if (DWARF2_ASM_LINE_DEBUG_INFO)
15831 /* Emit the .loc directive understood by GNU as. */
15832 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
15834 /* Indicate that line number info exists. */
15835 line_info_table_in_use++;
15837 else if (function_section (current_function_decl) != text_section)
15839 dw_separate_line_info_ref line_info;
15840 targetm.asm_out.internal_label (asm_out_file,
15841 SEPARATE_LINE_CODE_LABEL,
15842 separate_line_info_table_in_use);
15844 /* Expand the line info table if necessary. */
15845 if (separate_line_info_table_in_use
15846 == separate_line_info_table_allocated)
15848 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15849 separate_line_info_table
15850 = GGC_RESIZEVEC (dw_separate_line_info_entry,
15851 separate_line_info_table,
15852 separate_line_info_table_allocated);
15853 memset (separate_line_info_table
15854 + separate_line_info_table_in_use,
15856 (LINE_INFO_TABLE_INCREMENT
15857 * sizeof (dw_separate_line_info_entry)));
15860 /* Add the new entry at the end of the line_info_table. */
15862 = &separate_line_info_table[separate_line_info_table_in_use++];
15863 line_info->dw_file_num = file_num;
15864 line_info->dw_line_num = line;
15865 line_info->function = current_function_funcdef_no;
15869 dw_line_info_ref line_info;
15871 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
15872 line_info_table_in_use);
15874 /* Expand the line info table if necessary. */
15875 if (line_info_table_in_use == line_info_table_allocated)
15877 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15879 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
15880 line_info_table_allocated);
15881 memset (line_info_table + line_info_table_in_use, 0,
15882 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
15885 /* Add the new entry at the end of the line_info_table. */
15886 line_info = &line_info_table[line_info_table_in_use++];
15887 line_info->dw_file_num = file_num;
15888 line_info->dw_line_num = line;
15893 /* Record the beginning of a new source file. */
15896 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
15898 if (flag_eliminate_dwarf2_dups)
15900 /* Record the beginning of the file for break_out_includes. */
15901 dw_die_ref bincl_die;
15903 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
15904 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
15907 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15909 int file_num = maybe_emit_file (lookup_filename (filename));
15911 switch_to_section (debug_macinfo_section);
15912 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
15913 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
15916 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
15920 /* Record the end of a source file. */
15923 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
15925 if (flag_eliminate_dwarf2_dups)
15926 /* Record the end of the file for break_out_includes. */
15927 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
15929 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15931 switch_to_section (debug_macinfo_section);
15932 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
15936 /* Called from debug_define in toplev.c. The `buffer' parameter contains
15937 the tail part of the directive line, i.e. the part which is past the
15938 initial whitespace, #, whitespace, directive-name, whitespace part. */
15941 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
15942 const char *buffer ATTRIBUTE_UNUSED)
15944 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15946 switch_to_section (debug_macinfo_section);
15947 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
15948 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
15949 dw2_asm_output_nstring (buffer, -1, "The macro");
15953 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
15954 the tail part of the directive line, i.e. the part which is past the
15955 initial whitespace, #, whitespace, directive-name, whitespace part. */
15958 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
15959 const char *buffer ATTRIBUTE_UNUSED)
15961 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15963 switch_to_section (debug_macinfo_section);
15964 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
15965 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
15966 dw2_asm_output_nstring (buffer, -1, "The macro");
15970 /* Set up for Dwarf output at the start of compilation. */
15973 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
15975 /* Allocate the file_table. */
15976 file_table = htab_create_ggc (50, file_table_hash,
15977 file_table_eq, NULL);
15979 /* Allocate the decl_die_table. */
15980 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
15981 decl_die_table_eq, NULL);
15983 /* Allocate the decl_loc_table. */
15984 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
15985 decl_loc_table_eq, NULL);
15987 /* Allocate the initial hunk of the decl_scope_table. */
15988 decl_scope_table = VEC_alloc (tree, gc, 256);
15990 /* Allocate the initial hunk of the abbrev_die_table. */
15991 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
15992 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
15993 /* Zero-th entry is allocated, but unused. */
15994 abbrev_die_table_in_use = 1;
15996 /* Allocate the initial hunk of the line_info_table. */
15997 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
15998 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
16000 /* Zero-th entry is allocated, but unused. */
16001 line_info_table_in_use = 1;
16003 /* Allocate the pubtypes and pubnames vectors. */
16004 pubname_table = VEC_alloc (pubname_entry, gc, 32);
16005 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
16007 /* Generate the initial DIE for the .debug section. Note that the (string)
16008 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
16009 will (typically) be a relative pathname and that this pathname should be
16010 taken as being relative to the directory from which the compiler was
16011 invoked when the given (base) source file was compiled. We will fill
16012 in this value in dwarf2out_finish. */
16013 comp_unit_die = gen_compile_unit_die (NULL);
16015 incomplete_types = VEC_alloc (tree, gc, 64);
16017 used_rtx_array = VEC_alloc (rtx, gc, 32);
16019 debug_info_section = get_section (DEBUG_INFO_SECTION,
16020 SECTION_DEBUG, NULL);
16021 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
16022 SECTION_DEBUG, NULL);
16023 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
16024 SECTION_DEBUG, NULL);
16025 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
16026 SECTION_DEBUG, NULL);
16027 debug_line_section = get_section (DEBUG_LINE_SECTION,
16028 SECTION_DEBUG, NULL);
16029 debug_loc_section = get_section (DEBUG_LOC_SECTION,
16030 SECTION_DEBUG, NULL);
16031 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
16032 SECTION_DEBUG, NULL);
16033 #ifdef DEBUG_PUBTYPES_SECTION
16034 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
16035 SECTION_DEBUG, NULL);
16037 debug_str_section = get_section (DEBUG_STR_SECTION,
16038 DEBUG_STR_SECTION_FLAGS, NULL);
16039 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
16040 SECTION_DEBUG, NULL);
16041 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
16042 SECTION_DEBUG, NULL);
16044 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
16045 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
16046 DEBUG_ABBREV_SECTION_LABEL, 0);
16047 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
16048 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
16049 COLD_TEXT_SECTION_LABEL, 0);
16050 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
16052 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
16053 DEBUG_INFO_SECTION_LABEL, 0);
16054 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
16055 DEBUG_LINE_SECTION_LABEL, 0);
16056 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
16057 DEBUG_RANGES_SECTION_LABEL, 0);
16058 switch_to_section (debug_abbrev_section);
16059 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
16060 switch_to_section (debug_info_section);
16061 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
16062 switch_to_section (debug_line_section);
16063 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
16065 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16067 switch_to_section (debug_macinfo_section);
16068 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
16069 DEBUG_MACINFO_SECTION_LABEL, 0);
16070 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
16073 switch_to_section (text_section);
16074 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
16075 if (flag_reorder_blocks_and_partition)
16077 cold_text_section = unlikely_text_section ();
16078 switch_to_section (cold_text_section);
16079 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
16083 /* A helper function for dwarf2out_finish called through
16084 ht_forall. Emit one queued .debug_str string. */
16087 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
16089 struct indirect_string_node *node = (struct indirect_string_node *) *h;
16091 if (node->form == DW_FORM_strp)
16093 switch_to_section (debug_str_section);
16094 ASM_OUTPUT_LABEL (asm_out_file, node->label);
16095 assemble_string (node->str, strlen (node->str) + 1);
16101 #if ENABLE_ASSERT_CHECKING
16102 /* Verify that all marks are clear. */
16105 verify_marks_clear (dw_die_ref die)
16109 gcc_assert (! die->die_mark);
16110 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
16112 #endif /* ENABLE_ASSERT_CHECKING */
16114 /* Clear the marks for a die and its children.
16115 Be cool if the mark isn't set. */
16118 prune_unmark_dies (dw_die_ref die)
16124 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
16127 /* Given DIE that we're marking as used, find any other dies
16128 it references as attributes and mark them as used. */
16131 prune_unused_types_walk_attribs (dw_die_ref die)
16136 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16138 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
16140 /* A reference to another DIE.
16141 Make sure that it will get emitted. */
16142 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
16144 /* Set the string's refcount to 0 so that prune_unused_types_mark
16145 accounts properly for it. */
16146 if (AT_class (a) == dw_val_class_str)
16147 a->dw_attr_val.v.val_str->refcount = 0;
16152 /* Mark DIE as being used. If DOKIDS is true, then walk down
16153 to DIE's children. */
16156 prune_unused_types_mark (dw_die_ref die, int dokids)
16160 if (die->die_mark == 0)
16162 /* We haven't done this node yet. Mark it as used. */
16165 /* We also have to mark its parents as used.
16166 (But we don't want to mark our parents' kids due to this.) */
16167 if (die->die_parent)
16168 prune_unused_types_mark (die->die_parent, 0);
16170 /* Mark any referenced nodes. */
16171 prune_unused_types_walk_attribs (die);
16173 /* If this node is a specification,
16174 also mark the definition, if it exists. */
16175 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
16176 prune_unused_types_mark (die->die_definition, 1);
16179 if (dokids && die->die_mark != 2)
16181 /* We need to walk the children, but haven't done so yet.
16182 Remember that we've walked the kids. */
16185 /* If this is an array type, we need to make sure our
16186 kids get marked, even if they're types. */
16187 if (die->die_tag == DW_TAG_array_type)
16188 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
16190 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16194 /* For local classes, look if any static member functions were emitted
16195 and if so, mark them. */
16198 prune_unused_types_walk_local_classes (dw_die_ref die)
16202 if (die->die_mark == 2)
16205 switch (die->die_tag)
16207 case DW_TAG_structure_type:
16208 case DW_TAG_union_type:
16209 case DW_TAG_class_type:
16212 case DW_TAG_subprogram:
16213 if (!get_AT_flag (die, DW_AT_declaration)
16214 || die->die_definition != NULL)
16215 prune_unused_types_mark (die, 1);
16222 /* Mark children. */
16223 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
16226 /* Walk the tree DIE and mark types that we actually use. */
16229 prune_unused_types_walk (dw_die_ref die)
16233 /* Don't do anything if this node is already marked and
16234 children have been marked as well. */
16235 if (die->die_mark == 2)
16238 switch (die->die_tag)
16240 case DW_TAG_structure_type:
16241 case DW_TAG_union_type:
16242 case DW_TAG_class_type:
16243 if (die->die_perennial_p)
16246 for (c = die->die_parent; c; c = c->die_parent)
16247 if (c->die_tag == DW_TAG_subprogram)
16250 /* Finding used static member functions inside of classes
16251 is needed just for local classes, because for other classes
16252 static member function DIEs with DW_AT_specification
16253 are emitted outside of the DW_TAG_*_type. If we ever change
16254 it, we'd need to call this even for non-local classes. */
16256 prune_unused_types_walk_local_classes (die);
16258 /* It's a type node --- don't mark it. */
16261 case DW_TAG_const_type:
16262 case DW_TAG_packed_type:
16263 case DW_TAG_pointer_type:
16264 case DW_TAG_reference_type:
16265 case DW_TAG_volatile_type:
16266 case DW_TAG_typedef:
16267 case DW_TAG_array_type:
16268 case DW_TAG_interface_type:
16269 case DW_TAG_friend:
16270 case DW_TAG_variant_part:
16271 case DW_TAG_enumeration_type:
16272 case DW_TAG_subroutine_type:
16273 case DW_TAG_string_type:
16274 case DW_TAG_set_type:
16275 case DW_TAG_subrange_type:
16276 case DW_TAG_ptr_to_member_type:
16277 case DW_TAG_file_type:
16278 if (die->die_perennial_p)
16281 /* It's a type node --- don't mark it. */
16285 /* Mark everything else. */
16289 if (die->die_mark == 0)
16293 /* Now, mark any dies referenced from here. */
16294 prune_unused_types_walk_attribs (die);
16299 /* Mark children. */
16300 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16303 /* Increment the string counts on strings referred to from DIE's
16307 prune_unused_types_update_strings (dw_die_ref die)
16312 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16313 if (AT_class (a) == dw_val_class_str)
16315 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
16317 /* Avoid unnecessarily putting strings that are used less than
16318 twice in the hash table. */
16320 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
16323 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
16324 htab_hash_string (s->str),
16326 gcc_assert (*slot == NULL);
16332 /* Remove from the tree DIE any dies that aren't marked. */
16335 prune_unused_types_prune (dw_die_ref die)
16339 gcc_assert (die->die_mark);
16340 prune_unused_types_update_strings (die);
16342 if (! die->die_child)
16345 c = die->die_child;
16347 dw_die_ref prev = c;
16348 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
16349 if (c == die->die_child)
16351 /* No marked children between 'prev' and the end of the list. */
16353 /* No marked children at all. */
16354 die->die_child = NULL;
16357 prev->die_sib = c->die_sib;
16358 die->die_child = prev;
16363 if (c != prev->die_sib)
16365 prune_unused_types_prune (c);
16366 } while (c != die->die_child);
16370 /* Remove dies representing declarations that we never use. */
16373 prune_unused_types (void)
16376 limbo_die_node *node;
16379 #if ENABLE_ASSERT_CHECKING
16380 /* All the marks should already be clear. */
16381 verify_marks_clear (comp_unit_die);
16382 for (node = limbo_die_list; node; node = node->next)
16383 verify_marks_clear (node->die);
16384 #endif /* ENABLE_ASSERT_CHECKING */
16386 /* Set the mark on nodes that are actually used. */
16387 prune_unused_types_walk (comp_unit_die);
16388 for (node = limbo_die_list; node; node = node->next)
16389 prune_unused_types_walk (node->die);
16391 /* Also set the mark on nodes referenced from the
16392 pubname_table or arange_table. */
16393 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
16394 prune_unused_types_mark (pub->die, 1);
16395 for (i = 0; i < arange_table_in_use; i++)
16396 prune_unused_types_mark (arange_table[i], 1);
16398 /* Get rid of nodes that aren't marked; and update the string counts. */
16399 if (debug_str_hash)
16400 htab_empty (debug_str_hash);
16401 prune_unused_types_prune (comp_unit_die);
16402 for (node = limbo_die_list; node; node = node->next)
16403 prune_unused_types_prune (node->die);
16405 /* Leave the marks clear. */
16406 prune_unmark_dies (comp_unit_die);
16407 for (node = limbo_die_list; node; node = node->next)
16408 prune_unmark_dies (node->die);
16411 /* Set the parameter to true if there are any relative pathnames in
16414 file_table_relative_p (void ** slot, void *param)
16416 bool *p = (bool *) param;
16417 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
16418 if (!IS_ABSOLUTE_PATH (d->filename))
16426 /* Output stuff that dwarf requires at the end of every file,
16427 and generate the DWARF-2 debugging info. */
16430 dwarf2out_finish (const char *filename)
16432 limbo_die_node *node, *next_node;
16433 dw_die_ref die = 0;
16436 /* Add the name for the main input file now. We delayed this from
16437 dwarf2out_init to avoid complications with PCH. */
16438 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
16439 if (!IS_ABSOLUTE_PATH (filename))
16440 add_comp_dir_attribute (comp_unit_die);
16441 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
16444 htab_traverse (file_table, file_table_relative_p, &p);
16446 add_comp_dir_attribute (comp_unit_die);
16449 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
16451 add_location_or_const_value_attribute (
16452 VEC_index (deferred_locations, deferred_locations_list, i)->die,
16453 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
16457 /* Traverse the limbo die list, and add parent/child links. The only
16458 dies without parents that should be here are concrete instances of
16459 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
16460 For concrete instances, we can get the parent die from the abstract
16462 for (node = limbo_die_list; node; node = next_node)
16464 next_node = node->next;
16467 if (die->die_parent == NULL)
16469 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
16472 add_child_die (origin->die_parent, die);
16473 else if (die == comp_unit_die)
16475 else if (errorcount > 0 || sorrycount > 0)
16476 /* It's OK to be confused by errors in the input. */
16477 add_child_die (comp_unit_die, die);
16480 /* In certain situations, the lexical block containing a
16481 nested function can be optimized away, which results
16482 in the nested function die being orphaned. Likewise
16483 with the return type of that nested function. Force
16484 this to be a child of the containing function.
16486 It may happen that even the containing function got fully
16487 inlined and optimized out. In that case we are lost and
16488 assign the empty child. This should not be big issue as
16489 the function is likely unreachable too. */
16490 tree context = NULL_TREE;
16492 gcc_assert (node->created_for);
16494 if (DECL_P (node->created_for))
16495 context = DECL_CONTEXT (node->created_for);
16496 else if (TYPE_P (node->created_for))
16497 context = TYPE_CONTEXT (node->created_for);
16499 gcc_assert (context
16500 && (TREE_CODE (context) == FUNCTION_DECL
16501 || TREE_CODE (context) == NAMESPACE_DECL));
16503 origin = lookup_decl_die (context);
16505 add_child_die (origin, die);
16507 add_child_die (comp_unit_die, die);
16512 limbo_die_list = NULL;
16514 /* Walk through the list of incomplete types again, trying once more to
16515 emit full debugging info for them. */
16516 retry_incomplete_types ();
16518 if (flag_eliminate_unused_debug_types)
16519 prune_unused_types ();
16521 /* Generate separate CUs for each of the include files we've seen.
16522 They will go into limbo_die_list. */
16523 if (flag_eliminate_dwarf2_dups)
16524 break_out_includes (comp_unit_die);
16526 /* Traverse the DIE's and add add sibling attributes to those DIE's
16527 that have children. */
16528 add_sibling_attributes (comp_unit_die);
16529 for (node = limbo_die_list; node; node = node->next)
16530 add_sibling_attributes (node->die);
16532 /* Output a terminator label for the .text section. */
16533 switch_to_section (text_section);
16534 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
16535 if (flag_reorder_blocks_and_partition)
16537 switch_to_section (unlikely_text_section ());
16538 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
16541 /* We can only use the low/high_pc attributes if all of the code was
16543 if (!have_multiple_function_sections)
16545 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
16546 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
16551 unsigned fde_idx = 0;
16553 /* We need to give .debug_loc and .debug_ranges an appropriate
16554 "base address". Use zero so that these addresses become
16555 absolute. Historically, we've emitted the unexpected
16556 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
16557 Emit both to give time for other tools to adapt. */
16558 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
16559 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
16561 add_AT_range_list (comp_unit_die, DW_AT_ranges,
16562 add_ranges_by_labels (text_section_label,
16564 if (flag_reorder_blocks_and_partition)
16565 add_ranges_by_labels (cold_text_section_label,
16568 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
16570 dw_fde_ref fde = &fde_table[fde_idx];
16572 if (fde->dw_fde_switched_sections)
16574 add_ranges_by_labels (fde->dw_fde_hot_section_label,
16575 fde->dw_fde_hot_section_end_label);
16576 add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
16577 fde->dw_fde_unlikely_section_end_label);
16580 add_ranges_by_labels (fde->dw_fde_begin,
16587 /* Output location list section if necessary. */
16588 if (have_location_lists)
16590 /* Output the location lists info. */
16591 switch_to_section (debug_loc_section);
16592 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
16593 DEBUG_LOC_SECTION_LABEL, 0);
16594 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
16595 output_location_lists (die);
16598 if (debug_info_level >= DINFO_LEVEL_NORMAL)
16599 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
16600 debug_line_section_label);
16602 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16603 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
16605 /* Output all of the compilation units. We put the main one last so that
16606 the offsets are available to output_pubnames. */
16607 for (node = limbo_die_list; node; node = node->next)
16608 output_comp_unit (node->die, 0);
16610 /* Output the main compilation unit if non-empty or if .debug_macinfo
16611 has been emitted. */
16612 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
16614 /* Output the abbreviation table. */
16615 switch_to_section (debug_abbrev_section);
16616 output_abbrev_section ();
16618 /* Output public names table if necessary. */
16619 if (!VEC_empty (pubname_entry, pubname_table))
16621 switch_to_section (debug_pubnames_section);
16622 output_pubnames (pubname_table);
16625 #ifdef DEBUG_PUBTYPES_SECTION
16626 /* Output public types table if necessary. */
16627 if (!VEC_empty (pubname_entry, pubtype_table))
16629 switch_to_section (debug_pubtypes_section);
16630 output_pubnames (pubtype_table);
16634 /* Output the address range information. We only put functions in the arange
16635 table, so don't write it out if we don't have any. */
16636 if (fde_table_in_use)
16638 switch_to_section (debug_aranges_section);
16642 /* Output ranges section if necessary. */
16643 if (ranges_table_in_use)
16645 switch_to_section (debug_ranges_section);
16646 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
16650 /* Output the source line correspondence table. We must do this
16651 even if there is no line information. Otherwise, on an empty
16652 translation unit, we will generate a present, but empty,
16653 .debug_info section. IRIX 6.5 `nm' will then complain when
16654 examining the file. This is done late so that any filenames
16655 used by the debug_info section are marked as 'used'. */
16656 if (! DWARF2_ASM_LINE_DEBUG_INFO)
16658 switch_to_section (debug_line_section);
16659 output_line_info ();
16662 /* Have to end the macro section. */
16663 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16665 switch_to_section (debug_macinfo_section);
16666 dw2_asm_output_data (1, 0, "End compilation unit");
16669 /* If we emitted any DW_FORM_strp form attribute, output the string
16671 if (debug_str_hash)
16672 htab_traverse (debug_str_hash, output_indirect_string, NULL);
16676 /* This should never be used, but its address is needed for comparisons. */
16677 const struct gcc_debug_hooks dwarf2_debug_hooks;
16679 #endif /* DWARF2_DEBUGGING_INFO */
16681 #include "gt-dwarf2out.h"