1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* TODO: Emit .debug_line header even when there are no functions, since
25 the file numbers are used by .debug_info. Alternately, leave
26 out locations for types and decls.
27 Avoid talking about ctors and op= for PODs.
28 Factor out common prologue sequences into multiple CIEs. */
30 /* The first part of this file deals with the DWARF 2 frame unwind
31 information, which is also used by the GCC efficient exception handling
32 mechanism. The second part, controlled only by an #ifdef
33 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
36 /* DWARF2 Abbreviation Glossary:
38 CFA = Canonical Frame Address
39 a fixed address on the stack which identifies a call frame.
40 We define it to be the value of SP just before the call insn.
41 The CFA register and offset, which may change during the course
42 of the function, are used to calculate its value at runtime.
44 CFI = Call Frame Instruction
45 an instruction for the DWARF2 abstract machine
47 CIE = Common Information Entry
48 information describing information common to one or more FDEs
50 DIE = Debugging Information Entry
52 FDE = Frame Description Entry
53 information describing the stack call frame, in particular,
54 how to restore registers
56 DW_CFA_... = DWARF2 CFA call frame instruction
57 DW_TAG_... = DWARF2 DIE tag */
61 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
85 #include "diagnostic.h"
88 #include "langhooks.h"
93 #ifdef DWARF2_DEBUGGING_INFO
94 static void dwarf2out_source_line (unsigned int, const char *);
97 #ifndef DWARF2_FRAME_INFO
98 # ifdef DWARF2_DEBUGGING_INFO
99 # define DWARF2_FRAME_INFO \
100 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
102 # define DWARF2_FRAME_INFO 0
106 /* Map register numbers held in the call frame info that gcc has
107 collected using DWARF_FRAME_REGNUM to those that should be output in
108 .debug_frame and .eh_frame. */
109 #ifndef DWARF2_FRAME_REG_OUT
110 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
113 /* Save the result of dwarf2out_do_frame across PCH. */
114 static GTY(()) bool saved_do_cfi_asm = 0;
116 /* Decide whether we want to emit frame unwind information for the current
120 dwarf2out_do_frame (void)
122 /* We want to emit correct CFA location expressions or lists, so we
123 have to return true if we're going to output debug info, even if
124 we're not going to output frame or unwind info. */
125 return (write_symbols == DWARF2_DEBUG
126 || write_symbols == VMS_AND_DWARF2_DEBUG
127 || DWARF2_FRAME_INFO || saved_do_cfi_asm
128 #ifdef DWARF2_UNWIND_INFO
129 || (DWARF2_UNWIND_INFO
130 && (flag_unwind_tables
131 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
136 /* Decide whether to emit frame unwind via assembler directives. */
139 dwarf2out_do_cfi_asm (void)
143 #ifdef MIPS_DEBUGGING_INFO
146 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
148 if (saved_do_cfi_asm || !eh_personality_libfunc)
150 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
153 /* Make sure the personality encoding is one the assembler can support.
154 In particular, aligned addresses can't be handled. */
155 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
156 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
158 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
159 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
162 saved_do_cfi_asm = true;
166 /* The size of the target's pointer type. */
168 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
171 /* Array of RTXes referenced by the debugging information, which therefore
172 must be kept around forever. */
173 static GTY(()) VEC(rtx,gc) *used_rtx_array;
175 /* A pointer to the base of a list of incomplete types which might be
176 completed at some later time. incomplete_types_list needs to be a
177 VEC(tree,gc) because we want to tell the garbage collector about
179 static GTY(()) VEC(tree,gc) *incomplete_types;
181 /* A pointer to the base of a table of references to declaration
182 scopes. This table is a display which tracks the nesting
183 of declaration scopes at the current scope and containing
184 scopes. This table is used to find the proper place to
185 define type declaration DIE's. */
186 static GTY(()) VEC(tree,gc) *decl_scope_table;
188 /* Pointers to various DWARF2 sections. */
189 static GTY(()) section *debug_info_section;
190 static GTY(()) section *debug_abbrev_section;
191 static GTY(()) section *debug_aranges_section;
192 static GTY(()) section *debug_macinfo_section;
193 static GTY(()) section *debug_line_section;
194 static GTY(()) section *debug_loc_section;
195 static GTY(()) section *debug_pubnames_section;
196 static GTY(()) section *debug_pubtypes_section;
197 static GTY(()) section *debug_str_section;
198 static GTY(()) section *debug_ranges_section;
199 static GTY(()) section *debug_frame_section;
201 /* How to start an assembler comment. */
202 #ifndef ASM_COMMENT_START
203 #define ASM_COMMENT_START ";#"
206 typedef struct dw_cfi_struct *dw_cfi_ref;
207 typedef struct dw_fde_struct *dw_fde_ref;
208 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
210 /* Call frames are described using a sequence of Call Frame
211 Information instructions. The register number, offset
212 and address fields are provided as possible operands;
213 their use is selected by the opcode field. */
215 enum dw_cfi_oprnd_type {
217 dw_cfi_oprnd_reg_num,
223 typedef union dw_cfi_oprnd_struct GTY(())
225 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
226 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
227 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
228 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
232 typedef struct dw_cfi_struct GTY(())
234 dw_cfi_ref dw_cfi_next;
235 enum dwarf_call_frame_info dw_cfi_opc;
236 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
238 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
243 /* This is how we define the location of the CFA. We use to handle it
244 as REG + OFFSET all the time, but now it can be more complex.
245 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
246 Instead of passing around REG and OFFSET, we pass a copy
247 of this structure. */
248 typedef struct cfa_loc GTY(())
250 HOST_WIDE_INT offset;
251 HOST_WIDE_INT base_offset;
253 int indirect; /* 1 if CFA is accessed via a dereference. */
256 /* All call frame descriptions (FDE's) in the GCC generated DWARF
257 refer to a single Common Information Entry (CIE), defined at
258 the beginning of the .debug_frame section. This use of a single
259 CIE obviates the need to keep track of multiple CIE's
260 in the DWARF generation routines below. */
262 typedef struct dw_fde_struct GTY(())
265 const char *dw_fde_begin;
266 const char *dw_fde_current_label;
267 const char *dw_fde_end;
268 const char *dw_fde_hot_section_label;
269 const char *dw_fde_hot_section_end_label;
270 const char *dw_fde_unlikely_section_label;
271 const char *dw_fde_unlikely_section_end_label;
272 bool dw_fde_switched_sections;
273 dw_cfi_ref dw_fde_cfi;
274 unsigned funcdef_number;
275 HOST_WIDE_INT stack_realignment;
276 /* Dynamic realign argument pointer register. */
277 unsigned int drap_reg;
278 /* Virtual dynamic realign argument pointer register. */
279 unsigned int vdrap_reg;
280 unsigned all_throwers_are_sibcalls : 1;
281 unsigned nothrow : 1;
282 unsigned uses_eh_lsda : 1;
283 /* Whether we did stack realign in this call frame. */
284 unsigned stack_realign : 1;
285 /* Whether dynamic realign argument pointer register has been saved. */
286 unsigned drap_reg_saved: 1;
290 /* Maximum size (in bytes) of an artificially generated label. */
291 #define MAX_ARTIFICIAL_LABEL_BYTES 30
293 /* The size of addresses as they appear in the Dwarf 2 data.
294 Some architectures use word addresses to refer to code locations,
295 but Dwarf 2 info always uses byte addresses. On such machines,
296 Dwarf 2 addresses need to be larger than the architecture's
298 #ifndef DWARF2_ADDR_SIZE
299 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
302 /* The size in bytes of a DWARF field indicating an offset or length
303 relative to a debug info section, specified to be 4 bytes in the
304 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
307 #ifndef DWARF_OFFSET_SIZE
308 #define DWARF_OFFSET_SIZE 4
311 /* According to the (draft) DWARF 3 specification, the initial length
312 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
313 bytes are 0xffffffff, followed by the length stored in the next 8
316 However, the SGI/MIPS ABI uses an initial length which is equal to
317 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
319 #ifndef DWARF_INITIAL_LENGTH_SIZE
320 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
323 #define DWARF_VERSION 2
325 /* Round SIZE up to the nearest BOUNDARY. */
326 #define DWARF_ROUND(SIZE,BOUNDARY) \
327 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
329 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
330 #ifndef DWARF_CIE_DATA_ALIGNMENT
331 #ifdef STACK_GROWS_DOWNWARD
332 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
334 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
338 /* CIE identifier. */
339 #if HOST_BITS_PER_WIDE_INT >= 64
340 #define DWARF_CIE_ID \
341 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
343 #define DWARF_CIE_ID DW_CIE_ID
346 /* A pointer to the base of a table that contains frame description
347 information for each routine. */
348 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
350 /* Number of elements currently allocated for fde_table. */
351 static GTY(()) unsigned fde_table_allocated;
353 /* Number of elements in fde_table currently in use. */
354 static GTY(()) unsigned fde_table_in_use;
356 /* Size (in elements) of increments by which we may expand the
358 #define FDE_TABLE_INCREMENT 256
360 /* Get the current fde_table entry we should use. */
362 static inline dw_fde_ref
365 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
368 /* A list of call frame insns for the CIE. */
369 static GTY(()) dw_cfi_ref cie_cfi_head;
371 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
372 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
373 attribute that accelerates the lookup of the FDE associated
374 with the subprogram. This variable holds the table index of the FDE
375 associated with the current function (body) definition. */
376 static unsigned current_funcdef_fde;
379 struct indirect_string_node GTY(())
382 unsigned int refcount;
387 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
389 static GTY(()) int dw2_string_counter;
390 static GTY(()) unsigned long dwarf2out_cfi_label_num;
392 /* True if the compilation unit places functions in more than one section. */
393 static GTY(()) bool have_multiple_function_sections = false;
395 /* Whether the default text and cold text sections have been used at all. */
397 static GTY(()) bool text_section_used = false;
398 static GTY(()) bool cold_text_section_used = false;
400 /* The default cold text section. */
401 static GTY(()) section *cold_text_section;
403 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
405 /* Forward declarations for functions defined in this file. */
407 static char *stripattributes (const char *);
408 static const char *dwarf_cfi_name (unsigned);
409 static dw_cfi_ref new_cfi (void);
410 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
411 static void add_fde_cfi (const char *, dw_cfi_ref);
412 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
413 static void lookup_cfa (dw_cfa_location *);
414 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
415 #ifdef DWARF2_UNWIND_INFO
416 static void initial_return_save (rtx);
418 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
420 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
421 static void output_cfi_directive (dw_cfi_ref);
422 static void output_call_frame_info (int);
423 static void dwarf2out_note_section_used (void);
424 static void dwarf2out_stack_adjust (rtx, bool);
425 static void dwarf2out_args_size_adjust (HOST_WIDE_INT, const char *);
426 static void flush_queued_reg_saves (void);
427 static bool clobbers_queued_reg_save (const_rtx);
428 static void dwarf2out_frame_debug_expr (rtx, const char *);
430 /* Support for complex CFA locations. */
431 static void output_cfa_loc (dw_cfi_ref);
432 static void output_cfa_loc_raw (dw_cfi_ref);
433 static void get_cfa_from_loc_descr (dw_cfa_location *,
434 struct dw_loc_descr_struct *);
435 static struct dw_loc_descr_struct *build_cfa_loc
436 (dw_cfa_location *, HOST_WIDE_INT);
437 static struct dw_loc_descr_struct *build_cfa_aligned_loc
438 (HOST_WIDE_INT, HOST_WIDE_INT);
439 static void def_cfa_1 (const char *, dw_cfa_location *);
441 /* How to start an assembler comment. */
442 #ifndef ASM_COMMENT_START
443 #define ASM_COMMENT_START ";#"
446 /* Data and reference forms for relocatable data. */
447 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
448 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
450 #ifndef DEBUG_FRAME_SECTION
451 #define DEBUG_FRAME_SECTION ".debug_frame"
454 #ifndef FUNC_BEGIN_LABEL
455 #define FUNC_BEGIN_LABEL "LFB"
458 #ifndef FUNC_END_LABEL
459 #define FUNC_END_LABEL "LFE"
462 #ifndef FRAME_BEGIN_LABEL
463 #define FRAME_BEGIN_LABEL "Lframe"
465 #define CIE_AFTER_SIZE_LABEL "LSCIE"
466 #define CIE_END_LABEL "LECIE"
467 #define FDE_LABEL "LSFDE"
468 #define FDE_AFTER_SIZE_LABEL "LASFDE"
469 #define FDE_END_LABEL "LEFDE"
470 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
471 #define LINE_NUMBER_END_LABEL "LELT"
472 #define LN_PROLOG_AS_LABEL "LASLTP"
473 #define LN_PROLOG_END_LABEL "LELTP"
474 #define DIE_LABEL_PREFIX "DW"
476 /* The DWARF 2 CFA column which tracks the return address. Normally this
477 is the column for PC, or the first column after all of the hard
479 #ifndef DWARF_FRAME_RETURN_COLUMN
481 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
483 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
487 /* The mapping from gcc register number to DWARF 2 CFA column number. By
488 default, we just provide columns for all registers. */
489 #ifndef DWARF_FRAME_REGNUM
490 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
493 /* Hook used by __throw. */
496 expand_builtin_dwarf_sp_column (void)
498 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
499 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
502 /* Return a pointer to a copy of the section string name S with all
503 attributes stripped off, and an asterisk prepended (for assemble_name). */
506 stripattributes (const char *s)
508 char *stripped = XNEWVEC (char, strlen (s) + 2);
513 while (*s && *s != ',')
520 /* MEM is a memory reference for the register size table, each element of
521 which has mode MODE. Initialize column C as a return address column. */
524 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
526 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
527 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
528 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
531 /* Generate code to initialize the register size table. */
534 expand_builtin_init_dwarf_reg_sizes (tree address)
537 enum machine_mode mode = TYPE_MODE (char_type_node);
538 rtx addr = expand_normal (address);
539 rtx mem = gen_rtx_MEM (BLKmode, addr);
540 bool wrote_return_column = false;
542 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
544 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
546 if (rnum < DWARF_FRAME_REGISTERS)
548 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
549 enum machine_mode save_mode = reg_raw_mode[i];
552 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
553 save_mode = choose_hard_reg_mode (i, 1, true);
554 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
556 if (save_mode == VOIDmode)
558 wrote_return_column = true;
560 size = GET_MODE_SIZE (save_mode);
564 emit_move_insn (adjust_address (mem, mode, offset),
565 gen_int_mode (size, mode));
569 if (!wrote_return_column)
570 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
572 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
573 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
576 targetm.init_dwarf_reg_sizes_extra (address);
579 /* Convert a DWARF call frame info. operation to its string name */
582 dwarf_cfi_name (unsigned int cfi_opc)
586 case DW_CFA_advance_loc:
587 return "DW_CFA_advance_loc";
589 return "DW_CFA_offset";
591 return "DW_CFA_restore";
595 return "DW_CFA_set_loc";
596 case DW_CFA_advance_loc1:
597 return "DW_CFA_advance_loc1";
598 case DW_CFA_advance_loc2:
599 return "DW_CFA_advance_loc2";
600 case DW_CFA_advance_loc4:
601 return "DW_CFA_advance_loc4";
602 case DW_CFA_offset_extended:
603 return "DW_CFA_offset_extended";
604 case DW_CFA_restore_extended:
605 return "DW_CFA_restore_extended";
606 case DW_CFA_undefined:
607 return "DW_CFA_undefined";
608 case DW_CFA_same_value:
609 return "DW_CFA_same_value";
610 case DW_CFA_register:
611 return "DW_CFA_register";
612 case DW_CFA_remember_state:
613 return "DW_CFA_remember_state";
614 case DW_CFA_restore_state:
615 return "DW_CFA_restore_state";
617 return "DW_CFA_def_cfa";
618 case DW_CFA_def_cfa_register:
619 return "DW_CFA_def_cfa_register";
620 case DW_CFA_def_cfa_offset:
621 return "DW_CFA_def_cfa_offset";
624 case DW_CFA_def_cfa_expression:
625 return "DW_CFA_def_cfa_expression";
626 case DW_CFA_expression:
627 return "DW_CFA_expression";
628 case DW_CFA_offset_extended_sf:
629 return "DW_CFA_offset_extended_sf";
630 case DW_CFA_def_cfa_sf:
631 return "DW_CFA_def_cfa_sf";
632 case DW_CFA_def_cfa_offset_sf:
633 return "DW_CFA_def_cfa_offset_sf";
635 /* SGI/MIPS specific */
636 case DW_CFA_MIPS_advance_loc8:
637 return "DW_CFA_MIPS_advance_loc8";
640 case DW_CFA_GNU_window_save:
641 return "DW_CFA_GNU_window_save";
642 case DW_CFA_GNU_args_size:
643 return "DW_CFA_GNU_args_size";
644 case DW_CFA_GNU_negative_offset_extended:
645 return "DW_CFA_GNU_negative_offset_extended";
648 return "DW_CFA_<unknown>";
652 /* Return a pointer to a newly allocated Call Frame Instruction. */
654 static inline dw_cfi_ref
657 dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
659 cfi->dw_cfi_next = NULL;
660 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
661 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
666 /* Add a Call Frame Instruction to list of instructions. */
669 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
672 dw_fde_ref fde = current_fde ();
674 /* When DRAP is used, CFA is defined with an expression. Redefine
675 CFA may lead to a different CFA value. */
676 if (fde && fde->drap_reg != INVALID_REGNUM)
677 switch (cfi->dw_cfi_opc)
679 case DW_CFA_def_cfa_register:
680 case DW_CFA_def_cfa_offset:
681 case DW_CFA_def_cfa_offset_sf:
683 case DW_CFA_def_cfa_sf:
690 /* Find the end of the chain. */
691 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
697 /* Generate a new label for the CFI info to refer to. */
700 dwarf2out_cfi_label (void)
702 static char label[20];
704 if (dwarf2out_do_cfi_asm ())
706 /* In this case, we will be emitting the asm directive instead of
707 the label, so just return a placeholder to keep the rest of the
709 strcpy (label, "<do not output>");
713 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
714 ASM_OUTPUT_LABEL (asm_out_file, label);
720 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
721 or to the CIE if LABEL is NULL. */
724 add_fde_cfi (const char *label, dw_cfi_ref cfi)
726 dw_cfi_ref *list_head = &cie_cfi_head;
728 if (dwarf2out_do_cfi_asm ())
732 output_cfi_directive (cfi);
734 /* We still have to add the cfi to the list so that
735 lookup_cfa works later on. */
736 list_head = ¤t_fde ()->dw_fde_cfi;
738 /* ??? If this is a CFI for the CIE, we don't emit. This
739 assumes that the standard CIE contents that the assembler
740 uses matches the standard CIE contents that the compiler
741 uses. This is probably a bad assumption. I'm not quite
742 sure how to address this for now. */
746 dw_fde_ref fde = current_fde ();
748 gcc_assert (fde != NULL);
751 label = dwarf2out_cfi_label ();
753 if (fde->dw_fde_current_label == NULL
754 || strcmp (label, fde->dw_fde_current_label) != 0)
758 label = xstrdup (label);
760 /* Set the location counter to the new label. */
762 /* If we have a current label, advance from there, otherwise
763 set the location directly using set_loc. */
764 xcfi->dw_cfi_opc = fde->dw_fde_current_label
765 ? DW_CFA_advance_loc4
767 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
768 add_cfi (&fde->dw_fde_cfi, xcfi);
770 fde->dw_fde_current_label = label;
773 list_head = &fde->dw_fde_cfi;
776 add_cfi (list_head, cfi);
779 /* Subroutine of lookup_cfa. */
782 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
784 switch (cfi->dw_cfi_opc)
786 case DW_CFA_def_cfa_offset:
787 case DW_CFA_def_cfa_offset_sf:
788 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
790 case DW_CFA_def_cfa_register:
791 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
794 case DW_CFA_def_cfa_sf:
795 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
796 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
798 case DW_CFA_def_cfa_expression:
799 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
806 /* Find the previous value for the CFA. */
809 lookup_cfa (dw_cfa_location *loc)
814 loc->reg = INVALID_REGNUM;
817 loc->base_offset = 0;
819 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
820 lookup_cfa_1 (cfi, loc);
822 fde = current_fde ();
824 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
825 lookup_cfa_1 (cfi, loc);
828 /* The current rule for calculating the DWARF2 canonical frame address. */
829 static dw_cfa_location cfa;
831 /* The register used for saving registers to the stack, and its offset
833 static dw_cfa_location cfa_store;
835 /* The running total of the size of arguments pushed onto the stack. */
836 static HOST_WIDE_INT args_size;
838 /* The last args_size we actually output. */
839 static HOST_WIDE_INT old_args_size;
841 /* Entry point to update the canonical frame address (CFA).
842 LABEL is passed to add_fde_cfi. The value of CFA is now to be
843 calculated from REG+OFFSET. */
846 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
853 def_cfa_1 (label, &loc);
856 /* Determine if two dw_cfa_location structures define the same data. */
859 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
861 return (loc1->reg == loc2->reg
862 && loc1->offset == loc2->offset
863 && loc1->indirect == loc2->indirect
864 && (loc1->indirect == 0
865 || loc1->base_offset == loc2->base_offset));
868 /* This routine does the actual work. The CFA is now calculated from
869 the dw_cfa_location structure. */
872 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
875 dw_cfa_location old_cfa, loc;
880 if (cfa_store.reg == loc.reg && loc.indirect == 0)
881 cfa_store.offset = loc.offset;
883 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
884 lookup_cfa (&old_cfa);
886 /* If nothing changed, no need to issue any call frame instructions. */
887 if (cfa_equal_p (&loc, &old_cfa))
892 if (loc.reg == old_cfa.reg && !loc.indirect)
894 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
895 the CFA register did not change but the offset did. The data
896 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
897 in the assembler via the .cfi_def_cfa_offset directive. */
899 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
901 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
902 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
905 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
906 else if (loc.offset == old_cfa.offset
907 && old_cfa.reg != INVALID_REGNUM
910 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
911 indicating the CFA register has changed to <register> but the
912 offset has not changed. */
913 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
914 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
918 else if (loc.indirect == 0)
920 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
921 indicating the CFA register has changed to <register> with
922 the specified offset. The data factoring for DW_CFA_def_cfa_sf
923 happens in output_cfi, or in the assembler via the .cfi_def_cfa
926 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
928 cfi->dw_cfi_opc = DW_CFA_def_cfa;
929 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
930 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
934 /* Construct a DW_CFA_def_cfa_expression instruction to
935 calculate the CFA using a full location expression since no
936 register-offset pair is available. */
937 struct dw_loc_descr_struct *loc_list;
939 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
940 loc_list = build_cfa_loc (&loc, 0);
941 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
944 add_fde_cfi (label, cfi);
947 /* Add the CFI for saving a register. REG is the CFA column number.
948 LABEL is passed to add_fde_cfi.
949 If SREG is -1, the register is saved at OFFSET from the CFA;
950 otherwise it is saved in SREG. */
953 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
955 dw_cfi_ref cfi = new_cfi ();
956 dw_fde_ref fde = current_fde ();
958 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
960 /* When stack is aligned, store REG using DW_CFA_expression with
963 && fde->stack_realign
964 && sreg == INVALID_REGNUM)
966 cfi->dw_cfi_opc = DW_CFA_expression;
967 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = reg;
968 cfi->dw_cfi_oprnd1.dw_cfi_loc
969 = build_cfa_aligned_loc (offset, fde->stack_realignment);
971 else if (sreg == INVALID_REGNUM)
974 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
975 else if (reg & ~0x3f)
976 cfi->dw_cfi_opc = DW_CFA_offset_extended;
978 cfi->dw_cfi_opc = DW_CFA_offset;
979 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
981 else if (sreg == reg)
982 cfi->dw_cfi_opc = DW_CFA_same_value;
985 cfi->dw_cfi_opc = DW_CFA_register;
986 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
989 add_fde_cfi (label, cfi);
992 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
993 This CFI tells the unwinder that it needs to restore the window registers
994 from the previous frame's window save area.
996 ??? Perhaps we should note in the CIE where windows are saved (instead of
997 assuming 0(cfa)) and what registers are in the window. */
1000 dwarf2out_window_save (const char *label)
1002 dw_cfi_ref cfi = new_cfi ();
1004 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1005 add_fde_cfi (label, cfi);
1008 /* Add a CFI to update the running total of the size of arguments
1009 pushed onto the stack. */
1012 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1016 if (size == old_args_size)
1019 old_args_size = size;
1022 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1023 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1024 add_fde_cfi (label, cfi);
1027 /* Entry point for saving a register to the stack. REG is the GCC register
1028 number. LABEL and OFFSET are passed to reg_save. */
1031 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1033 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1036 /* Entry point for saving the return address in the stack.
1037 LABEL and OFFSET are passed to reg_save. */
1040 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1042 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1045 /* Entry point for saving the return address in a register.
1046 LABEL and SREG are passed to reg_save. */
1049 dwarf2out_return_reg (const char *label, unsigned int sreg)
1051 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1054 #ifdef DWARF2_UNWIND_INFO
1055 /* Record the initial position of the return address. RTL is
1056 INCOMING_RETURN_ADDR_RTX. */
1059 initial_return_save (rtx rtl)
1061 unsigned int reg = INVALID_REGNUM;
1062 HOST_WIDE_INT offset = 0;
1064 switch (GET_CODE (rtl))
1067 /* RA is in a register. */
1068 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1072 /* RA is on the stack. */
1073 rtl = XEXP (rtl, 0);
1074 switch (GET_CODE (rtl))
1077 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1082 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1083 offset = INTVAL (XEXP (rtl, 1));
1087 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1088 offset = -INTVAL (XEXP (rtl, 1));
1098 /* The return address is at some offset from any value we can
1099 actually load. For instance, on the SPARC it is in %i7+8. Just
1100 ignore the offset for now; it doesn't matter for unwinding frames. */
1101 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1102 initial_return_save (XEXP (rtl, 0));
1109 if (reg != DWARF_FRAME_RETURN_COLUMN)
1110 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1114 /* Given a SET, calculate the amount of stack adjustment it
1117 static HOST_WIDE_INT
1118 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1119 HOST_WIDE_INT cur_offset)
1121 const_rtx src = SET_SRC (pattern);
1122 const_rtx dest = SET_DEST (pattern);
1123 HOST_WIDE_INT offset = 0;
1126 if (dest == stack_pointer_rtx)
1128 code = GET_CODE (src);
1130 /* Assume (set (reg sp) (reg whatever)) sets args_size
1132 if (code == REG && src != stack_pointer_rtx)
1134 offset = -cur_args_size;
1135 #ifndef STACK_GROWS_DOWNWARD
1138 return offset - cur_offset;
1141 if (! (code == PLUS || code == MINUS)
1142 || XEXP (src, 0) != stack_pointer_rtx
1143 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1146 /* (set (reg sp) (plus (reg sp) (const_int))) */
1147 offset = INTVAL (XEXP (src, 1));
1153 if (MEM_P (src) && !MEM_P (dest))
1157 /* (set (mem (pre_dec (reg sp))) (foo)) */
1158 src = XEXP (dest, 0);
1159 code = GET_CODE (src);
1165 if (XEXP (src, 0) == stack_pointer_rtx)
1167 rtx val = XEXP (XEXP (src, 1), 1);
1168 /* We handle only adjustments by constant amount. */
1169 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1170 && GET_CODE (val) == CONST_INT);
1171 offset = -INTVAL (val);
1178 if (XEXP (src, 0) == stack_pointer_rtx)
1180 offset = GET_MODE_SIZE (GET_MODE (dest));
1187 if (XEXP (src, 0) == stack_pointer_rtx)
1189 offset = -GET_MODE_SIZE (GET_MODE (dest));
1204 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1205 indexed by INSN_UID. */
1207 static HOST_WIDE_INT *barrier_args_size;
1209 /* Helper function for compute_barrier_args_size. Handle one insn. */
1211 static HOST_WIDE_INT
1212 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1213 VEC (rtx, heap) **next)
1215 HOST_WIDE_INT offset = 0;
1218 if (! RTX_FRAME_RELATED_P (insn))
1220 if (prologue_epilogue_contains (insn)
1221 || sibcall_epilogue_contains (insn))
1223 else if (GET_CODE (PATTERN (insn)) == SET)
1224 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1225 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1226 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1228 /* There may be stack adjustments inside compound insns. Search
1230 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1231 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1232 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1233 cur_args_size, offset);
1238 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1242 expr = XEXP (expr, 0);
1243 if (GET_CODE (expr) == PARALLEL
1244 || GET_CODE (expr) == SEQUENCE)
1245 for (i = 1; i < XVECLEN (expr, 0); i++)
1247 rtx elem = XVECEXP (expr, 0, i);
1249 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1250 offset += stack_adjust_offset (elem, cur_args_size, offset);
1255 #ifndef STACK_GROWS_DOWNWARD
1259 cur_args_size += offset;
1260 if (cur_args_size < 0)
1265 rtx dest = JUMP_LABEL (insn);
1269 if (barrier_args_size [INSN_UID (dest)] < 0)
1271 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1272 VEC_safe_push (rtx, heap, *next, dest);
1277 return cur_args_size;
1280 /* Walk the whole function and compute args_size on BARRIERs. */
1283 compute_barrier_args_size (void)
1285 int max_uid = get_max_uid (), i;
1287 VEC (rtx, heap) *worklist, *next, *tmp;
1289 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1290 for (i = 0; i < max_uid; i++)
1291 barrier_args_size[i] = -1;
1293 worklist = VEC_alloc (rtx, heap, 20);
1294 next = VEC_alloc (rtx, heap, 20);
1295 insn = get_insns ();
1296 barrier_args_size[INSN_UID (insn)] = 0;
1297 VEC_quick_push (rtx, worklist, insn);
1300 while (!VEC_empty (rtx, worklist))
1302 rtx prev, body, first_insn;
1303 HOST_WIDE_INT cur_args_size;
1305 first_insn = insn = VEC_pop (rtx, worklist);
1306 cur_args_size = barrier_args_size[INSN_UID (insn)];
1307 prev = prev_nonnote_insn (insn);
1308 if (prev && BARRIER_P (prev))
1309 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1311 for (; insn; insn = NEXT_INSN (insn))
1313 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1315 if (BARRIER_P (insn))
1320 if (insn == first_insn)
1322 else if (barrier_args_size[INSN_UID (insn)] < 0)
1324 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1329 /* The insns starting with this label have been
1330 already scanned or are in the worklist. */
1335 body = PATTERN (insn);
1336 if (GET_CODE (body) == SEQUENCE)
1338 HOST_WIDE_INT dest_args_size = cur_args_size;
1339 for (i = 1; i < XVECLEN (body, 0); i++)
1340 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1341 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1343 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1344 dest_args_size, &next);
1347 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1348 cur_args_size, &next);
1350 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1351 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1352 dest_args_size, &next);
1355 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1356 cur_args_size, &next);
1360 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1364 if (VEC_empty (rtx, next))
1367 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1371 VEC_truncate (rtx, next, 0);
1374 VEC_free (rtx, heap, worklist);
1375 VEC_free (rtx, heap, next);
1379 /* Check INSN to see if it looks like a push or a stack adjustment, and
1380 make a note of it if it does. EH uses this information to find out how
1381 much extra space it needs to pop off the stack. */
1384 dwarf2out_stack_adjust (rtx insn, bool after_p)
1386 HOST_WIDE_INT offset;
1390 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1391 with this function. Proper support would require all frame-related
1392 insns to be marked, and to be able to handle saving state around
1393 epilogues textually in the middle of the function. */
1394 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1397 /* If INSN is an instruction from target of an annulled branch, the
1398 effects are for the target only and so current argument size
1399 shouldn't change at all. */
1401 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1402 && INSN_FROM_TARGET_P (insn))
1405 /* If only calls can throw, and we have a frame pointer,
1406 save up adjustments until we see the CALL_INSN. */
1407 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1409 if (CALL_P (insn) && !after_p)
1411 /* Extract the size of the args from the CALL rtx itself. */
1412 insn = PATTERN (insn);
1413 if (GET_CODE (insn) == PARALLEL)
1414 insn = XVECEXP (insn, 0, 0);
1415 if (GET_CODE (insn) == SET)
1416 insn = SET_SRC (insn);
1417 gcc_assert (GET_CODE (insn) == CALL);
1418 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1423 if (CALL_P (insn) && !after_p)
1425 if (!flag_asynchronous_unwind_tables)
1426 dwarf2out_args_size ("", args_size);
1429 else if (BARRIER_P (insn))
1431 /* Don't call compute_barrier_args_size () if the only
1432 BARRIER is at the end of function. */
1433 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1434 compute_barrier_args_size ();
1435 if (barrier_args_size == NULL)
1439 offset = barrier_args_size[INSN_UID (insn)];
1444 offset -= args_size;
1445 #ifndef STACK_GROWS_DOWNWARD
1449 else if (GET_CODE (PATTERN (insn)) == SET)
1450 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1451 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1452 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1454 /* There may be stack adjustments inside compound insns. Search
1456 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1457 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1458 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1467 label = dwarf2out_cfi_label ();
1468 dwarf2out_args_size_adjust (offset, label);
1471 /* Adjust args_size based on stack adjustment OFFSET. */
1474 dwarf2out_args_size_adjust (HOST_WIDE_INT offset, const char *label)
1476 if (cfa.reg == STACK_POINTER_REGNUM)
1477 cfa.offset += offset;
1479 if (cfa_store.reg == STACK_POINTER_REGNUM)
1480 cfa_store.offset += offset;
1482 #ifndef STACK_GROWS_DOWNWARD
1486 args_size += offset;
1490 def_cfa_1 (label, &cfa);
1491 if (flag_asynchronous_unwind_tables)
1492 dwarf2out_args_size (label, args_size);
1497 /* We delay emitting a register save until either (a) we reach the end
1498 of the prologue or (b) the register is clobbered. This clusters
1499 register saves so that there are fewer pc advances. */
1501 struct queued_reg_save GTY(())
1503 struct queued_reg_save *next;
1505 HOST_WIDE_INT cfa_offset;
1509 static GTY(()) struct queued_reg_save *queued_reg_saves;
1511 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1512 struct reg_saved_in_data GTY(()) {
1517 /* A list of registers saved in other registers.
1518 The list intentionally has a small maximum capacity of 4; if your
1519 port needs more than that, you might consider implementing a
1520 more efficient data structure. */
1521 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1522 static GTY(()) size_t num_regs_saved_in_regs;
1524 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1525 static const char *last_reg_save_label;
1527 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1528 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1531 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1533 struct queued_reg_save *q;
1535 /* Duplicates waste space, but it's also necessary to remove them
1536 for correctness, since the queue gets output in reverse
1538 for (q = queued_reg_saves; q != NULL; q = q->next)
1539 if (REGNO (q->reg) == REGNO (reg))
1544 q = GGC_NEW (struct queued_reg_save);
1545 q->next = queued_reg_saves;
1546 queued_reg_saves = q;
1550 q->cfa_offset = offset;
1551 q->saved_reg = sreg;
1553 last_reg_save_label = label;
1556 /* Output all the entries in QUEUED_REG_SAVES. */
1559 flush_queued_reg_saves (void)
1561 struct queued_reg_save *q;
1563 for (q = queued_reg_saves; q; q = q->next)
1566 unsigned int reg, sreg;
1568 for (i = 0; i < num_regs_saved_in_regs; i++)
1569 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1571 if (q->saved_reg && i == num_regs_saved_in_regs)
1573 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1574 num_regs_saved_in_regs++;
1576 if (i != num_regs_saved_in_regs)
1578 regs_saved_in_regs[i].orig_reg = q->reg;
1579 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1582 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1584 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1586 sreg = INVALID_REGNUM;
1587 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1590 queued_reg_saves = NULL;
1591 last_reg_save_label = NULL;
1594 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1595 location for? Or, does it clobber a register which we've previously
1596 said that some other register is saved in, and for which we now
1597 have a new location for? */
1600 clobbers_queued_reg_save (const_rtx insn)
1602 struct queued_reg_save *q;
1604 for (q = queued_reg_saves; q; q = q->next)
1607 if (modified_in_p (q->reg, insn))
1609 for (i = 0; i < num_regs_saved_in_regs; i++)
1610 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1611 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1618 /* Entry point for saving the first register into the second. */
1621 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1624 unsigned int regno, sregno;
1626 for (i = 0; i < num_regs_saved_in_regs; i++)
1627 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1629 if (i == num_regs_saved_in_regs)
1631 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1632 num_regs_saved_in_regs++;
1634 regs_saved_in_regs[i].orig_reg = reg;
1635 regs_saved_in_regs[i].saved_in_reg = sreg;
1637 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1638 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1639 reg_save (label, regno, sregno, 0);
1642 /* What register, if any, is currently saved in REG? */
1645 reg_saved_in (rtx reg)
1647 unsigned int regn = REGNO (reg);
1649 struct queued_reg_save *q;
1651 for (q = queued_reg_saves; q; q = q->next)
1652 if (q->saved_reg && regn == REGNO (q->saved_reg))
1655 for (i = 0; i < num_regs_saved_in_regs; i++)
1656 if (regs_saved_in_regs[i].saved_in_reg
1657 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1658 return regs_saved_in_regs[i].orig_reg;
1664 /* A temporary register holding an integral value used in adjusting SP
1665 or setting up the store_reg. The "offset" field holds the integer
1666 value, not an offset. */
1667 static dw_cfa_location cfa_temp;
1669 /* Record call frame debugging information for an expression EXPR,
1670 which either sets SP or FP (adjusting how we calculate the frame
1671 address) or saves a register to the stack or another register.
1672 LABEL indicates the address of EXPR.
1674 This function encodes a state machine mapping rtxes to actions on
1675 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1676 users need not read the source code.
1678 The High-Level Picture
1680 Changes in the register we use to calculate the CFA: Currently we
1681 assume that if you copy the CFA register into another register, we
1682 should take the other one as the new CFA register; this seems to
1683 work pretty well. If it's wrong for some target, it's simple
1684 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1686 Changes in the register we use for saving registers to the stack:
1687 This is usually SP, but not always. Again, we deduce that if you
1688 copy SP into another register (and SP is not the CFA register),
1689 then the new register is the one we will be using for register
1690 saves. This also seems to work.
1692 Register saves: There's not much guesswork about this one; if
1693 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1694 register save, and the register used to calculate the destination
1695 had better be the one we think we're using for this purpose.
1696 It's also assumed that a copy from a call-saved register to another
1697 register is saving that register if RTX_FRAME_RELATED_P is set on
1698 that instruction. If the copy is from a call-saved register to
1699 the *same* register, that means that the register is now the same
1700 value as in the caller.
1702 Except: If the register being saved is the CFA register, and the
1703 offset is nonzero, we are saving the CFA, so we assume we have to
1704 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1705 the intent is to save the value of SP from the previous frame.
1707 In addition, if a register has previously been saved to a different
1710 Invariants / Summaries of Rules
1712 cfa current rule for calculating the CFA. It usually
1713 consists of a register and an offset.
1714 cfa_store register used by prologue code to save things to the stack
1715 cfa_store.offset is the offset from the value of
1716 cfa_store.reg to the actual CFA
1717 cfa_temp register holding an integral value. cfa_temp.offset
1718 stores the value, which will be used to adjust the
1719 stack pointer. cfa_temp is also used like cfa_store,
1720 to track stores to the stack via fp or a temp reg.
1722 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1723 with cfa.reg as the first operand changes the cfa.reg and its
1724 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1727 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1728 expression yielding a constant. This sets cfa_temp.reg
1729 and cfa_temp.offset.
1731 Rule 5: Create a new register cfa_store used to save items to the
1734 Rules 10-14: Save a register to the stack. Define offset as the
1735 difference of the original location and cfa_store's
1736 location (or cfa_temp's location if cfa_temp is used).
1738 Rules 16-20: If AND operation happens on sp in prologue, we assume
1739 stack is realigned. We will use a group of DW_OP_XXX
1740 expressions to represent the location of the stored
1741 register instead of CFA+offset.
1745 "{a,b}" indicates a choice of a xor b.
1746 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1749 (set <reg1> <reg2>:cfa.reg)
1750 effects: cfa.reg = <reg1>
1751 cfa.offset unchanged
1752 cfa_temp.reg = <reg1>
1753 cfa_temp.offset = cfa.offset
1756 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1757 {<const_int>,<reg>:cfa_temp.reg}))
1758 effects: cfa.reg = sp if fp used
1759 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1760 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1761 if cfa_store.reg==sp
1764 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1765 effects: cfa.reg = fp
1766 cfa_offset += +/- <const_int>
1769 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1770 constraints: <reg1> != fp
1772 effects: cfa.reg = <reg1>
1773 cfa_temp.reg = <reg1>
1774 cfa_temp.offset = cfa.offset
1777 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1778 constraints: <reg1> != fp
1780 effects: cfa_store.reg = <reg1>
1781 cfa_store.offset = cfa.offset - cfa_temp.offset
1784 (set <reg> <const_int>)
1785 effects: cfa_temp.reg = <reg>
1786 cfa_temp.offset = <const_int>
1789 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1790 effects: cfa_temp.reg = <reg1>
1791 cfa_temp.offset |= <const_int>
1794 (set <reg> (high <exp>))
1798 (set <reg> (lo_sum <exp> <const_int>))
1799 effects: cfa_temp.reg = <reg>
1800 cfa_temp.offset = <const_int>
1803 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1804 effects: cfa_store.offset -= <const_int>
1805 cfa.offset = cfa_store.offset if cfa.reg == sp
1807 cfa.base_offset = -cfa_store.offset
1810 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1811 effects: cfa_store.offset += -/+ mode_size(mem)
1812 cfa.offset = cfa_store.offset if cfa.reg == sp
1814 cfa.base_offset = -cfa_store.offset
1817 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1820 effects: cfa.reg = <reg1>
1821 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1824 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1825 effects: cfa.reg = <reg1>
1826 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1829 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1830 effects: cfa.reg = <reg1>
1831 cfa.base_offset = -cfa_temp.offset
1832 cfa_temp.offset -= mode_size(mem)
1835 (set <reg> {unspec, unspec_volatile})
1836 effects: target-dependent
1839 (set sp (and: sp <const_int>))
1840 constraints: cfa_store.reg == sp
1841 effects: current_fde.stack_realign = 1
1842 cfa_store.offset = 0
1843 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
1846 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
1847 effects: cfa_store.offset += -/+ mode_size(mem)
1850 (set (mem ({pre_inc, pre_dec} sp)) fp)
1851 constraints: fde->stack_realign == 1
1852 effects: cfa_store.offset = 0
1853 cfa.reg != HARD_FRAME_POINTER_REGNUM
1856 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
1857 constraints: fde->stack_realign == 1
1859 && cfa.indirect == 0
1860 && cfa.reg != HARD_FRAME_POINTER_REGNUM
1861 effects: Use DW_CFA_def_cfa_expression to define cfa
1862 cfa.reg == fde->drap_reg
1865 (set reg fde->drap_reg)
1866 constraints: fde->vdrap_reg == INVALID_REGNUM
1867 effects: fde->vdrap_reg = reg.
1868 (set mem fde->drap_reg)
1869 constraints: fde->drap_reg_saved == 1
1873 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1875 rtx src, dest, span;
1876 HOST_WIDE_INT offset;
1879 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1880 the PARALLEL independently. The first element is always processed if
1881 it is a SET. This is for backward compatibility. Other elements
1882 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1883 flag is set in them. */
1884 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1887 int limit = XVECLEN (expr, 0);
1890 /* PARALLELs have strict read-modify-write semantics, so we
1891 ought to evaluate every rvalue before changing any lvalue.
1892 It's cumbersome to do that in general, but there's an
1893 easy approximation that is enough for all current users:
1894 handle register saves before register assignments. */
1895 if (GET_CODE (expr) == PARALLEL)
1896 for (par_index = 0; par_index < limit; par_index++)
1898 elem = XVECEXP (expr, 0, par_index);
1899 if (GET_CODE (elem) == SET
1900 && MEM_P (SET_DEST (elem))
1901 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1902 dwarf2out_frame_debug_expr (elem, label);
1905 for (par_index = 0; par_index < limit; par_index++)
1907 elem = XVECEXP (expr, 0, par_index);
1908 if (GET_CODE (elem) == SET
1909 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
1910 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1911 dwarf2out_frame_debug_expr (elem, label);
1912 else if (GET_CODE (elem) == SET
1914 && !RTX_FRAME_RELATED_P (elem))
1916 /* Stack adjustment combining might combine some post-prologue
1917 stack adjustment into a prologue stack adjustment. */
1918 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
1921 dwarf2out_args_size_adjust (offset, label);
1927 gcc_assert (GET_CODE (expr) == SET);
1929 src = SET_SRC (expr);
1930 dest = SET_DEST (expr);
1934 rtx rsi = reg_saved_in (src);
1939 fde = current_fde ();
1941 if (GET_CODE (src) == REG
1943 && fde->drap_reg == REGNO (src)
1944 && (fde->drap_reg_saved
1945 || GET_CODE (dest) == REG))
1948 /* If we are saving dynamic realign argument pointer to a
1949 register, the destination is virtual dynamic realign
1950 argument pointer. It may be used to access argument. */
1951 if (GET_CODE (dest) == REG)
1953 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
1954 fde->vdrap_reg = REGNO (dest);
1959 switch (GET_CODE (dest))
1962 switch (GET_CODE (src))
1964 /* Setting FP from SP. */
1966 if (cfa.reg == (unsigned) REGNO (src))
1969 /* Update the CFA rule wrt SP or FP. Make sure src is
1970 relative to the current CFA register.
1972 We used to require that dest be either SP or FP, but the
1973 ARM copies SP to a temporary register, and from there to
1974 FP. So we just rely on the backends to only set
1975 RTX_FRAME_RELATED_P on appropriate insns. */
1976 cfa.reg = REGNO (dest);
1977 cfa_temp.reg = cfa.reg;
1978 cfa_temp.offset = cfa.offset;
1982 /* Saving a register in a register. */
1983 gcc_assert (!fixed_regs [REGNO (dest)]
1984 /* For the SPARC and its register window. */
1985 || (DWARF_FRAME_REGNUM (REGNO (src))
1986 == DWARF_FRAME_RETURN_COLUMN));
1988 /* After stack is aligned, we can only save SP in FP
1989 if drap register is used. In this case, we have
1990 to restore stack pointer with the CFA value and we
1991 don't generate this DWARF information. */
1993 && fde->stack_realign
1994 && REGNO (src) == STACK_POINTER_REGNUM)
1995 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
1996 && fde->drap_reg != INVALID_REGNUM
1997 && cfa.reg != REGNO (src));
1999 queue_reg_save (label, src, dest, 0);
2006 if (dest == stack_pointer_rtx)
2010 switch (GET_CODE (XEXP (src, 1)))
2013 offset = INTVAL (XEXP (src, 1));
2016 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2018 offset = cfa_temp.offset;
2024 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2026 /* Restoring SP from FP in the epilogue. */
2027 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2028 cfa.reg = STACK_POINTER_REGNUM;
2030 else if (GET_CODE (src) == LO_SUM)
2031 /* Assume we've set the source reg of the LO_SUM from sp. */
2034 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2036 if (GET_CODE (src) != MINUS)
2038 if (cfa.reg == STACK_POINTER_REGNUM)
2039 cfa.offset += offset;
2040 if (cfa_store.reg == STACK_POINTER_REGNUM)
2041 cfa_store.offset += offset;
2043 else if (dest == hard_frame_pointer_rtx)
2046 /* Either setting the FP from an offset of the SP,
2047 or adjusting the FP */
2048 gcc_assert (frame_pointer_needed);
2050 gcc_assert (REG_P (XEXP (src, 0))
2051 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2052 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2053 offset = INTVAL (XEXP (src, 1));
2054 if (GET_CODE (src) != MINUS)
2056 cfa.offset += offset;
2057 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2061 gcc_assert (GET_CODE (src) != MINUS);
2064 if (REG_P (XEXP (src, 0))
2065 && REGNO (XEXP (src, 0)) == cfa.reg
2066 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2068 /* Setting a temporary CFA register that will be copied
2069 into the FP later on. */
2070 offset = - INTVAL (XEXP (src, 1));
2071 cfa.offset += offset;
2072 cfa.reg = REGNO (dest);
2073 /* Or used to save regs to the stack. */
2074 cfa_temp.reg = cfa.reg;
2075 cfa_temp.offset = cfa.offset;
2079 else if (REG_P (XEXP (src, 0))
2080 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2081 && XEXP (src, 1) == stack_pointer_rtx)
2083 /* Setting a scratch register that we will use instead
2084 of SP for saving registers to the stack. */
2085 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2086 cfa_store.reg = REGNO (dest);
2087 cfa_store.offset = cfa.offset - cfa_temp.offset;
2091 else if (GET_CODE (src) == LO_SUM
2092 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2094 cfa_temp.reg = REGNO (dest);
2095 cfa_temp.offset = INTVAL (XEXP (src, 1));
2104 cfa_temp.reg = REGNO (dest);
2105 cfa_temp.offset = INTVAL (src);
2110 gcc_assert (REG_P (XEXP (src, 0))
2111 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2112 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2114 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2115 cfa_temp.reg = REGNO (dest);
2116 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2119 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2120 which will fill in all of the bits. */
2127 case UNSPEC_VOLATILE:
2128 gcc_assert (targetm.dwarf_handle_frame_unspec);
2129 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2134 /* If this AND operation happens on stack pointer in prologue,
2135 we assume the stack is realigned and we extract the
2137 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2139 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2140 fde->stack_realign = 1;
2141 fde->stack_realignment = INTVAL (XEXP (src, 1));
2142 cfa_store.offset = 0;
2144 if (cfa.reg != STACK_POINTER_REGNUM
2145 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2146 fde->drap_reg = cfa.reg;
2154 def_cfa_1 (label, &cfa);
2159 /* Saving a register to the stack. Make sure dest is relative to the
2161 switch (GET_CODE (XEXP (dest, 0)))
2166 /* We can't handle variable size modifications. */
2167 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2169 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2171 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2172 && cfa_store.reg == STACK_POINTER_REGNUM);
2174 cfa_store.offset += offset;
2175 if (cfa.reg == STACK_POINTER_REGNUM)
2176 cfa.offset = cfa_store.offset;
2178 offset = -cfa_store.offset;
2184 offset = GET_MODE_SIZE (GET_MODE (dest));
2185 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2188 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2189 == STACK_POINTER_REGNUM)
2190 && cfa_store.reg == STACK_POINTER_REGNUM);
2192 cfa_store.offset += offset;
2194 /* Rule 18: If stack is aligned, we will use FP as a
2195 reference to represent the address of the stored
2198 && fde->stack_realign
2199 && src == hard_frame_pointer_rtx)
2201 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2202 cfa_store.offset = 0;
2205 if (cfa.reg == STACK_POINTER_REGNUM)
2206 cfa.offset = cfa_store.offset;
2208 offset = -cfa_store.offset;
2212 /* With an offset. */
2219 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
2220 && REG_P (XEXP (XEXP (dest, 0), 0)));
2221 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2222 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2225 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2227 if (cfa_store.reg == (unsigned) regno)
2228 offset -= cfa_store.offset;
2231 gcc_assert (cfa_temp.reg == (unsigned) regno);
2232 offset -= cfa_temp.offset;
2238 /* Without an offset. */
2241 int regno = REGNO (XEXP (dest, 0));
2243 if (cfa_store.reg == (unsigned) regno)
2244 offset = -cfa_store.offset;
2247 gcc_assert (cfa_temp.reg == (unsigned) regno);
2248 offset = -cfa_temp.offset;
2255 gcc_assert (cfa_temp.reg
2256 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2257 offset = -cfa_temp.offset;
2258 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2266 /* If the source operand of this MEM operation is not a
2267 register, basically the source is return address. Here
2268 we only care how much stack grew and we don't save it. */
2272 if (REGNO (src) != STACK_POINTER_REGNUM
2273 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2274 && (unsigned) REGNO (src) == cfa.reg)
2276 /* We're storing the current CFA reg into the stack. */
2278 if (cfa.offset == 0)
2281 /* If stack is aligned, putting CFA reg into stack means
2282 we can no longer use reg + offset to represent CFA.
2283 Here we use DW_CFA_def_cfa_expression instead. The
2284 result of this expression equals to the original CFA
2287 && fde->stack_realign
2288 && cfa.indirect == 0
2289 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2291 dw_cfa_location cfa_exp;
2293 gcc_assert (fde->drap_reg == cfa.reg);
2295 cfa_exp.indirect = 1;
2296 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2297 cfa_exp.base_offset = offset;
2300 fde->drap_reg_saved = 1;
2302 def_cfa_1 (label, &cfa_exp);
2306 /* If the source register is exactly the CFA, assume
2307 we're saving SP like any other register; this happens
2309 def_cfa_1 (label, &cfa);
2310 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2315 /* Otherwise, we'll need to look in the stack to
2316 calculate the CFA. */
2317 rtx x = XEXP (dest, 0);
2321 gcc_assert (REG_P (x));
2323 cfa.reg = REGNO (x);
2324 cfa.base_offset = offset;
2326 def_cfa_1 (label, &cfa);
2331 def_cfa_1 (label, &cfa);
2333 span = targetm.dwarf_register_span (src);
2336 queue_reg_save (label, src, NULL_RTX, offset);
2339 /* We have a PARALLEL describing where the contents of SRC
2340 live. Queue register saves for each piece of the
2344 HOST_WIDE_INT span_offset = offset;
2346 gcc_assert (GET_CODE (span) == PARALLEL);
2348 limit = XVECLEN (span, 0);
2349 for (par_index = 0; par_index < limit; par_index++)
2351 rtx elem = XVECEXP (span, 0, par_index);
2353 queue_reg_save (label, elem, NULL_RTX, span_offset);
2354 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2365 /* Record call frame debugging information for INSN, which either
2366 sets SP or FP (adjusting how we calculate the frame address) or saves a
2367 register to the stack. If INSN is NULL_RTX, initialize our state.
2369 If AFTER_P is false, we're being called before the insn is emitted,
2370 otherwise after. Call instructions get invoked twice. */
2373 dwarf2out_frame_debug (rtx insn, bool after_p)
2378 if (insn == NULL_RTX)
2382 /* Flush any queued register saves. */
2383 flush_queued_reg_saves ();
2385 /* Set up state for generating call frame debug info. */
2388 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2390 cfa.reg = STACK_POINTER_REGNUM;
2393 cfa_temp.offset = 0;
2395 for (i = 0; i < num_regs_saved_in_regs; i++)
2397 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2398 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2400 num_regs_saved_in_regs = 0;
2402 if (barrier_args_size)
2404 XDELETEVEC (barrier_args_size);
2405 barrier_args_size = NULL;
2410 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2411 flush_queued_reg_saves ();
2413 if (! RTX_FRAME_RELATED_P (insn))
2415 if (!ACCUMULATE_OUTGOING_ARGS)
2416 dwarf2out_stack_adjust (insn, after_p);
2420 label = dwarf2out_cfi_label ();
2421 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
2423 insn = XEXP (src, 0);
2425 insn = PATTERN (insn);
2427 dwarf2out_frame_debug_expr (insn, label);
2432 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2433 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2434 (enum dwarf_call_frame_info cfi);
2436 static enum dw_cfi_oprnd_type
2437 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2442 case DW_CFA_GNU_window_save:
2443 return dw_cfi_oprnd_unused;
2445 case DW_CFA_set_loc:
2446 case DW_CFA_advance_loc1:
2447 case DW_CFA_advance_loc2:
2448 case DW_CFA_advance_loc4:
2449 case DW_CFA_MIPS_advance_loc8:
2450 return dw_cfi_oprnd_addr;
2453 case DW_CFA_offset_extended:
2454 case DW_CFA_def_cfa:
2455 case DW_CFA_offset_extended_sf:
2456 case DW_CFA_def_cfa_sf:
2457 case DW_CFA_restore_extended:
2458 case DW_CFA_undefined:
2459 case DW_CFA_same_value:
2460 case DW_CFA_def_cfa_register:
2461 case DW_CFA_register:
2462 return dw_cfi_oprnd_reg_num;
2464 case DW_CFA_def_cfa_offset:
2465 case DW_CFA_GNU_args_size:
2466 case DW_CFA_def_cfa_offset_sf:
2467 return dw_cfi_oprnd_offset;
2469 case DW_CFA_def_cfa_expression:
2470 case DW_CFA_expression:
2471 return dw_cfi_oprnd_loc;
2478 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2479 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2480 (enum dwarf_call_frame_info cfi);
2482 static enum dw_cfi_oprnd_type
2483 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2487 case DW_CFA_def_cfa:
2488 case DW_CFA_def_cfa_sf:
2490 case DW_CFA_offset_extended_sf:
2491 case DW_CFA_offset_extended:
2492 return dw_cfi_oprnd_offset;
2494 case DW_CFA_register:
2495 return dw_cfi_oprnd_reg_num;
2498 return dw_cfi_oprnd_unused;
2502 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2504 /* Switch to eh_frame_section. If we don't have an eh_frame_section,
2505 switch to the data section instead, and write out a synthetic label
2509 switch_to_eh_frame_section (void)
2513 #ifdef EH_FRAME_SECTION_NAME
2514 if (eh_frame_section == 0)
2518 if (EH_TABLES_CAN_BE_READ_ONLY)
2524 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2526 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2528 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2530 flags = ((! flag_pic
2531 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2532 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2533 && (per_encoding & 0x70) != DW_EH_PE_absptr
2534 && (per_encoding & 0x70) != DW_EH_PE_aligned
2535 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2536 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2537 ? 0 : SECTION_WRITE);
2540 flags = SECTION_WRITE;
2541 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2545 if (eh_frame_section)
2546 switch_to_section (eh_frame_section);
2549 /* We have no special eh_frame section. Put the information in
2550 the data section and emit special labels to guide collect2. */
2551 switch_to_section (data_section);
2552 label = get_file_function_name ("F");
2553 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2554 targetm.asm_out.globalize_label (asm_out_file,
2555 IDENTIFIER_POINTER (label));
2556 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2560 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
2562 static HOST_WIDE_INT
2563 div_data_align (HOST_WIDE_INT off)
2565 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
2566 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
2570 /* Output a Call Frame Information opcode and its operand(s). */
2573 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2578 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2579 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2580 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2581 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2582 ((unsigned HOST_WIDE_INT)
2583 cfi->dw_cfi_oprnd1.dw_cfi_offset));
2584 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2586 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2587 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2588 "DW_CFA_offset, column 0x%lx", r);
2589 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2590 dw2_asm_output_data_uleb128 (off, NULL);
2592 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2594 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2595 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2596 "DW_CFA_restore, column 0x%lx", r);
2600 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2601 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2603 switch (cfi->dw_cfi_opc)
2605 case DW_CFA_set_loc:
2607 dw2_asm_output_encoded_addr_rtx (
2608 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2609 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2612 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2613 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2614 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2617 case DW_CFA_advance_loc1:
2618 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2619 fde->dw_fde_current_label, NULL);
2620 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2623 case DW_CFA_advance_loc2:
2624 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2625 fde->dw_fde_current_label, NULL);
2626 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2629 case DW_CFA_advance_loc4:
2630 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2631 fde->dw_fde_current_label, NULL);
2632 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2635 case DW_CFA_MIPS_advance_loc8:
2636 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2637 fde->dw_fde_current_label, NULL);
2638 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2641 case DW_CFA_offset_extended:
2642 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2643 dw2_asm_output_data_uleb128 (r, NULL);
2644 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2645 dw2_asm_output_data_uleb128 (off, NULL);
2648 case DW_CFA_def_cfa:
2649 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2650 dw2_asm_output_data_uleb128 (r, NULL);
2651 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2654 case DW_CFA_offset_extended_sf:
2655 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2656 dw2_asm_output_data_uleb128 (r, NULL);
2657 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2658 dw2_asm_output_data_sleb128 (off, NULL);
2661 case DW_CFA_def_cfa_sf:
2662 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2663 dw2_asm_output_data_uleb128 (r, NULL);
2664 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2665 dw2_asm_output_data_sleb128 (off, NULL);
2668 case DW_CFA_restore_extended:
2669 case DW_CFA_undefined:
2670 case DW_CFA_same_value:
2671 case DW_CFA_def_cfa_register:
2672 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2673 dw2_asm_output_data_uleb128 (r, NULL);
2676 case DW_CFA_register:
2677 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2678 dw2_asm_output_data_uleb128 (r, NULL);
2679 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2680 dw2_asm_output_data_uleb128 (r, NULL);
2683 case DW_CFA_def_cfa_offset:
2684 case DW_CFA_GNU_args_size:
2685 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2688 case DW_CFA_def_cfa_offset_sf:
2689 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
2690 dw2_asm_output_data_sleb128 (off, NULL);
2693 case DW_CFA_GNU_window_save:
2696 case DW_CFA_def_cfa_expression:
2697 case DW_CFA_expression:
2698 output_cfa_loc (cfi);
2701 case DW_CFA_GNU_negative_offset_extended:
2702 /* Obsoleted by DW_CFA_offset_extended_sf. */
2711 /* Similar, but do it via assembler directives instead. */
2714 output_cfi_directive (dw_cfi_ref cfi)
2716 unsigned long r, r2;
2718 switch (cfi->dw_cfi_opc)
2720 case DW_CFA_advance_loc:
2721 case DW_CFA_advance_loc1:
2722 case DW_CFA_advance_loc2:
2723 case DW_CFA_advance_loc4:
2724 case DW_CFA_MIPS_advance_loc8:
2725 case DW_CFA_set_loc:
2726 /* Should only be created by add_fde_cfi in a code path not
2727 followed when emitting via directives. The assembler is
2728 going to take care of this for us. */
2732 case DW_CFA_offset_extended:
2733 case DW_CFA_offset_extended_sf:
2734 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2735 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
2736 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
2739 case DW_CFA_restore:
2740 case DW_CFA_restore_extended:
2741 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2742 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
2745 case DW_CFA_undefined:
2746 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2747 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
2750 case DW_CFA_same_value:
2751 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2752 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
2755 case DW_CFA_def_cfa:
2756 case DW_CFA_def_cfa_sf:
2757 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2758 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
2759 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
2762 case DW_CFA_def_cfa_register:
2763 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2764 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
2767 case DW_CFA_register:
2768 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2769 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 0);
2770 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
2773 case DW_CFA_def_cfa_offset:
2774 case DW_CFA_def_cfa_offset_sf:
2775 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
2776 HOST_WIDE_INT_PRINT_DEC"\n",
2777 cfi->dw_cfi_oprnd1.dw_cfi_offset);
2780 case DW_CFA_GNU_args_size:
2781 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size);
2782 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
2784 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
2785 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
2786 fputc ('\n', asm_out_file);
2789 case DW_CFA_GNU_window_save:
2790 fprintf (asm_out_file, "\t.cfi_window_save\n");
2793 case DW_CFA_def_cfa_expression:
2794 case DW_CFA_expression:
2795 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", cfi->dw_cfi_opc);
2796 output_cfa_loc_raw (cfi);
2797 fputc ('\n', asm_out_file);
2805 /* Output the call frame information used to record information
2806 that relates to calculating the frame pointer, and records the
2807 location of saved registers. */
2810 output_call_frame_info (int for_eh)
2815 char l1[20], l2[20], section_start_label[20];
2816 bool any_lsda_needed = false;
2817 char augmentation[6];
2818 int augmentation_size;
2819 int fde_encoding = DW_EH_PE_absptr;
2820 int per_encoding = DW_EH_PE_absptr;
2821 int lsda_encoding = DW_EH_PE_absptr;
2824 /* Don't emit a CIE if there won't be any FDEs. */
2825 if (fde_table_in_use == 0)
2828 /* Nothing to do if the assembler's doing it all. */
2829 if (dwarf2out_do_cfi_asm ())
2832 /* If we make FDEs linkonce, we may have to emit an empty label for
2833 an FDE that wouldn't otherwise be emitted. We want to avoid
2834 having an FDE kept around when the function it refers to is
2835 discarded. Example where this matters: a primary function
2836 template in C++ requires EH information, but an explicit
2837 specialization doesn't. */
2838 if (TARGET_USES_WEAK_UNWIND_INFO
2839 && ! flag_asynchronous_unwind_tables
2842 for (i = 0; i < fde_table_in_use; i++)
2843 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2844 && !fde_table[i].uses_eh_lsda
2845 && ! DECL_WEAK (fde_table[i].decl))
2846 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2847 for_eh, /* empty */ 1);
2849 /* If we don't have any functions we'll want to unwind out of, don't
2850 emit any EH unwind information. Note that if exceptions aren't
2851 enabled, we won't have collected nothrow information, and if we
2852 asked for asynchronous tables, we always want this info. */
2855 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2857 for (i = 0; i < fde_table_in_use; i++)
2858 if (fde_table[i].uses_eh_lsda)
2859 any_eh_needed = any_lsda_needed = true;
2860 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2861 any_eh_needed = true;
2862 else if (! fde_table[i].nothrow
2863 && ! fde_table[i].all_throwers_are_sibcalls)
2864 any_eh_needed = true;
2866 if (! any_eh_needed)
2870 /* We're going to be generating comments, so turn on app. */
2875 switch_to_eh_frame_section ();
2878 if (!debug_frame_section)
2879 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
2880 SECTION_DEBUG, NULL);
2881 switch_to_section (debug_frame_section);
2884 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2885 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2887 /* Output the CIE. */
2888 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2889 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2890 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2891 dw2_asm_output_data (4, 0xffffffff,
2892 "Initial length escape value indicating 64-bit DWARF extension");
2893 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2894 "Length of Common Information Entry");
2895 ASM_OUTPUT_LABEL (asm_out_file, l1);
2897 /* Now that the CIE pointer is PC-relative for EH,
2898 use 0 to identify the CIE. */
2899 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2900 (for_eh ? 0 : DWARF_CIE_ID),
2901 "CIE Identifier Tag");
2903 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2905 augmentation[0] = 0;
2906 augmentation_size = 0;
2912 z Indicates that a uleb128 is present to size the
2913 augmentation section.
2914 L Indicates the encoding (and thus presence) of
2915 an LSDA pointer in the FDE augmentation.
2916 R Indicates a non-default pointer encoding for
2918 P Indicates the presence of an encoding + language
2919 personality routine in the CIE augmentation. */
2921 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2922 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2923 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2925 p = augmentation + 1;
2926 if (eh_personality_libfunc)
2929 augmentation_size += 1 + size_of_encoded_value (per_encoding);
2930 assemble_external_libcall (eh_personality_libfunc);
2932 if (any_lsda_needed)
2935 augmentation_size += 1;
2937 if (fde_encoding != DW_EH_PE_absptr)
2940 augmentation_size += 1;
2942 if (p > augmentation + 1)
2944 augmentation[0] = 'z';
2948 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2949 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2951 int offset = ( 4 /* Length */
2953 + 1 /* CIE version */
2954 + strlen (augmentation) + 1 /* Augmentation */
2955 + size_of_uleb128 (1) /* Code alignment */
2956 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2958 + 1 /* Augmentation size */
2959 + 1 /* Personality encoding */ );
2960 int pad = -offset & (PTR_SIZE - 1);
2962 augmentation_size += pad;
2964 /* Augmentations should be small, so there's scarce need to
2965 iterate for a solution. Die if we exceed one uleb128 byte. */
2966 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2970 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2971 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2972 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2973 "CIE Data Alignment Factor");
2975 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2976 if (DW_CIE_VERSION == 1)
2977 dw2_asm_output_data (1, return_reg, "CIE RA Column");
2979 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2981 if (augmentation[0])
2983 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2984 if (eh_personality_libfunc)
2986 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2987 eh_data_format_name (per_encoding));
2988 dw2_asm_output_encoded_addr_rtx (per_encoding,
2989 eh_personality_libfunc,
2993 if (any_lsda_needed)
2994 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2995 eh_data_format_name (lsda_encoding));
2997 if (fde_encoding != DW_EH_PE_absptr)
2998 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2999 eh_data_format_name (fde_encoding));
3002 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3003 output_cfi (cfi, NULL, for_eh);
3005 /* Pad the CIE out to an address sized boundary. */
3006 ASM_OUTPUT_ALIGN (asm_out_file,
3007 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3008 ASM_OUTPUT_LABEL (asm_out_file, l2);
3010 /* Loop through all of the FDE's. */
3011 for (i = 0; i < fde_table_in_use; i++)
3013 fde = &fde_table[i];
3015 /* Don't emit EH unwind info for leaf functions that don't need it. */
3016 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3017 && (fde->nothrow || fde->all_throwers_are_sibcalls)
3018 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3019 && !fde->uses_eh_lsda)
3022 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
3023 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
3024 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
3025 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
3026 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3027 dw2_asm_output_data (4, 0xffffffff,
3028 "Initial length escape value indicating 64-bit DWARF extension");
3029 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3031 ASM_OUTPUT_LABEL (asm_out_file, l1);
3034 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3036 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3037 debug_frame_section, "FDE CIE offset");
3041 if (fde->dw_fde_switched_sections)
3043 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
3044 fde->dw_fde_unlikely_section_label);
3045 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
3046 fde->dw_fde_hot_section_label);
3047 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
3048 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
3049 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
3050 "FDE initial location");
3051 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3052 fde->dw_fde_hot_section_end_label,
3053 fde->dw_fde_hot_section_label,
3054 "FDE address range");
3055 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
3056 "FDE initial location");
3057 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3058 fde->dw_fde_unlikely_section_end_label,
3059 fde->dw_fde_unlikely_section_label,
3060 "FDE address range");
3064 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
3065 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3066 dw2_asm_output_encoded_addr_rtx (fde_encoding,
3069 "FDE initial location");
3070 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3071 fde->dw_fde_end, fde->dw_fde_begin,
3072 "FDE address range");
3077 if (fde->dw_fde_switched_sections)
3079 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3080 fde->dw_fde_hot_section_label,
3081 "FDE initial location");
3082 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3083 fde->dw_fde_hot_section_end_label,
3084 fde->dw_fde_hot_section_label,
3085 "FDE address range");
3086 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3087 fde->dw_fde_unlikely_section_label,
3088 "FDE initial location");
3089 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3090 fde->dw_fde_unlikely_section_end_label,
3091 fde->dw_fde_unlikely_section_label,
3092 "FDE address range");
3096 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
3097 "FDE initial location");
3098 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3099 fde->dw_fde_end, fde->dw_fde_begin,
3100 "FDE address range");
3104 if (augmentation[0])
3106 if (any_lsda_needed)
3108 int size = size_of_encoded_value (lsda_encoding);
3110 if (lsda_encoding == DW_EH_PE_aligned)
3112 int offset = ( 4 /* Length */
3113 + 4 /* CIE offset */
3114 + 2 * size_of_encoded_value (fde_encoding)
3115 + 1 /* Augmentation size */ );
3116 int pad = -offset & (PTR_SIZE - 1);
3119 gcc_assert (size_of_uleb128 (size) == 1);
3122 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3124 if (fde->uses_eh_lsda)
3126 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
3127 fde->funcdef_number);
3128 dw2_asm_output_encoded_addr_rtx (
3129 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
3130 false, "Language Specific Data Area");
3134 if (lsda_encoding == DW_EH_PE_aligned)
3135 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3137 (size_of_encoded_value (lsda_encoding), 0,
3138 "Language Specific Data Area (none)");
3142 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3145 /* Loop through the Call Frame Instructions associated with
3147 fde->dw_fde_current_label = fde->dw_fde_begin;
3148 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3149 output_cfi (cfi, fde, for_eh);
3151 /* Pad the FDE out to an address sized boundary. */
3152 ASM_OUTPUT_ALIGN (asm_out_file,
3153 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3154 ASM_OUTPUT_LABEL (asm_out_file, l2);
3157 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3158 dw2_asm_output_data (4, 0, "End of Table");
3159 #ifdef MIPS_DEBUGGING_INFO
3160 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3161 get a value of 0. Putting .align 0 after the label fixes it. */
3162 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3165 /* Turn off app to make assembly quicker. */
3170 /* Output a marker (i.e. a label) for the beginning of a function, before
3174 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3175 const char *file ATTRIBUTE_UNUSED)
3177 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3181 current_function_func_begin_label = NULL;
3183 #ifdef TARGET_UNWIND_INFO
3184 /* ??? current_function_func_begin_label is also used by except.c
3185 for call-site information. We must emit this label if it might
3187 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3188 && ! dwarf2out_do_frame ())
3191 if (! dwarf2out_do_frame ())
3195 switch_to_section (function_section (current_function_decl));
3196 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3197 current_function_funcdef_no);
3198 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3199 current_function_funcdef_no);
3200 dup_label = xstrdup (label);
3201 current_function_func_begin_label = dup_label;
3203 #ifdef TARGET_UNWIND_INFO
3204 /* We can elide the fde allocation if we're not emitting debug info. */
3205 if (! dwarf2out_do_frame ())
3209 /* Expand the fde table if necessary. */
3210 if (fde_table_in_use == fde_table_allocated)
3212 fde_table_allocated += FDE_TABLE_INCREMENT;
3213 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3214 memset (fde_table + fde_table_in_use, 0,
3215 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3218 /* Record the FDE associated with this function. */
3219 current_funcdef_fde = fde_table_in_use;
3221 /* Add the new FDE at the end of the fde_table. */
3222 fde = &fde_table[fde_table_in_use++];
3223 fde->decl = current_function_decl;
3224 fde->dw_fde_begin = dup_label;
3225 fde->dw_fde_current_label = dup_label;
3226 fde->dw_fde_hot_section_label = NULL;
3227 fde->dw_fde_hot_section_end_label = NULL;
3228 fde->dw_fde_unlikely_section_label = NULL;
3229 fde->dw_fde_unlikely_section_end_label = NULL;
3230 fde->dw_fde_switched_sections = false;
3231 fde->dw_fde_end = NULL;
3232 fde->dw_fde_cfi = NULL;
3233 fde->funcdef_number = current_function_funcdef_no;
3234 fde->nothrow = crtl->nothrow;
3235 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3236 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3237 fde->drap_reg = INVALID_REGNUM;
3238 fde->vdrap_reg = INVALID_REGNUM;
3240 args_size = old_args_size = 0;
3242 /* We only want to output line number information for the genuine dwarf2
3243 prologue case, not the eh frame case. */
3244 #ifdef DWARF2_DEBUGGING_INFO
3246 dwarf2out_source_line (line, file);
3249 if (dwarf2out_do_cfi_asm ())
3254 fprintf (asm_out_file, "\t.cfi_startproc\n");
3256 if (eh_personality_libfunc)
3258 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3259 ref = eh_personality_libfunc;
3261 /* ??? The GAS support isn't entirely consistent. We have to
3262 handle indirect support ourselves, but PC-relative is done
3263 in the assembler. Further, the assembler can't handle any
3264 of the weirder relocation types. */
3265 if (enc & DW_EH_PE_indirect)
3266 ref = dw2_force_const_mem (ref, true);
3268 fprintf (asm_out_file, "\t.cfi_personality 0x%x,", enc);
3269 output_addr_const (asm_out_file, ref);
3270 fputc ('\n', asm_out_file);
3273 if (crtl->uses_eh_lsda)
3277 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3278 ASM_GENERATE_INTERNAL_LABEL (lab, "LLSDA",
3279 current_function_funcdef_no);
3280 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3281 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3283 if (enc & DW_EH_PE_indirect)
3284 ref = dw2_force_const_mem (ref, true);
3286 fprintf (asm_out_file, "\t.cfi_lsda 0x%x,", enc);
3287 output_addr_const (asm_out_file, ref);
3288 fputc ('\n', asm_out_file);
3293 /* Output a marker (i.e. a label) for the absolute end of the generated code
3294 for a function definition. This gets called *after* the epilogue code has
3298 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
3299 const char *file ATTRIBUTE_UNUSED)
3302 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3304 if (dwarf2out_do_cfi_asm ())
3305 fprintf (asm_out_file, "\t.cfi_endproc\n");
3307 /* Output a label to mark the endpoint of the code generated for this
3309 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
3310 current_function_funcdef_no);
3311 ASM_OUTPUT_LABEL (asm_out_file, label);
3312 fde = current_fde ();
3313 gcc_assert (fde != NULL);
3314 fde->dw_fde_end = xstrdup (label);
3318 dwarf2out_frame_init (void)
3320 /* Allocate the initial hunk of the fde_table. */
3321 fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
3322 fde_table_allocated = FDE_TABLE_INCREMENT;
3323 fde_table_in_use = 0;
3325 /* Generate the CFA instructions common to all FDE's. Do it now for the
3326 sake of lookup_cfa. */
3328 /* On entry, the Canonical Frame Address is at SP. */
3329 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
3331 #ifdef DWARF2_UNWIND_INFO
3332 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
3333 initial_return_save (INCOMING_RETURN_ADDR_RTX);
3338 dwarf2out_frame_finish (void)
3340 /* Output call frame information. */
3341 if (DWARF2_FRAME_INFO)
3342 output_call_frame_info (0);
3344 #ifndef TARGET_UNWIND_INFO
3345 /* Output another copy for the unwinder. */
3346 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
3347 output_call_frame_info (1);
3351 /* Note that the current function section is being used for code. */
3354 dwarf2out_note_section_used (void)
3356 section *sec = current_function_section ();
3357 if (sec == text_section)
3358 text_section_used = true;
3359 else if (sec == cold_text_section)
3360 cold_text_section_used = true;
3364 dwarf2out_switch_text_section (void)
3366 dw_fde_ref fde = current_fde ();
3368 gcc_assert (cfun && fde);
3370 fde->dw_fde_switched_sections = true;
3371 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
3372 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
3373 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
3374 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
3375 have_multiple_function_sections = true;
3377 /* Reset the current label on switching text sections, so that we
3378 don't attempt to advance_loc4 between labels in different sections. */
3379 fde->dw_fde_current_label = NULL;
3381 /* There is no need to mark used sections when not debugging. */
3382 if (cold_text_section != NULL)
3383 dwarf2out_note_section_used ();
3387 /* And now, the subset of the debugging information support code necessary
3388 for emitting location expressions. */
3390 /* Data about a single source file. */
3391 struct dwarf_file_data GTY(())
3393 const char * filename;
3397 /* We need some way to distinguish DW_OP_addr with a direct symbol
3398 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
3399 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
3402 typedef struct dw_val_struct *dw_val_ref;
3403 typedef struct die_struct *dw_die_ref;
3404 typedef const struct die_struct *const_dw_die_ref;
3405 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
3406 typedef struct dw_loc_list_struct *dw_loc_list_ref;
3408 typedef struct deferred_locations_struct GTY(())
3412 } deferred_locations;
3414 DEF_VEC_O(deferred_locations);
3415 DEF_VEC_ALLOC_O(deferred_locations,gc);
3417 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
3419 /* Each DIE may have a series of attribute/value pairs. Values
3420 can take on several forms. The forms that are used in this
3421 implementation are listed below. */
3426 dw_val_class_offset,
3428 dw_val_class_loc_list,
3429 dw_val_class_range_list,
3431 dw_val_class_unsigned_const,
3432 dw_val_class_long_long,
3435 dw_val_class_die_ref,
3436 dw_val_class_fde_ref,
3437 dw_val_class_lbl_id,
3438 dw_val_class_lineptr,
3440 dw_val_class_macptr,
3444 /* Describe a double word constant value. */
3445 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
3447 typedef struct dw_long_long_struct GTY(())
3454 /* Describe a floating point constant value, or a vector constant value. */
3456 typedef struct dw_vec_struct GTY(())
3458 unsigned char * GTY((length ("%h.length"))) array;
3464 /* The dw_val_node describes an attribute's value, as it is
3465 represented internally. */
3467 typedef struct dw_val_struct GTY(())
3469 enum dw_val_class val_class;
3470 union dw_val_struct_union
3472 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
3473 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
3474 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
3475 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
3476 HOST_WIDE_INT GTY ((default)) val_int;
3477 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
3478 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
3479 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
3480 struct dw_val_die_union
3484 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
3485 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
3486 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
3487 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
3488 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
3489 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
3491 GTY ((desc ("%1.val_class"))) v;
3495 /* Locations in memory are described using a sequence of stack machine
3498 typedef struct dw_loc_descr_struct GTY(())
3500 dw_loc_descr_ref dw_loc_next;
3501 enum dwarf_location_atom dw_loc_opc;
3503 dw_val_node dw_loc_oprnd1;
3504 dw_val_node dw_loc_oprnd2;
3508 /* Location lists are ranges + location descriptions for that range,
3509 so you can track variables that are in different places over
3510 their entire life. */
3511 typedef struct dw_loc_list_struct GTY(())
3513 dw_loc_list_ref dw_loc_next;
3514 const char *begin; /* Label for begin address of range */
3515 const char *end; /* Label for end address of range */
3516 char *ll_symbol; /* Label for beginning of location list.
3517 Only on head of list */
3518 const char *section; /* Section this loclist is relative to */
3519 dw_loc_descr_ref expr;
3522 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
3524 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
3526 /* Convert a DWARF stack opcode into its string name. */
3529 dwarf_stack_op_name (unsigned int op)
3534 case INTERNAL_DW_OP_tls_addr:
3535 return "DW_OP_addr";
3537 return "DW_OP_deref";
3539 return "DW_OP_const1u";
3541 return "DW_OP_const1s";
3543 return "DW_OP_const2u";
3545 return "DW_OP_const2s";
3547 return "DW_OP_const4u";
3549 return "DW_OP_const4s";
3551 return "DW_OP_const8u";
3553 return "DW_OP_const8s";
3555 return "DW_OP_constu";
3557 return "DW_OP_consts";
3561 return "DW_OP_drop";
3563 return "DW_OP_over";
3565 return "DW_OP_pick";
3567 return "DW_OP_swap";
3571 return "DW_OP_xderef";
3579 return "DW_OP_minus";
3591 return "DW_OP_plus";
3592 case DW_OP_plus_uconst:
3593 return "DW_OP_plus_uconst";
3599 return "DW_OP_shra";
3617 return "DW_OP_skip";
3619 return "DW_OP_lit0";
3621 return "DW_OP_lit1";
3623 return "DW_OP_lit2";
3625 return "DW_OP_lit3";
3627 return "DW_OP_lit4";
3629 return "DW_OP_lit5";
3631 return "DW_OP_lit6";
3633 return "DW_OP_lit7";
3635 return "DW_OP_lit8";
3637 return "DW_OP_lit9";
3639 return "DW_OP_lit10";
3641 return "DW_OP_lit11";
3643 return "DW_OP_lit12";
3645 return "DW_OP_lit13";
3647 return "DW_OP_lit14";
3649 return "DW_OP_lit15";
3651 return "DW_OP_lit16";
3653 return "DW_OP_lit17";
3655 return "DW_OP_lit18";
3657 return "DW_OP_lit19";
3659 return "DW_OP_lit20";
3661 return "DW_OP_lit21";
3663 return "DW_OP_lit22";
3665 return "DW_OP_lit23";
3667 return "DW_OP_lit24";
3669 return "DW_OP_lit25";
3671 return "DW_OP_lit26";
3673 return "DW_OP_lit27";
3675 return "DW_OP_lit28";
3677 return "DW_OP_lit29";
3679 return "DW_OP_lit30";
3681 return "DW_OP_lit31";
3683 return "DW_OP_reg0";
3685 return "DW_OP_reg1";
3687 return "DW_OP_reg2";
3689 return "DW_OP_reg3";
3691 return "DW_OP_reg4";
3693 return "DW_OP_reg5";
3695 return "DW_OP_reg6";
3697 return "DW_OP_reg7";
3699 return "DW_OP_reg8";
3701 return "DW_OP_reg9";
3703 return "DW_OP_reg10";
3705 return "DW_OP_reg11";
3707 return "DW_OP_reg12";
3709 return "DW_OP_reg13";
3711 return "DW_OP_reg14";
3713 return "DW_OP_reg15";
3715 return "DW_OP_reg16";
3717 return "DW_OP_reg17";
3719 return "DW_OP_reg18";
3721 return "DW_OP_reg19";
3723 return "DW_OP_reg20";
3725 return "DW_OP_reg21";
3727 return "DW_OP_reg22";
3729 return "DW_OP_reg23";
3731 return "DW_OP_reg24";
3733 return "DW_OP_reg25";
3735 return "DW_OP_reg26";
3737 return "DW_OP_reg27";
3739 return "DW_OP_reg28";
3741 return "DW_OP_reg29";
3743 return "DW_OP_reg30";
3745 return "DW_OP_reg31";
3747 return "DW_OP_breg0";
3749 return "DW_OP_breg1";
3751 return "DW_OP_breg2";
3753 return "DW_OP_breg3";
3755 return "DW_OP_breg4";
3757 return "DW_OP_breg5";
3759 return "DW_OP_breg6";
3761 return "DW_OP_breg7";
3763 return "DW_OP_breg8";
3765 return "DW_OP_breg9";
3767 return "DW_OP_breg10";
3769 return "DW_OP_breg11";
3771 return "DW_OP_breg12";
3773 return "DW_OP_breg13";
3775 return "DW_OP_breg14";
3777 return "DW_OP_breg15";
3779 return "DW_OP_breg16";
3781 return "DW_OP_breg17";
3783 return "DW_OP_breg18";
3785 return "DW_OP_breg19";
3787 return "DW_OP_breg20";
3789 return "DW_OP_breg21";
3791 return "DW_OP_breg22";
3793 return "DW_OP_breg23";
3795 return "DW_OP_breg24";
3797 return "DW_OP_breg25";
3799 return "DW_OP_breg26";
3801 return "DW_OP_breg27";
3803 return "DW_OP_breg28";
3805 return "DW_OP_breg29";
3807 return "DW_OP_breg30";
3809 return "DW_OP_breg31";
3811 return "DW_OP_regx";
3813 return "DW_OP_fbreg";
3815 return "DW_OP_bregx";
3817 return "DW_OP_piece";
3818 case DW_OP_deref_size:
3819 return "DW_OP_deref_size";
3820 case DW_OP_xderef_size:
3821 return "DW_OP_xderef_size";
3824 case DW_OP_push_object_address:
3825 return "DW_OP_push_object_address";
3827 return "DW_OP_call2";
3829 return "DW_OP_call4";
3830 case DW_OP_call_ref:
3831 return "DW_OP_call_ref";
3832 case DW_OP_GNU_push_tls_address:
3833 return "DW_OP_GNU_push_tls_address";
3834 case DW_OP_GNU_uninit:
3835 return "DW_OP_GNU_uninit";
3837 return "OP_<unknown>";
3841 /* Return a pointer to a newly allocated location description. Location
3842 descriptions are simple expression terms that can be strung
3843 together to form more complicated location (address) descriptions. */
3845 static inline dw_loc_descr_ref
3846 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3847 unsigned HOST_WIDE_INT oprnd2)
3849 dw_loc_descr_ref descr = GGC_CNEW (dw_loc_descr_node);
3851 descr->dw_loc_opc = op;
3852 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3853 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3854 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3855 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3860 /* Return a pointer to a newly allocated location description for
3863 static inline dw_loc_descr_ref
3864 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
3869 return new_loc_descr (DW_OP_breg0 + reg, offset, 0);
3871 return new_loc_descr (DW_OP_bregx, reg, offset);
3874 return new_loc_descr (DW_OP_reg0 + reg, 0, 0);
3876 return new_loc_descr (DW_OP_regx, reg, 0);
3879 /* Add a location description term to a location description expression. */
3882 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3884 dw_loc_descr_ref *d;
3886 /* Find the end of the chain. */
3887 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3893 /* Return the size of a location descriptor. */
3895 static unsigned long
3896 size_of_loc_descr (dw_loc_descr_ref loc)
3898 unsigned long size = 1;
3900 switch (loc->dw_loc_opc)
3903 case INTERNAL_DW_OP_tls_addr:
3904 size += DWARF2_ADDR_SIZE;
3923 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3926 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3931 case DW_OP_plus_uconst:
3932 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3970 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3973 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3976 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3979 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3980 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3983 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3985 case DW_OP_deref_size:
3986 case DW_OP_xderef_size:
3995 case DW_OP_call_ref:
3996 size += DWARF2_ADDR_SIZE;
4005 /* Return the size of a series of location descriptors. */
4007 static unsigned long
4008 size_of_locs (dw_loc_descr_ref loc)
4013 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4014 field, to avoid writing to a PCH file. */
4015 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4017 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4019 size += size_of_loc_descr (l);
4024 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4026 l->dw_loc_addr = size;
4027 size += size_of_loc_descr (l);
4033 /* Output location description stack opcode's operands (if any). */
4036 output_loc_operands (dw_loc_descr_ref loc)
4038 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4039 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4041 switch (loc->dw_loc_opc)
4043 #ifdef DWARF2_DEBUGGING_INFO
4045 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
4049 dw2_asm_output_data (2, val1->v.val_int, NULL);
4053 dw2_asm_output_data (4, val1->v.val_int, NULL);
4057 gcc_assert (HOST_BITS_PER_LONG >= 64);
4058 dw2_asm_output_data (8, val1->v.val_int, NULL);
4065 gcc_assert (val1->val_class == dw_val_class_loc);
4066 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4068 dw2_asm_output_data (2, offset, NULL);
4081 /* We currently don't make any attempt to make sure these are
4082 aligned properly like we do for the main unwind info, so
4083 don't support emitting things larger than a byte if we're
4084 only doing unwinding. */
4089 dw2_asm_output_data (1, val1->v.val_int, NULL);
4092 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4095 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4098 dw2_asm_output_data (1, val1->v.val_int, NULL);
4100 case DW_OP_plus_uconst:
4101 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4135 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4138 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4141 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4144 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4145 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
4148 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4150 case DW_OP_deref_size:
4151 case DW_OP_xderef_size:
4152 dw2_asm_output_data (1, val1->v.val_int, NULL);
4155 case INTERNAL_DW_OP_tls_addr:
4156 if (targetm.asm_out.output_dwarf_dtprel)
4158 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
4161 fputc ('\n', asm_out_file);
4168 /* Other codes have no operands. */
4173 /* Output a sequence of location operations. */
4176 output_loc_sequence (dw_loc_descr_ref loc)
4178 for (; loc != NULL; loc = loc->dw_loc_next)
4180 /* Output the opcode. */
4181 dw2_asm_output_data (1, loc->dw_loc_opc,
4182 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
4184 /* Output the operand(s) (if any). */
4185 output_loc_operands (loc);
4189 /* Output location description stack opcode's operands (if any).
4190 The output is single bytes on a line, suitable for .cfi_escape. */
4193 output_loc_operands_raw (dw_loc_descr_ref loc)
4195 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4196 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4198 switch (loc->dw_loc_opc)
4201 /* We cannot output addresses in .cfi_escape, only bytes. */
4207 case DW_OP_deref_size:
4208 case DW_OP_xderef_size:
4209 fputc (',', asm_out_file);
4210 dw2_asm_output_data_raw (1, val1->v.val_int);
4215 fputc (',', asm_out_file);
4216 dw2_asm_output_data_raw (2, val1->v.val_int);
4221 fputc (',', asm_out_file);
4222 dw2_asm_output_data_raw (4, val1->v.val_int);
4227 gcc_assert (HOST_BITS_PER_LONG >= 64);
4228 fputc (',', asm_out_file);
4229 dw2_asm_output_data_raw (8, val1->v.val_int);
4237 gcc_assert (val1->val_class == dw_val_class_loc);
4238 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4240 fputc (',', asm_out_file);
4241 dw2_asm_output_data_raw (2, offset);
4246 case DW_OP_plus_uconst:
4249 fputc (',', asm_out_file);
4250 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4287 fputc (',', asm_out_file);
4288 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
4292 fputc (',', asm_out_file);
4293 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4294 fputc (',', asm_out_file);
4295 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
4298 case INTERNAL_DW_OP_tls_addr:
4302 /* Other codes have no operands. */
4308 output_loc_sequence_raw (dw_loc_descr_ref loc)
4312 /* Output the opcode. */
4313 fprintf (asm_out_file, "0x%x", loc->dw_loc_opc);
4314 output_loc_operands_raw (loc);
4316 if (!loc->dw_loc_next)
4318 loc = loc->dw_loc_next;
4320 fputc (',', asm_out_file);
4324 /* This routine will generate the correct assembly data for a location
4325 description based on a cfi entry with a complex address. */
4328 output_cfa_loc (dw_cfi_ref cfi)
4330 dw_loc_descr_ref loc;
4333 if (cfi->dw_cfi_opc == DW_CFA_expression)
4334 dw2_asm_output_data (1, cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL);
4336 /* Output the size of the block. */
4337 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4338 size = size_of_locs (loc);
4339 dw2_asm_output_data_uleb128 (size, NULL);
4341 /* Now output the operations themselves. */
4342 output_loc_sequence (loc);
4345 /* Similar, but used for .cfi_escape. */
4348 output_cfa_loc_raw (dw_cfi_ref cfi)
4350 dw_loc_descr_ref loc;
4353 if (cfi->dw_cfi_opc == DW_CFA_expression)
4354 fprintf (asm_out_file, "0x%x,", cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4356 /* Output the size of the block. */
4357 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4358 size = size_of_locs (loc);
4359 dw2_asm_output_data_uleb128_raw (size);
4360 fputc (',', asm_out_file);
4362 /* Now output the operations themselves. */
4363 output_loc_sequence_raw (loc);
4366 /* This function builds a dwarf location descriptor sequence from a
4367 dw_cfa_location, adding the given OFFSET to the result of the
4370 static struct dw_loc_descr_struct *
4371 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
4373 struct dw_loc_descr_struct *head, *tmp;
4375 offset += cfa->offset;
4379 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
4380 head->dw_loc_oprnd1.val_class = dw_val_class_const;
4381 tmp = new_loc_descr (DW_OP_deref, 0, 0);
4382 add_loc_descr (&head, tmp);
4385 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4386 add_loc_descr (&head, tmp);
4390 head = new_reg_loc_descr (cfa->reg, offset);
4395 /* This function builds a dwarf location descriptor sequence for
4396 the address at OFFSET from the CFA when stack is aligned to
4399 static struct dw_loc_descr_struct *
4400 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
4402 struct dw_loc_descr_struct *head;
4403 unsigned int dwarf_fp
4404 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
4406 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
4407 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
4409 head = new_reg_loc_descr (dwarf_fp, 0);
4410 add_loc_descr (&head, int_loc_descriptor (alignment));
4411 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
4413 add_loc_descr (&head, int_loc_descriptor (offset));
4414 add_loc_descr (&head, new_loc_descr (DW_OP_plus, 0, 0));
4417 head = new_reg_loc_descr (dwarf_fp, offset);
4421 /* This function fills in aa dw_cfa_location structure from a dwarf location
4422 descriptor sequence. */
4425 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
4427 struct dw_loc_descr_struct *ptr;
4429 cfa->base_offset = 0;
4433 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
4435 enum dwarf_location_atom op = ptr->dw_loc_opc;
4471 cfa->reg = op - DW_OP_reg0;
4474 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4508 cfa->reg = op - DW_OP_breg0;
4509 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
4512 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4513 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
4518 case DW_OP_plus_uconst:
4519 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
4522 internal_error ("DW_LOC_OP %s not implemented",
4523 dwarf_stack_op_name (ptr->dw_loc_opc));
4527 #endif /* .debug_frame support */
4529 /* And now, the support for symbolic debugging information. */
4530 #ifdef DWARF2_DEBUGGING_INFO
4532 /* .debug_str support. */
4533 static int output_indirect_string (void **, void *);
4535 static void dwarf2out_init (const char *);
4536 static void dwarf2out_finish (const char *);
4537 static void dwarf2out_define (unsigned int, const char *);
4538 static void dwarf2out_undef (unsigned int, const char *);
4539 static void dwarf2out_start_source_file (unsigned, const char *);
4540 static void dwarf2out_end_source_file (unsigned);
4541 static void dwarf2out_begin_block (unsigned, unsigned);
4542 static void dwarf2out_end_block (unsigned, unsigned);
4543 static bool dwarf2out_ignore_block (const_tree);
4544 static void dwarf2out_global_decl (tree);
4545 static void dwarf2out_type_decl (tree, int);
4546 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
4547 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
4549 static void dwarf2out_abstract_function (tree);
4550 static void dwarf2out_var_location (rtx);
4551 static void dwarf2out_begin_function (tree);
4552 static void dwarf2out_set_name (tree, tree);
4554 /* The debug hooks structure. */
4556 const struct gcc_debug_hooks dwarf2_debug_hooks =
4562 dwarf2out_start_source_file,
4563 dwarf2out_end_source_file,
4564 dwarf2out_begin_block,
4565 dwarf2out_end_block,
4566 dwarf2out_ignore_block,
4567 dwarf2out_source_line,
4568 dwarf2out_begin_prologue,
4569 debug_nothing_int_charstar, /* end_prologue */
4570 dwarf2out_end_epilogue,
4571 dwarf2out_begin_function,
4572 debug_nothing_int, /* end_function */
4573 dwarf2out_decl, /* function_decl */
4574 dwarf2out_global_decl,
4575 dwarf2out_type_decl, /* type_decl */
4576 dwarf2out_imported_module_or_decl,
4577 debug_nothing_tree, /* deferred_inline_function */
4578 /* The DWARF 2 backend tries to reduce debugging bloat by not
4579 emitting the abstract description of inline functions until
4580 something tries to reference them. */
4581 dwarf2out_abstract_function, /* outlining_inline_function */
4582 debug_nothing_rtx, /* label */
4583 debug_nothing_int, /* handle_pch */
4584 dwarf2out_var_location,
4585 dwarf2out_switch_text_section,
4587 1 /* start_end_main_source_file */
4591 /* NOTE: In the comments in this file, many references are made to
4592 "Debugging Information Entries". This term is abbreviated as `DIE'
4593 throughout the remainder of this file. */
4595 /* An internal representation of the DWARF output is built, and then
4596 walked to generate the DWARF debugging info. The walk of the internal
4597 representation is done after the entire program has been compiled.
4598 The types below are used to describe the internal representation. */
4600 /* Various DIE's use offsets relative to the beginning of the
4601 .debug_info section to refer to each other. */
4603 typedef long int dw_offset;
4605 /* Define typedefs here to avoid circular dependencies. */
4607 typedef struct dw_attr_struct *dw_attr_ref;
4608 typedef struct dw_line_info_struct *dw_line_info_ref;
4609 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
4610 typedef struct pubname_struct *pubname_ref;
4611 typedef struct dw_ranges_struct *dw_ranges_ref;
4612 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
4614 /* Each entry in the line_info_table maintains the file and
4615 line number associated with the label generated for that
4616 entry. The label gives the PC value associated with
4617 the line number entry. */
4619 typedef struct dw_line_info_struct GTY(())
4621 unsigned long dw_file_num;
4622 unsigned long dw_line_num;
4626 /* Line information for functions in separate sections; each one gets its
4628 typedef struct dw_separate_line_info_struct GTY(())
4630 unsigned long dw_file_num;
4631 unsigned long dw_line_num;
4632 unsigned long function;
4634 dw_separate_line_info_entry;
4636 /* Each DIE attribute has a field specifying the attribute kind,
4637 a link to the next attribute in the chain, and an attribute value.
4638 Attributes are typically linked below the DIE they modify. */
4640 typedef struct dw_attr_struct GTY(())
4642 enum dwarf_attribute dw_attr;
4643 dw_val_node dw_attr_val;
4647 DEF_VEC_O(dw_attr_node);
4648 DEF_VEC_ALLOC_O(dw_attr_node,gc);
4650 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
4651 The children of each node form a circular list linked by
4652 die_sib. die_child points to the node *before* the "first" child node. */
4654 typedef struct die_struct GTY((chain_circular ("%h.die_sib")))
4656 enum dwarf_tag die_tag;
4658 VEC(dw_attr_node,gc) * die_attr;
4659 dw_die_ref die_parent;
4660 dw_die_ref die_child;
4662 dw_die_ref die_definition; /* ref from a specification to its definition */
4663 dw_offset die_offset;
4664 unsigned long die_abbrev;
4666 /* Die is used and must not be pruned as unused. */
4667 int die_perennial_p;
4668 unsigned int decl_id;
4672 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
4673 #define FOR_EACH_CHILD(die, c, expr) do { \
4674 c = die->die_child; \
4678 } while (c != die->die_child); \
4681 /* The pubname structure */
4683 typedef struct pubname_struct GTY(())
4690 DEF_VEC_O(pubname_entry);
4691 DEF_VEC_ALLOC_O(pubname_entry, gc);
4693 struct dw_ranges_struct GTY(())
4695 /* If this is positive, it's a block number, otherwise it's a
4696 bitwise-negated index into dw_ranges_by_label. */
4700 struct dw_ranges_by_label_struct GTY(())
4706 /* The limbo die list structure. */
4707 typedef struct limbo_die_struct GTY(())
4711 struct limbo_die_struct *next;
4715 /* How to start an assembler comment. */
4716 #ifndef ASM_COMMENT_START
4717 #define ASM_COMMENT_START ";#"
4720 /* Define a macro which returns nonzero for a TYPE_DECL which was
4721 implicitly generated for a tagged type.
4723 Note that unlike the gcc front end (which generates a NULL named
4724 TYPE_DECL node for each complete tagged type, each array type, and
4725 each function type node created) the g++ front end generates a
4726 _named_ TYPE_DECL node for each tagged type node created.
4727 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
4728 generate a DW_TAG_typedef DIE for them. */
4730 #define TYPE_DECL_IS_STUB(decl) \
4731 (DECL_NAME (decl) == NULL_TREE \
4732 || (DECL_ARTIFICIAL (decl) \
4733 && is_tagged_type (TREE_TYPE (decl)) \
4734 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
4735 /* This is necessary for stub decls that \
4736 appear in nested inline functions. */ \
4737 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
4738 && (decl_ultimate_origin (decl) \
4739 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
4741 /* Information concerning the compilation unit's programming
4742 language, and compiler version. */
4744 /* Fixed size portion of the DWARF compilation unit header. */
4745 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
4746 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
4748 /* Fixed size portion of public names info. */
4749 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
4751 /* Fixed size portion of the address range info. */
4752 #define DWARF_ARANGES_HEADER_SIZE \
4753 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4754 DWARF2_ADDR_SIZE * 2) \
4755 - DWARF_INITIAL_LENGTH_SIZE)
4757 /* Size of padding portion in the address range info. It must be
4758 aligned to twice the pointer size. */
4759 #define DWARF_ARANGES_PAD_SIZE \
4760 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4761 DWARF2_ADDR_SIZE * 2) \
4762 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
4764 /* Use assembler line directives if available. */
4765 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
4766 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
4767 #define DWARF2_ASM_LINE_DEBUG_INFO 1
4769 #define DWARF2_ASM_LINE_DEBUG_INFO 0
4773 /* Minimum line offset in a special line info. opcode.
4774 This value was chosen to give a reasonable range of values. */
4775 #define DWARF_LINE_BASE -10
4777 /* First special line opcode - leave room for the standard opcodes. */
4778 #define DWARF_LINE_OPCODE_BASE 10
4780 /* Range of line offsets in a special line info. opcode. */
4781 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
4783 /* Flag that indicates the initial value of the is_stmt_start flag.
4784 In the present implementation, we do not mark any lines as
4785 the beginning of a source statement, because that information
4786 is not made available by the GCC front-end. */
4787 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
4789 #ifdef DWARF2_DEBUGGING_INFO
4790 /* This location is used by calc_die_sizes() to keep track
4791 the offset of each DIE within the .debug_info section. */
4792 static unsigned long next_die_offset;
4795 /* Record the root of the DIE's built for the current compilation unit. */
4796 static GTY(()) dw_die_ref comp_unit_die;
4798 /* A list of DIEs with a NULL parent waiting to be relocated. */
4799 static GTY(()) limbo_die_node *limbo_die_list;
4801 /* Filenames referenced by this compilation unit. */
4802 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
4804 /* A hash table of references to DIE's that describe declarations.
4805 The key is a DECL_UID() which is a unique number identifying each decl. */
4806 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
4808 /* A hash table of references to DIE's that describe COMMON blocks.
4809 The key is DECL_UID() ^ die_parent. */
4810 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
4812 /* Node of the variable location list. */
4813 struct var_loc_node GTY ((chain_next ("%h.next")))
4815 rtx GTY (()) var_loc_note;
4816 const char * GTY (()) label;
4817 const char * GTY (()) section_label;
4818 struct var_loc_node * GTY (()) next;
4821 /* Variable location list. */
4822 struct var_loc_list_def GTY (())
4824 struct var_loc_node * GTY (()) first;
4826 /* Do not mark the last element of the chained list because
4827 it is marked through the chain. */
4828 struct var_loc_node * GTY ((skip ("%h"))) last;
4830 /* DECL_UID of the variable decl. */
4831 unsigned int decl_id;
4833 typedef struct var_loc_list_def var_loc_list;
4836 /* Table of decl location linked lists. */
4837 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
4839 /* A pointer to the base of a list of references to DIE's that
4840 are uniquely identified by their tag, presence/absence of
4841 children DIE's, and list of attribute/value pairs. */
4842 static GTY((length ("abbrev_die_table_allocated")))
4843 dw_die_ref *abbrev_die_table;
4845 /* Number of elements currently allocated for abbrev_die_table. */
4846 static GTY(()) unsigned abbrev_die_table_allocated;
4848 /* Number of elements in type_die_table currently in use. */
4849 static GTY(()) unsigned abbrev_die_table_in_use;
4851 /* Size (in elements) of increments by which we may expand the
4852 abbrev_die_table. */
4853 #define ABBREV_DIE_TABLE_INCREMENT 256
4855 /* A pointer to the base of a table that contains line information
4856 for each source code line in .text in the compilation unit. */
4857 static GTY((length ("line_info_table_allocated")))
4858 dw_line_info_ref line_info_table;
4860 /* Number of elements currently allocated for line_info_table. */
4861 static GTY(()) unsigned line_info_table_allocated;
4863 /* Number of elements in line_info_table currently in use. */
4864 static GTY(()) unsigned line_info_table_in_use;
4866 /* A pointer to the base of a table that contains line information
4867 for each source code line outside of .text in the compilation unit. */
4868 static GTY ((length ("separate_line_info_table_allocated")))
4869 dw_separate_line_info_ref separate_line_info_table;
4871 /* Number of elements currently allocated for separate_line_info_table. */
4872 static GTY(()) unsigned separate_line_info_table_allocated;
4874 /* Number of elements in separate_line_info_table currently in use. */
4875 static GTY(()) unsigned separate_line_info_table_in_use;
4877 /* Size (in elements) of increments by which we may expand the
4879 #define LINE_INFO_TABLE_INCREMENT 1024
4881 /* A pointer to the base of a table that contains a list of publicly
4882 accessible names. */
4883 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
4885 /* A pointer to the base of a table that contains a list of publicly
4886 accessible types. */
4887 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
4889 /* Array of dies for which we should generate .debug_arange info. */
4890 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
4892 /* Number of elements currently allocated for arange_table. */
4893 static GTY(()) unsigned arange_table_allocated;
4895 /* Number of elements in arange_table currently in use. */
4896 static GTY(()) unsigned arange_table_in_use;
4898 /* Size (in elements) of increments by which we may expand the
4900 #define ARANGE_TABLE_INCREMENT 64
4902 /* Array of dies for which we should generate .debug_ranges info. */
4903 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
4905 /* Number of elements currently allocated for ranges_table. */
4906 static GTY(()) unsigned ranges_table_allocated;
4908 /* Number of elements in ranges_table currently in use. */
4909 static GTY(()) unsigned ranges_table_in_use;
4911 /* Array of pairs of labels referenced in ranges_table. */
4912 static GTY ((length ("ranges_by_label_allocated")))
4913 dw_ranges_by_label_ref ranges_by_label;
4915 /* Number of elements currently allocated for ranges_by_label. */
4916 static GTY(()) unsigned ranges_by_label_allocated;
4918 /* Number of elements in ranges_by_label currently in use. */
4919 static GTY(()) unsigned ranges_by_label_in_use;
4921 /* Size (in elements) of increments by which we may expand the
4923 #define RANGES_TABLE_INCREMENT 64
4925 /* Whether we have location lists that need outputting */
4926 static GTY(()) bool have_location_lists;
4928 /* Unique label counter. */
4929 static GTY(()) unsigned int loclabel_num;
4931 #ifdef DWARF2_DEBUGGING_INFO
4932 /* Record whether the function being analyzed contains inlined functions. */
4933 static int current_function_has_inlines;
4935 #if 0 && defined (MIPS_DEBUGGING_INFO)
4936 static int comp_unit_has_inlines;
4939 /* The last file entry emitted by maybe_emit_file(). */
4940 static GTY(()) struct dwarf_file_data * last_emitted_file;
4942 /* Number of internal labels generated by gen_internal_sym(). */
4943 static GTY(()) int label_num;
4945 /* Cached result of previous call to lookup_filename. */
4946 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
4948 #ifdef DWARF2_DEBUGGING_INFO
4950 /* Offset from the "steady-state frame pointer" to the frame base,
4951 within the current function. */
4952 static HOST_WIDE_INT frame_pointer_fb_offset;
4954 /* Forward declarations for functions defined in this file. */
4956 static int is_pseudo_reg (const_rtx);
4957 static tree type_main_variant (tree);
4958 static int is_tagged_type (const_tree);
4959 static const char *dwarf_tag_name (unsigned);
4960 static const char *dwarf_attr_name (unsigned);
4961 static const char *dwarf_form_name (unsigned);
4962 static tree decl_ultimate_origin (const_tree);
4963 static tree decl_class_context (tree);
4964 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4965 static inline enum dw_val_class AT_class (dw_attr_ref);
4966 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4967 static inline unsigned AT_flag (dw_attr_ref);
4968 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4969 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4970 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4971 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4972 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4974 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4975 unsigned int, unsigned char *);
4976 static hashval_t debug_str_do_hash (const void *);
4977 static int debug_str_eq (const void *, const void *);
4978 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4979 static inline const char *AT_string (dw_attr_ref);
4980 static int AT_string_form (dw_attr_ref);
4981 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4982 static void add_AT_specification (dw_die_ref, dw_die_ref);
4983 static inline dw_die_ref AT_ref (dw_attr_ref);
4984 static inline int AT_ref_external (dw_attr_ref);
4985 static inline void set_AT_ref_external (dw_attr_ref, int);
4986 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4987 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4988 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4989 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4991 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4992 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4993 static inline rtx AT_addr (dw_attr_ref);
4994 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4995 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4996 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4997 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4998 unsigned HOST_WIDE_INT);
4999 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
5001 static inline const char *AT_lbl (dw_attr_ref);
5002 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
5003 static const char *get_AT_low_pc (dw_die_ref);
5004 static const char *get_AT_hi_pc (dw_die_ref);
5005 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
5006 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
5007 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
5008 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
5009 static bool is_c_family (void);
5010 static bool is_cxx (void);
5011 static bool is_java (void);
5012 static bool is_fortran (void);
5013 static bool is_ada (void);
5014 static void remove_AT (dw_die_ref, enum dwarf_attribute);
5015 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
5016 static void add_child_die (dw_die_ref, dw_die_ref);
5017 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
5018 static dw_die_ref lookup_type_die (tree);
5019 static void equate_type_number_to_die (tree, dw_die_ref);
5020 static hashval_t decl_die_table_hash (const void *);
5021 static int decl_die_table_eq (const void *, const void *);
5022 static dw_die_ref lookup_decl_die (tree);
5023 static hashval_t common_block_die_table_hash (const void *);
5024 static int common_block_die_table_eq (const void *, const void *);
5025 static hashval_t decl_loc_table_hash (const void *);
5026 static int decl_loc_table_eq (const void *, const void *);
5027 static var_loc_list *lookup_decl_loc (const_tree);
5028 static void equate_decl_number_to_die (tree, dw_die_ref);
5029 static void add_var_loc_to_decl (tree, struct var_loc_node *);
5030 static void print_spaces (FILE *);
5031 static void print_die (dw_die_ref, FILE *);
5032 static void print_dwarf_line_table (FILE *);
5033 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
5034 static dw_die_ref pop_compile_unit (dw_die_ref);
5035 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
5036 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
5037 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
5038 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
5039 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
5040 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
5041 static int same_die_p (dw_die_ref, dw_die_ref, int *);
5042 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
5043 static void compute_section_prefix (dw_die_ref);
5044 static int is_type_die (dw_die_ref);
5045 static int is_comdat_die (dw_die_ref);
5046 static int is_symbol_die (dw_die_ref);
5047 static void assign_symbol_names (dw_die_ref);
5048 static void break_out_includes (dw_die_ref);
5049 static hashval_t htab_cu_hash (const void *);
5050 static int htab_cu_eq (const void *, const void *);
5051 static void htab_cu_del (void *);
5052 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
5053 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
5054 static void add_sibling_attributes (dw_die_ref);
5055 static void build_abbrev_table (dw_die_ref);
5056 static void output_location_lists (dw_die_ref);
5057 static int constant_size (unsigned HOST_WIDE_INT);
5058 static unsigned long size_of_die (dw_die_ref);
5059 static void calc_die_sizes (dw_die_ref);
5060 static void mark_dies (dw_die_ref);
5061 static void unmark_dies (dw_die_ref);
5062 static void unmark_all_dies (dw_die_ref);
5063 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
5064 static unsigned long size_of_aranges (void);
5065 static enum dwarf_form value_format (dw_attr_ref);
5066 static void output_value_format (dw_attr_ref);
5067 static void output_abbrev_section (void);
5068 static void output_die_symbol (dw_die_ref);
5069 static void output_die (dw_die_ref);
5070 static void output_compilation_unit_header (void);
5071 static void output_comp_unit (dw_die_ref, int);
5072 static const char *dwarf2_name (tree, int);
5073 static void add_pubname (tree, dw_die_ref);
5074 static void add_pubname_string (const char *, dw_die_ref);
5075 static void add_pubtype (tree, dw_die_ref);
5076 static void output_pubnames (VEC (pubname_entry,gc) *);
5077 static void add_arange (tree, dw_die_ref);
5078 static void output_aranges (void);
5079 static unsigned int add_ranges_num (int);
5080 static unsigned int add_ranges (const_tree);
5081 static unsigned int add_ranges_by_labels (const char *, const char *);
5082 static void output_ranges (void);
5083 static void output_line_info (void);
5084 static void output_file_names (void);
5085 static dw_die_ref base_type_die (tree);
5086 static int is_base_type (tree);
5087 static bool is_subrange_type (const_tree);
5088 static dw_die_ref subrange_type_die (tree, dw_die_ref);
5089 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
5090 static int type_is_enum (const_tree);
5091 static unsigned int dbx_reg_number (const_rtx);
5092 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
5093 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
5094 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
5095 enum var_init_status);
5096 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
5097 enum var_init_status);
5098 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
5099 enum var_init_status);
5100 static int is_based_loc (const_rtx);
5101 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
5102 enum var_init_status);
5103 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
5104 enum var_init_status);
5105 static dw_loc_descr_ref loc_descriptor (rtx, enum var_init_status);
5106 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
5107 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
5108 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
5109 static tree field_type (const_tree);
5110 static unsigned int simple_type_align_in_bits (const_tree);
5111 static unsigned int simple_decl_align_in_bits (const_tree);
5112 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
5113 static HOST_WIDE_INT field_byte_offset (const_tree);
5114 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
5116 static void add_data_member_location_attribute (dw_die_ref, tree);
5117 static void add_const_value_attribute (dw_die_ref, rtx);
5118 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
5119 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
5120 static void insert_float (const_rtx, unsigned char *);
5121 static rtx rtl_for_decl_location (tree);
5122 static void add_location_or_const_value_attribute (dw_die_ref, tree,
5123 enum dwarf_attribute);
5124 static void tree_add_const_value_attribute (dw_die_ref, tree);
5125 static void add_name_attribute (dw_die_ref, const char *);
5126 static void add_comp_dir_attribute (dw_die_ref);
5127 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
5128 static void add_subscript_info (dw_die_ref, tree, bool);
5129 static void add_byte_size_attribute (dw_die_ref, tree);
5130 static void add_bit_offset_attribute (dw_die_ref, tree);
5131 static void add_bit_size_attribute (dw_die_ref, tree);
5132 static void add_prototyped_attribute (dw_die_ref, tree);
5133 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
5134 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
5135 static void add_src_coords_attributes (dw_die_ref, tree);
5136 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
5137 static void push_decl_scope (tree);
5138 static void pop_decl_scope (void);
5139 static dw_die_ref scope_die_for (tree, dw_die_ref);
5140 static inline int local_scope_p (dw_die_ref);
5141 static inline int class_scope_p (dw_die_ref);
5142 static inline int class_or_namespace_scope_p (dw_die_ref);
5143 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
5144 static void add_calling_convention_attribute (dw_die_ref, tree);
5145 static const char *type_tag (const_tree);
5146 static tree member_declared_type (const_tree);
5148 static const char *decl_start_label (tree);
5150 static void gen_array_type_die (tree, dw_die_ref);
5151 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
5153 static void gen_entry_point_die (tree, dw_die_ref);
5155 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
5156 static dw_die_ref gen_formal_parameter_die (tree, tree, dw_die_ref);
5157 static void gen_unspecified_parameters_die (tree, dw_die_ref);
5158 static void gen_formal_types_die (tree, dw_die_ref);
5159 static void gen_subprogram_die (tree, dw_die_ref);
5160 static void gen_variable_die (tree, tree, dw_die_ref);
5161 static void gen_const_die (tree, dw_die_ref);
5162 static void gen_label_die (tree, dw_die_ref);
5163 static void gen_lexical_block_die (tree, dw_die_ref, int);
5164 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
5165 static void gen_field_die (tree, dw_die_ref);
5166 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
5167 static dw_die_ref gen_compile_unit_die (const char *);
5168 static void gen_inheritance_die (tree, tree, dw_die_ref);
5169 static void gen_member_die (tree, dw_die_ref);
5170 static void gen_struct_or_union_type_die (tree, dw_die_ref,
5171 enum debug_info_usage);
5172 static void gen_subroutine_type_die (tree, dw_die_ref);
5173 static void gen_typedef_die (tree, dw_die_ref);
5174 static void gen_type_die (tree, dw_die_ref);
5175 static void gen_block_die (tree, dw_die_ref, int);
5176 static void decls_for_scope (tree, dw_die_ref, int);
5177 static int is_redundant_typedef (const_tree);
5178 static void gen_namespace_die (tree, dw_die_ref);
5179 static void gen_decl_die (tree, tree, dw_die_ref);
5180 static dw_die_ref force_decl_die (tree);
5181 static dw_die_ref force_type_die (tree);
5182 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
5183 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
5184 static struct dwarf_file_data * lookup_filename (const char *);
5185 static void retry_incomplete_types (void);
5186 static void gen_type_die_for_member (tree, tree, dw_die_ref);
5187 static void splice_child_die (dw_die_ref, dw_die_ref);
5188 static int file_info_cmp (const void *, const void *);
5189 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
5190 const char *, const char *, unsigned);
5191 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
5192 const char *, const char *,
5194 static void output_loc_list (dw_loc_list_ref);
5195 static char *gen_internal_sym (const char *);
5197 static void prune_unmark_dies (dw_die_ref);
5198 static void prune_unused_types_mark (dw_die_ref, int);
5199 static void prune_unused_types_walk (dw_die_ref);
5200 static void prune_unused_types_walk_attribs (dw_die_ref);
5201 static void prune_unused_types_prune (dw_die_ref);
5202 static void prune_unused_types (void);
5203 static int maybe_emit_file (struct dwarf_file_data *fd);
5205 /* Section names used to hold DWARF debugging information. */
5206 #ifndef DEBUG_INFO_SECTION
5207 #define DEBUG_INFO_SECTION ".debug_info"
5209 #ifndef DEBUG_ABBREV_SECTION
5210 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
5212 #ifndef DEBUG_ARANGES_SECTION
5213 #define DEBUG_ARANGES_SECTION ".debug_aranges"
5215 #ifndef DEBUG_MACINFO_SECTION
5216 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
5218 #ifndef DEBUG_LINE_SECTION
5219 #define DEBUG_LINE_SECTION ".debug_line"
5221 #ifndef DEBUG_LOC_SECTION
5222 #define DEBUG_LOC_SECTION ".debug_loc"
5224 #ifndef DEBUG_PUBNAMES_SECTION
5225 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
5227 #ifndef DEBUG_STR_SECTION
5228 #define DEBUG_STR_SECTION ".debug_str"
5230 #ifndef DEBUG_RANGES_SECTION
5231 #define DEBUG_RANGES_SECTION ".debug_ranges"
5234 /* Standard ELF section names for compiled code and data. */
5235 #ifndef TEXT_SECTION_NAME
5236 #define TEXT_SECTION_NAME ".text"
5239 /* Section flags for .debug_str section. */
5240 #define DEBUG_STR_SECTION_FLAGS \
5241 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
5242 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
5245 /* Labels we insert at beginning sections we can reference instead of
5246 the section names themselves. */
5248 #ifndef TEXT_SECTION_LABEL
5249 #define TEXT_SECTION_LABEL "Ltext"
5251 #ifndef COLD_TEXT_SECTION_LABEL
5252 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
5254 #ifndef DEBUG_LINE_SECTION_LABEL
5255 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
5257 #ifndef DEBUG_INFO_SECTION_LABEL
5258 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
5260 #ifndef DEBUG_ABBREV_SECTION_LABEL
5261 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
5263 #ifndef DEBUG_LOC_SECTION_LABEL
5264 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
5266 #ifndef DEBUG_RANGES_SECTION_LABEL
5267 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
5269 #ifndef DEBUG_MACINFO_SECTION_LABEL
5270 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
5273 /* Definitions of defaults for formats and names of various special
5274 (artificial) labels which may be generated within this file (when the -g
5275 options is used and DWARF2_DEBUGGING_INFO is in effect.
5276 If necessary, these may be overridden from within the tm.h file, but
5277 typically, overriding these defaults is unnecessary. */
5279 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5280 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5281 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5282 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5283 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5284 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5285 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5286 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5287 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5288 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
5290 #ifndef TEXT_END_LABEL
5291 #define TEXT_END_LABEL "Letext"
5293 #ifndef COLD_END_LABEL
5294 #define COLD_END_LABEL "Letext_cold"
5296 #ifndef BLOCK_BEGIN_LABEL
5297 #define BLOCK_BEGIN_LABEL "LBB"
5299 #ifndef BLOCK_END_LABEL
5300 #define BLOCK_END_LABEL "LBE"
5302 #ifndef LINE_CODE_LABEL
5303 #define LINE_CODE_LABEL "LM"
5305 #ifndef SEPARATE_LINE_CODE_LABEL
5306 #define SEPARATE_LINE_CODE_LABEL "LSM"
5310 /* We allow a language front-end to designate a function that is to be
5311 called to "demangle" any name before it is put into a DIE. */
5313 static const char *(*demangle_name_func) (const char *);
5316 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
5318 demangle_name_func = func;
5321 /* Test if rtl node points to a pseudo register. */
5324 is_pseudo_reg (const_rtx rtl)
5326 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
5327 || (GET_CODE (rtl) == SUBREG
5328 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
5331 /* Return a reference to a type, with its const and volatile qualifiers
5335 type_main_variant (tree type)
5337 type = TYPE_MAIN_VARIANT (type);
5339 /* ??? There really should be only one main variant among any group of
5340 variants of a given type (and all of the MAIN_VARIANT values for all
5341 members of the group should point to that one type) but sometimes the C
5342 front-end messes this up for array types, so we work around that bug
5344 if (TREE_CODE (type) == ARRAY_TYPE)
5345 while (type != TYPE_MAIN_VARIANT (type))
5346 type = TYPE_MAIN_VARIANT (type);
5351 /* Return nonzero if the given type node represents a tagged type. */
5354 is_tagged_type (const_tree type)
5356 enum tree_code code = TREE_CODE (type);
5358 return (code == RECORD_TYPE || code == UNION_TYPE
5359 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
5362 /* Convert a DIE tag into its string name. */
5365 dwarf_tag_name (unsigned int tag)
5369 case DW_TAG_padding:
5370 return "DW_TAG_padding";
5371 case DW_TAG_array_type:
5372 return "DW_TAG_array_type";
5373 case DW_TAG_class_type:
5374 return "DW_TAG_class_type";
5375 case DW_TAG_entry_point:
5376 return "DW_TAG_entry_point";
5377 case DW_TAG_enumeration_type:
5378 return "DW_TAG_enumeration_type";
5379 case DW_TAG_formal_parameter:
5380 return "DW_TAG_formal_parameter";
5381 case DW_TAG_imported_declaration:
5382 return "DW_TAG_imported_declaration";
5384 return "DW_TAG_label";
5385 case DW_TAG_lexical_block:
5386 return "DW_TAG_lexical_block";
5388 return "DW_TAG_member";
5389 case DW_TAG_pointer_type:
5390 return "DW_TAG_pointer_type";
5391 case DW_TAG_reference_type:
5392 return "DW_TAG_reference_type";
5393 case DW_TAG_compile_unit:
5394 return "DW_TAG_compile_unit";
5395 case DW_TAG_string_type:
5396 return "DW_TAG_string_type";
5397 case DW_TAG_structure_type:
5398 return "DW_TAG_structure_type";
5399 case DW_TAG_subroutine_type:
5400 return "DW_TAG_subroutine_type";
5401 case DW_TAG_typedef:
5402 return "DW_TAG_typedef";
5403 case DW_TAG_union_type:
5404 return "DW_TAG_union_type";
5405 case DW_TAG_unspecified_parameters:
5406 return "DW_TAG_unspecified_parameters";
5407 case DW_TAG_variant:
5408 return "DW_TAG_variant";
5409 case DW_TAG_common_block:
5410 return "DW_TAG_common_block";
5411 case DW_TAG_common_inclusion:
5412 return "DW_TAG_common_inclusion";
5413 case DW_TAG_inheritance:
5414 return "DW_TAG_inheritance";
5415 case DW_TAG_inlined_subroutine:
5416 return "DW_TAG_inlined_subroutine";
5418 return "DW_TAG_module";
5419 case DW_TAG_ptr_to_member_type:
5420 return "DW_TAG_ptr_to_member_type";
5421 case DW_TAG_set_type:
5422 return "DW_TAG_set_type";
5423 case DW_TAG_subrange_type:
5424 return "DW_TAG_subrange_type";
5425 case DW_TAG_with_stmt:
5426 return "DW_TAG_with_stmt";
5427 case DW_TAG_access_declaration:
5428 return "DW_TAG_access_declaration";
5429 case DW_TAG_base_type:
5430 return "DW_TAG_base_type";
5431 case DW_TAG_catch_block:
5432 return "DW_TAG_catch_block";
5433 case DW_TAG_const_type:
5434 return "DW_TAG_const_type";
5435 case DW_TAG_constant:
5436 return "DW_TAG_constant";
5437 case DW_TAG_enumerator:
5438 return "DW_TAG_enumerator";
5439 case DW_TAG_file_type:
5440 return "DW_TAG_file_type";
5442 return "DW_TAG_friend";
5443 case DW_TAG_namelist:
5444 return "DW_TAG_namelist";
5445 case DW_TAG_namelist_item:
5446 return "DW_TAG_namelist_item";
5447 case DW_TAG_packed_type:
5448 return "DW_TAG_packed_type";
5449 case DW_TAG_subprogram:
5450 return "DW_TAG_subprogram";
5451 case DW_TAG_template_type_param:
5452 return "DW_TAG_template_type_param";
5453 case DW_TAG_template_value_param:
5454 return "DW_TAG_template_value_param";
5455 case DW_TAG_thrown_type:
5456 return "DW_TAG_thrown_type";
5457 case DW_TAG_try_block:
5458 return "DW_TAG_try_block";
5459 case DW_TAG_variant_part:
5460 return "DW_TAG_variant_part";
5461 case DW_TAG_variable:
5462 return "DW_TAG_variable";
5463 case DW_TAG_volatile_type:
5464 return "DW_TAG_volatile_type";
5465 case DW_TAG_dwarf_procedure:
5466 return "DW_TAG_dwarf_procedure";
5467 case DW_TAG_restrict_type:
5468 return "DW_TAG_restrict_type";
5469 case DW_TAG_interface_type:
5470 return "DW_TAG_interface_type";
5471 case DW_TAG_namespace:
5472 return "DW_TAG_namespace";
5473 case DW_TAG_imported_module:
5474 return "DW_TAG_imported_module";
5475 case DW_TAG_unspecified_type:
5476 return "DW_TAG_unspecified_type";
5477 case DW_TAG_partial_unit:
5478 return "DW_TAG_partial_unit";
5479 case DW_TAG_imported_unit:
5480 return "DW_TAG_imported_unit";
5481 case DW_TAG_condition:
5482 return "DW_TAG_condition";
5483 case DW_TAG_shared_type:
5484 return "DW_TAG_shared_type";
5485 case DW_TAG_MIPS_loop:
5486 return "DW_TAG_MIPS_loop";
5487 case DW_TAG_format_label:
5488 return "DW_TAG_format_label";
5489 case DW_TAG_function_template:
5490 return "DW_TAG_function_template";
5491 case DW_TAG_class_template:
5492 return "DW_TAG_class_template";
5493 case DW_TAG_GNU_BINCL:
5494 return "DW_TAG_GNU_BINCL";
5495 case DW_TAG_GNU_EINCL:
5496 return "DW_TAG_GNU_EINCL";
5498 return "DW_TAG_<unknown>";
5502 /* Convert a DWARF attribute code into its string name. */
5505 dwarf_attr_name (unsigned int attr)
5510 return "DW_AT_sibling";
5511 case DW_AT_location:
5512 return "DW_AT_location";
5514 return "DW_AT_name";
5515 case DW_AT_ordering:
5516 return "DW_AT_ordering";
5517 case DW_AT_subscr_data:
5518 return "DW_AT_subscr_data";
5519 case DW_AT_byte_size:
5520 return "DW_AT_byte_size";
5521 case DW_AT_bit_offset:
5522 return "DW_AT_bit_offset";
5523 case DW_AT_bit_size:
5524 return "DW_AT_bit_size";
5525 case DW_AT_element_list:
5526 return "DW_AT_element_list";
5527 case DW_AT_stmt_list:
5528 return "DW_AT_stmt_list";
5530 return "DW_AT_low_pc";
5532 return "DW_AT_high_pc";
5533 case DW_AT_language:
5534 return "DW_AT_language";
5536 return "DW_AT_member";
5538 return "DW_AT_discr";
5539 case DW_AT_discr_value:
5540 return "DW_AT_discr_value";
5541 case DW_AT_visibility:
5542 return "DW_AT_visibility";
5544 return "DW_AT_import";
5545 case DW_AT_string_length:
5546 return "DW_AT_string_length";
5547 case DW_AT_common_reference:
5548 return "DW_AT_common_reference";
5549 case DW_AT_comp_dir:
5550 return "DW_AT_comp_dir";
5551 case DW_AT_const_value:
5552 return "DW_AT_const_value";
5553 case DW_AT_containing_type:
5554 return "DW_AT_containing_type";
5555 case DW_AT_default_value:
5556 return "DW_AT_default_value";
5558 return "DW_AT_inline";
5559 case DW_AT_is_optional:
5560 return "DW_AT_is_optional";
5561 case DW_AT_lower_bound:
5562 return "DW_AT_lower_bound";
5563 case DW_AT_producer:
5564 return "DW_AT_producer";
5565 case DW_AT_prototyped:
5566 return "DW_AT_prototyped";
5567 case DW_AT_return_addr:
5568 return "DW_AT_return_addr";
5569 case DW_AT_start_scope:
5570 return "DW_AT_start_scope";
5571 case DW_AT_bit_stride:
5572 return "DW_AT_bit_stride";
5573 case DW_AT_upper_bound:
5574 return "DW_AT_upper_bound";
5575 case DW_AT_abstract_origin:
5576 return "DW_AT_abstract_origin";
5577 case DW_AT_accessibility:
5578 return "DW_AT_accessibility";
5579 case DW_AT_address_class:
5580 return "DW_AT_address_class";
5581 case DW_AT_artificial:
5582 return "DW_AT_artificial";
5583 case DW_AT_base_types:
5584 return "DW_AT_base_types";
5585 case DW_AT_calling_convention:
5586 return "DW_AT_calling_convention";
5588 return "DW_AT_count";
5589 case DW_AT_data_member_location:
5590 return "DW_AT_data_member_location";
5591 case DW_AT_decl_column:
5592 return "DW_AT_decl_column";
5593 case DW_AT_decl_file:
5594 return "DW_AT_decl_file";
5595 case DW_AT_decl_line:
5596 return "DW_AT_decl_line";
5597 case DW_AT_declaration:
5598 return "DW_AT_declaration";
5599 case DW_AT_discr_list:
5600 return "DW_AT_discr_list";
5601 case DW_AT_encoding:
5602 return "DW_AT_encoding";
5603 case DW_AT_external:
5604 return "DW_AT_external";
5605 case DW_AT_explicit:
5606 return "DW_AT_explicit";
5607 case DW_AT_frame_base:
5608 return "DW_AT_frame_base";
5610 return "DW_AT_friend";
5611 case DW_AT_identifier_case:
5612 return "DW_AT_identifier_case";
5613 case DW_AT_macro_info:
5614 return "DW_AT_macro_info";
5615 case DW_AT_namelist_items:
5616 return "DW_AT_namelist_items";
5617 case DW_AT_priority:
5618 return "DW_AT_priority";
5620 return "DW_AT_segment";
5621 case DW_AT_specification:
5622 return "DW_AT_specification";
5623 case DW_AT_static_link:
5624 return "DW_AT_static_link";
5626 return "DW_AT_type";
5627 case DW_AT_use_location:
5628 return "DW_AT_use_location";
5629 case DW_AT_variable_parameter:
5630 return "DW_AT_variable_parameter";
5631 case DW_AT_virtuality:
5632 return "DW_AT_virtuality";
5633 case DW_AT_vtable_elem_location:
5634 return "DW_AT_vtable_elem_location";
5636 case DW_AT_allocated:
5637 return "DW_AT_allocated";
5638 case DW_AT_associated:
5639 return "DW_AT_associated";
5640 case DW_AT_data_location:
5641 return "DW_AT_data_location";
5642 case DW_AT_byte_stride:
5643 return "DW_AT_byte_stride";
5644 case DW_AT_entry_pc:
5645 return "DW_AT_entry_pc";
5646 case DW_AT_use_UTF8:
5647 return "DW_AT_use_UTF8";
5648 case DW_AT_extension:
5649 return "DW_AT_extension";
5651 return "DW_AT_ranges";
5652 case DW_AT_trampoline:
5653 return "DW_AT_trampoline";
5654 case DW_AT_call_column:
5655 return "DW_AT_call_column";
5656 case DW_AT_call_file:
5657 return "DW_AT_call_file";
5658 case DW_AT_call_line:
5659 return "DW_AT_call_line";
5661 case DW_AT_MIPS_fde:
5662 return "DW_AT_MIPS_fde";
5663 case DW_AT_MIPS_loop_begin:
5664 return "DW_AT_MIPS_loop_begin";
5665 case DW_AT_MIPS_tail_loop_begin:
5666 return "DW_AT_MIPS_tail_loop_begin";
5667 case DW_AT_MIPS_epilog_begin:
5668 return "DW_AT_MIPS_epilog_begin";
5669 case DW_AT_MIPS_loop_unroll_factor:
5670 return "DW_AT_MIPS_loop_unroll_factor";
5671 case DW_AT_MIPS_software_pipeline_depth:
5672 return "DW_AT_MIPS_software_pipeline_depth";
5673 case DW_AT_MIPS_linkage_name:
5674 return "DW_AT_MIPS_linkage_name";
5675 case DW_AT_MIPS_stride:
5676 return "DW_AT_MIPS_stride";
5677 case DW_AT_MIPS_abstract_name:
5678 return "DW_AT_MIPS_abstract_name";
5679 case DW_AT_MIPS_clone_origin:
5680 return "DW_AT_MIPS_clone_origin";
5681 case DW_AT_MIPS_has_inlines:
5682 return "DW_AT_MIPS_has_inlines";
5684 case DW_AT_sf_names:
5685 return "DW_AT_sf_names";
5686 case DW_AT_src_info:
5687 return "DW_AT_src_info";
5688 case DW_AT_mac_info:
5689 return "DW_AT_mac_info";
5690 case DW_AT_src_coords:
5691 return "DW_AT_src_coords";
5692 case DW_AT_body_begin:
5693 return "DW_AT_body_begin";
5694 case DW_AT_body_end:
5695 return "DW_AT_body_end";
5696 case DW_AT_GNU_vector:
5697 return "DW_AT_GNU_vector";
5699 case DW_AT_VMS_rtnbeg_pd_address:
5700 return "DW_AT_VMS_rtnbeg_pd_address";
5703 return "DW_AT_<unknown>";
5707 /* Convert a DWARF value form code into its string name. */
5710 dwarf_form_name (unsigned int form)
5715 return "DW_FORM_addr";
5716 case DW_FORM_block2:
5717 return "DW_FORM_block2";
5718 case DW_FORM_block4:
5719 return "DW_FORM_block4";
5721 return "DW_FORM_data2";
5723 return "DW_FORM_data4";
5725 return "DW_FORM_data8";
5726 case DW_FORM_string:
5727 return "DW_FORM_string";
5729 return "DW_FORM_block";
5730 case DW_FORM_block1:
5731 return "DW_FORM_block1";
5733 return "DW_FORM_data1";
5735 return "DW_FORM_flag";
5737 return "DW_FORM_sdata";
5739 return "DW_FORM_strp";
5741 return "DW_FORM_udata";
5742 case DW_FORM_ref_addr:
5743 return "DW_FORM_ref_addr";
5745 return "DW_FORM_ref1";
5747 return "DW_FORM_ref2";
5749 return "DW_FORM_ref4";
5751 return "DW_FORM_ref8";
5752 case DW_FORM_ref_udata:
5753 return "DW_FORM_ref_udata";
5754 case DW_FORM_indirect:
5755 return "DW_FORM_indirect";
5757 return "DW_FORM_<unknown>";
5761 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
5762 instance of an inlined instance of a decl which is local to an inline
5763 function, so we have to trace all of the way back through the origin chain
5764 to find out what sort of node actually served as the original seed for the
5768 decl_ultimate_origin (const_tree decl)
5770 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
5773 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
5774 nodes in the function to point to themselves; ignore that if
5775 we're trying to output the abstract instance of this function. */
5776 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
5779 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
5780 most distant ancestor, this should never happen. */
5781 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
5783 return DECL_ABSTRACT_ORIGIN (decl);
5786 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
5787 of a virtual function may refer to a base class, so we check the 'this'
5791 decl_class_context (tree decl)
5793 tree context = NULL_TREE;
5795 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
5796 context = DECL_CONTEXT (decl);
5798 context = TYPE_MAIN_VARIANT
5799 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
5801 if (context && !TYPE_P (context))
5802 context = NULL_TREE;
5807 /* Add an attribute/value pair to a DIE. */
5810 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
5812 /* Maybe this should be an assert? */
5816 if (die->die_attr == NULL)
5817 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
5818 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
5821 static inline enum dw_val_class
5822 AT_class (dw_attr_ref a)
5824 return a->dw_attr_val.val_class;
5827 /* Add a flag value attribute to a DIE. */
5830 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
5834 attr.dw_attr = attr_kind;
5835 attr.dw_attr_val.val_class = dw_val_class_flag;
5836 attr.dw_attr_val.v.val_flag = flag;
5837 add_dwarf_attr (die, &attr);
5840 static inline unsigned
5841 AT_flag (dw_attr_ref a)
5843 gcc_assert (a && AT_class (a) == dw_val_class_flag);
5844 return a->dw_attr_val.v.val_flag;
5847 /* Add a signed integer attribute value to a DIE. */
5850 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
5854 attr.dw_attr = attr_kind;
5855 attr.dw_attr_val.val_class = dw_val_class_const;
5856 attr.dw_attr_val.v.val_int = int_val;
5857 add_dwarf_attr (die, &attr);
5860 static inline HOST_WIDE_INT
5861 AT_int (dw_attr_ref a)
5863 gcc_assert (a && AT_class (a) == dw_val_class_const);
5864 return a->dw_attr_val.v.val_int;
5867 /* Add an unsigned integer attribute value to a DIE. */
5870 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
5871 unsigned HOST_WIDE_INT unsigned_val)
5875 attr.dw_attr = attr_kind;
5876 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
5877 attr.dw_attr_val.v.val_unsigned = unsigned_val;
5878 add_dwarf_attr (die, &attr);
5881 static inline unsigned HOST_WIDE_INT
5882 AT_unsigned (dw_attr_ref a)
5884 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
5885 return a->dw_attr_val.v.val_unsigned;
5888 /* Add an unsigned double integer attribute value to a DIE. */
5891 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
5892 long unsigned int val_hi, long unsigned int val_low)
5896 attr.dw_attr = attr_kind;
5897 attr.dw_attr_val.val_class = dw_val_class_long_long;
5898 attr.dw_attr_val.v.val_long_long.hi = val_hi;
5899 attr.dw_attr_val.v.val_long_long.low = val_low;
5900 add_dwarf_attr (die, &attr);
5903 /* Add a floating point attribute value to a DIE and return it. */
5906 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
5907 unsigned int length, unsigned int elt_size, unsigned char *array)
5911 attr.dw_attr = attr_kind;
5912 attr.dw_attr_val.val_class = dw_val_class_vec;
5913 attr.dw_attr_val.v.val_vec.length = length;
5914 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
5915 attr.dw_attr_val.v.val_vec.array = array;
5916 add_dwarf_attr (die, &attr);
5919 /* Hash and equality functions for debug_str_hash. */
5922 debug_str_do_hash (const void *x)
5924 return htab_hash_string (((const struct indirect_string_node *)x)->str);
5928 debug_str_eq (const void *x1, const void *x2)
5930 return strcmp ((((const struct indirect_string_node *)x1)->str),
5931 (const char *)x2) == 0;
5934 static struct indirect_string_node *
5935 find_AT_string (const char *str)
5937 struct indirect_string_node *node;
5940 if (! debug_str_hash)
5941 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5942 debug_str_eq, NULL);
5944 slot = htab_find_slot_with_hash (debug_str_hash, str,
5945 htab_hash_string (str), INSERT);
5948 node = (struct indirect_string_node *)
5949 ggc_alloc_cleared (sizeof (struct indirect_string_node));
5950 node->str = ggc_strdup (str);
5954 node = (struct indirect_string_node *) *slot;
5960 /* Add a string attribute value to a DIE. */
5963 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5966 struct indirect_string_node *node;
5968 node = find_AT_string (str);
5970 attr.dw_attr = attr_kind;
5971 attr.dw_attr_val.val_class = dw_val_class_str;
5972 attr.dw_attr_val.v.val_str = node;
5973 add_dwarf_attr (die, &attr);
5976 static inline const char *
5977 AT_string (dw_attr_ref a)
5979 gcc_assert (a && AT_class (a) == dw_val_class_str);
5980 return a->dw_attr_val.v.val_str->str;
5983 /* Find out whether a string should be output inline in DIE
5984 or out-of-line in .debug_str section. */
5987 AT_string_form (dw_attr_ref a)
5989 struct indirect_string_node *node;
5993 gcc_assert (a && AT_class (a) == dw_val_class_str);
5995 node = a->dw_attr_val.v.val_str;
5999 len = strlen (node->str) + 1;
6001 /* If the string is shorter or equal to the size of the reference, it is
6002 always better to put it inline. */
6003 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
6004 return node->form = DW_FORM_string;
6006 /* If we cannot expect the linker to merge strings in .debug_str
6007 section, only put it into .debug_str if it is worth even in this
6009 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
6010 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
6011 return node->form = DW_FORM_string;
6013 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
6014 ++dw2_string_counter;
6015 node->label = xstrdup (label);
6017 return node->form = DW_FORM_strp;
6020 /* Add a DIE reference attribute value to a DIE. */
6023 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
6027 attr.dw_attr = attr_kind;
6028 attr.dw_attr_val.val_class = dw_val_class_die_ref;
6029 attr.dw_attr_val.v.val_die_ref.die = targ_die;
6030 attr.dw_attr_val.v.val_die_ref.external = 0;
6031 add_dwarf_attr (die, &attr);
6034 /* Add an AT_specification attribute to a DIE, and also make the back
6035 pointer from the specification to the definition. */
6038 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
6040 add_AT_die_ref (die, DW_AT_specification, targ_die);
6041 gcc_assert (!targ_die->die_definition);
6042 targ_die->die_definition = die;
6045 static inline dw_die_ref
6046 AT_ref (dw_attr_ref a)
6048 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6049 return a->dw_attr_val.v.val_die_ref.die;
6053 AT_ref_external (dw_attr_ref a)
6055 if (a && AT_class (a) == dw_val_class_die_ref)
6056 return a->dw_attr_val.v.val_die_ref.external;
6062 set_AT_ref_external (dw_attr_ref a, int i)
6064 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6065 a->dw_attr_val.v.val_die_ref.external = i;
6068 /* Add an FDE reference attribute value to a DIE. */
6071 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
6075 attr.dw_attr = attr_kind;
6076 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
6077 attr.dw_attr_val.v.val_fde_index = targ_fde;
6078 add_dwarf_attr (die, &attr);
6081 /* Add a location description attribute value to a DIE. */
6084 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
6088 attr.dw_attr = attr_kind;
6089 attr.dw_attr_val.val_class = dw_val_class_loc;
6090 attr.dw_attr_val.v.val_loc = loc;
6091 add_dwarf_attr (die, &attr);
6094 static inline dw_loc_descr_ref
6095 AT_loc (dw_attr_ref a)
6097 gcc_assert (a && AT_class (a) == dw_val_class_loc);
6098 return a->dw_attr_val.v.val_loc;
6102 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
6106 attr.dw_attr = attr_kind;
6107 attr.dw_attr_val.val_class = dw_val_class_loc_list;
6108 attr.dw_attr_val.v.val_loc_list = loc_list;
6109 add_dwarf_attr (die, &attr);
6110 have_location_lists = true;
6113 static inline dw_loc_list_ref
6114 AT_loc_list (dw_attr_ref a)
6116 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
6117 return a->dw_attr_val.v.val_loc_list;
6120 /* Add an address constant attribute value to a DIE. */
6123 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
6127 attr.dw_attr = attr_kind;
6128 attr.dw_attr_val.val_class = dw_val_class_addr;
6129 attr.dw_attr_val.v.val_addr = addr;
6130 add_dwarf_attr (die, &attr);
6133 /* Get the RTX from to an address DIE attribute. */
6136 AT_addr (dw_attr_ref a)
6138 gcc_assert (a && AT_class (a) == dw_val_class_addr);
6139 return a->dw_attr_val.v.val_addr;
6142 /* Add a file attribute value to a DIE. */
6145 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
6146 struct dwarf_file_data *fd)
6150 attr.dw_attr = attr_kind;
6151 attr.dw_attr_val.val_class = dw_val_class_file;
6152 attr.dw_attr_val.v.val_file = fd;
6153 add_dwarf_attr (die, &attr);
6156 /* Get the dwarf_file_data from a file DIE attribute. */
6158 static inline struct dwarf_file_data *
6159 AT_file (dw_attr_ref a)
6161 gcc_assert (a && AT_class (a) == dw_val_class_file);
6162 return a->dw_attr_val.v.val_file;
6165 /* Add a label identifier attribute value to a DIE. */
6168 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
6172 attr.dw_attr = attr_kind;
6173 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
6174 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
6175 add_dwarf_attr (die, &attr);
6178 /* Add a section offset attribute value to a DIE, an offset into the
6179 debug_line section. */
6182 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6187 attr.dw_attr = attr_kind;
6188 attr.dw_attr_val.val_class = dw_val_class_lineptr;
6189 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6190 add_dwarf_attr (die, &attr);
6193 /* Add a section offset attribute value to a DIE, an offset into the
6194 debug_macinfo section. */
6197 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6202 attr.dw_attr = attr_kind;
6203 attr.dw_attr_val.val_class = dw_val_class_macptr;
6204 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6205 add_dwarf_attr (die, &attr);
6208 /* Add an offset attribute value to a DIE. */
6211 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
6212 unsigned HOST_WIDE_INT offset)
6216 attr.dw_attr = attr_kind;
6217 attr.dw_attr_val.val_class = dw_val_class_offset;
6218 attr.dw_attr_val.v.val_offset = offset;
6219 add_dwarf_attr (die, &attr);
6222 /* Add an range_list attribute value to a DIE. */
6225 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
6226 long unsigned int offset)
6230 attr.dw_attr = attr_kind;
6231 attr.dw_attr_val.val_class = dw_val_class_range_list;
6232 attr.dw_attr_val.v.val_offset = offset;
6233 add_dwarf_attr (die, &attr);
6236 static inline const char *
6237 AT_lbl (dw_attr_ref a)
6239 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
6240 || AT_class (a) == dw_val_class_lineptr
6241 || AT_class (a) == dw_val_class_macptr));
6242 return a->dw_attr_val.v.val_lbl_id;
6245 /* Get the attribute of type attr_kind. */
6248 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6252 dw_die_ref spec = NULL;
6257 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6258 if (a->dw_attr == attr_kind)
6260 else if (a->dw_attr == DW_AT_specification
6261 || a->dw_attr == DW_AT_abstract_origin)
6265 return get_AT (spec, attr_kind);
6270 /* Return the "low pc" attribute value, typically associated with a subprogram
6271 DIE. Return null if the "low pc" attribute is either not present, or if it
6272 cannot be represented as an assembler label identifier. */
6274 static inline const char *
6275 get_AT_low_pc (dw_die_ref die)
6277 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
6279 return a ? AT_lbl (a) : NULL;
6282 /* Return the "high pc" attribute value, typically associated with a subprogram
6283 DIE. Return null if the "high pc" attribute is either not present, or if it
6284 cannot be represented as an assembler label identifier. */
6286 static inline const char *
6287 get_AT_hi_pc (dw_die_ref die)
6289 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
6291 return a ? AT_lbl (a) : NULL;
6294 /* Return the value of the string attribute designated by ATTR_KIND, or
6295 NULL if it is not present. */
6297 static inline const char *
6298 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
6300 dw_attr_ref a = get_AT (die, attr_kind);
6302 return a ? AT_string (a) : NULL;
6305 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
6306 if it is not present. */
6309 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
6311 dw_attr_ref a = get_AT (die, attr_kind);
6313 return a ? AT_flag (a) : 0;
6316 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
6317 if it is not present. */
6319 static inline unsigned
6320 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
6322 dw_attr_ref a = get_AT (die, attr_kind);
6324 return a ? AT_unsigned (a) : 0;
6327 static inline dw_die_ref
6328 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
6330 dw_attr_ref a = get_AT (die, attr_kind);
6332 return a ? AT_ref (a) : NULL;
6335 static inline struct dwarf_file_data *
6336 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
6338 dw_attr_ref a = get_AT (die, attr_kind);
6340 return a ? AT_file (a) : NULL;
6343 /* Return TRUE if the language is C or C++. */
6348 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6350 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
6351 || lang == DW_LANG_C99
6352 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
6355 /* Return TRUE if the language is C++. */
6360 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6362 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
6365 /* Return TRUE if the language is Fortran. */
6370 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6372 return (lang == DW_LANG_Fortran77
6373 || lang == DW_LANG_Fortran90
6374 || lang == DW_LANG_Fortran95);
6377 /* Return TRUE if the language is Java. */
6382 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6384 return lang == DW_LANG_Java;
6387 /* Return TRUE if the language is Ada. */
6392 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6394 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
6397 /* Remove the specified attribute if present. */
6400 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6408 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6409 if (a->dw_attr == attr_kind)
6411 if (AT_class (a) == dw_val_class_str)
6412 if (a->dw_attr_val.v.val_str->refcount)
6413 a->dw_attr_val.v.val_str->refcount--;
6415 /* VEC_ordered_remove should help reduce the number of abbrevs
6417 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
6422 /* Remove CHILD from its parent. PREV must have the property that
6423 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
6426 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
6428 gcc_assert (child->die_parent == prev->die_parent);
6429 gcc_assert (prev->die_sib == child);
6432 gcc_assert (child->die_parent->die_child == child);
6436 prev->die_sib = child->die_sib;
6437 if (child->die_parent->die_child == child)
6438 child->die_parent->die_child = prev;
6441 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
6445 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
6451 dw_die_ref prev = c;
6453 while (c->die_tag == tag)
6455 remove_child_with_prev (c, prev);
6456 /* Might have removed every child. */
6457 if (c == c->die_sib)
6461 } while (c != die->die_child);
6464 /* Add a CHILD_DIE as the last child of DIE. */
6467 add_child_die (dw_die_ref die, dw_die_ref child_die)
6469 /* FIXME this should probably be an assert. */
6470 if (! die || ! child_die)
6472 gcc_assert (die != child_die);
6474 child_die->die_parent = die;
6477 child_die->die_sib = die->die_child->die_sib;
6478 die->die_child->die_sib = child_die;
6481 child_die->die_sib = child_die;
6482 die->die_child = child_die;
6485 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
6486 is the specification, to the end of PARENT's list of children.
6487 This is done by removing and re-adding it. */
6490 splice_child_die (dw_die_ref parent, dw_die_ref child)
6494 /* We want the declaration DIE from inside the class, not the
6495 specification DIE at toplevel. */
6496 if (child->die_parent != parent)
6498 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
6504 gcc_assert (child->die_parent == parent
6505 || (child->die_parent
6506 == get_AT_ref (parent, DW_AT_specification)));
6508 for (p = child->die_parent->die_child; ; p = p->die_sib)
6509 if (p->die_sib == child)
6511 remove_child_with_prev (child, p);
6515 add_child_die (parent, child);
6518 /* Return a pointer to a newly created DIE node. */
6520 static inline dw_die_ref
6521 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
6523 dw_die_ref die = GGC_CNEW (die_node);
6525 die->die_tag = tag_value;
6527 if (parent_die != NULL)
6528 add_child_die (parent_die, die);
6531 limbo_die_node *limbo_node;
6533 limbo_node = GGC_CNEW (limbo_die_node);
6534 limbo_node->die = die;
6535 limbo_node->created_for = t;
6536 limbo_node->next = limbo_die_list;
6537 limbo_die_list = limbo_node;
6543 /* Return the DIE associated with the given type specifier. */
6545 static inline dw_die_ref
6546 lookup_type_die (tree type)
6548 return TYPE_SYMTAB_DIE (type);
6551 /* Equate a DIE to a given type specifier. */
6554 equate_type_number_to_die (tree type, dw_die_ref type_die)
6556 TYPE_SYMTAB_DIE (type) = type_die;
6559 /* Returns a hash value for X (which really is a die_struct). */
6562 decl_die_table_hash (const void *x)
6564 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
6567 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
6570 decl_die_table_eq (const void *x, const void *y)
6572 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
6575 /* Return the DIE associated with a given declaration. */
6577 static inline dw_die_ref
6578 lookup_decl_die (tree decl)
6580 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
6583 /* Returns a hash value for X (which really is a var_loc_list). */
6586 decl_loc_table_hash (const void *x)
6588 return (hashval_t) ((const var_loc_list *) x)->decl_id;
6591 /* Return nonzero if decl_id of var_loc_list X is the same as
6595 decl_loc_table_eq (const void *x, const void *y)
6597 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
6600 /* Return the var_loc list associated with a given declaration. */
6602 static inline var_loc_list *
6603 lookup_decl_loc (const_tree decl)
6605 return (var_loc_list *)
6606 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
6609 /* Equate a DIE to a particular declaration. */
6612 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
6614 unsigned int decl_id = DECL_UID (decl);
6617 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
6619 decl_die->decl_id = decl_id;
6622 /* Add a variable location node to the linked list for DECL. */
6625 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
6627 unsigned int decl_id = DECL_UID (decl);
6631 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
6634 temp = GGC_CNEW (var_loc_list);
6635 temp->decl_id = decl_id;
6639 temp = (var_loc_list *) *slot;
6643 /* If the current location is the same as the end of the list,
6644 and either both or neither of the locations is uninitialized,
6645 we have nothing to do. */
6646 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
6647 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
6648 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6649 != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
6650 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6651 == VAR_INIT_STATUS_UNINITIALIZED)
6652 || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
6653 == VAR_INIT_STATUS_UNINITIALIZED))))
6655 /* Add LOC to the end of list and update LAST. */
6656 temp->last->next = loc;
6660 /* Do not add empty location to the beginning of the list. */
6661 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
6668 /* Keep track of the number of spaces used to indent the
6669 output of the debugging routines that print the structure of
6670 the DIE internal representation. */
6671 static int print_indent;
6673 /* Indent the line the number of spaces given by print_indent. */
6676 print_spaces (FILE *outfile)
6678 fprintf (outfile, "%*s", print_indent, "");
6681 /* Print the information associated with a given DIE, and its children.
6682 This routine is a debugging aid only. */
6685 print_die (dw_die_ref die, FILE *outfile)
6691 print_spaces (outfile);
6692 fprintf (outfile, "DIE %4ld: %s\n",
6693 die->die_offset, dwarf_tag_name (die->die_tag));
6694 print_spaces (outfile);
6695 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
6696 fprintf (outfile, " offset: %ld\n", die->die_offset);
6698 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6700 print_spaces (outfile);
6701 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
6703 switch (AT_class (a))
6705 case dw_val_class_addr:
6706 fprintf (outfile, "address");
6708 case dw_val_class_offset:
6709 fprintf (outfile, "offset");
6711 case dw_val_class_loc:
6712 fprintf (outfile, "location descriptor");
6714 case dw_val_class_loc_list:
6715 fprintf (outfile, "location list -> label:%s",
6716 AT_loc_list (a)->ll_symbol);
6718 case dw_val_class_range_list:
6719 fprintf (outfile, "range list");
6721 case dw_val_class_const:
6722 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
6724 case dw_val_class_unsigned_const:
6725 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
6727 case dw_val_class_long_long:
6728 fprintf (outfile, "constant (%lu,%lu)",
6729 a->dw_attr_val.v.val_long_long.hi,
6730 a->dw_attr_val.v.val_long_long.low);
6732 case dw_val_class_vec:
6733 fprintf (outfile, "floating-point or vector constant");
6735 case dw_val_class_flag:
6736 fprintf (outfile, "%u", AT_flag (a));
6738 case dw_val_class_die_ref:
6739 if (AT_ref (a) != NULL)
6741 if (AT_ref (a)->die_symbol)
6742 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
6744 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
6747 fprintf (outfile, "die -> <null>");
6749 case dw_val_class_lbl_id:
6750 case dw_val_class_lineptr:
6751 case dw_val_class_macptr:
6752 fprintf (outfile, "label: %s", AT_lbl (a));
6754 case dw_val_class_str:
6755 if (AT_string (a) != NULL)
6756 fprintf (outfile, "\"%s\"", AT_string (a));
6758 fprintf (outfile, "<null>");
6760 case dw_val_class_file:
6761 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
6762 AT_file (a)->emitted_number);
6768 fprintf (outfile, "\n");
6771 if (die->die_child != NULL)
6774 FOR_EACH_CHILD (die, c, print_die (c, outfile));
6777 if (print_indent == 0)
6778 fprintf (outfile, "\n");
6781 /* Print the contents of the source code line number correspondence table.
6782 This routine is a debugging aid only. */
6785 print_dwarf_line_table (FILE *outfile)
6788 dw_line_info_ref line_info;
6790 fprintf (outfile, "\n\nDWARF source line information\n");
6791 for (i = 1; i < line_info_table_in_use; i++)
6793 line_info = &line_info_table[i];
6794 fprintf (outfile, "%5d: %4ld %6ld\n", i,
6795 line_info->dw_file_num,
6796 line_info->dw_line_num);
6799 fprintf (outfile, "\n\n");
6802 /* Print the information collected for a given DIE. */
6805 debug_dwarf_die (dw_die_ref die)
6807 print_die (die, stderr);
6810 /* Print all DWARF information collected for the compilation unit.
6811 This routine is a debugging aid only. */
6817 print_die (comp_unit_die, stderr);
6818 if (! DWARF2_ASM_LINE_DEBUG_INFO)
6819 print_dwarf_line_table (stderr);
6822 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
6823 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
6824 DIE that marks the start of the DIEs for this include file. */
6827 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
6829 const char *filename = get_AT_string (bincl_die, DW_AT_name);
6830 dw_die_ref new_unit = gen_compile_unit_die (filename);
6832 new_unit->die_sib = old_unit;
6836 /* Close an include-file CU and reopen the enclosing one. */
6839 pop_compile_unit (dw_die_ref old_unit)
6841 dw_die_ref new_unit = old_unit->die_sib;
6843 old_unit->die_sib = NULL;
6847 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6848 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6850 /* Calculate the checksum of a location expression. */
6853 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
6855 CHECKSUM (loc->dw_loc_opc);
6856 CHECKSUM (loc->dw_loc_oprnd1);
6857 CHECKSUM (loc->dw_loc_oprnd2);
6860 /* Calculate the checksum of an attribute. */
6863 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
6865 dw_loc_descr_ref loc;
6868 CHECKSUM (at->dw_attr);
6870 /* We don't care that this was compiled with a different compiler
6871 snapshot; if the output is the same, that's what matters. */
6872 if (at->dw_attr == DW_AT_producer)
6875 switch (AT_class (at))
6877 case dw_val_class_const:
6878 CHECKSUM (at->dw_attr_val.v.val_int);
6880 case dw_val_class_unsigned_const:
6881 CHECKSUM (at->dw_attr_val.v.val_unsigned);
6883 case dw_val_class_long_long:
6884 CHECKSUM (at->dw_attr_val.v.val_long_long);
6886 case dw_val_class_vec:
6887 CHECKSUM (at->dw_attr_val.v.val_vec);
6889 case dw_val_class_flag:
6890 CHECKSUM (at->dw_attr_val.v.val_flag);
6892 case dw_val_class_str:
6893 CHECKSUM_STRING (AT_string (at));
6896 case dw_val_class_addr:
6898 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6899 CHECKSUM_STRING (XSTR (r, 0));
6902 case dw_val_class_offset:
6903 CHECKSUM (at->dw_attr_val.v.val_offset);
6906 case dw_val_class_loc:
6907 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6908 loc_checksum (loc, ctx);
6911 case dw_val_class_die_ref:
6912 die_checksum (AT_ref (at), ctx, mark);
6915 case dw_val_class_fde_ref:
6916 case dw_val_class_lbl_id:
6917 case dw_val_class_lineptr:
6918 case dw_val_class_macptr:
6921 case dw_val_class_file:
6922 CHECKSUM_STRING (AT_file (at)->filename);
6930 /* Calculate the checksum of a DIE. */
6933 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6939 /* To avoid infinite recursion. */
6942 CHECKSUM (die->die_mark);
6945 die->die_mark = ++(*mark);
6947 CHECKSUM (die->die_tag);
6949 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6950 attr_checksum (a, ctx, mark);
6952 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6956 #undef CHECKSUM_STRING
6958 /* Do the location expressions look same? */
6960 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6962 return loc1->dw_loc_opc == loc2->dw_loc_opc
6963 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6964 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6967 /* Do the values look the same? */
6969 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6971 dw_loc_descr_ref loc1, loc2;
6974 if (v1->val_class != v2->val_class)
6977 switch (v1->val_class)
6979 case dw_val_class_const:
6980 return v1->v.val_int == v2->v.val_int;
6981 case dw_val_class_unsigned_const:
6982 return v1->v.val_unsigned == v2->v.val_unsigned;
6983 case dw_val_class_long_long:
6984 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6985 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6986 case dw_val_class_vec:
6987 if (v1->v.val_vec.length != v2->v.val_vec.length
6988 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6990 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6991 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6994 case dw_val_class_flag:
6995 return v1->v.val_flag == v2->v.val_flag;
6996 case dw_val_class_str:
6997 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6999 case dw_val_class_addr:
7000 r1 = v1->v.val_addr;
7001 r2 = v2->v.val_addr;
7002 if (GET_CODE (r1) != GET_CODE (r2))
7004 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
7005 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
7007 case dw_val_class_offset:
7008 return v1->v.val_offset == v2->v.val_offset;
7010 case dw_val_class_loc:
7011 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
7013 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7014 if (!same_loc_p (loc1, loc2, mark))
7016 return !loc1 && !loc2;
7018 case dw_val_class_die_ref:
7019 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7021 case dw_val_class_fde_ref:
7022 case dw_val_class_lbl_id:
7023 case dw_val_class_lineptr:
7024 case dw_val_class_macptr:
7027 case dw_val_class_file:
7028 return v1->v.val_file == v2->v.val_file;
7035 /* Do the attributes look the same? */
7038 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
7040 if (at1->dw_attr != at2->dw_attr)
7043 /* We don't care that this was compiled with a different compiler
7044 snapshot; if the output is the same, that's what matters. */
7045 if (at1->dw_attr == DW_AT_producer)
7048 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7051 /* Do the dies look the same? */
7054 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7060 /* To avoid infinite recursion. */
7062 return die1->die_mark == die2->die_mark;
7063 die1->die_mark = die2->die_mark = ++(*mark);
7065 if (die1->die_tag != die2->die_tag)
7068 if (VEC_length (dw_attr_node, die1->die_attr)
7069 != VEC_length (dw_attr_node, die2->die_attr))
7072 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
7073 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
7076 c1 = die1->die_child;
7077 c2 = die2->die_child;
7086 if (!same_die_p (c1, c2, mark))
7090 if (c1 == die1->die_child)
7092 if (c2 == die2->die_child)
7102 /* Do the dies look the same? Wrapper around same_die_p. */
7105 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
7108 int ret = same_die_p (die1, die2, &mark);
7110 unmark_all_dies (die1);
7111 unmark_all_dies (die2);
7116 /* The prefix to attach to symbols on DIEs in the current comdat debug
7118 static char *comdat_symbol_id;
7120 /* The index of the current symbol within the current comdat CU. */
7121 static unsigned int comdat_symbol_number;
7123 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7124 children, and set comdat_symbol_id accordingly. */
7127 compute_section_prefix (dw_die_ref unit_die)
7129 const char *die_name = get_AT_string (unit_die, DW_AT_name);
7130 const char *base = die_name ? lbasename (die_name) : "anonymous";
7131 char *name = XALLOCAVEC (char, strlen (base) + 64);
7134 unsigned char checksum[16];
7137 /* Compute the checksum of the DIE, then append part of it as hex digits to
7138 the name filename of the unit. */
7140 md5_init_ctx (&ctx);
7142 die_checksum (unit_die, &ctx, &mark);
7143 unmark_all_dies (unit_die);
7144 md5_finish_ctx (&ctx, checksum);
7146 sprintf (name, "%s.", base);
7147 clean_symbol_name (name);
7149 p = name + strlen (name);
7150 for (i = 0; i < 4; i++)
7152 sprintf (p, "%.2x", checksum[i]);
7156 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
7157 comdat_symbol_number = 0;
7160 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7163 is_type_die (dw_die_ref die)
7165 switch (die->die_tag)
7167 case DW_TAG_array_type:
7168 case DW_TAG_class_type:
7169 case DW_TAG_interface_type:
7170 case DW_TAG_enumeration_type:
7171 case DW_TAG_pointer_type:
7172 case DW_TAG_reference_type:
7173 case DW_TAG_string_type:
7174 case DW_TAG_structure_type:
7175 case DW_TAG_subroutine_type:
7176 case DW_TAG_union_type:
7177 case DW_TAG_ptr_to_member_type:
7178 case DW_TAG_set_type:
7179 case DW_TAG_subrange_type:
7180 case DW_TAG_base_type:
7181 case DW_TAG_const_type:
7182 case DW_TAG_file_type:
7183 case DW_TAG_packed_type:
7184 case DW_TAG_volatile_type:
7185 case DW_TAG_typedef:
7192 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7193 Basically, we want to choose the bits that are likely to be shared between
7194 compilations (types) and leave out the bits that are specific to individual
7195 compilations (functions). */
7198 is_comdat_die (dw_die_ref c)
7200 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7201 we do for stabs. The advantage is a greater likelihood of sharing between
7202 objects that don't include headers in the same order (and therefore would
7203 put the base types in a different comdat). jason 8/28/00 */
7205 if (c->die_tag == DW_TAG_base_type)
7208 if (c->die_tag == DW_TAG_pointer_type
7209 || c->die_tag == DW_TAG_reference_type
7210 || c->die_tag == DW_TAG_const_type
7211 || c->die_tag == DW_TAG_volatile_type)
7213 dw_die_ref t = get_AT_ref (c, DW_AT_type);
7215 return t ? is_comdat_die (t) : 0;
7218 return is_type_die (c);
7221 /* Returns 1 iff C is the sort of DIE that might be referred to from another
7222 compilation unit. */
7225 is_symbol_die (dw_die_ref c)
7227 return (is_type_die (c)
7228 || (get_AT (c, DW_AT_declaration)
7229 && !get_AT (c, DW_AT_specification))
7230 || c->die_tag == DW_TAG_namespace
7231 || c->die_tag == DW_TAG_module);
7235 gen_internal_sym (const char *prefix)
7239 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
7240 return xstrdup (buf);
7243 /* Assign symbols to all worthy DIEs under DIE. */
7246 assign_symbol_names (dw_die_ref die)
7250 if (is_symbol_die (die))
7252 if (comdat_symbol_id)
7254 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
7256 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
7257 comdat_symbol_id, comdat_symbol_number++);
7258 die->die_symbol = xstrdup (p);
7261 die->die_symbol = gen_internal_sym ("LDIE");
7264 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
7267 struct cu_hash_table_entry
7270 unsigned min_comdat_num, max_comdat_num;
7271 struct cu_hash_table_entry *next;
7274 /* Routines to manipulate hash table of CUs. */
7276 htab_cu_hash (const void *of)
7278 const struct cu_hash_table_entry *const entry =
7279 (const struct cu_hash_table_entry *) of;
7281 return htab_hash_string (entry->cu->die_symbol);
7285 htab_cu_eq (const void *of1, const void *of2)
7287 const struct cu_hash_table_entry *const entry1 =
7288 (const struct cu_hash_table_entry *) of1;
7289 const struct die_struct *const entry2 = (const struct die_struct *) of2;
7291 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
7295 htab_cu_del (void *what)
7297 struct cu_hash_table_entry *next,
7298 *entry = (struct cu_hash_table_entry *) what;
7308 /* Check whether we have already seen this CU and set up SYM_NUM
7311 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
7313 struct cu_hash_table_entry dummy;
7314 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
7316 dummy.max_comdat_num = 0;
7318 slot = (struct cu_hash_table_entry **)
7319 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7323 for (; entry; last = entry, entry = entry->next)
7325 if (same_die_p_wrap (cu, entry->cu))
7331 *sym_num = entry->min_comdat_num;
7335 entry = XCNEW (struct cu_hash_table_entry);
7337 entry->min_comdat_num = *sym_num = last->max_comdat_num;
7338 entry->next = *slot;
7344 /* Record SYM_NUM to record of CU in HTABLE. */
7346 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
7348 struct cu_hash_table_entry **slot, *entry;
7350 slot = (struct cu_hash_table_entry **)
7351 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7355 entry->max_comdat_num = sym_num;
7358 /* Traverse the DIE (which is always comp_unit_die), and set up
7359 additional compilation units for each of the include files we see
7360 bracketed by BINCL/EINCL. */
7363 break_out_includes (dw_die_ref die)
7366 dw_die_ref unit = NULL;
7367 limbo_die_node *node, **pnode;
7368 htab_t cu_hash_table;
7372 dw_die_ref prev = c;
7374 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
7375 || (unit && is_comdat_die (c)))
7377 dw_die_ref next = c->die_sib;
7379 /* This DIE is for a secondary CU; remove it from the main one. */
7380 remove_child_with_prev (c, prev);
7382 if (c->die_tag == DW_TAG_GNU_BINCL)
7383 unit = push_new_compile_unit (unit, c);
7384 else if (c->die_tag == DW_TAG_GNU_EINCL)
7385 unit = pop_compile_unit (unit);
7387 add_child_die (unit, c);
7389 if (c == die->die_child)
7392 } while (c != die->die_child);
7395 /* We can only use this in debugging, since the frontend doesn't check
7396 to make sure that we leave every include file we enter. */
7400 assign_symbol_names (die);
7401 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
7402 for (node = limbo_die_list, pnode = &limbo_die_list;
7408 compute_section_prefix (node->die);
7409 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
7410 &comdat_symbol_number);
7411 assign_symbol_names (node->die);
7413 *pnode = node->next;
7416 pnode = &node->next;
7417 record_comdat_symbol_number (node->die, cu_hash_table,
7418 comdat_symbol_number);
7421 htab_delete (cu_hash_table);
7424 /* Traverse the DIE and add a sibling attribute if it may have the
7425 effect of speeding up access to siblings. To save some space,
7426 avoid generating sibling attributes for DIE's without children. */
7429 add_sibling_attributes (dw_die_ref die)
7433 if (! die->die_child)
7436 if (die->die_parent && die != die->die_parent->die_child)
7437 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7439 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7442 /* Output all location lists for the DIE and its children. */
7445 output_location_lists (dw_die_ref die)
7451 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7452 if (AT_class (a) == dw_val_class_loc_list)
7453 output_loc_list (AT_loc_list (a));
7455 FOR_EACH_CHILD (die, c, output_location_lists (c));
7458 /* The format of each DIE (and its attribute value pairs) is encoded in an
7459 abbreviation table. This routine builds the abbreviation table and assigns
7460 a unique abbreviation id for each abbreviation entry. The children of each
7461 die are visited recursively. */
7464 build_abbrev_table (dw_die_ref die)
7466 unsigned long abbrev_id;
7467 unsigned int n_alloc;
7472 /* Scan the DIE references, and mark as external any that refer to
7473 DIEs from other CUs (i.e. those which are not marked). */
7474 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7475 if (AT_class (a) == dw_val_class_die_ref
7476 && AT_ref (a)->die_mark == 0)
7478 gcc_assert (AT_ref (a)->die_symbol);
7480 set_AT_ref_external (a, 1);
7483 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7485 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7486 dw_attr_ref die_a, abbrev_a;
7490 if (abbrev->die_tag != die->die_tag)
7492 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7495 if (VEC_length (dw_attr_node, abbrev->die_attr)
7496 != VEC_length (dw_attr_node, die->die_attr))
7499 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
7501 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
7502 if ((abbrev_a->dw_attr != die_a->dw_attr)
7503 || (value_format (abbrev_a) != value_format (die_a)))
7513 if (abbrev_id >= abbrev_die_table_in_use)
7515 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7517 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7518 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7521 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7522 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7523 abbrev_die_table_allocated = n_alloc;
7526 ++abbrev_die_table_in_use;
7527 abbrev_die_table[abbrev_id] = die;
7530 die->die_abbrev = abbrev_id;
7531 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
7534 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7537 constant_size (unsigned HOST_WIDE_INT value)
7544 log = floor_log2 (value);
7547 log = 1 << (floor_log2 (log) + 1);
7552 /* Return the size of a DIE as it is represented in the
7553 .debug_info section. */
7555 static unsigned long
7556 size_of_die (dw_die_ref die)
7558 unsigned long size = 0;
7562 size += size_of_uleb128 (die->die_abbrev);
7563 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7565 switch (AT_class (a))
7567 case dw_val_class_addr:
7568 size += DWARF2_ADDR_SIZE;
7570 case dw_val_class_offset:
7571 size += DWARF_OFFSET_SIZE;
7573 case dw_val_class_loc:
7575 unsigned long lsize = size_of_locs (AT_loc (a));
7578 size += constant_size (lsize);
7582 case dw_val_class_loc_list:
7583 size += DWARF_OFFSET_SIZE;
7585 case dw_val_class_range_list:
7586 size += DWARF_OFFSET_SIZE;
7588 case dw_val_class_const:
7589 size += size_of_sleb128 (AT_int (a));
7591 case dw_val_class_unsigned_const:
7592 size += constant_size (AT_unsigned (a));
7594 case dw_val_class_long_long:
7595 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
7597 case dw_val_class_vec:
7598 size += constant_size (a->dw_attr_val.v.val_vec.length
7599 * a->dw_attr_val.v.val_vec.elt_size)
7600 + a->dw_attr_val.v.val_vec.length
7601 * a->dw_attr_val.v.val_vec.elt_size; /* block */
7603 case dw_val_class_flag:
7606 case dw_val_class_die_ref:
7607 if (AT_ref_external (a))
7608 size += DWARF2_ADDR_SIZE;
7610 size += DWARF_OFFSET_SIZE;
7612 case dw_val_class_fde_ref:
7613 size += DWARF_OFFSET_SIZE;
7615 case dw_val_class_lbl_id:
7616 size += DWARF2_ADDR_SIZE;
7618 case dw_val_class_lineptr:
7619 case dw_val_class_macptr:
7620 size += DWARF_OFFSET_SIZE;
7622 case dw_val_class_str:
7623 if (AT_string_form (a) == DW_FORM_strp)
7624 size += DWARF_OFFSET_SIZE;
7626 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
7628 case dw_val_class_file:
7629 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
7639 /* Size the debugging information associated with a given DIE. Visits the
7640 DIE's children recursively. Updates the global variable next_die_offset, on
7641 each time through. Uses the current value of next_die_offset to update the
7642 die_offset field in each DIE. */
7645 calc_die_sizes (dw_die_ref die)
7649 die->die_offset = next_die_offset;
7650 next_die_offset += size_of_die (die);
7652 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
7654 if (die->die_child != NULL)
7655 /* Count the null byte used to terminate sibling lists. */
7656 next_die_offset += 1;
7659 /* Set the marks for a die and its children. We do this so
7660 that we know whether or not a reference needs to use FORM_ref_addr; only
7661 DIEs in the same CU will be marked. We used to clear out the offset
7662 and use that as the flag, but ran into ordering problems. */
7665 mark_dies (dw_die_ref die)
7669 gcc_assert (!die->die_mark);
7672 FOR_EACH_CHILD (die, c, mark_dies (c));
7675 /* Clear the marks for a die and its children. */
7678 unmark_dies (dw_die_ref die)
7682 gcc_assert (die->die_mark);
7685 FOR_EACH_CHILD (die, c, unmark_dies (c));
7688 /* Clear the marks for a die, its children and referred dies. */
7691 unmark_all_dies (dw_die_ref die)
7701 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
7703 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7704 if (AT_class (a) == dw_val_class_die_ref)
7705 unmark_all_dies (AT_ref (a));
7708 /* Return the size of the .debug_pubnames or .debug_pubtypes table
7709 generated for the compilation unit. */
7711 static unsigned long
7712 size_of_pubnames (VEC (pubname_entry, gc) * names)
7718 size = DWARF_PUBNAMES_HEADER_SIZE;
7719 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
7720 if (names != pubtype_table
7721 || p->die->die_offset != 0
7722 || !flag_eliminate_unused_debug_types)
7723 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
7725 size += DWARF_OFFSET_SIZE;
7729 /* Return the size of the information in the .debug_aranges section. */
7731 static unsigned long
7732 size_of_aranges (void)
7736 size = DWARF_ARANGES_HEADER_SIZE;
7738 /* Count the address/length pair for this compilation unit. */
7739 if (text_section_used)
7740 size += 2 * DWARF2_ADDR_SIZE;
7741 if (cold_text_section_used)
7742 size += 2 * DWARF2_ADDR_SIZE;
7743 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
7745 /* Count the two zero words used to terminated the address range table. */
7746 size += 2 * DWARF2_ADDR_SIZE;
7750 /* Select the encoding of an attribute value. */
7752 static enum dwarf_form
7753 value_format (dw_attr_ref a)
7755 switch (a->dw_attr_val.val_class)
7757 case dw_val_class_addr:
7758 return DW_FORM_addr;
7759 case dw_val_class_range_list:
7760 case dw_val_class_offset:
7761 case dw_val_class_loc_list:
7762 switch (DWARF_OFFSET_SIZE)
7765 return DW_FORM_data4;
7767 return DW_FORM_data8;
7771 case dw_val_class_loc:
7772 switch (constant_size (size_of_locs (AT_loc (a))))
7775 return DW_FORM_block1;
7777 return DW_FORM_block2;
7781 case dw_val_class_const:
7782 return DW_FORM_sdata;
7783 case dw_val_class_unsigned_const:
7784 switch (constant_size (AT_unsigned (a)))
7787 return DW_FORM_data1;
7789 return DW_FORM_data2;
7791 return DW_FORM_data4;
7793 return DW_FORM_data8;
7797 case dw_val_class_long_long:
7798 return DW_FORM_block1;
7799 case dw_val_class_vec:
7800 switch (constant_size (a->dw_attr_val.v.val_vec.length
7801 * a->dw_attr_val.v.val_vec.elt_size))
7804 return DW_FORM_block1;
7806 return DW_FORM_block2;
7808 return DW_FORM_block4;
7812 case dw_val_class_flag:
7813 return DW_FORM_flag;
7814 case dw_val_class_die_ref:
7815 if (AT_ref_external (a))
7816 return DW_FORM_ref_addr;
7819 case dw_val_class_fde_ref:
7820 return DW_FORM_data;
7821 case dw_val_class_lbl_id:
7822 return DW_FORM_addr;
7823 case dw_val_class_lineptr:
7824 case dw_val_class_macptr:
7825 return DW_FORM_data;
7826 case dw_val_class_str:
7827 return AT_string_form (a);
7828 case dw_val_class_file:
7829 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
7832 return DW_FORM_data1;
7834 return DW_FORM_data2;
7836 return DW_FORM_data4;
7846 /* Output the encoding of an attribute value. */
7849 output_value_format (dw_attr_ref a)
7851 enum dwarf_form form = value_format (a);
7853 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
7856 /* Output the .debug_abbrev section which defines the DIE abbreviation
7860 output_abbrev_section (void)
7862 unsigned long abbrev_id;
7864 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7866 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7870 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
7871 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
7872 dwarf_tag_name (abbrev->die_tag));
7874 if (abbrev->die_child != NULL)
7875 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
7877 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
7879 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
7882 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
7883 dwarf_attr_name (a_attr->dw_attr));
7884 output_value_format (a_attr);
7887 dw2_asm_output_data (1, 0, NULL);
7888 dw2_asm_output_data (1, 0, NULL);
7891 /* Terminate the table. */
7892 dw2_asm_output_data (1, 0, NULL);
7895 /* Output a symbol we can use to refer to this DIE from another CU. */
7898 output_die_symbol (dw_die_ref die)
7900 char *sym = die->die_symbol;
7905 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
7906 /* We make these global, not weak; if the target doesn't support
7907 .linkonce, it doesn't support combining the sections, so debugging
7909 targetm.asm_out.globalize_label (asm_out_file, sym);
7911 ASM_OUTPUT_LABEL (asm_out_file, sym);
7914 /* Return a new location list, given the begin and end range, and the
7915 expression. gensym tells us whether to generate a new internal symbol for
7916 this location list node, which is done for the head of the list only. */
7918 static inline dw_loc_list_ref
7919 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
7920 const char *section, unsigned int gensym)
7922 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
7924 retlist->begin = begin;
7926 retlist->expr = expr;
7927 retlist->section = section;
7929 retlist->ll_symbol = gen_internal_sym ("LLST");
7934 /* Add a location description expression to a location list. */
7937 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
7938 const char *begin, const char *end,
7939 const char *section)
7943 /* Find the end of the chain. */
7944 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
7947 /* Add a new location list node to the list. */
7948 *d = new_loc_list (descr, begin, end, section, 0);
7951 /* Output the location list given to us. */
7954 output_loc_list (dw_loc_list_ref list_head)
7956 dw_loc_list_ref curr = list_head;
7958 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7960 /* Walk the location list, and output each range + expression. */
7961 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7964 /* Don't output an entry that starts and ends at the same address. */
7965 if (strcmp (curr->begin, curr->end) == 0)
7967 if (!have_multiple_function_sections)
7969 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7970 "Location list begin address (%s)",
7971 list_head->ll_symbol);
7972 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7973 "Location list end address (%s)",
7974 list_head->ll_symbol);
7978 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7979 "Location list begin address (%s)",
7980 list_head->ll_symbol);
7981 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7982 "Location list end address (%s)",
7983 list_head->ll_symbol);
7985 size = size_of_locs (curr->expr);
7987 /* Output the block length for this list of location operations. */
7988 gcc_assert (size <= 0xffff);
7989 dw2_asm_output_data (2, size, "%s", "Location expression size");
7991 output_loc_sequence (curr->expr);
7994 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7995 "Location list terminator begin (%s)",
7996 list_head->ll_symbol);
7997 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7998 "Location list terminator end (%s)",
7999 list_head->ll_symbol);
8002 /* Output the DIE and its attributes. Called recursively to generate
8003 the definitions of each child DIE. */
8006 output_die (dw_die_ref die)
8013 /* If someone in another CU might refer to us, set up a symbol for
8014 them to point to. */
8015 if (die->die_symbol)
8016 output_die_symbol (die);
8018 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
8019 (unsigned long)die->die_offset,
8020 dwarf_tag_name (die->die_tag));
8022 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8024 const char *name = dwarf_attr_name (a->dw_attr);
8026 switch (AT_class (a))
8028 case dw_val_class_addr:
8029 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8032 case dw_val_class_offset:
8033 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8037 case dw_val_class_range_list:
8039 char *p = strchr (ranges_section_label, '\0');
8041 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8042 a->dw_attr_val.v.val_offset);
8043 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8044 debug_ranges_section, "%s", name);
8049 case dw_val_class_loc:
8050 size = size_of_locs (AT_loc (a));
8052 /* Output the block length for this list of location operations. */
8053 dw2_asm_output_data (constant_size (size), size, "%s", name);
8055 output_loc_sequence (AT_loc (a));
8058 case dw_val_class_const:
8059 /* ??? It would be slightly more efficient to use a scheme like is
8060 used for unsigned constants below, but gdb 4.x does not sign
8061 extend. Gdb 5.x does sign extend. */
8062 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8065 case dw_val_class_unsigned_const:
8066 dw2_asm_output_data (constant_size (AT_unsigned (a)),
8067 AT_unsigned (a), "%s", name);
8070 case dw_val_class_long_long:
8072 unsigned HOST_WIDE_INT first, second;
8074 dw2_asm_output_data (1,
8075 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8078 if (WORDS_BIG_ENDIAN)
8080 first = a->dw_attr_val.v.val_long_long.hi;
8081 second = a->dw_attr_val.v.val_long_long.low;
8085 first = a->dw_attr_val.v.val_long_long.low;
8086 second = a->dw_attr_val.v.val_long_long.hi;
8089 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8090 first, "long long constant");
8091 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8096 case dw_val_class_vec:
8098 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8099 unsigned int len = a->dw_attr_val.v.val_vec.length;
8103 dw2_asm_output_data (constant_size (len * elt_size),
8104 len * elt_size, "%s", name);
8105 if (elt_size > sizeof (HOST_WIDE_INT))
8110 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8113 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8114 "fp or vector constant word %u", i);
8118 case dw_val_class_flag:
8119 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8122 case dw_val_class_loc_list:
8124 char *sym = AT_loc_list (a)->ll_symbol;
8127 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8132 case dw_val_class_die_ref:
8133 if (AT_ref_external (a))
8135 char *sym = AT_ref (a)->die_symbol;
8138 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
8143 gcc_assert (AT_ref (a)->die_offset);
8144 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8149 case dw_val_class_fde_ref:
8153 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8154 a->dw_attr_val.v.val_fde_index * 2);
8155 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
8160 case dw_val_class_lbl_id:
8161 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8164 case dw_val_class_lineptr:
8165 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8166 debug_line_section, "%s", name);
8169 case dw_val_class_macptr:
8170 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8171 debug_macinfo_section, "%s", name);
8174 case dw_val_class_str:
8175 if (AT_string_form (a) == DW_FORM_strp)
8176 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
8177 a->dw_attr_val.v.val_str->label,
8179 "%s: \"%s\"", name, AT_string (a));
8181 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
8184 case dw_val_class_file:
8186 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
8188 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
8189 a->dw_attr_val.v.val_file->filename);
8198 FOR_EACH_CHILD (die, c, output_die (c));
8200 /* Add null byte to terminate sibling list. */
8201 if (die->die_child != NULL)
8202 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
8203 (unsigned long) die->die_offset);
8206 /* Output the compilation unit that appears at the beginning of the
8207 .debug_info section, and precedes the DIE descriptions. */
8210 output_compilation_unit_header (void)
8212 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8213 dw2_asm_output_data (4, 0xffffffff,
8214 "Initial length escape value indicating 64-bit DWARF extension");
8215 dw2_asm_output_data (DWARF_OFFSET_SIZE,
8216 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
8217 "Length of Compilation Unit Info");
8218 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
8219 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
8220 debug_abbrev_section,
8221 "Offset Into Abbrev. Section");
8222 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
8225 /* Output the compilation unit DIE and its children. */
8228 output_comp_unit (dw_die_ref die, int output_if_empty)
8230 const char *secname;
8233 /* Unless we are outputting main CU, we may throw away empty ones. */
8234 if (!output_if_empty && die->die_child == NULL)
8237 /* Even if there are no children of this DIE, we must output the information
8238 about the compilation unit. Otherwise, on an empty translation unit, we
8239 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8240 will then complain when examining the file. First mark all the DIEs in
8241 this CU so we know which get local refs. */
8244 build_abbrev_table (die);
8246 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8247 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8248 calc_die_sizes (die);
8250 oldsym = die->die_symbol;
8253 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
8255 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
8257 die->die_symbol = NULL;
8258 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
8261 switch_to_section (debug_info_section);
8263 /* Output debugging information. */
8264 output_compilation_unit_header ();
8267 /* Leave the marks on the main CU, so we can check them in
8272 die->die_symbol = oldsym;
8276 /* Return the DWARF2/3 pubname associated with a decl. */
8279 dwarf2_name (tree decl, int scope)
8281 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
8284 /* Add a new entry to .debug_pubnames if appropriate. */
8287 add_pubname_string (const char *str, dw_die_ref die)
8292 e.name = xstrdup (str);
8293 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
8297 add_pubname (tree decl, dw_die_ref die)
8300 if (TREE_PUBLIC (decl))
8301 add_pubname_string (dwarf2_name (decl, 1), die);
8304 /* Add a new entry to .debug_pubtypes if appropriate. */
8307 add_pubtype (tree decl, dw_die_ref die)
8312 if ((TREE_PUBLIC (decl)
8313 || die->die_parent == comp_unit_die)
8314 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
8319 if (TYPE_NAME (decl))
8321 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
8322 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
8323 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
8324 && DECL_NAME (TYPE_NAME (decl)))
8325 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
8327 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
8331 e.name = xstrdup (dwarf2_name (decl, 1));
8333 /* If we don't have a name for the type, there's no point in adding
8335 if (e.name && e.name[0] != '\0')
8336 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
8340 /* Output the public names table used to speed up access to externally
8341 visible names; or the public types table used to find type definitions. */
8344 output_pubnames (VEC (pubname_entry, gc) * names)
8347 unsigned long pubnames_length = size_of_pubnames (names);
8350 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8351 dw2_asm_output_data (4, 0xffffffff,
8352 "Initial length escape value indicating 64-bit DWARF extension");
8353 if (names == pubname_table)
8354 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8355 "Length of Public Names Info");
8357 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8358 "Length of Public Type Names Info");
8359 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8360 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8362 "Offset of Compilation Unit Info");
8363 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
8364 "Compilation Unit Length");
8366 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
8368 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8369 if (names == pubname_table)
8370 gcc_assert (pub->die->die_mark);
8372 if (names != pubtype_table
8373 || pub->die->die_offset != 0
8374 || !flag_eliminate_unused_debug_types)
8376 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
8379 dw2_asm_output_nstring (pub->name, -1, "external name");
8383 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
8386 /* Add a new entry to .debug_aranges if appropriate. */
8389 add_arange (tree decl, dw_die_ref die)
8391 if (! DECL_SECTION_NAME (decl))
8394 if (arange_table_in_use == arange_table_allocated)
8396 arange_table_allocated += ARANGE_TABLE_INCREMENT;
8397 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
8398 arange_table_allocated);
8399 memset (arange_table + arange_table_in_use, 0,
8400 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
8403 arange_table[arange_table_in_use++] = die;
8406 /* Output the information that goes into the .debug_aranges table.
8407 Namely, define the beginning and ending address range of the
8408 text section generated for this compilation unit. */
8411 output_aranges (void)
8414 unsigned long aranges_length = size_of_aranges ();
8416 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8417 dw2_asm_output_data (4, 0xffffffff,
8418 "Initial length escape value indicating 64-bit DWARF extension");
8419 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
8420 "Length of Address Ranges Info");
8421 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8422 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8424 "Offset of Compilation Unit Info");
8425 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
8426 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8428 /* We need to align to twice the pointer size here. */
8429 if (DWARF_ARANGES_PAD_SIZE)
8431 /* Pad using a 2 byte words so that padding is correct for any
8433 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8434 2 * DWARF2_ADDR_SIZE);
8435 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
8436 dw2_asm_output_data (2, 0, NULL);
8439 /* It is necessary not to output these entries if the sections were
8440 not used; if the sections were not used, the length will be 0 and
8441 the address may end up as 0 if the section is discarded by ld
8442 --gc-sections, leaving an invalid (0, 0) entry that can be
8443 confused with the terminator. */
8444 if (text_section_used)
8446 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
8447 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
8448 text_section_label, "Length");
8450 if (cold_text_section_used)
8452 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
8454 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
8455 cold_text_section_label, "Length");
8458 for (i = 0; i < arange_table_in_use; i++)
8460 dw_die_ref die = arange_table[i];
8462 /* We shouldn't see aranges for DIEs outside of the main CU. */
8463 gcc_assert (die->die_mark);
8465 if (die->die_tag == DW_TAG_subprogram)
8467 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
8469 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
8470 get_AT_low_pc (die), "Length");
8474 /* A static variable; extract the symbol from DW_AT_location.
8475 Note that this code isn't currently hit, as we only emit
8476 aranges for functions (jason 9/23/99). */
8477 dw_attr_ref a = get_AT (die, DW_AT_location);
8478 dw_loc_descr_ref loc;
8480 gcc_assert (a && AT_class (a) == dw_val_class_loc);
8483 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
8485 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
8486 loc->dw_loc_oprnd1.v.val_addr, "Address");
8487 dw2_asm_output_data (DWARF2_ADDR_SIZE,
8488 get_AT_unsigned (die, DW_AT_byte_size),
8493 /* Output the terminator words. */
8494 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8495 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8498 /* Add a new entry to .debug_ranges. Return the offset at which it
8502 add_ranges_num (int num)
8504 unsigned int in_use = ranges_table_in_use;
8506 if (in_use == ranges_table_allocated)
8508 ranges_table_allocated += RANGES_TABLE_INCREMENT;
8509 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
8510 ranges_table_allocated);
8511 memset (ranges_table + ranges_table_in_use, 0,
8512 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
8515 ranges_table[in_use].num = num;
8516 ranges_table_in_use = in_use + 1;
8518 return in_use * 2 * DWARF2_ADDR_SIZE;
8521 /* Add a new entry to .debug_ranges corresponding to a block, or a
8522 range terminator if BLOCK is NULL. */
8525 add_ranges (const_tree block)
8527 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
8530 /* Add a new entry to .debug_ranges corresponding to a pair of
8534 add_ranges_by_labels (const char *begin, const char *end)
8536 unsigned int in_use = ranges_by_label_in_use;
8538 if (in_use == ranges_by_label_allocated)
8540 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
8541 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
8543 ranges_by_label_allocated);
8544 memset (ranges_by_label + ranges_by_label_in_use, 0,
8545 RANGES_TABLE_INCREMENT
8546 * sizeof (struct dw_ranges_by_label_struct));
8549 ranges_by_label[in_use].begin = begin;
8550 ranges_by_label[in_use].end = end;
8551 ranges_by_label_in_use = in_use + 1;
8553 return add_ranges_num (-(int)in_use - 1);
8557 output_ranges (void)
8560 static const char *const start_fmt = "Offset 0x%x";
8561 const char *fmt = start_fmt;
8563 for (i = 0; i < ranges_table_in_use; i++)
8565 int block_num = ranges_table[i].num;
8569 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
8570 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
8572 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
8573 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
8575 /* If all code is in the text section, then the compilation
8576 unit base address defaults to DW_AT_low_pc, which is the
8577 base of the text section. */
8578 if (!have_multiple_function_sections)
8580 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
8582 fmt, i * 2 * DWARF2_ADDR_SIZE);
8583 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
8584 text_section_label, NULL);
8587 /* Otherwise, the compilation unit base address is zero,
8588 which allows us to use absolute addresses, and not worry
8589 about whether the target supports cross-section
8593 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
8594 fmt, i * 2 * DWARF2_ADDR_SIZE);
8595 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
8601 /* Negative block_num stands for an index into ranges_by_label. */
8602 else if (block_num < 0)
8604 int lab_idx = - block_num - 1;
8606 if (!have_multiple_function_sections)
8610 /* If we ever use add_ranges_by_labels () for a single
8611 function section, all we have to do is to take out
8613 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8614 ranges_by_label[lab_idx].begin,
8616 fmt, i * 2 * DWARF2_ADDR_SIZE);
8617 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8618 ranges_by_label[lab_idx].end,
8619 text_section_label, NULL);
8624 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8625 ranges_by_label[lab_idx].begin,
8626 fmt, i * 2 * DWARF2_ADDR_SIZE);
8627 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8628 ranges_by_label[lab_idx].end,
8634 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8635 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8641 /* Data structure containing information about input files. */
8644 const char *path; /* Complete file name. */
8645 const char *fname; /* File name part. */
8646 int length; /* Length of entire string. */
8647 struct dwarf_file_data * file_idx; /* Index in input file table. */
8648 int dir_idx; /* Index in directory table. */
8651 /* Data structure containing information about directories with source
8655 const char *path; /* Path including directory name. */
8656 int length; /* Path length. */
8657 int prefix; /* Index of directory entry which is a prefix. */
8658 int count; /* Number of files in this directory. */
8659 int dir_idx; /* Index of directory used as base. */
8662 /* Callback function for file_info comparison. We sort by looking at
8663 the directories in the path. */
8666 file_info_cmp (const void *p1, const void *p2)
8668 const struct file_info *const s1 = (const struct file_info *) p1;
8669 const struct file_info *const s2 = (const struct file_info *) p2;
8670 const unsigned char *cp1;
8671 const unsigned char *cp2;
8673 /* Take care of file names without directories. We need to make sure that
8674 we return consistent values to qsort since some will get confused if
8675 we return the same value when identical operands are passed in opposite
8676 orders. So if neither has a directory, return 0 and otherwise return
8677 1 or -1 depending on which one has the directory. */
8678 if ((s1->path == s1->fname || s2->path == s2->fname))
8679 return (s2->path == s2->fname) - (s1->path == s1->fname);
8681 cp1 = (const unsigned char *) s1->path;
8682 cp2 = (const unsigned char *) s2->path;
8688 /* Reached the end of the first path? If so, handle like above. */
8689 if ((cp1 == (const unsigned char *) s1->fname)
8690 || (cp2 == (const unsigned char *) s2->fname))
8691 return ((cp2 == (const unsigned char *) s2->fname)
8692 - (cp1 == (const unsigned char *) s1->fname));
8694 /* Character of current path component the same? */
8695 else if (*cp1 != *cp2)
8700 struct file_name_acquire_data
8702 struct file_info *files;
8707 /* Traversal function for the hash table. */
8710 file_name_acquire (void ** slot, void *data)
8712 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
8713 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
8714 struct file_info *fi;
8717 gcc_assert (fnad->max_files >= d->emitted_number);
8719 if (! d->emitted_number)
8722 gcc_assert (fnad->max_files != fnad->used_files);
8724 fi = fnad->files + fnad->used_files++;
8726 /* Skip all leading "./". */
8728 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
8731 /* Create a new array entry. */
8733 fi->length = strlen (f);
8736 /* Search for the file name part. */
8737 f = strrchr (f, DIR_SEPARATOR);
8738 #if defined (DIR_SEPARATOR_2)
8740 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
8744 if (f == NULL || f < g)
8750 fi->fname = f == NULL ? fi->path : f + 1;
8754 /* Output the directory table and the file name table. We try to minimize
8755 the total amount of memory needed. A heuristic is used to avoid large
8756 slowdowns with many input files. */
8759 output_file_names (void)
8761 struct file_name_acquire_data fnad;
8763 struct file_info *files;
8764 struct dir_info *dirs;
8773 if (!last_emitted_file)
8775 dw2_asm_output_data (1, 0, "End directory table");
8776 dw2_asm_output_data (1, 0, "End file name table");
8780 numfiles = last_emitted_file->emitted_number;
8782 /* Allocate the various arrays we need. */
8783 files = XALLOCAVEC (struct file_info, numfiles);
8784 dirs = XALLOCAVEC (struct dir_info, numfiles);
8787 fnad.used_files = 0;
8788 fnad.max_files = numfiles;
8789 htab_traverse (file_table, file_name_acquire, &fnad);
8790 gcc_assert (fnad.used_files == fnad.max_files);
8792 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
8794 /* Find all the different directories used. */
8795 dirs[0].path = files[0].path;
8796 dirs[0].length = files[0].fname - files[0].path;
8797 dirs[0].prefix = -1;
8799 dirs[0].dir_idx = 0;
8800 files[0].dir_idx = 0;
8803 for (i = 1; i < numfiles; i++)
8804 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
8805 && memcmp (dirs[ndirs - 1].path, files[i].path,
8806 dirs[ndirs - 1].length) == 0)
8808 /* Same directory as last entry. */
8809 files[i].dir_idx = ndirs - 1;
8810 ++dirs[ndirs - 1].count;
8816 /* This is a new directory. */
8817 dirs[ndirs].path = files[i].path;
8818 dirs[ndirs].length = files[i].fname - files[i].path;
8819 dirs[ndirs].count = 1;
8820 dirs[ndirs].dir_idx = ndirs;
8821 files[i].dir_idx = ndirs;
8823 /* Search for a prefix. */
8824 dirs[ndirs].prefix = -1;
8825 for (j = 0; j < ndirs; j++)
8826 if (dirs[j].length < dirs[ndirs].length
8827 && dirs[j].length > 1
8828 && (dirs[ndirs].prefix == -1
8829 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
8830 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
8831 dirs[ndirs].prefix = j;
8836 /* Now to the actual work. We have to find a subset of the directories which
8837 allow expressing the file name using references to the directory table
8838 with the least amount of characters. We do not do an exhaustive search
8839 where we would have to check out every combination of every single
8840 possible prefix. Instead we use a heuristic which provides nearly optimal
8841 results in most cases and never is much off. */
8842 saved = XALLOCAVEC (int, ndirs);
8843 savehere = XALLOCAVEC (int, ndirs);
8845 memset (saved, '\0', ndirs * sizeof (saved[0]));
8846 for (i = 0; i < ndirs; i++)
8851 /* We can always save some space for the current directory. But this
8852 does not mean it will be enough to justify adding the directory. */
8853 savehere[i] = dirs[i].length;
8854 total = (savehere[i] - saved[i]) * dirs[i].count;
8856 for (j = i + 1; j < ndirs; j++)
8859 if (saved[j] < dirs[i].length)
8861 /* Determine whether the dirs[i] path is a prefix of the
8866 while (k != -1 && k != (int) i)
8871 /* Yes it is. We can possibly save some memory by
8872 writing the filenames in dirs[j] relative to
8874 savehere[j] = dirs[i].length;
8875 total += (savehere[j] - saved[j]) * dirs[j].count;
8880 /* Check whether we can save enough to justify adding the dirs[i]
8882 if (total > dirs[i].length + 1)
8884 /* It's worthwhile adding. */
8885 for (j = i; j < ndirs; j++)
8886 if (savehere[j] > 0)
8888 /* Remember how much we saved for this directory so far. */
8889 saved[j] = savehere[j];
8891 /* Remember the prefix directory. */
8892 dirs[j].dir_idx = i;
8897 /* Emit the directory name table. */
8899 idx_offset = dirs[0].length > 0 ? 1 : 0;
8900 for (i = 1 - idx_offset; i < ndirs; i++)
8901 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
8902 "Directory Entry: 0x%x", i + idx_offset);
8904 dw2_asm_output_data (1, 0, "End directory table");
8906 /* We have to emit them in the order of emitted_number since that's
8907 used in the debug info generation. To do this efficiently we
8908 generate a back-mapping of the indices first. */
8909 backmap = XALLOCAVEC (int, numfiles);
8910 for (i = 0; i < numfiles; i++)
8911 backmap[files[i].file_idx->emitted_number - 1] = i;
8913 /* Now write all the file names. */
8914 for (i = 0; i < numfiles; i++)
8916 int file_idx = backmap[i];
8917 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
8919 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
8920 "File Entry: 0x%x", (unsigned) i + 1);
8922 /* Include directory index. */
8923 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
8925 /* Modification time. */
8926 dw2_asm_output_data_uleb128 (0, NULL);
8928 /* File length in bytes. */
8929 dw2_asm_output_data_uleb128 (0, NULL);
8932 dw2_asm_output_data (1, 0, "End file name table");
8936 /* Output the source line number correspondence information. This
8937 information goes into the .debug_line section. */
8940 output_line_info (void)
8942 char l1[20], l2[20], p1[20], p2[20];
8943 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8944 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8947 unsigned long lt_index;
8948 unsigned long current_line;
8951 unsigned long current_file;
8952 unsigned long function;
8954 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
8955 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
8956 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
8957 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
8959 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8960 dw2_asm_output_data (4, 0xffffffff,
8961 "Initial length escape value indicating 64-bit DWARF extension");
8962 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
8963 "Length of Source Line Info");
8964 ASM_OUTPUT_LABEL (asm_out_file, l1);
8966 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8967 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
8968 ASM_OUTPUT_LABEL (asm_out_file, p1);
8970 /* Define the architecture-dependent minimum instruction length (in
8971 bytes). In this implementation of DWARF, this field is used for
8972 information purposes only. Since GCC generates assembly language,
8973 we have no a priori knowledge of how many instruction bytes are
8974 generated for each source line, and therefore can use only the
8975 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
8976 commands. Accordingly, we fix this as `1', which is "correct
8977 enough" for all architectures, and don't let the target override. */
8978 dw2_asm_output_data (1, 1,
8979 "Minimum Instruction Length");
8981 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
8982 "Default is_stmt_start flag");
8983 dw2_asm_output_data (1, DWARF_LINE_BASE,
8984 "Line Base Value (Special Opcodes)");
8985 dw2_asm_output_data (1, DWARF_LINE_RANGE,
8986 "Line Range Value (Special Opcodes)");
8987 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
8988 "Special Opcode Base");
8990 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
8994 case DW_LNS_advance_pc:
8995 case DW_LNS_advance_line:
8996 case DW_LNS_set_file:
8997 case DW_LNS_set_column:
8998 case DW_LNS_fixed_advance_pc:
9006 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
9010 /* Write out the information about the files we use. */
9011 output_file_names ();
9012 ASM_OUTPUT_LABEL (asm_out_file, p2);
9014 /* We used to set the address register to the first location in the text
9015 section here, but that didn't accomplish anything since we already
9016 have a line note for the opening brace of the first function. */
9018 /* Generate the line number to PC correspondence table, encoded as
9019 a series of state machine operations. */
9023 if (cfun && in_cold_section_p)
9024 strcpy (prev_line_label, crtl->subsections.cold_section_label);
9026 strcpy (prev_line_label, text_section_label);
9027 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
9029 dw_line_info_ref line_info = &line_info_table[lt_index];
9032 /* Disable this optimization for now; GDB wants to see two line notes
9033 at the beginning of a function so it can find the end of the
9036 /* Don't emit anything for redundant notes. Just updating the
9037 address doesn't accomplish anything, because we already assume
9038 that anything after the last address is this line. */
9039 if (line_info->dw_line_num == current_line
9040 && line_info->dw_file_num == current_file)
9044 /* Emit debug info for the address of the current line.
9046 Unfortunately, we have little choice here currently, and must always
9047 use the most general form. GCC does not know the address delta
9048 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9049 attributes which will give an upper bound on the address range. We
9050 could perhaps use length attributes to determine when it is safe to
9051 use DW_LNS_fixed_advance_pc. */
9053 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
9056 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
9057 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9058 "DW_LNS_fixed_advance_pc");
9059 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9063 /* This can handle any delta. This takes
9064 4+DWARF2_ADDR_SIZE bytes. */
9065 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9066 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9067 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9068 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9071 strcpy (prev_line_label, line_label);
9073 /* Emit debug info for the source file of the current line, if
9074 different from the previous line. */
9075 if (line_info->dw_file_num != current_file)
9077 current_file = line_info->dw_file_num;
9078 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9079 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9082 /* Emit debug info for the current line number, choosing the encoding
9083 that uses the least amount of space. */
9084 if (line_info->dw_line_num != current_line)
9086 line_offset = line_info->dw_line_num - current_line;
9087 line_delta = line_offset - DWARF_LINE_BASE;
9088 current_line = line_info->dw_line_num;
9089 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9090 /* This can handle deltas from -10 to 234, using the current
9091 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
9093 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9094 "line %lu", current_line);
9097 /* This can handle any delta. This takes at least 4 bytes,
9098 depending on the value being encoded. */
9099 dw2_asm_output_data (1, DW_LNS_advance_line,
9100 "advance to line %lu", current_line);
9101 dw2_asm_output_data_sleb128 (line_offset, NULL);
9102 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9106 /* We still need to start a new row, so output a copy insn. */
9107 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9110 /* Emit debug info for the address of the end of the function. */
9113 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9114 "DW_LNS_fixed_advance_pc");
9115 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
9119 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9120 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9121 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9122 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
9125 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9126 dw2_asm_output_data_uleb128 (1, NULL);
9127 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9132 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
9134 dw_separate_line_info_ref line_info
9135 = &separate_line_info_table[lt_index];
9138 /* Don't emit anything for redundant notes. */
9139 if (line_info->dw_line_num == current_line
9140 && line_info->dw_file_num == current_file
9141 && line_info->function == function)
9145 /* Emit debug info for the address of the current line. If this is
9146 a new function, or the first line of a function, then we need
9147 to handle it differently. */
9148 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
9150 if (function != line_info->function)
9152 function = line_info->function;
9154 /* Set the address register to the first line in the function. */
9155 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9156 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9157 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9158 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9162 /* ??? See the DW_LNS_advance_pc comment above. */
9165 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9166 "DW_LNS_fixed_advance_pc");
9167 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9171 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9172 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9173 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9174 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9178 strcpy (prev_line_label, line_label);
9180 /* Emit debug info for the source file of the current line, if
9181 different from the previous line. */
9182 if (line_info->dw_file_num != current_file)
9184 current_file = line_info->dw_file_num;
9185 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9186 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9189 /* Emit debug info for the current line number, choosing the encoding
9190 that uses the least amount of space. */
9191 if (line_info->dw_line_num != current_line)
9193 line_offset = line_info->dw_line_num - current_line;
9194 line_delta = line_offset - DWARF_LINE_BASE;
9195 current_line = line_info->dw_line_num;
9196 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9197 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9198 "line %lu", current_line);
9201 dw2_asm_output_data (1, DW_LNS_advance_line,
9202 "advance to line %lu", current_line);
9203 dw2_asm_output_data_sleb128 (line_offset, NULL);
9204 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9208 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9216 /* If we're done with a function, end its sequence. */
9217 if (lt_index == separate_line_info_table_in_use
9218 || separate_line_info_table[lt_index].function != function)
9223 /* Emit debug info for the address of the end of the function. */
9224 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
9227 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9228 "DW_LNS_fixed_advance_pc");
9229 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9233 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9234 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9235 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9236 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9239 /* Output the marker for the end of this sequence. */
9240 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9241 dw2_asm_output_data_uleb128 (1, NULL);
9242 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9246 /* Output the marker for the end of the line number info. */
9247 ASM_OUTPUT_LABEL (asm_out_file, l2);
9250 /* Given a pointer to a tree node for some base type, return a pointer to
9251 a DIE that describes the given type.
9253 This routine must only be called for GCC type nodes that correspond to
9254 Dwarf base (fundamental) types. */
9257 base_type_die (tree type)
9259 dw_die_ref base_type_result;
9260 enum dwarf_type encoding;
9262 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
9265 switch (TREE_CODE (type))
9268 if (TYPE_STRING_FLAG (type))
9270 if (TYPE_UNSIGNED (type))
9271 encoding = DW_ATE_unsigned_char;
9273 encoding = DW_ATE_signed_char;
9275 else if (TYPE_UNSIGNED (type))
9276 encoding = DW_ATE_unsigned;
9278 encoding = DW_ATE_signed;
9282 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
9283 encoding = DW_ATE_decimal_float;
9285 encoding = DW_ATE_float;
9288 case FIXED_POINT_TYPE:
9289 if (TYPE_UNSIGNED (type))
9290 encoding = DW_ATE_unsigned_fixed;
9292 encoding = DW_ATE_signed_fixed;
9295 /* Dwarf2 doesn't know anything about complex ints, so use
9296 a user defined type for it. */
9298 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
9299 encoding = DW_ATE_complex_float;
9301 encoding = DW_ATE_lo_user;
9305 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9306 encoding = DW_ATE_boolean;
9310 /* No other TREE_CODEs are Dwarf fundamental types. */
9314 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
9316 /* This probably indicates a bug. */
9317 if (! TYPE_NAME (type))
9318 add_name_attribute (base_type_result, "__unknown__");
9320 add_AT_unsigned (base_type_result, DW_AT_byte_size,
9321 int_size_in_bytes (type));
9322 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
9324 return base_type_result;
9327 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9328 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9331 is_base_type (tree type)
9333 switch (TREE_CODE (type))
9339 case FIXED_POINT_TYPE:
9347 case QUAL_UNION_TYPE:
9352 case REFERENCE_TYPE:
9365 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9366 node, return the size in bits for the type if it is a constant, or else
9367 return the alignment for the type if the type's size is not constant, or
9368 else return BITS_PER_WORD if the type actually turns out to be an
9371 static inline unsigned HOST_WIDE_INT
9372 simple_type_size_in_bits (const_tree type)
9374 if (TREE_CODE (type) == ERROR_MARK)
9375 return BITS_PER_WORD;
9376 else if (TYPE_SIZE (type) == NULL_TREE)
9378 else if (host_integerp (TYPE_SIZE (type), 1))
9379 return tree_low_cst (TYPE_SIZE (type), 1);
9381 return TYPE_ALIGN (type);
9384 /* Return true if the debug information for the given type should be
9385 emitted as a subrange type. */
9388 is_subrange_type (const_tree type)
9390 tree subtype = TREE_TYPE (type);
9392 /* Subrange types are identified by the fact that they are integer
9393 types, and that they have a subtype which is either an integer type
9394 or an enumeral type. */
9396 if (TREE_CODE (type) != INTEGER_TYPE
9397 || subtype == NULL_TREE)
9400 if (TREE_CODE (subtype) != INTEGER_TYPE
9401 && TREE_CODE (subtype) != ENUMERAL_TYPE
9402 && TREE_CODE (subtype) != BOOLEAN_TYPE)
9405 if (TREE_CODE (type) == TREE_CODE (subtype)
9406 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
9407 && TYPE_MIN_VALUE (type) != NULL
9408 && TYPE_MIN_VALUE (subtype) != NULL
9409 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
9410 && TYPE_MAX_VALUE (type) != NULL
9411 && TYPE_MAX_VALUE (subtype) != NULL
9412 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
9414 /* The type and its subtype have the same representation. If in
9415 addition the two types also have the same name, then the given
9416 type is not a subrange type, but rather a plain base type. */
9417 /* FIXME: brobecker/2004-03-22:
9418 Sizetype INTEGER_CSTs nodes are canonicalized. It should
9419 therefore be sufficient to check the TYPE_SIZE node pointers
9420 rather than checking the actual size. Unfortunately, we have
9421 found some cases, such as in the Ada "integer" type, where
9422 this is not the case. Until this problem is solved, we need to
9423 keep checking the actual size. */
9424 tree type_name = TYPE_NAME (type);
9425 tree subtype_name = TYPE_NAME (subtype);
9427 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
9428 type_name = DECL_NAME (type_name);
9430 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
9431 subtype_name = DECL_NAME (subtype_name);
9433 if (type_name == subtype_name)
9440 /* Given a pointer to a tree node for a subrange type, return a pointer
9441 to a DIE that describes the given type. */
9444 subrange_type_die (tree type, dw_die_ref context_die)
9446 dw_die_ref subrange_die;
9447 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
9449 if (context_die == NULL)
9450 context_die = comp_unit_die;
9452 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
9454 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
9456 /* The size of the subrange type and its base type do not match,
9457 so we need to generate a size attribute for the subrange type. */
9458 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
9461 if (TYPE_MIN_VALUE (type) != NULL)
9462 add_bound_info (subrange_die, DW_AT_lower_bound,
9463 TYPE_MIN_VALUE (type));
9464 if (TYPE_MAX_VALUE (type) != NULL)
9465 add_bound_info (subrange_die, DW_AT_upper_bound,
9466 TYPE_MAX_VALUE (type));
9468 return subrange_die;
9471 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9472 entry that chains various modifiers in front of the given type. */
9475 modified_type_die (tree type, int is_const_type, int is_volatile_type,
9476 dw_die_ref context_die)
9478 enum tree_code code = TREE_CODE (type);
9479 dw_die_ref mod_type_die;
9480 dw_die_ref sub_die = NULL;
9481 tree item_type = NULL;
9482 tree qualified_type;
9485 if (code == ERROR_MARK)
9488 /* See if we already have the appropriately qualified variant of
9491 = get_qualified_type (type,
9492 ((is_const_type ? TYPE_QUAL_CONST : 0)
9493 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
9495 /* If we do, then we can just use its DIE, if it exists. */
9498 mod_type_die = lookup_type_die (qualified_type);
9500 return mod_type_die;
9503 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
9505 /* Handle C typedef types. */
9506 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
9508 tree dtype = TREE_TYPE (name);
9510 if (qualified_type == dtype)
9512 /* For a named type, use the typedef. */
9513 gen_type_die (qualified_type, context_die);
9514 return lookup_type_die (qualified_type);
9516 else if (is_const_type < TYPE_READONLY (dtype)
9517 || is_volatile_type < TYPE_VOLATILE (dtype)
9518 || (is_const_type <= TYPE_READONLY (dtype)
9519 && is_volatile_type <= TYPE_VOLATILE (dtype)
9520 && DECL_ORIGINAL_TYPE (name) != type))
9521 /* cv-unqualified version of named type. Just use the unnamed
9522 type to which it refers. */
9523 return modified_type_die (DECL_ORIGINAL_TYPE (name),
9524 is_const_type, is_volatile_type,
9526 /* Else cv-qualified version of named type; fall through. */
9531 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
9532 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
9534 else if (is_volatile_type)
9536 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
9537 sub_die = modified_type_die (type, 0, 0, context_die);
9539 else if (code == POINTER_TYPE)
9541 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
9542 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9543 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9544 item_type = TREE_TYPE (type);
9546 else if (code == REFERENCE_TYPE)
9548 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
9549 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9550 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9551 item_type = TREE_TYPE (type);
9553 else if (is_subrange_type (type))
9555 mod_type_die = subrange_type_die (type, context_die);
9556 item_type = TREE_TYPE (type);
9558 else if (is_base_type (type))
9559 mod_type_die = base_type_die (type);
9562 gen_type_die (type, context_die);
9564 /* We have to get the type_main_variant here (and pass that to the
9565 `lookup_type_die' routine) because the ..._TYPE node we have
9566 might simply be a *copy* of some original type node (where the
9567 copy was created to help us keep track of typedef names) and
9568 that copy might have a different TYPE_UID from the original
9570 if (TREE_CODE (type) != VECTOR_TYPE)
9571 return lookup_type_die (type_main_variant (type));
9573 /* Vectors have the debugging information in the type,
9574 not the main variant. */
9575 return lookup_type_die (type);
9578 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9579 don't output a DW_TAG_typedef, since there isn't one in the
9580 user's program; just attach a DW_AT_name to the type. */
9582 && (TREE_CODE (name) != TYPE_DECL
9583 || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
9585 if (TREE_CODE (name) == TYPE_DECL)
9586 /* Could just call add_name_and_src_coords_attributes here,
9587 but since this is a builtin type it doesn't have any
9588 useful source coordinates anyway. */
9589 name = DECL_NAME (name);
9590 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
9594 equate_type_number_to_die (qualified_type, mod_type_die);
9597 /* We must do this after the equate_type_number_to_die call, in case
9598 this is a recursive type. This ensures that the modified_type_die
9599 recursion will terminate even if the type is recursive. Recursive
9600 types are possible in Ada. */
9601 sub_die = modified_type_die (item_type,
9602 TYPE_READONLY (item_type),
9603 TYPE_VOLATILE (item_type),
9606 if (sub_die != NULL)
9607 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
9609 return mod_type_die;
9612 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
9613 an enumerated type. */
9616 type_is_enum (const_tree type)
9618 return TREE_CODE (type) == ENUMERAL_TYPE;
9621 /* Return the DBX register number described by a given RTL node. */
9624 dbx_reg_number (const_rtx rtl)
9626 unsigned regno = REGNO (rtl);
9628 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
9630 #ifdef LEAF_REG_REMAP
9631 if (current_function_uses_only_leaf_regs)
9633 int leaf_reg = LEAF_REG_REMAP (regno);
9635 regno = (unsigned) leaf_reg;
9639 return DBX_REGISTER_NUMBER (regno);
9642 /* Optionally add a DW_OP_piece term to a location description expression.
9643 DW_OP_piece is only added if the location description expression already
9644 doesn't end with DW_OP_piece. */
9647 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
9649 dw_loc_descr_ref loc;
9651 if (*list_head != NULL)
9653 /* Find the end of the chain. */
9654 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
9657 if (loc->dw_loc_opc != DW_OP_piece)
9658 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
9662 /* Return a location descriptor that designates a machine register or
9663 zero if there is none. */
9665 static dw_loc_descr_ref
9666 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
9670 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
9673 regs = targetm.dwarf_register_span (rtl);
9675 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
9676 return multiple_reg_loc_descriptor (rtl, regs, initialized);
9678 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
9681 /* Return a location descriptor that designates a machine register for
9682 a given hard register number. */
9684 static dw_loc_descr_ref
9685 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
9687 dw_loc_descr_ref reg_loc_descr = new_reg_loc_descr (regno, 0);
9689 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9690 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9692 return reg_loc_descr;
9695 /* Given an RTL of a register, return a location descriptor that
9696 designates a value that spans more than one register. */
9698 static dw_loc_descr_ref
9699 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
9700 enum var_init_status initialized)
9704 dw_loc_descr_ref loc_result = NULL;
9707 #ifdef LEAF_REG_REMAP
9708 if (current_function_uses_only_leaf_regs)
9710 int leaf_reg = LEAF_REG_REMAP (reg);
9712 reg = (unsigned) leaf_reg;
9715 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
9716 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
9718 /* Simple, contiguous registers. */
9719 if (regs == NULL_RTX)
9721 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
9728 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
9729 VAR_INIT_STATUS_INITIALIZED);
9730 add_loc_descr (&loc_result, t);
9731 add_loc_descr_op_piece (&loc_result, size);
9737 /* Now onto stupid register sets in non contiguous locations. */
9739 gcc_assert (GET_CODE (regs) == PARALLEL);
9741 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9744 for (i = 0; i < XVECLEN (regs, 0); ++i)
9748 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
9749 VAR_INIT_STATUS_INITIALIZED);
9750 add_loc_descr (&loc_result, t);
9751 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9752 add_loc_descr_op_piece (&loc_result, size);
9755 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9756 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9760 #endif /* DWARF2_DEBUGGING_INFO */
9762 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
9764 /* Return a location descriptor that designates a constant. */
9766 static dw_loc_descr_ref
9767 int_loc_descriptor (HOST_WIDE_INT i)
9769 enum dwarf_location_atom op;
9771 /* Pick the smallest representation of a constant, rather than just
9772 defaulting to the LEB encoding. */
9776 op = DW_OP_lit0 + i;
9779 else if (i <= 0xffff)
9781 else if (HOST_BITS_PER_WIDE_INT == 32
9791 else if (i >= -0x8000)
9793 else if (HOST_BITS_PER_WIDE_INT == 32
9794 || i >= -0x80000000)
9800 return new_loc_descr (op, i, 0);
9804 #ifdef DWARF2_DEBUGGING_INFO
9806 /* Return a location descriptor that designates a base+offset location. */
9808 static dw_loc_descr_ref
9809 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
9810 enum var_init_status initialized)
9813 dw_loc_descr_ref result;
9814 dw_fde_ref fde = current_fde ();
9816 /* We only use "frame base" when we're sure we're talking about the
9817 post-prologue local stack frame. We do this by *not* running
9818 register elimination until this point, and recognizing the special
9819 argument pointer and soft frame pointer rtx's. */
9820 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
9822 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
9826 if (GET_CODE (elim) == PLUS)
9828 offset += INTVAL (XEXP (elim, 1));
9829 elim = XEXP (elim, 0);
9831 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
9832 && (elim == hard_frame_pointer_rtx
9833 || elim == stack_pointer_rtx))
9834 || elim == (frame_pointer_needed
9835 ? hard_frame_pointer_rtx
9836 : stack_pointer_rtx));
9838 /* If drap register is used to align stack, use frame
9839 pointer + offset to access stack variables. If stack
9840 is aligned without drap, use stack pointer + offset to
9841 access stack variables. */
9842 if (crtl->stack_realign_tried
9843 && cfa.reg == HARD_FRAME_POINTER_REGNUM
9844 && reg == frame_pointer_rtx)
9847 = DWARF_FRAME_REGNUM (cfa.indirect
9848 ? HARD_FRAME_POINTER_REGNUM
9849 : STACK_POINTER_REGNUM);
9850 return new_reg_loc_descr (base_reg, offset);
9853 offset += frame_pointer_fb_offset;
9854 return new_loc_descr (DW_OP_fbreg, offset, 0);
9858 && fde->drap_reg != INVALID_REGNUM
9859 && (fde->drap_reg == REGNO (reg)
9860 || fde->vdrap_reg == REGNO (reg)))
9862 /* Use cfa+offset to represent the location of arguments passed
9863 on stack when drap is used to align stack. */
9864 return new_loc_descr (DW_OP_fbreg, offset, 0);
9867 regno = dbx_reg_number (reg);
9869 result = new_loc_descr (DW_OP_breg0 + regno, offset, 0);
9871 result = new_loc_descr (DW_OP_bregx, regno, offset);
9873 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9874 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9879 /* Return true if this RTL expression describes a base+offset calculation. */
9882 is_based_loc (const_rtx rtl)
9884 return (GET_CODE (rtl) == PLUS
9885 && ((REG_P (XEXP (rtl, 0))
9886 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
9887 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
9890 /* Return a descriptor that describes the concatenation of N locations
9891 used to form the address of a memory location. */
9893 static dw_loc_descr_ref
9894 concatn_mem_loc_descriptor (rtx concatn, enum machine_mode mode,
9895 enum var_init_status initialized)
9898 dw_loc_descr_ref cc_loc_result = NULL;
9899 unsigned int n = XVECLEN (concatn, 0);
9901 for (i = 0; i < n; ++i)
9903 dw_loc_descr_ref ref;
9904 rtx x = XVECEXP (concatn, 0, i);
9906 ref = mem_loc_descriptor (x, mode, VAR_INIT_STATUS_INITIALIZED);
9910 add_loc_descr (&cc_loc_result, ref);
9911 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9914 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9915 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9917 return cc_loc_result;
9920 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
9923 static dw_loc_descr_ref
9924 tls_mem_loc_descriptor (rtx mem)
9927 dw_loc_descr_ref loc_result, loc_result2;
9929 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
9932 base = get_base_address (MEM_EXPR (mem));
9934 || TREE_CODE (base) != VAR_DECL
9935 || !DECL_THREAD_LOCAL_P (base))
9938 loc_result = loc_descriptor_from_tree_1 (MEM_EXPR (mem), 2);
9939 if (loc_result == NULL)
9942 if (INTVAL (MEM_OFFSET (mem)))
9944 if (INTVAL (MEM_OFFSET (mem)) >= 0)
9945 add_loc_descr (&loc_result,
9946 new_loc_descr (DW_OP_plus_uconst,
9947 INTVAL (MEM_OFFSET (mem)), 0));
9950 loc_result2 = mem_loc_descriptor (MEM_OFFSET (mem), GET_MODE (mem),
9951 VAR_INIT_STATUS_INITIALIZED);
9952 if (loc_result2 == 0)
9954 add_loc_descr (&loc_result, loc_result2);
9955 add_loc_descr (&loc_result, new_loc_descr (DW_OP_plus, 0, 0));
9962 /* The following routine converts the RTL for a variable or parameter
9963 (resident in memory) into an equivalent Dwarf representation of a
9964 mechanism for getting the address of that same variable onto the top of a
9965 hypothetical "address evaluation" stack.
9967 When creating memory location descriptors, we are effectively transforming
9968 the RTL for a memory-resident object into its Dwarf postfix expression
9969 equivalent. This routine recursively descends an RTL tree, turning
9970 it into Dwarf postfix code as it goes.
9972 MODE is the mode of the memory reference, needed to handle some
9973 autoincrement addressing modes.
9975 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
9976 location list for RTL.
9978 Return 0 if we can't represent the location. */
9980 static dw_loc_descr_ref
9981 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
9982 enum var_init_status initialized)
9984 dw_loc_descr_ref mem_loc_result = NULL;
9985 enum dwarf_location_atom op;
9987 /* Note that for a dynamically sized array, the location we will generate a
9988 description of here will be the lowest numbered location which is
9989 actually within the array. That's *not* necessarily the same as the
9990 zeroth element of the array. */
9992 rtl = targetm.delegitimize_address (rtl);
9994 switch (GET_CODE (rtl))
9999 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
10000 just fall into the SUBREG code. */
10002 /* ... fall through ... */
10005 /* The case of a subreg may arise when we have a local (register)
10006 variable or a formal (register) parameter which doesn't quite fill
10007 up an entire register. For now, just assume that it is
10008 legitimate to make the Dwarf info refer to the whole register which
10009 contains the given subreg. */
10010 rtl = XEXP (rtl, 0);
10012 /* ... fall through ... */
10015 /* Whenever a register number forms a part of the description of the
10016 method for calculating the (dynamic) address of a memory resident
10017 object, DWARF rules require the register number be referred to as
10018 a "base register". This distinction is not based in any way upon
10019 what category of register the hardware believes the given register
10020 belongs to. This is strictly DWARF terminology we're dealing with
10021 here. Note that in cases where the location of a memory-resident
10022 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
10023 OP_CONST (0)) the actual DWARF location descriptor that we generate
10024 may just be OP_BASEREG (basereg). This may look deceptively like
10025 the object in question was allocated to a register (rather than in
10026 memory) so DWARF consumers need to be aware of the subtle
10027 distinction between OP_REG and OP_BASEREG. */
10028 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
10029 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
10030 else if (stack_realign_drap
10032 && crtl->args.internal_arg_pointer == rtl
10033 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
10035 /* If RTL is internal_arg_pointer, which has been optimized
10036 out, use DRAP instead. */
10037 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
10038 VAR_INIT_STATUS_INITIALIZED);
10043 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10044 VAR_INIT_STATUS_INITIALIZED);
10045 if (mem_loc_result == NULL)
10046 mem_loc_result = tls_mem_loc_descriptor (rtl);
10047 if (mem_loc_result != 0)
10048 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
10052 rtl = XEXP (rtl, 1);
10054 /* ... fall through ... */
10057 /* Some ports can transform a symbol ref into a label ref, because
10058 the symbol ref is too far away and has to be dumped into a constant
10062 /* Alternatively, the symbol in the constant pool might be referenced
10063 by a different symbol. */
10064 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
10067 rtx tmp = get_pool_constant_mark (rtl, &marked);
10069 if (GET_CODE (tmp) == SYMBOL_REF)
10072 if (CONSTANT_POOL_ADDRESS_P (tmp))
10073 get_pool_constant_mark (tmp, &marked);
10078 /* If all references to this pool constant were optimized away,
10079 it was not output and thus we can't represent it.
10080 FIXME: might try to use DW_OP_const_value here, though
10081 DW_OP_piece complicates it. */
10086 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
10087 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
10088 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
10089 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10093 /* Extract the PLUS expression nested inside and fall into
10094 PLUS code below. */
10095 rtl = XEXP (rtl, 1);
10100 /* Turn these into a PLUS expression and fall into the PLUS code
10102 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
10103 GEN_INT (GET_CODE (rtl) == PRE_INC
10104 ? GET_MODE_UNIT_SIZE (mode)
10105 : -GET_MODE_UNIT_SIZE (mode)));
10107 /* ... fall through ... */
10111 if (is_based_loc (rtl))
10112 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
10113 INTVAL (XEXP (rtl, 1)),
10114 VAR_INIT_STATUS_INITIALIZED);
10117 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
10118 VAR_INIT_STATUS_INITIALIZED);
10119 if (mem_loc_result == 0)
10122 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
10123 && INTVAL (XEXP (rtl, 1)) >= 0)
10124 add_loc_descr (&mem_loc_result,
10125 new_loc_descr (DW_OP_plus_uconst,
10126 INTVAL (XEXP (rtl, 1)), 0));
10129 dw_loc_descr_ref mem_loc_result2
10130 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10131 VAR_INIT_STATUS_INITIALIZED);
10132 if (mem_loc_result2 == 0)
10134 add_loc_descr (&mem_loc_result, mem_loc_result2);
10135 add_loc_descr (&mem_loc_result,
10136 new_loc_descr (DW_OP_plus, 0, 0));
10141 /* If a pseudo-reg is optimized away, it is possible for it to
10142 be replaced with a MEM containing a multiply or shift. */
10161 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
10162 VAR_INIT_STATUS_INITIALIZED);
10163 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10164 VAR_INIT_STATUS_INITIALIZED);
10166 if (op0 == 0 || op1 == 0)
10169 mem_loc_result = op0;
10170 add_loc_descr (&mem_loc_result, op1);
10171 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
10176 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
10180 mem_loc_result = concatn_mem_loc_descriptor (rtl, mode,
10181 VAR_INIT_STATUS_INITIALIZED);
10185 /* If delegitimize_address couldn't do anything with the UNSPEC, we
10186 can't express it in the debug info. This can happen e.g. with some
10191 gcc_unreachable ();
10194 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10195 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10197 return mem_loc_result;
10200 /* Return a descriptor that describes the concatenation of two locations.
10201 This is typically a complex variable. */
10203 static dw_loc_descr_ref
10204 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
10206 dw_loc_descr_ref cc_loc_result = NULL;
10207 dw_loc_descr_ref x0_ref = loc_descriptor (x0, VAR_INIT_STATUS_INITIALIZED);
10208 dw_loc_descr_ref x1_ref = loc_descriptor (x1, VAR_INIT_STATUS_INITIALIZED);
10210 if (x0_ref == 0 || x1_ref == 0)
10213 cc_loc_result = x0_ref;
10214 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
10216 add_loc_descr (&cc_loc_result, x1_ref);
10217 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
10219 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10220 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10222 return cc_loc_result;
10225 /* Return a descriptor that describes the concatenation of N
10228 static dw_loc_descr_ref
10229 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
10232 dw_loc_descr_ref cc_loc_result = NULL;
10233 unsigned int n = XVECLEN (concatn, 0);
10235 for (i = 0; i < n; ++i)
10237 dw_loc_descr_ref ref;
10238 rtx x = XVECEXP (concatn, 0, i);
10240 ref = loc_descriptor (x, VAR_INIT_STATUS_INITIALIZED);
10244 add_loc_descr (&cc_loc_result, ref);
10245 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
10248 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10249 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10251 return cc_loc_result;
10254 /* Output a proper Dwarf location descriptor for a variable or parameter
10255 which is either allocated in a register or in a memory location. For a
10256 register, we just generate an OP_REG and the register number. For a
10257 memory location we provide a Dwarf postfix expression describing how to
10258 generate the (dynamic) address of the object onto the address stack.
10260 If we don't know how to describe it, return 0. */
10262 static dw_loc_descr_ref
10263 loc_descriptor (rtx rtl, enum var_init_status initialized)
10265 dw_loc_descr_ref loc_result = NULL;
10267 switch (GET_CODE (rtl))
10270 /* The case of a subreg may arise when we have a local (register)
10271 variable or a formal (register) parameter which doesn't quite fill
10272 up an entire register. For now, just assume that it is
10273 legitimate to make the Dwarf info refer to the whole register which
10274 contains the given subreg. */
10275 rtl = SUBREG_REG (rtl);
10277 /* ... fall through ... */
10280 loc_result = reg_loc_descriptor (rtl, initialized);
10284 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10286 if (loc_result == NULL)
10287 loc_result = tls_mem_loc_descriptor (rtl);
10291 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
10296 loc_result = concatn_loc_descriptor (rtl, initialized);
10301 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
10303 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), initialized);
10307 rtl = XEXP (rtl, 1);
10312 rtvec par_elems = XVEC (rtl, 0);
10313 int num_elem = GET_NUM_ELEM (par_elems);
10314 enum machine_mode mode;
10317 /* Create the first one, so we have something to add to. */
10318 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
10320 if (loc_result == NULL)
10322 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
10323 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10324 for (i = 1; i < num_elem; i++)
10326 dw_loc_descr_ref temp;
10328 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
10332 add_loc_descr (&loc_result, temp);
10333 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
10334 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10340 gcc_unreachable ();
10346 /* Similar, but generate the descriptor from trees instead of rtl. This comes
10347 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
10348 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
10349 top-level invocation, and we require the address of LOC; is 0 if we require
10350 the value of LOC. */
10352 static dw_loc_descr_ref
10353 loc_descriptor_from_tree_1 (tree loc, int want_address)
10355 dw_loc_descr_ref ret, ret1;
10356 int have_address = 0;
10357 enum dwarf_location_atom op;
10359 /* ??? Most of the time we do not take proper care for sign/zero
10360 extending the values properly. Hopefully this won't be a real
10363 switch (TREE_CODE (loc))
10368 case PLACEHOLDER_EXPR:
10369 /* This case involves extracting fields from an object to determine the
10370 position of other fields. We don't try to encode this here. The
10371 only user of this is Ada, which encodes the needed information using
10372 the names of types. */
10378 case PREINCREMENT_EXPR:
10379 case PREDECREMENT_EXPR:
10380 case POSTINCREMENT_EXPR:
10381 case POSTDECREMENT_EXPR:
10382 /* There are no opcodes for these operations. */
10386 /* If we already want an address, there's nothing we can do. */
10390 /* Otherwise, process the argument and look for the address. */
10391 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
10394 if (DECL_THREAD_LOCAL_P (loc))
10398 unsigned second_op;
10400 if (targetm.have_tls)
10402 /* If this is not defined, we have no way to emit the
10404 if (!targetm.asm_out.output_dwarf_dtprel)
10407 /* The way DW_OP_GNU_push_tls_address is specified, we
10408 can only look up addresses of objects in the current
10410 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
10412 first_op = INTERNAL_DW_OP_tls_addr;
10413 second_op = DW_OP_GNU_push_tls_address;
10417 if (!targetm.emutls.debug_form_tls_address)
10419 loc = emutls_decl (loc);
10420 first_op = DW_OP_addr;
10421 second_op = DW_OP_form_tls_address;
10424 rtl = rtl_for_decl_location (loc);
10425 if (rtl == NULL_RTX)
10430 rtl = XEXP (rtl, 0);
10431 if (! CONSTANT_P (rtl))
10434 ret = new_loc_descr (first_op, 0, 0);
10435 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10436 ret->dw_loc_oprnd1.v.val_addr = rtl;
10438 ret1 = new_loc_descr (second_op, 0, 0);
10439 add_loc_descr (&ret, ret1);
10447 if (DECL_HAS_VALUE_EXPR_P (loc))
10448 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
10453 case FUNCTION_DECL:
10455 rtx rtl = rtl_for_decl_location (loc);
10457 if (rtl == NULL_RTX)
10459 else if (GET_CODE (rtl) == CONST_INT)
10461 HOST_WIDE_INT val = INTVAL (rtl);
10462 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
10463 val &= GET_MODE_MASK (DECL_MODE (loc));
10464 ret = int_loc_descriptor (val);
10466 else if (GET_CODE (rtl) == CONST_STRING)
10468 else if (CONSTANT_P (rtl))
10470 ret = new_loc_descr (DW_OP_addr, 0, 0);
10471 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10472 ret->dw_loc_oprnd1.v.val_addr = rtl;
10476 enum machine_mode mode;
10478 /* Certain constructs can only be represented at top-level. */
10479 if (want_address == 2)
10480 return loc_descriptor (rtl, VAR_INIT_STATUS_INITIALIZED);
10482 mode = GET_MODE (rtl);
10485 rtl = XEXP (rtl, 0);
10488 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10494 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10498 case COMPOUND_EXPR:
10499 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
10502 case VIEW_CONVERT_EXPR:
10505 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
10507 case COMPONENT_REF:
10508 case BIT_FIELD_REF:
10510 case ARRAY_RANGE_REF:
10513 HOST_WIDE_INT bitsize, bitpos, bytepos;
10514 enum machine_mode mode;
10516 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
10518 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
10519 &unsignedp, &volatilep, false);
10524 ret = loc_descriptor_from_tree_1 (obj, 1);
10526 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
10529 if (offset != NULL_TREE)
10531 /* Variable offset. */
10532 ret1 = loc_descriptor_from_tree_1 (offset, 0);
10535 add_loc_descr (&ret, ret1);
10536 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10539 bytepos = bitpos / BITS_PER_UNIT;
10541 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
10542 else if (bytepos < 0)
10544 add_loc_descr (&ret, int_loc_descriptor (bytepos));
10545 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10553 if (host_integerp (loc, 0))
10554 ret = int_loc_descriptor (tree_low_cst (loc, 0));
10561 /* Get an RTL for this, if something has been emitted. */
10562 rtx rtl = lookup_constant_def (loc);
10563 enum machine_mode mode;
10565 if (!rtl || !MEM_P (rtl))
10567 mode = GET_MODE (rtl);
10568 rtl = XEXP (rtl, 0);
10569 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10574 case TRUTH_AND_EXPR:
10575 case TRUTH_ANDIF_EXPR:
10580 case TRUTH_XOR_EXPR:
10585 case TRUTH_OR_EXPR:
10586 case TRUTH_ORIF_EXPR:
10591 case FLOOR_DIV_EXPR:
10592 case CEIL_DIV_EXPR:
10593 case ROUND_DIV_EXPR:
10594 case TRUNC_DIV_EXPR:
10602 case FLOOR_MOD_EXPR:
10603 case CEIL_MOD_EXPR:
10604 case ROUND_MOD_EXPR:
10605 case TRUNC_MOD_EXPR:
10618 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
10621 case POINTER_PLUS_EXPR:
10623 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
10624 && host_integerp (TREE_OPERAND (loc, 1), 0))
10626 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10630 add_loc_descr (&ret,
10631 new_loc_descr (DW_OP_plus_uconst,
10632 tree_low_cst (TREE_OPERAND (loc, 1),
10642 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10649 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10656 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10663 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10678 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10679 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10680 if (ret == 0 || ret1 == 0)
10683 add_loc_descr (&ret, ret1);
10684 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10687 case TRUTH_NOT_EXPR:
10701 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10705 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10711 const enum tree_code code =
10712 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
10714 loc = build3 (COND_EXPR, TREE_TYPE (loc),
10715 build2 (code, integer_type_node,
10716 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
10717 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
10720 /* ... fall through ... */
10724 dw_loc_descr_ref lhs
10725 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10726 dw_loc_descr_ref rhs
10727 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
10728 dw_loc_descr_ref bra_node, jump_node, tmp;
10730 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10731 if (ret == 0 || lhs == 0 || rhs == 0)
10734 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
10735 add_loc_descr (&ret, bra_node);
10737 add_loc_descr (&ret, rhs);
10738 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
10739 add_loc_descr (&ret, jump_node);
10741 add_loc_descr (&ret, lhs);
10742 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10743 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
10745 /* ??? Need a node to point the skip at. Use a nop. */
10746 tmp = new_loc_descr (DW_OP_nop, 0, 0);
10747 add_loc_descr (&ret, tmp);
10748 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10749 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
10753 case FIX_TRUNC_EXPR:
10757 /* Leave front-end specific codes as simply unknown. This comes
10758 up, for instance, with the C STMT_EXPR. */
10759 if ((unsigned int) TREE_CODE (loc)
10760 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
10763 #ifdef ENABLE_CHECKING
10764 /* Otherwise this is a generic code; we should just lists all of
10765 these explicitly. We forgot one. */
10766 gcc_unreachable ();
10768 /* In a release build, we want to degrade gracefully: better to
10769 generate incomplete debugging information than to crash. */
10774 /* Show if we can't fill the request for an address. */
10775 if (want_address && !have_address)
10778 /* If we've got an address and don't want one, dereference. */
10779 if (!want_address && have_address && ret)
10781 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
10783 if (size > DWARF2_ADDR_SIZE || size == -1)
10785 else if (size == DWARF2_ADDR_SIZE)
10788 op = DW_OP_deref_size;
10790 add_loc_descr (&ret, new_loc_descr (op, size, 0));
10796 static inline dw_loc_descr_ref
10797 loc_descriptor_from_tree (tree loc)
10799 return loc_descriptor_from_tree_1 (loc, 2);
10802 /* Given a value, round it up to the lowest multiple of `boundary'
10803 which is not less than the value itself. */
10805 static inline HOST_WIDE_INT
10806 ceiling (HOST_WIDE_INT value, unsigned int boundary)
10808 return (((value + boundary - 1) / boundary) * boundary);
10811 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
10812 pointer to the declared type for the relevant field variable, or return
10813 `integer_type_node' if the given node turns out to be an
10814 ERROR_MARK node. */
10817 field_type (const_tree decl)
10821 if (TREE_CODE (decl) == ERROR_MARK)
10822 return integer_type_node;
10824 type = DECL_BIT_FIELD_TYPE (decl);
10825 if (type == NULL_TREE)
10826 type = TREE_TYPE (decl);
10831 /* Given a pointer to a tree node, return the alignment in bits for
10832 it, or else return BITS_PER_WORD if the node actually turns out to
10833 be an ERROR_MARK node. */
10835 static inline unsigned
10836 simple_type_align_in_bits (const_tree type)
10838 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
10841 static inline unsigned
10842 simple_decl_align_in_bits (const_tree decl)
10844 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
10847 /* Return the result of rounding T up to ALIGN. */
10849 static inline HOST_WIDE_INT
10850 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
10852 /* We must be careful if T is negative because HOST_WIDE_INT can be
10853 either "above" or "below" unsigned int as per the C promotion
10854 rules, depending on the host, thus making the signedness of the
10855 direct multiplication and division unpredictable. */
10856 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
10862 return (HOST_WIDE_INT) u;
10865 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
10866 lowest addressed byte of the "containing object" for the given FIELD_DECL,
10867 or return 0 if we are unable to determine what that offset is, either
10868 because the argument turns out to be a pointer to an ERROR_MARK node, or
10869 because the offset is actually variable. (We can't handle the latter case
10872 static HOST_WIDE_INT
10873 field_byte_offset (const_tree decl)
10875 HOST_WIDE_INT object_offset_in_bits;
10876 HOST_WIDE_INT bitpos_int;
10878 if (TREE_CODE (decl) == ERROR_MARK)
10881 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
10883 /* We cannot yet cope with fields whose positions are variable, so
10884 for now, when we see such things, we simply return 0. Someday, we may
10885 be able to handle such cases, but it will be damn difficult. */
10886 if (! host_integerp (bit_position (decl), 0))
10889 bitpos_int = int_bit_position (decl);
10891 #ifdef PCC_BITFIELD_TYPE_MATTERS
10892 if (PCC_BITFIELD_TYPE_MATTERS)
10895 tree field_size_tree;
10896 HOST_WIDE_INT deepest_bitpos;
10897 unsigned HOST_WIDE_INT field_size_in_bits;
10898 unsigned int type_align_in_bits;
10899 unsigned int decl_align_in_bits;
10900 unsigned HOST_WIDE_INT type_size_in_bits;
10902 type = field_type (decl);
10903 type_size_in_bits = simple_type_size_in_bits (type);
10904 type_align_in_bits = simple_type_align_in_bits (type);
10906 field_size_tree = DECL_SIZE (decl);
10908 /* The size could be unspecified if there was an error, or for
10909 a flexible array member. */
10910 if (!field_size_tree)
10911 field_size_tree = bitsize_zero_node;
10913 /* If the size of the field is not constant, use the type size. */
10914 if (host_integerp (field_size_tree, 1))
10915 field_size_in_bits = tree_low_cst (field_size_tree, 1);
10917 field_size_in_bits = type_size_in_bits;
10919 decl_align_in_bits = simple_decl_align_in_bits (decl);
10921 /* The GCC front-end doesn't make any attempt to keep track of the
10922 starting bit offset (relative to the start of the containing
10923 structure type) of the hypothetical "containing object" for a
10924 bit-field. Thus, when computing the byte offset value for the
10925 start of the "containing object" of a bit-field, we must deduce
10926 this information on our own. This can be rather tricky to do in
10927 some cases. For example, handling the following structure type
10928 definition when compiling for an i386/i486 target (which only
10929 aligns long long's to 32-bit boundaries) can be very tricky:
10931 struct S { int field1; long long field2:31; };
10933 Fortunately, there is a simple rule-of-thumb which can be used
10934 in such cases. When compiling for an i386/i486, GCC will
10935 allocate 8 bytes for the structure shown above. It decides to
10936 do this based upon one simple rule for bit-field allocation.
10937 GCC allocates each "containing object" for each bit-field at
10938 the first (i.e. lowest addressed) legitimate alignment boundary
10939 (based upon the required minimum alignment for the declared
10940 type of the field) which it can possibly use, subject to the
10941 condition that there is still enough available space remaining
10942 in the containing object (when allocated at the selected point)
10943 to fully accommodate all of the bits of the bit-field itself.
10945 This simple rule makes it obvious why GCC allocates 8 bytes for
10946 each object of the structure type shown above. When looking
10947 for a place to allocate the "containing object" for `field2',
10948 the compiler simply tries to allocate a 64-bit "containing
10949 object" at each successive 32-bit boundary (starting at zero)
10950 until it finds a place to allocate that 64- bit field such that
10951 at least 31 contiguous (and previously unallocated) bits remain
10952 within that selected 64 bit field. (As it turns out, for the
10953 example above, the compiler finds it is OK to allocate the
10954 "containing object" 64-bit field at bit-offset zero within the
10957 Here we attempt to work backwards from the limited set of facts
10958 we're given, and we try to deduce from those facts, where GCC
10959 must have believed that the containing object started (within
10960 the structure type). The value we deduce is then used (by the
10961 callers of this routine) to generate DW_AT_location and
10962 DW_AT_bit_offset attributes for fields (both bit-fields and, in
10963 the case of DW_AT_location, regular fields as well). */
10965 /* Figure out the bit-distance from the start of the structure to
10966 the "deepest" bit of the bit-field. */
10967 deepest_bitpos = bitpos_int + field_size_in_bits;
10969 /* This is the tricky part. Use some fancy footwork to deduce
10970 where the lowest addressed bit of the containing object must
10972 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10974 /* Round up to type_align by default. This works best for
10976 object_offset_in_bits
10977 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
10979 if (object_offset_in_bits > bitpos_int)
10981 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10983 /* Round up to decl_align instead. */
10984 object_offset_in_bits
10985 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
10990 object_offset_in_bits = bitpos_int;
10992 return object_offset_in_bits / BITS_PER_UNIT;
10995 /* The following routines define various Dwarf attributes and any data
10996 associated with them. */
10998 /* Add a location description attribute value to a DIE.
11000 This emits location attributes suitable for whole variables and
11001 whole parameters. Note that the location attributes for struct fields are
11002 generated by the routine `data_member_location_attribute' below. */
11005 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
11006 dw_loc_descr_ref descr)
11009 add_AT_loc (die, attr_kind, descr);
11012 /* Attach the specialized form of location attribute used for data members of
11013 struct and union types. In the special case of a FIELD_DECL node which
11014 represents a bit-field, the "offset" part of this special location
11015 descriptor must indicate the distance in bytes from the lowest-addressed
11016 byte of the containing struct or union type to the lowest-addressed byte of
11017 the "containing object" for the bit-field. (See the `field_byte_offset'
11020 For any given bit-field, the "containing object" is a hypothetical object
11021 (of some integral or enum type) within which the given bit-field lives. The
11022 type of this hypothetical "containing object" is always the same as the
11023 declared type of the individual bit-field itself (for GCC anyway... the
11024 DWARF spec doesn't actually mandate this). Note that it is the size (in
11025 bytes) of the hypothetical "containing object" which will be given in the
11026 DW_AT_byte_size attribute for this bit-field. (See the
11027 `byte_size_attribute' function below.) It is also used when calculating the
11028 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
11029 function below.) */
11032 add_data_member_location_attribute (dw_die_ref die, tree decl)
11034 HOST_WIDE_INT offset;
11035 dw_loc_descr_ref loc_descr = 0;
11037 if (TREE_CODE (decl) == TREE_BINFO)
11039 /* We're working on the TAG_inheritance for a base class. */
11040 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
11042 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
11043 aren't at a fixed offset from all (sub)objects of the same
11044 type. We need to extract the appropriate offset from our
11045 vtable. The following dwarf expression means
11047 BaseAddr = ObAddr + *((*ObAddr) - Offset)
11049 This is specific to the V3 ABI, of course. */
11051 dw_loc_descr_ref tmp;
11053 /* Make a copy of the object address. */
11054 tmp = new_loc_descr (DW_OP_dup, 0, 0);
11055 add_loc_descr (&loc_descr, tmp);
11057 /* Extract the vtable address. */
11058 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11059 add_loc_descr (&loc_descr, tmp);
11061 /* Calculate the address of the offset. */
11062 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
11063 gcc_assert (offset < 0);
11065 tmp = int_loc_descriptor (-offset);
11066 add_loc_descr (&loc_descr, tmp);
11067 tmp = new_loc_descr (DW_OP_minus, 0, 0);
11068 add_loc_descr (&loc_descr, tmp);
11070 /* Extract the offset. */
11071 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11072 add_loc_descr (&loc_descr, tmp);
11074 /* Add it to the object address. */
11075 tmp = new_loc_descr (DW_OP_plus, 0, 0);
11076 add_loc_descr (&loc_descr, tmp);
11079 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
11082 offset = field_byte_offset (decl);
11086 enum dwarf_location_atom op;
11088 /* The DWARF2 standard says that we should assume that the structure
11089 address is already on the stack, so we can specify a structure field
11090 address by using DW_OP_plus_uconst. */
11092 #ifdef MIPS_DEBUGGING_INFO
11093 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
11094 operator correctly. It works only if we leave the offset on the
11098 op = DW_OP_plus_uconst;
11101 loc_descr = new_loc_descr (op, offset, 0);
11104 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
11107 /* Writes integer values to dw_vec_const array. */
11110 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
11114 *dest++ = val & 0xff;
11120 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
11122 static HOST_WIDE_INT
11123 extract_int (const unsigned char *src, unsigned int size)
11125 HOST_WIDE_INT val = 0;
11131 val |= *--src & 0xff;
11137 /* Writes floating point values to dw_vec_const array. */
11140 insert_float (const_rtx rtl, unsigned char *array)
11142 REAL_VALUE_TYPE rv;
11146 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
11147 real_to_target (val, &rv, GET_MODE (rtl));
11149 /* real_to_target puts 32-bit pieces in each long. Pack them. */
11150 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
11152 insert_int (val[i], 4, array);
11157 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
11158 does not have a "location" either in memory or in a register. These
11159 things can arise in GNU C when a constant is passed as an actual parameter
11160 to an inlined function. They can also arise in C++ where declared
11161 constants do not necessarily get memory "homes". */
11164 add_const_value_attribute (dw_die_ref die, rtx rtl)
11166 switch (GET_CODE (rtl))
11170 HOST_WIDE_INT val = INTVAL (rtl);
11173 add_AT_int (die, DW_AT_const_value, val);
11175 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
11180 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
11181 floating-point constant. A CONST_DOUBLE is used whenever the
11182 constant requires more than one word in order to be adequately
11183 represented. We output CONST_DOUBLEs as blocks. */
11185 enum machine_mode mode = GET_MODE (rtl);
11187 if (SCALAR_FLOAT_MODE_P (mode))
11189 unsigned int length = GET_MODE_SIZE (mode);
11190 unsigned char *array = GGC_NEWVEC (unsigned char, length);
11192 insert_float (rtl, array);
11193 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
11197 /* ??? We really should be using HOST_WIDE_INT throughout. */
11198 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
11200 add_AT_long_long (die, DW_AT_const_value,
11201 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
11208 enum machine_mode mode = GET_MODE (rtl);
11209 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
11210 unsigned int length = CONST_VECTOR_NUNITS (rtl);
11211 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
11215 switch (GET_MODE_CLASS (mode))
11217 case MODE_VECTOR_INT:
11218 for (i = 0, p = array; i < length; i++, p += elt_size)
11220 rtx elt = CONST_VECTOR_ELT (rtl, i);
11221 HOST_WIDE_INT lo, hi;
11223 switch (GET_CODE (elt))
11231 lo = CONST_DOUBLE_LOW (elt);
11232 hi = CONST_DOUBLE_HIGH (elt);
11236 gcc_unreachable ();
11239 if (elt_size <= sizeof (HOST_WIDE_INT))
11240 insert_int (lo, elt_size, p);
11243 unsigned char *p0 = p;
11244 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
11246 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
11247 if (WORDS_BIG_ENDIAN)
11252 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
11253 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
11258 case MODE_VECTOR_FLOAT:
11259 for (i = 0, p = array; i < length; i++, p += elt_size)
11261 rtx elt = CONST_VECTOR_ELT (rtl, i);
11262 insert_float (elt, p);
11267 gcc_unreachable ();
11270 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
11275 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
11281 add_AT_addr (die, DW_AT_const_value, rtl);
11282 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11286 /* In cases where an inlined instance of an inline function is passed
11287 the address of an `auto' variable (which is local to the caller) we
11288 can get a situation where the DECL_RTL of the artificial local
11289 variable (for the inlining) which acts as a stand-in for the
11290 corresponding formal parameter (of the inline function) will look
11291 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
11292 exactly a compile-time constant expression, but it isn't the address
11293 of the (artificial) local variable either. Rather, it represents the
11294 *value* which the artificial local variable always has during its
11295 lifetime. We currently have no way to represent such quasi-constant
11296 values in Dwarf, so for now we just punt and generate nothing. */
11300 /* No other kinds of rtx should be possible here. */
11301 gcc_unreachable ();
11306 /* Determine whether the evaluation of EXPR references any variables
11307 or functions which aren't otherwise used (and therefore may not be
11310 reference_to_unused (tree * tp, int * walk_subtrees,
11311 void * data ATTRIBUTE_UNUSED)
11313 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
11314 *walk_subtrees = 0;
11316 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
11317 && ! TREE_ASM_WRITTEN (*tp))
11319 /* ??? The C++ FE emits debug information for using decls, so
11320 putting gcc_unreachable here falls over. See PR31899. For now
11321 be conservative. */
11322 else if (!cgraph_global_info_ready
11323 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
11325 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
11327 struct varpool_node *node = varpool_node (*tp);
11331 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
11332 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
11334 struct cgraph_node *node = cgraph_node (*tp);
11335 if (node->process || TREE_ASM_WRITTEN (*tp))
11338 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
11344 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
11345 for use in a later add_const_value_attribute call. */
11348 rtl_for_decl_init (tree init, tree type)
11350 rtx rtl = NULL_RTX;
11352 /* If a variable is initialized with a string constant without embedded
11353 zeros, build CONST_STRING. */
11354 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
11356 tree enttype = TREE_TYPE (type);
11357 tree domain = TYPE_DOMAIN (type);
11358 enum machine_mode mode = TYPE_MODE (enttype);
11360 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
11362 && integer_zerop (TYPE_MIN_VALUE (domain))
11363 && compare_tree_int (TYPE_MAX_VALUE (domain),
11364 TREE_STRING_LENGTH (init) - 1) == 0
11365 && ((size_t) TREE_STRING_LENGTH (init)
11366 == strlen (TREE_STRING_POINTER (init)) + 1))
11367 rtl = gen_rtx_CONST_STRING (VOIDmode,
11368 ggc_strdup (TREE_STRING_POINTER (init)));
11370 /* Other aggregates, and complex values, could be represented using
11372 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
11374 /* Vectors only work if their mode is supported by the target.
11375 FIXME: generic vectors ought to work too. */
11376 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
11378 /* If the initializer is something that we know will expand into an
11379 immediate RTL constant, expand it now. We must be careful not to
11380 reference variables which won't be output. */
11381 else if (initializer_constant_valid_p (init, type)
11382 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
11384 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
11386 if (TREE_CODE (type) == VECTOR_TYPE)
11387 switch (TREE_CODE (init))
11392 if (TREE_CONSTANT (init))
11394 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
11395 bool constant_p = true;
11397 unsigned HOST_WIDE_INT ix;
11399 /* Even when ctor is constant, it might contain non-*_CST
11400 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
11401 belong into VECTOR_CST nodes. */
11402 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
11403 if (!CONSTANT_CLASS_P (value))
11405 constant_p = false;
11411 init = build_vector_from_ctor (type, elts);
11421 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
11423 /* If expand_expr returns a MEM, it wasn't immediate. */
11424 gcc_assert (!rtl || !MEM_P (rtl));
11430 /* Generate RTL for the variable DECL to represent its location. */
11433 rtl_for_decl_location (tree decl)
11437 /* Here we have to decide where we are going to say the parameter "lives"
11438 (as far as the debugger is concerned). We only have a couple of
11439 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
11441 DECL_RTL normally indicates where the parameter lives during most of the
11442 activation of the function. If optimization is enabled however, this
11443 could be either NULL or else a pseudo-reg. Both of those cases indicate
11444 that the parameter doesn't really live anywhere (as far as the code
11445 generation parts of GCC are concerned) during most of the function's
11446 activation. That will happen (for example) if the parameter is never
11447 referenced within the function.
11449 We could just generate a location descriptor here for all non-NULL
11450 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
11451 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
11452 where DECL_RTL is NULL or is a pseudo-reg.
11454 Note however that we can only get away with using DECL_INCOMING_RTL as
11455 a backup substitute for DECL_RTL in certain limited cases. In cases
11456 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
11457 we can be sure that the parameter was passed using the same type as it is
11458 declared to have within the function, and that its DECL_INCOMING_RTL
11459 points us to a place where a value of that type is passed.
11461 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
11462 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
11463 because in these cases DECL_INCOMING_RTL points us to a value of some
11464 type which is *different* from the type of the parameter itself. Thus,
11465 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
11466 such cases, the debugger would end up (for example) trying to fetch a
11467 `float' from a place which actually contains the first part of a
11468 `double'. That would lead to really incorrect and confusing
11469 output at debug-time.
11471 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
11472 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
11473 are a couple of exceptions however. On little-endian machines we can
11474 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
11475 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
11476 an integral type that is smaller than TREE_TYPE (decl). These cases arise
11477 when (on a little-endian machine) a non-prototyped function has a
11478 parameter declared to be of type `short' or `char'. In such cases,
11479 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
11480 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
11481 passed `int' value. If the debugger then uses that address to fetch
11482 a `short' or a `char' (on a little-endian machine) the result will be
11483 the correct data, so we allow for such exceptional cases below.
11485 Note that our goal here is to describe the place where the given formal
11486 parameter lives during most of the function's activation (i.e. between the
11487 end of the prologue and the start of the epilogue). We'll do that as best
11488 as we can. Note however that if the given formal parameter is modified
11489 sometime during the execution of the function, then a stack backtrace (at
11490 debug-time) will show the function as having been called with the *new*
11491 value rather than the value which was originally passed in. This happens
11492 rarely enough that it is not a major problem, but it *is* a problem, and
11493 I'd like to fix it.
11495 A future version of dwarf2out.c may generate two additional attributes for
11496 any given DW_TAG_formal_parameter DIE which will describe the "passed
11497 type" and the "passed location" for the given formal parameter in addition
11498 to the attributes we now generate to indicate the "declared type" and the
11499 "active location" for each parameter. This additional set of attributes
11500 could be used by debuggers for stack backtraces. Separately, note that
11501 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
11502 This happens (for example) for inlined-instances of inline function formal
11503 parameters which are never referenced. This really shouldn't be
11504 happening. All PARM_DECL nodes should get valid non-NULL
11505 DECL_INCOMING_RTL values. FIXME. */
11507 /* Use DECL_RTL as the "location" unless we find something better. */
11508 rtl = DECL_RTL_IF_SET (decl);
11510 /* When generating abstract instances, ignore everything except
11511 constants, symbols living in memory, and symbols living in
11512 fixed registers. */
11513 if (! reload_completed)
11516 && (CONSTANT_P (rtl)
11518 && CONSTANT_P (XEXP (rtl, 0)))
11520 && TREE_CODE (decl) == VAR_DECL
11521 && TREE_STATIC (decl))))
11523 rtl = targetm.delegitimize_address (rtl);
11528 else if (TREE_CODE (decl) == PARM_DECL)
11530 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
11532 tree declared_type = TREE_TYPE (decl);
11533 tree passed_type = DECL_ARG_TYPE (decl);
11534 enum machine_mode dmode = TYPE_MODE (declared_type);
11535 enum machine_mode pmode = TYPE_MODE (passed_type);
11537 /* This decl represents a formal parameter which was optimized out.
11538 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
11539 all cases where (rtl == NULL_RTX) just below. */
11540 if (dmode == pmode)
11541 rtl = DECL_INCOMING_RTL (decl);
11542 else if (SCALAR_INT_MODE_P (dmode)
11543 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
11544 && DECL_INCOMING_RTL (decl))
11546 rtx inc = DECL_INCOMING_RTL (decl);
11549 else if (MEM_P (inc))
11551 if (BYTES_BIG_ENDIAN)
11552 rtl = adjust_address_nv (inc, dmode,
11553 GET_MODE_SIZE (pmode)
11554 - GET_MODE_SIZE (dmode));
11561 /* If the parm was passed in registers, but lives on the stack, then
11562 make a big endian correction if the mode of the type of the
11563 parameter is not the same as the mode of the rtl. */
11564 /* ??? This is the same series of checks that are made in dbxout.c before
11565 we reach the big endian correction code there. It isn't clear if all
11566 of these checks are necessary here, but keeping them all is the safe
11568 else if (MEM_P (rtl)
11569 && XEXP (rtl, 0) != const0_rtx
11570 && ! CONSTANT_P (XEXP (rtl, 0))
11571 /* Not passed in memory. */
11572 && !MEM_P (DECL_INCOMING_RTL (decl))
11573 /* Not passed by invisible reference. */
11574 && (!REG_P (XEXP (rtl, 0))
11575 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
11576 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
11577 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
11578 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
11581 /* Big endian correction check. */
11582 && BYTES_BIG_ENDIAN
11583 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
11584 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
11587 int offset = (UNITS_PER_WORD
11588 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
11590 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11591 plus_constant (XEXP (rtl, 0), offset));
11594 else if (TREE_CODE (decl) == VAR_DECL
11597 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
11598 && BYTES_BIG_ENDIAN)
11600 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
11601 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
11603 /* If a variable is declared "register" yet is smaller than
11604 a register, then if we store the variable to memory, it
11605 looks like we're storing a register-sized value, when in
11606 fact we are not. We need to adjust the offset of the
11607 storage location to reflect the actual value's bytes,
11608 else gdb will not be able to display it. */
11610 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11611 plus_constant (XEXP (rtl, 0), rsize-dsize));
11614 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
11615 and will have been substituted directly into all expressions that use it.
11616 C does not have such a concept, but C++ and other languages do. */
11617 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
11618 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
11621 rtl = targetm.delegitimize_address (rtl);
11623 /* If we don't look past the constant pool, we risk emitting a
11624 reference to a constant pool entry that isn't referenced from
11625 code, and thus is not emitted. */
11627 rtl = avoid_constant_pool_reference (rtl);
11632 /* We need to figure out what section we should use as the base for the
11633 address ranges where a given location is valid.
11634 1. If this particular DECL has a section associated with it, use that.
11635 2. If this function has a section associated with it, use that.
11636 3. Otherwise, use the text section.
11637 XXX: If you split a variable across multiple sections, we won't notice. */
11639 static const char *
11640 secname_for_decl (const_tree decl)
11642 const char *secname;
11644 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
11646 tree sectree = DECL_SECTION_NAME (decl);
11647 secname = TREE_STRING_POINTER (sectree);
11649 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
11651 tree sectree = DECL_SECTION_NAME (current_function_decl);
11652 secname = TREE_STRING_POINTER (sectree);
11654 else if (cfun && in_cold_section_p)
11655 secname = crtl->subsections.cold_section_label;
11657 secname = text_section_label;
11662 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
11663 returned. If so, the decl for the COMMON block is returned, and the
11664 value is the offset into the common block for the symbol. */
11667 fortran_common (tree decl, HOST_WIDE_INT *value)
11669 tree val_expr, cvar;
11670 enum machine_mode mode;
11671 HOST_WIDE_INT bitsize, bitpos;
11673 int volatilep = 0, unsignedp = 0;
11675 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
11676 it does not have a value (the offset into the common area), or if it
11677 is thread local (as opposed to global) then it isn't common, and shouldn't
11678 be handled as such. */
11679 if (TREE_CODE (decl) != VAR_DECL
11680 || !TREE_PUBLIC (decl)
11681 || !TREE_STATIC (decl)
11682 || !DECL_HAS_VALUE_EXPR_P (decl)
11686 val_expr = DECL_VALUE_EXPR (decl);
11687 if (TREE_CODE (val_expr) != COMPONENT_REF)
11690 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
11691 &mode, &unsignedp, &volatilep, true);
11693 if (cvar == NULL_TREE
11694 || TREE_CODE (cvar) != VAR_DECL
11695 || DECL_ARTIFICIAL (cvar)
11696 || !TREE_PUBLIC (cvar))
11700 if (offset != NULL)
11702 if (!host_integerp (offset, 0))
11704 *value = tree_low_cst (offset, 0);
11707 *value += bitpos / BITS_PER_UNIT;
11712 /* Dereference a location expression LOC if DECL is passed by invisible
11715 static dw_loc_descr_ref
11716 loc_by_reference (dw_loc_descr_ref loc, tree decl)
11718 HOST_WIDE_INT size;
11719 enum dwarf_location_atom op;
11724 if ((TREE_CODE (decl) != PARM_DECL && TREE_CODE (decl) != RESULT_DECL)
11725 || !DECL_BY_REFERENCE (decl))
11728 size = int_size_in_bytes (TREE_TYPE (decl));
11729 if (size > DWARF2_ADDR_SIZE || size == -1)
11731 else if (size == DWARF2_ADDR_SIZE)
11734 op = DW_OP_deref_size;
11735 add_loc_descr (&loc, new_loc_descr (op, size, 0));
11739 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
11740 data attribute for a variable or a parameter. We generate the
11741 DW_AT_const_value attribute only in those cases where the given variable
11742 or parameter does not have a true "location" either in memory or in a
11743 register. This can happen (for example) when a constant is passed as an
11744 actual argument in a call to an inline function. (It's possible that
11745 these things can crop up in other ways also.) Note that one type of
11746 constant value which can be passed into an inlined function is a constant
11747 pointer. This can happen for example if an actual argument in an inlined
11748 function call evaluates to a compile-time constant address. */
11751 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
11752 enum dwarf_attribute attr)
11755 dw_loc_descr_ref descr;
11756 var_loc_list *loc_list;
11757 struct var_loc_node *node;
11758 if (TREE_CODE (decl) == ERROR_MARK)
11761 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
11762 || TREE_CODE (decl) == RESULT_DECL);
11764 /* See if we possibly have multiple locations for this variable. */
11765 loc_list = lookup_decl_loc (decl);
11767 /* If it truly has multiple locations, the first and last node will
11769 if (loc_list && loc_list->first != loc_list->last)
11771 const char *endname, *secname;
11772 dw_loc_list_ref list;
11774 enum var_init_status initialized;
11776 /* Now that we know what section we are using for a base,
11777 actually construct the list of locations.
11778 The first location information is what is passed to the
11779 function that creates the location list, and the remaining
11780 locations just get added on to that list.
11781 Note that we only know the start address for a location
11782 (IE location changes), so to build the range, we use
11783 the range [current location start, next location start].
11784 This means we have to special case the last node, and generate
11785 a range of [last location start, end of function label]. */
11787 node = loc_list->first;
11788 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11789 secname = secname_for_decl (decl);
11791 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
11792 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11794 initialized = VAR_INIT_STATUS_INITIALIZED;
11796 descr = loc_by_reference (loc_descriptor (varloc, initialized), decl);
11797 list = new_loc_list (descr, node->label, node->next->label, secname, 1);
11800 for (; node->next; node = node->next)
11801 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11803 /* The variable has a location between NODE->LABEL and
11804 NODE->NEXT->LABEL. */
11805 enum var_init_status initialized =
11806 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11807 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11808 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11810 add_loc_descr_to_loc_list (&list, descr,
11811 node->label, node->next->label, secname);
11814 /* If the variable has a location at the last label
11815 it keeps its location until the end of function. */
11816 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11818 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11819 enum var_init_status initialized =
11820 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11822 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11823 if (!current_function_decl)
11824 endname = text_end_label;
11827 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11828 current_function_funcdef_no);
11829 endname = ggc_strdup (label_id);
11831 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11833 add_loc_descr_to_loc_list (&list, descr,
11834 node->label, endname, secname);
11837 /* Finally, add the location list to the DIE, and we are done. */
11838 add_AT_loc_list (die, attr, list);
11842 /* Try to get some constant RTL for this decl, and use that as the value of
11845 rtl = rtl_for_decl_location (decl);
11846 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
11848 add_const_value_attribute (die, rtl);
11852 /* If we have tried to generate the location otherwise, and it
11853 didn't work out (we wouldn't be here if we did), and we have a one entry
11854 location list, try generating a location from that. */
11855 if (loc_list && loc_list->first)
11857 enum var_init_status status;
11858 node = loc_list->first;
11859 status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11860 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note), status);
11863 descr = loc_by_reference (descr, decl);
11864 add_AT_location_description (die, attr, descr);
11869 /* We couldn't get any rtl, so try directly generating the location
11870 description from the tree. */
11871 descr = loc_descriptor_from_tree (decl);
11874 descr = loc_by_reference (descr, decl);
11875 add_AT_location_description (die, attr, descr);
11878 /* None of that worked, so it must not really have a location;
11879 try adding a constant value attribute from the DECL_INITIAL. */
11880 tree_add_const_value_attribute (die, decl);
11883 /* Add VARIABLE and DIE into deferred locations list. */
11886 defer_location (tree variable, dw_die_ref die)
11888 deferred_locations entry;
11889 entry.variable = variable;
11891 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
11894 /* Helper function for tree_add_const_value_attribute. Natively encode
11895 initializer INIT into an array. Return true if successful. */
11898 native_encode_initializer (tree init, unsigned char *array, int size)
11902 if (init == NULL_TREE)
11906 switch (TREE_CODE (init))
11909 type = TREE_TYPE (init);
11910 if (TREE_CODE (type) == ARRAY_TYPE)
11912 tree enttype = TREE_TYPE (type);
11913 enum machine_mode mode = TYPE_MODE (enttype);
11915 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
11917 if (int_size_in_bytes (type) != size)
11919 if (size > TREE_STRING_LENGTH (init))
11921 memcpy (array, TREE_STRING_POINTER (init),
11922 TREE_STRING_LENGTH (init));
11923 memset (array + TREE_STRING_LENGTH (init),
11924 '\0', size - TREE_STRING_LENGTH (init));
11927 memcpy (array, TREE_STRING_POINTER (init), size);
11932 type = TREE_TYPE (init);
11933 if (int_size_in_bytes (type) != size)
11935 if (TREE_CODE (type) == ARRAY_TYPE)
11937 HOST_WIDE_INT min_index;
11938 unsigned HOST_WIDE_INT cnt;
11939 int curpos = 0, fieldsize;
11940 constructor_elt *ce;
11942 if (TYPE_DOMAIN (type) == NULL_TREE
11943 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
11946 fieldsize = int_size_in_bytes (TREE_TYPE (type));
11947 if (fieldsize <= 0)
11950 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
11951 memset (array, '\0', size);
11953 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
11956 tree val = ce->value;
11957 tree index = ce->index;
11959 if (index && TREE_CODE (index) == RANGE_EXPR)
11960 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
11963 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
11968 if (!native_encode_initializer (val, array + pos, fieldsize))
11971 curpos = pos + fieldsize;
11972 if (index && TREE_CODE (index) == RANGE_EXPR)
11974 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
11975 - tree_low_cst (TREE_OPERAND (index, 0), 0);
11979 memcpy (array + curpos, array + pos, fieldsize);
11980 curpos += fieldsize;
11983 gcc_assert (curpos <= size);
11987 else if (TREE_CODE (type) == RECORD_TYPE
11988 || TREE_CODE (type) == UNION_TYPE)
11990 tree field = NULL_TREE;
11991 unsigned HOST_WIDE_INT cnt;
11992 constructor_elt *ce;
11994 if (int_size_in_bytes (type) != size)
11997 if (TREE_CODE (type) == RECORD_TYPE)
11998 field = TYPE_FIELDS (type);
12001 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
12002 cnt++, field = field ? TREE_CHAIN (field) : 0)
12004 tree val = ce->value;
12005 int pos, fieldsize;
12007 if (ce->index != 0)
12013 if (field == NULL_TREE || DECL_BIT_FIELD (field))
12016 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
12017 && TYPE_DOMAIN (TREE_TYPE (field))
12018 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
12020 else if (DECL_SIZE_UNIT (field) == NULL_TREE
12021 || !host_integerp (DECL_SIZE_UNIT (field), 0))
12023 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
12024 pos = int_byte_position (field);
12025 gcc_assert (pos + fieldsize <= size);
12027 && !native_encode_initializer (val, array + pos, fieldsize))
12033 case VIEW_CONVERT_EXPR:
12034 case NON_LVALUE_EXPR:
12035 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
12037 return native_encode_expr (init, array, size) == size;
12041 /* If we don't have a copy of this variable in memory for some reason (such
12042 as a C++ member constant that doesn't have an out-of-line definition),
12043 we should tell the debugger about the constant value. */
12046 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
12049 tree type = TREE_TYPE (decl);
12052 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
12055 init = DECL_INITIAL (decl);
12056 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
12061 rtl = rtl_for_decl_init (init, type);
12063 add_const_value_attribute (var_die, rtl);
12064 /* If the host and target are sane, try harder. */
12065 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
12066 && initializer_constant_valid_p (init, type))
12068 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
12069 if (size > 0 && (int) size == size)
12071 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
12073 if (native_encode_initializer (init, array, size))
12074 add_AT_vec (var_die, DW_AT_const_value, size, 1, array);
12079 /* Convert the CFI instructions for the current function into a
12080 location list. This is used for DW_AT_frame_base when we targeting
12081 a dwarf2 consumer that does not support the dwarf3
12082 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
12085 static dw_loc_list_ref
12086 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
12089 dw_loc_list_ref list, *list_tail;
12091 dw_cfa_location last_cfa, next_cfa;
12092 const char *start_label, *last_label, *section;
12094 fde = current_fde ();
12095 gcc_assert (fde != NULL);
12097 section = secname_for_decl (current_function_decl);
12101 next_cfa.reg = INVALID_REGNUM;
12102 next_cfa.offset = 0;
12103 next_cfa.indirect = 0;
12104 next_cfa.base_offset = 0;
12106 start_label = fde->dw_fde_begin;
12108 /* ??? Bald assumption that the CIE opcode list does not contain
12109 advance opcodes. */
12110 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
12111 lookup_cfa_1 (cfi, &next_cfa);
12113 last_cfa = next_cfa;
12114 last_label = start_label;
12116 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
12117 switch (cfi->dw_cfi_opc)
12119 case DW_CFA_set_loc:
12120 case DW_CFA_advance_loc1:
12121 case DW_CFA_advance_loc2:
12122 case DW_CFA_advance_loc4:
12123 if (!cfa_equal_p (&last_cfa, &next_cfa))
12125 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12126 start_label, last_label, section,
12129 list_tail = &(*list_tail)->dw_loc_next;
12130 last_cfa = next_cfa;
12131 start_label = last_label;
12133 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
12136 case DW_CFA_advance_loc:
12137 /* The encoding is complex enough that we should never emit this. */
12138 case DW_CFA_remember_state:
12139 case DW_CFA_restore_state:
12140 /* We don't handle these two in this function. It would be possible
12141 if it were to be required. */
12142 gcc_unreachable ();
12145 lookup_cfa_1 (cfi, &next_cfa);
12149 if (!cfa_equal_p (&last_cfa, &next_cfa))
12151 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12152 start_label, last_label, section,
12154 list_tail = &(*list_tail)->dw_loc_next;
12155 start_label = last_label;
12157 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
12158 start_label, fde->dw_fde_end, section,
12164 /* Compute a displacement from the "steady-state frame pointer" to the
12165 frame base (often the same as the CFA), and store it in
12166 frame_pointer_fb_offset. OFFSET is added to the displacement
12167 before the latter is negated. */
12170 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
12174 #ifdef FRAME_POINTER_CFA_OFFSET
12175 reg = frame_pointer_rtx;
12176 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
12178 reg = arg_pointer_rtx;
12179 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
12182 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
12183 if (GET_CODE (elim) == PLUS)
12185 offset += INTVAL (XEXP (elim, 1));
12186 elim = XEXP (elim, 0);
12189 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12190 && (elim == hard_frame_pointer_rtx
12191 || elim == stack_pointer_rtx))
12192 || elim == (frame_pointer_needed
12193 ? hard_frame_pointer_rtx
12194 : stack_pointer_rtx));
12196 frame_pointer_fb_offset = -offset;
12199 /* Generate a DW_AT_name attribute given some string value to be included as
12200 the value of the attribute. */
12203 add_name_attribute (dw_die_ref die, const char *name_string)
12205 if (name_string != NULL && *name_string != 0)
12207 if (demangle_name_func)
12208 name_string = (*demangle_name_func) (name_string);
12210 add_AT_string (die, DW_AT_name, name_string);
12214 /* Generate a DW_AT_comp_dir attribute for DIE. */
12217 add_comp_dir_attribute (dw_die_ref die)
12219 const char *wd = get_src_pwd ();
12221 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
12224 /* Given a tree node describing an array bound (either lower or upper) output
12225 a representation for that bound. */
12228 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
12230 switch (TREE_CODE (bound))
12235 /* All fixed-bounds are represented by INTEGER_CST nodes. */
12237 if (! host_integerp (bound, 0)
12238 || (bound_attr == DW_AT_lower_bound
12239 && (((is_c_family () || is_java ()) && integer_zerop (bound))
12240 || (is_fortran () && integer_onep (bound)))))
12241 /* Use the default. */
12244 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
12248 case VIEW_CONVERT_EXPR:
12249 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
12259 dw_die_ref decl_die = lookup_decl_die (bound);
12260 dw_loc_descr_ref loc;
12262 /* ??? Can this happen, or should the variable have been bound
12263 first? Probably it can, since I imagine that we try to create
12264 the types of parameters in the order in which they exist in
12265 the list, and won't have created a forward reference to a
12266 later parameter. */
12267 if (decl_die != NULL)
12268 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12271 loc = loc_descriptor_from_tree_1 (bound, 0);
12272 add_AT_location_description (subrange_die, bound_attr, loc);
12279 /* Otherwise try to create a stack operation procedure to
12280 evaluate the value of the array bound. */
12282 dw_die_ref ctx, decl_die;
12283 dw_loc_descr_ref loc;
12285 loc = loc_descriptor_from_tree (bound);
12289 if (current_function_decl == 0)
12290 ctx = comp_unit_die;
12292 ctx = lookup_decl_die (current_function_decl);
12294 decl_die = new_die (DW_TAG_variable, ctx, bound);
12295 add_AT_flag (decl_die, DW_AT_artificial, 1);
12296 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
12297 add_AT_loc (decl_die, DW_AT_location, loc);
12299 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12305 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
12306 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
12307 Note that the block of subscript information for an array type also
12308 includes information about the element type of the given array type. */
12311 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
12313 unsigned dimension_number;
12315 dw_die_ref subrange_die;
12317 for (dimension_number = 0;
12318 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
12319 type = TREE_TYPE (type), dimension_number++)
12321 tree domain = TYPE_DOMAIN (type);
12323 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
12326 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
12327 and (in GNU C only) variable bounds. Handle all three forms
12329 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
12332 /* We have an array type with specified bounds. */
12333 lower = TYPE_MIN_VALUE (domain);
12334 upper = TYPE_MAX_VALUE (domain);
12336 /* Define the index type. */
12337 if (TREE_TYPE (domain))
12339 /* ??? This is probably an Ada unnamed subrange type. Ignore the
12340 TREE_TYPE field. We can't emit debug info for this
12341 because it is an unnamed integral type. */
12342 if (TREE_CODE (domain) == INTEGER_TYPE
12343 && TYPE_NAME (domain) == NULL_TREE
12344 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
12345 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
12348 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
12352 /* ??? If upper is NULL, the array has unspecified length,
12353 but it does have a lower bound. This happens with Fortran
12355 Since the debugger is definitely going to need to know N
12356 to produce useful results, go ahead and output the lower
12357 bound solo, and hope the debugger can cope. */
12359 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
12361 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
12364 /* Otherwise we have an array type with an unspecified length. The
12365 DWARF-2 spec does not say how to handle this; let's just leave out the
12371 add_byte_size_attribute (dw_die_ref die, tree tree_node)
12375 switch (TREE_CODE (tree_node))
12380 case ENUMERAL_TYPE:
12383 case QUAL_UNION_TYPE:
12384 size = int_size_in_bytes (tree_node);
12387 /* For a data member of a struct or union, the DW_AT_byte_size is
12388 generally given as the number of bytes normally allocated for an
12389 object of the *declared* type of the member itself. This is true
12390 even for bit-fields. */
12391 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
12394 gcc_unreachable ();
12397 /* Note that `size' might be -1 when we get to this point. If it is, that
12398 indicates that the byte size of the entity in question is variable. We
12399 have no good way of expressing this fact in Dwarf at the present time,
12400 so just let the -1 pass on through. */
12401 add_AT_unsigned (die, DW_AT_byte_size, size);
12404 /* For a FIELD_DECL node which represents a bit-field, output an attribute
12405 which specifies the distance in bits from the highest order bit of the
12406 "containing object" for the bit-field to the highest order bit of the
12409 For any given bit-field, the "containing object" is a hypothetical object
12410 (of some integral or enum type) within which the given bit-field lives. The
12411 type of this hypothetical "containing object" is always the same as the
12412 declared type of the individual bit-field itself. The determination of the
12413 exact location of the "containing object" for a bit-field is rather
12414 complicated. It's handled by the `field_byte_offset' function (above).
12416 Note that it is the size (in bytes) of the hypothetical "containing object"
12417 which will be given in the DW_AT_byte_size attribute for this bit-field.
12418 (See `byte_size_attribute' above). */
12421 add_bit_offset_attribute (dw_die_ref die, tree decl)
12423 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
12424 tree type = DECL_BIT_FIELD_TYPE (decl);
12425 HOST_WIDE_INT bitpos_int;
12426 HOST_WIDE_INT highest_order_object_bit_offset;
12427 HOST_WIDE_INT highest_order_field_bit_offset;
12428 HOST_WIDE_INT unsigned bit_offset;
12430 /* Must be a field and a bit field. */
12431 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
12433 /* We can't yet handle bit-fields whose offsets are variable, so if we
12434 encounter such things, just return without generating any attribute
12435 whatsoever. Likewise for variable or too large size. */
12436 if (! host_integerp (bit_position (decl), 0)
12437 || ! host_integerp (DECL_SIZE (decl), 1))
12440 bitpos_int = int_bit_position (decl);
12442 /* Note that the bit offset is always the distance (in bits) from the
12443 highest-order bit of the "containing object" to the highest-order bit of
12444 the bit-field itself. Since the "high-order end" of any object or field
12445 is different on big-endian and little-endian machines, the computation
12446 below must take account of these differences. */
12447 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
12448 highest_order_field_bit_offset = bitpos_int;
12450 if (! BYTES_BIG_ENDIAN)
12452 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
12453 highest_order_object_bit_offset += simple_type_size_in_bits (type);
12457 = (! BYTES_BIG_ENDIAN
12458 ? highest_order_object_bit_offset - highest_order_field_bit_offset
12459 : highest_order_field_bit_offset - highest_order_object_bit_offset);
12461 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
12464 /* For a FIELD_DECL node which represents a bit field, output an attribute
12465 which specifies the length in bits of the given field. */
12468 add_bit_size_attribute (dw_die_ref die, tree decl)
12470 /* Must be a field and a bit field. */
12471 gcc_assert (TREE_CODE (decl) == FIELD_DECL
12472 && DECL_BIT_FIELD_TYPE (decl));
12474 if (host_integerp (DECL_SIZE (decl), 1))
12475 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
12478 /* If the compiled language is ANSI C, then add a 'prototyped'
12479 attribute, if arg types are given for the parameters of a function. */
12482 add_prototyped_attribute (dw_die_ref die, tree func_type)
12484 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
12485 && TYPE_ARG_TYPES (func_type) != NULL)
12486 add_AT_flag (die, DW_AT_prototyped, 1);
12489 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
12490 by looking in either the type declaration or object declaration
12493 static inline dw_die_ref
12494 add_abstract_origin_attribute (dw_die_ref die, tree origin)
12496 dw_die_ref origin_die = NULL;
12498 if (TREE_CODE (origin) != FUNCTION_DECL)
12500 /* We may have gotten separated from the block for the inlined
12501 function, if we're in an exception handler or some such; make
12502 sure that the abstract function has been written out.
12504 Doing this for nested functions is wrong, however; functions are
12505 distinct units, and our context might not even be inline. */
12509 fn = TYPE_STUB_DECL (fn);
12511 fn = decl_function_context (fn);
12513 dwarf2out_abstract_function (fn);
12516 if (DECL_P (origin))
12517 origin_die = lookup_decl_die (origin);
12518 else if (TYPE_P (origin))
12519 origin_die = lookup_type_die (origin);
12521 /* XXX: Functions that are never lowered don't always have correct block
12522 trees (in the case of java, they simply have no block tree, in some other
12523 languages). For these functions, there is nothing we can really do to
12524 output correct debug info for inlined functions in all cases. Rather
12525 than die, we'll just produce deficient debug info now, in that we will
12526 have variables without a proper abstract origin. In the future, when all
12527 functions are lowered, we should re-add a gcc_assert (origin_die)
12531 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
12535 /* We do not currently support the pure_virtual attribute. */
12538 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
12540 if (DECL_VINDEX (func_decl))
12542 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12544 if (host_integerp (DECL_VINDEX (func_decl), 0))
12545 add_AT_loc (die, DW_AT_vtable_elem_location,
12546 new_loc_descr (DW_OP_constu,
12547 tree_low_cst (DECL_VINDEX (func_decl), 0),
12550 /* GNU extension: Record what type this method came from originally. */
12551 if (debug_info_level > DINFO_LEVEL_TERSE)
12552 add_AT_die_ref (die, DW_AT_containing_type,
12553 lookup_type_die (DECL_CONTEXT (func_decl)));
12557 /* Add source coordinate attributes for the given decl. */
12560 add_src_coords_attributes (dw_die_ref die, tree decl)
12562 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12564 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
12565 add_AT_unsigned (die, DW_AT_decl_line, s.line);
12568 /* Add a DW_AT_name attribute and source coordinate attribute for the
12569 given decl, but only if it actually has a name. */
12572 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
12576 decl_name = DECL_NAME (decl);
12577 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
12579 add_name_attribute (die, dwarf2_name (decl, 0));
12580 if (! DECL_ARTIFICIAL (decl))
12581 add_src_coords_attributes (die, decl);
12583 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
12584 && TREE_PUBLIC (decl)
12585 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
12586 && !DECL_ABSTRACT (decl)
12587 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
12589 add_AT_string (die, DW_AT_MIPS_linkage_name,
12590 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
12593 #ifdef VMS_DEBUGGING_INFO
12594 /* Get the function's name, as described by its RTL. This may be different
12595 from the DECL_NAME name used in the source file. */
12596 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
12598 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
12599 XEXP (DECL_RTL (decl), 0));
12600 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
12605 /* Push a new declaration scope. */
12608 push_decl_scope (tree scope)
12610 VEC_safe_push (tree, gc, decl_scope_table, scope);
12613 /* Pop a declaration scope. */
12616 pop_decl_scope (void)
12618 VEC_pop (tree, decl_scope_table);
12621 /* Return the DIE for the scope that immediately contains this type.
12622 Non-named types get global scope. Named types nested in other
12623 types get their containing scope if it's open, or global scope
12624 otherwise. All other types (i.e. function-local named types) get
12625 the current active scope. */
12628 scope_die_for (tree t, dw_die_ref context_die)
12630 dw_die_ref scope_die = NULL;
12631 tree containing_scope;
12634 /* Non-types always go in the current scope. */
12635 gcc_assert (TYPE_P (t));
12637 containing_scope = TYPE_CONTEXT (t);
12639 /* Use the containing namespace if it was passed in (for a declaration). */
12640 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
12642 if (context_die == lookup_decl_die (containing_scope))
12645 containing_scope = NULL_TREE;
12648 /* Ignore function type "scopes" from the C frontend. They mean that
12649 a tagged type is local to a parmlist of a function declarator, but
12650 that isn't useful to DWARF. */
12651 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
12652 containing_scope = NULL_TREE;
12654 if (containing_scope == NULL_TREE)
12655 scope_die = comp_unit_die;
12656 else if (TYPE_P (containing_scope))
12658 /* For types, we can just look up the appropriate DIE. But
12659 first we check to see if we're in the middle of emitting it
12660 so we know where the new DIE should go. */
12661 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
12662 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
12667 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
12668 || TREE_ASM_WRITTEN (containing_scope));
12670 /* If none of the current dies are suitable, we get file scope. */
12671 scope_die = comp_unit_die;
12674 scope_die = lookup_type_die (containing_scope);
12677 scope_die = context_die;
12682 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
12685 local_scope_p (dw_die_ref context_die)
12687 for (; context_die; context_die = context_die->die_parent)
12688 if (context_die->die_tag == DW_TAG_inlined_subroutine
12689 || context_die->die_tag == DW_TAG_subprogram)
12695 /* Returns nonzero if CONTEXT_DIE is a class. */
12698 class_scope_p (dw_die_ref context_die)
12700 return (context_die
12701 && (context_die->die_tag == DW_TAG_structure_type
12702 || context_die->die_tag == DW_TAG_class_type
12703 || context_die->die_tag == DW_TAG_interface_type
12704 || context_die->die_tag == DW_TAG_union_type));
12707 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
12708 whether or not to treat a DIE in this context as a declaration. */
12711 class_or_namespace_scope_p (dw_die_ref context_die)
12713 return (class_scope_p (context_die)
12714 || (context_die && context_die->die_tag == DW_TAG_namespace));
12717 /* Many forms of DIEs require a "type description" attribute. This
12718 routine locates the proper "type descriptor" die for the type given
12719 by 'type', and adds a DW_AT_type attribute below the given die. */
12722 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
12723 int decl_volatile, dw_die_ref context_die)
12725 enum tree_code code = TREE_CODE (type);
12726 dw_die_ref type_die = NULL;
12728 /* ??? If this type is an unnamed subrange type of an integral, floating-point
12729 or fixed-point type, use the inner type. This is because we have no
12730 support for unnamed types in base_type_die. This can happen if this is
12731 an Ada subrange type. Correct solution is emit a subrange type die. */
12732 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
12733 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
12734 type = TREE_TYPE (type), code = TREE_CODE (type);
12736 if (code == ERROR_MARK
12737 /* Handle a special case. For functions whose return type is void, we
12738 generate *no* type attribute. (Note that no object may have type
12739 `void', so this only applies to function return types). */
12740 || code == VOID_TYPE)
12743 type_die = modified_type_die (type,
12744 decl_const || TYPE_READONLY (type),
12745 decl_volatile || TYPE_VOLATILE (type),
12748 if (type_die != NULL)
12749 add_AT_die_ref (object_die, DW_AT_type, type_die);
12752 /* Given an object die, add the calling convention attribute for the
12753 function call type. */
12755 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
12757 enum dwarf_calling_convention value = DW_CC_normal;
12759 value = targetm.dwarf_calling_convention (TREE_TYPE (decl));
12761 /* DWARF doesn't provide a way to identify a program's source-level
12762 entry point. DW_AT_calling_convention attributes are only meant
12763 to describe functions' calling conventions. However, lacking a
12764 better way to signal the Fortran main program, we use this for the
12765 time being, following existing custom. */
12767 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
12768 value = DW_CC_program;
12770 /* Only add the attribute if the backend requests it, and
12771 is not DW_CC_normal. */
12772 if (value && (value != DW_CC_normal))
12773 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
12776 /* Given a tree pointer to a struct, class, union, or enum type node, return
12777 a pointer to the (string) tag name for the given type, or zero if the type
12778 was declared without a tag. */
12780 static const char *
12781 type_tag (const_tree type)
12783 const char *name = 0;
12785 if (TYPE_NAME (type) != 0)
12789 /* Find the IDENTIFIER_NODE for the type name. */
12790 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
12791 t = TYPE_NAME (type);
12793 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
12794 a TYPE_DECL node, regardless of whether or not a `typedef' was
12796 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12797 && ! DECL_IGNORED_P (TYPE_NAME (type)))
12799 /* We want to be extra verbose. Don't call dwarf_name if
12800 DECL_NAME isn't set. The default hook for decl_printable_name
12801 doesn't like that, and in this context it's correct to return
12802 0, instead of "<anonymous>" or the like. */
12803 if (DECL_NAME (TYPE_NAME (type)))
12804 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
12807 /* Now get the name as a string, or invent one. */
12808 if (!name && t != 0)
12809 name = IDENTIFIER_POINTER (t);
12812 return (name == 0 || *name == '\0') ? 0 : name;
12815 /* Return the type associated with a data member, make a special check
12816 for bit field types. */
12819 member_declared_type (const_tree member)
12821 return (DECL_BIT_FIELD_TYPE (member)
12822 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
12825 /* Get the decl's label, as described by its RTL. This may be different
12826 from the DECL_NAME name used in the source file. */
12829 static const char *
12830 decl_start_label (tree decl)
12833 const char *fnname;
12835 x = DECL_RTL (decl);
12836 gcc_assert (MEM_P (x));
12839 gcc_assert (GET_CODE (x) == SYMBOL_REF);
12841 fnname = XSTR (x, 0);
12846 /* These routines generate the internal representation of the DIE's for
12847 the compilation unit. Debugging information is collected by walking
12848 the declaration trees passed in from dwarf2out_decl(). */
12851 gen_array_type_die (tree type, dw_die_ref context_die)
12853 dw_die_ref scope_die = scope_die_for (type, context_die);
12854 dw_die_ref array_die;
12856 /* GNU compilers represent multidimensional array types as sequences of one
12857 dimensional array types whose element types are themselves array types.
12858 We sometimes squish that down to a single array_type DIE with multiple
12859 subscripts in the Dwarf debugging info. The draft Dwarf specification
12860 say that we are allowed to do this kind of compression in C, because
12861 there is no difference between an array of arrays and a multidimensional
12862 array. We don't do this for Ada to remain as close as possible to the
12863 actual representation, which is especially important against the language
12864 flexibilty wrt arrays of variable size. */
12866 bool collapse_nested_arrays = !is_ada ();
12869 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
12870 DW_TAG_string_type doesn't have DW_AT_type attribute). */
12871 if (TYPE_STRING_FLAG (type)
12872 && TREE_CODE (type) == ARRAY_TYPE
12874 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
12876 HOST_WIDE_INT size;
12878 array_die = new_die (DW_TAG_string_type, scope_die, type);
12879 add_name_attribute (array_die, type_tag (type));
12880 equate_type_number_to_die (type, array_die);
12881 size = int_size_in_bytes (type);
12883 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12884 else if (TYPE_DOMAIN (type) != NULL_TREE
12885 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
12886 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12888 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
12889 dw_loc_descr_ref loc = loc_descriptor_from_tree (szdecl);
12891 size = int_size_in_bytes (TREE_TYPE (szdecl));
12892 if (loc && size > 0)
12894 add_AT_loc (array_die, DW_AT_string_length, loc);
12895 if (size != DWARF2_ADDR_SIZE)
12896 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12902 /* ??? The SGI dwarf reader fails for array of array of enum types
12903 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
12904 array type comes before the outer array type. We thus call gen_type_die
12905 before we new_die and must prevent nested array types collapsing for this
12908 #ifdef MIPS_DEBUGGING_INFO
12909 gen_type_die (TREE_TYPE (type), context_die);
12910 collapse_nested_arrays = false;
12913 array_die = new_die (DW_TAG_array_type, scope_die, type);
12914 add_name_attribute (array_die, type_tag (type));
12915 equate_type_number_to_die (type, array_die);
12917 if (TREE_CODE (type) == VECTOR_TYPE)
12919 /* The frontend feeds us a representation for the vector as a struct
12920 containing an array. Pull out the array type. */
12921 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
12922 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
12925 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
12927 && TREE_CODE (type) == ARRAY_TYPE
12928 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
12929 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
12930 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
12933 /* We default the array ordering. SDB will probably do
12934 the right things even if DW_AT_ordering is not present. It's not even
12935 an issue until we start to get into multidimensional arrays anyway. If
12936 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
12937 then we'll have to put the DW_AT_ordering attribute back in. (But if
12938 and when we find out that we need to put these in, we will only do so
12939 for multidimensional arrays. */
12940 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
12943 #ifdef MIPS_DEBUGGING_INFO
12944 /* The SGI compilers handle arrays of unknown bound by setting
12945 AT_declaration and not emitting any subrange DIEs. */
12946 if (! TYPE_DOMAIN (type))
12947 add_AT_flag (array_die, DW_AT_declaration, 1);
12950 add_subscript_info (array_die, type, collapse_nested_arrays);
12952 /* Add representation of the type of the elements of this array type and
12953 emit the corresponding DIE if we haven't done it already. */
12954 element_type = TREE_TYPE (type);
12955 if (collapse_nested_arrays)
12956 while (TREE_CODE (element_type) == ARRAY_TYPE)
12958 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
12960 element_type = TREE_TYPE (element_type);
12963 #ifndef MIPS_DEBUGGING_INFO
12964 gen_type_die (element_type, context_die);
12967 add_type_attribute (array_die, element_type, 0, 0, context_die);
12969 if (get_AT (array_die, DW_AT_name))
12970 add_pubtype (type, array_die);
12973 static dw_loc_descr_ref
12974 descr_info_loc (tree val, tree base_decl)
12976 HOST_WIDE_INT size;
12977 dw_loc_descr_ref loc, loc2;
12978 enum dwarf_location_atom op;
12980 if (val == base_decl)
12981 return new_loc_descr (DW_OP_push_object_address, 0, 0);
12983 switch (TREE_CODE (val))
12986 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12988 return loc_descriptor_from_tree_1 (val, 0);
12990 if (host_integerp (val, 0))
12991 return int_loc_descriptor (tree_low_cst (val, 0));
12994 size = int_size_in_bytes (TREE_TYPE (val));
12997 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13000 if (size == DWARF2_ADDR_SIZE)
13001 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
13003 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
13005 case POINTER_PLUS_EXPR:
13007 if (host_integerp (TREE_OPERAND (val, 1), 1)
13008 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
13011 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13014 add_loc_descr (&loc,
13015 new_loc_descr (DW_OP_plus_uconst,
13016 tree_low_cst (TREE_OPERAND (val, 1),
13023 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13026 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
13029 add_loc_descr (&loc, loc2);
13030 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
13052 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
13053 tree val, tree base_decl)
13055 dw_loc_descr_ref loc;
13057 if (host_integerp (val, 0))
13059 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
13063 loc = descr_info_loc (val, base_decl);
13067 add_AT_loc (die, attr, loc);
13070 /* This routine generates DIE for array with hidden descriptor, details
13071 are filled into *info by a langhook. */
13074 gen_descr_array_type_die (tree type, struct array_descr_info *info,
13075 dw_die_ref context_die)
13077 dw_die_ref scope_die = scope_die_for (type, context_die);
13078 dw_die_ref array_die;
13081 array_die = new_die (DW_TAG_array_type, scope_die, type);
13082 add_name_attribute (array_die, type_tag (type));
13083 equate_type_number_to_die (type, array_die);
13085 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
13087 && info->ndimensions >= 2)
13088 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
13090 if (info->data_location)
13091 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
13093 if (info->associated)
13094 add_descr_info_field (array_die, DW_AT_associated, info->associated,
13096 if (info->allocated)
13097 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
13100 for (dim = 0; dim < info->ndimensions; dim++)
13102 dw_die_ref subrange_die
13103 = new_die (DW_TAG_subrange_type, array_die, NULL);
13105 if (info->dimen[dim].lower_bound)
13107 /* If it is the default value, omit it. */
13108 if ((is_c_family () || is_java ())
13109 && integer_zerop (info->dimen[dim].lower_bound))
13111 else if (is_fortran ()
13112 && integer_onep (info->dimen[dim].lower_bound))
13115 add_descr_info_field (subrange_die, DW_AT_lower_bound,
13116 info->dimen[dim].lower_bound,
13119 if (info->dimen[dim].upper_bound)
13120 add_descr_info_field (subrange_die, DW_AT_upper_bound,
13121 info->dimen[dim].upper_bound,
13123 if (info->dimen[dim].stride)
13124 add_descr_info_field (subrange_die, DW_AT_byte_stride,
13125 info->dimen[dim].stride,
13129 gen_type_die (info->element_type, context_die);
13130 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
13132 if (get_AT (array_die, DW_AT_name))
13133 add_pubtype (type, array_die);
13138 gen_entry_point_die (tree decl, dw_die_ref context_die)
13140 tree origin = decl_ultimate_origin (decl);
13141 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
13143 if (origin != NULL)
13144 add_abstract_origin_attribute (decl_die, origin);
13147 add_name_and_src_coords_attributes (decl_die, decl);
13148 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
13149 0, 0, context_die);
13152 if (DECL_ABSTRACT (decl))
13153 equate_decl_number_to_die (decl, decl_die);
13155 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
13159 /* Walk through the list of incomplete types again, trying once more to
13160 emit full debugging info for them. */
13163 retry_incomplete_types (void)
13167 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
13168 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
13171 /* Determine what tag to use for a record type. */
13173 static enum dwarf_tag
13174 record_type_tag (tree type)
13176 if (! lang_hooks.types.classify_record)
13177 return DW_TAG_structure_type;
13179 switch (lang_hooks.types.classify_record (type))
13181 case RECORD_IS_STRUCT:
13182 return DW_TAG_structure_type;
13184 case RECORD_IS_CLASS:
13185 return DW_TAG_class_type;
13187 case RECORD_IS_INTERFACE:
13188 return DW_TAG_interface_type;
13191 gcc_unreachable ();
13195 /* Generate a DIE to represent an enumeration type. Note that these DIEs
13196 include all of the information about the enumeration values also. Each
13197 enumerated type name/value is listed as a child of the enumerated type
13201 gen_enumeration_type_die (tree type, dw_die_ref context_die)
13203 dw_die_ref type_die = lookup_type_die (type);
13205 if (type_die == NULL)
13207 type_die = new_die (DW_TAG_enumeration_type,
13208 scope_die_for (type, context_die), type);
13209 equate_type_number_to_die (type, type_die);
13210 add_name_attribute (type_die, type_tag (type));
13212 else if (! TYPE_SIZE (type))
13215 remove_AT (type_die, DW_AT_declaration);
13217 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
13218 given enum type is incomplete, do not generate the DW_AT_byte_size
13219 attribute or the DW_AT_element_list attribute. */
13220 if (TYPE_SIZE (type))
13224 TREE_ASM_WRITTEN (type) = 1;
13225 add_byte_size_attribute (type_die, type);
13226 if (TYPE_STUB_DECL (type) != NULL_TREE)
13227 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
13229 /* If the first reference to this type was as the return type of an
13230 inline function, then it may not have a parent. Fix this now. */
13231 if (type_die->die_parent == NULL)
13232 add_child_die (scope_die_for (type, context_die), type_die);
13234 for (link = TYPE_VALUES (type);
13235 link != NULL; link = TREE_CHAIN (link))
13237 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
13238 tree value = TREE_VALUE (link);
13240 add_name_attribute (enum_die,
13241 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
13243 if (TREE_CODE (value) == CONST_DECL)
13244 value = DECL_INITIAL (value);
13246 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
13247 /* DWARF2 does not provide a way of indicating whether or
13248 not enumeration constants are signed or unsigned. GDB
13249 always assumes the values are signed, so we output all
13250 values as if they were signed. That means that
13251 enumeration constants with very large unsigned values
13252 will appear to have negative values in the debugger. */
13253 add_AT_int (enum_die, DW_AT_const_value,
13254 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
13258 add_AT_flag (type_die, DW_AT_declaration, 1);
13260 if (get_AT (type_die, DW_AT_name))
13261 add_pubtype (type, type_die);
13266 /* Generate a DIE to represent either a real live formal parameter decl or to
13267 represent just the type of some formal parameter position in some function
13270 Note that this routine is a bit unusual because its argument may be a
13271 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
13272 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
13273 node. If it's the former then this function is being called to output a
13274 DIE to represent a formal parameter object (or some inlining thereof). If
13275 it's the latter, then this function is only being called to output a
13276 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
13277 argument type of some subprogram type. */
13280 gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
13282 tree node_or_origin = node ? node : origin;
13283 dw_die_ref parm_die
13284 = new_die (DW_TAG_formal_parameter, context_die, node);
13286 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
13288 case tcc_declaration:
13290 origin = decl_ultimate_origin (node);
13291 if (origin != NULL)
13292 add_abstract_origin_attribute (parm_die, origin);
13295 tree type = TREE_TYPE (node);
13296 add_name_and_src_coords_attributes (parm_die, node);
13297 if (DECL_BY_REFERENCE (node))
13298 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
13301 add_type_attribute (parm_die, type,
13302 TREE_READONLY (node),
13303 TREE_THIS_VOLATILE (node),
13305 if (DECL_ARTIFICIAL (node))
13306 add_AT_flag (parm_die, DW_AT_artificial, 1);
13310 equate_decl_number_to_die (node, parm_die);
13311 if (! DECL_ABSTRACT (node_or_origin))
13312 add_location_or_const_value_attribute (parm_die, node_or_origin,
13318 /* We were called with some kind of a ..._TYPE node. */
13319 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
13323 gcc_unreachable ();
13329 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
13330 at the end of an (ANSI prototyped) formal parameters list. */
13333 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
13335 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
13338 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
13339 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
13340 parameters as specified in some function type specification (except for
13341 those which appear as part of a function *definition*). */
13344 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
13347 tree formal_type = NULL;
13348 tree first_parm_type;
13351 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
13353 arg = DECL_ARGUMENTS (function_or_method_type);
13354 function_or_method_type = TREE_TYPE (function_or_method_type);
13359 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
13361 /* Make our first pass over the list of formal parameter types and output a
13362 DW_TAG_formal_parameter DIE for each one. */
13363 for (link = first_parm_type; link; )
13365 dw_die_ref parm_die;
13367 formal_type = TREE_VALUE (link);
13368 if (formal_type == void_type_node)
13371 /* Output a (nameless) DIE to represent the formal parameter itself. */
13372 parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
13373 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
13374 && link == first_parm_type)
13375 || (arg && DECL_ARTIFICIAL (arg)))
13376 add_AT_flag (parm_die, DW_AT_artificial, 1);
13378 link = TREE_CHAIN (link);
13380 arg = TREE_CHAIN (arg);
13383 /* If this function type has an ellipsis, add a
13384 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
13385 if (formal_type != void_type_node)
13386 gen_unspecified_parameters_die (function_or_method_type, context_die);
13388 /* Make our second (and final) pass over the list of formal parameter types
13389 and output DIEs to represent those types (as necessary). */
13390 for (link = TYPE_ARG_TYPES (function_or_method_type);
13391 link && TREE_VALUE (link);
13392 link = TREE_CHAIN (link))
13393 gen_type_die (TREE_VALUE (link), context_die);
13396 /* We want to generate the DIE for TYPE so that we can generate the
13397 die for MEMBER, which has been defined; we will need to refer back
13398 to the member declaration nested within TYPE. If we're trying to
13399 generate minimal debug info for TYPE, processing TYPE won't do the
13400 trick; we need to attach the member declaration by hand. */
13403 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
13405 gen_type_die (type, context_die);
13407 /* If we're trying to avoid duplicate debug info, we may not have
13408 emitted the member decl for this function. Emit it now. */
13409 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
13410 && ! lookup_decl_die (member))
13412 dw_die_ref type_die;
13413 gcc_assert (!decl_ultimate_origin (member));
13415 push_decl_scope (type);
13416 type_die = lookup_type_die (type);
13417 if (TREE_CODE (member) == FUNCTION_DECL)
13418 gen_subprogram_die (member, type_die);
13419 else if (TREE_CODE (member) == FIELD_DECL)
13421 /* Ignore the nameless fields that are used to skip bits but handle
13422 C++ anonymous unions and structs. */
13423 if (DECL_NAME (member) != NULL_TREE
13424 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
13425 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
13427 gen_type_die (member_declared_type (member), type_die);
13428 gen_field_die (member, type_die);
13432 gen_variable_die (member, NULL_TREE, type_die);
13438 /* Generate the DWARF2 info for the "abstract" instance of a function which we
13439 may later generate inlined and/or out-of-line instances of. */
13442 dwarf2out_abstract_function (tree decl)
13444 dw_die_ref old_die;
13447 int was_abstract = DECL_ABSTRACT (decl);
13449 /* Make sure we have the actual abstract inline, not a clone. */
13450 decl = DECL_ORIGIN (decl);
13452 old_die = lookup_decl_die (decl);
13453 if (old_die && get_AT (old_die, DW_AT_inline))
13454 /* We've already generated the abstract instance. */
13457 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
13458 we don't get confused by DECL_ABSTRACT. */
13459 if (debug_info_level > DINFO_LEVEL_TERSE)
13461 context = decl_class_context (decl);
13463 gen_type_die_for_member
13464 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
13467 /* Pretend we've just finished compiling this function. */
13468 save_fn = current_function_decl;
13469 current_function_decl = decl;
13470 push_cfun (DECL_STRUCT_FUNCTION (decl));
13472 set_decl_abstract_flags (decl, 1);
13473 dwarf2out_decl (decl);
13474 if (! was_abstract)
13475 set_decl_abstract_flags (decl, 0);
13477 current_function_decl = save_fn;
13481 /* Helper function of premark_used_types() which gets called through
13482 htab_traverse_resize().
13484 Marks the DIE of a given type in *SLOT as perennial, so it never gets
13485 marked as unused by prune_unused_types. */
13487 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
13492 type = (tree) *slot;
13493 die = lookup_type_die (type);
13495 die->die_perennial_p = 1;
13499 /* Mark all members of used_types_hash as perennial. */
13501 premark_used_types (void)
13503 if (cfun && cfun->used_types_hash)
13504 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
13507 /* Generate a DIE to represent a declared function (either file-scope or
13511 gen_subprogram_die (tree decl, dw_die_ref context_die)
13513 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
13514 tree origin = decl_ultimate_origin (decl);
13515 dw_die_ref subr_die;
13518 dw_die_ref old_die = lookup_decl_die (decl);
13519 int declaration = (current_function_decl != decl
13520 || class_or_namespace_scope_p (context_die));
13522 premark_used_types ();
13524 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
13525 started to generate the abstract instance of an inline, decided to output
13526 its containing class, and proceeded to emit the declaration of the inline
13527 from the member list for the class. If so, DECLARATION takes priority;
13528 we'll get back to the abstract instance when done with the class. */
13530 /* The class-scope declaration DIE must be the primary DIE. */
13531 if (origin && declaration && class_or_namespace_scope_p (context_die))
13534 gcc_assert (!old_die);
13537 /* Now that the C++ front end lazily declares artificial member fns, we
13538 might need to retrofit the declaration into its class. */
13539 if (!declaration && !origin && !old_die
13540 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
13541 && !class_or_namespace_scope_p (context_die)
13542 && debug_info_level > DINFO_LEVEL_TERSE)
13543 old_die = force_decl_die (decl);
13545 if (origin != NULL)
13547 gcc_assert (!declaration || local_scope_p (context_die));
13549 /* Fixup die_parent for the abstract instance of a nested
13550 inline function. */
13551 if (old_die && old_die->die_parent == NULL)
13552 add_child_die (context_die, old_die);
13554 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13555 add_abstract_origin_attribute (subr_die, origin);
13559 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
13560 struct dwarf_file_data * file_index = lookup_filename (s.file);
13562 if (!get_AT_flag (old_die, DW_AT_declaration)
13563 /* We can have a normal definition following an inline one in the
13564 case of redefinition of GNU C extern inlines.
13565 It seems reasonable to use AT_specification in this case. */
13566 && !get_AT (old_die, DW_AT_inline))
13568 /* Detect and ignore this case, where we are trying to output
13569 something we have already output. */
13573 /* If the definition comes from the same place as the declaration,
13574 maybe use the old DIE. We always want the DIE for this function
13575 that has the *_pc attributes to be under comp_unit_die so the
13576 debugger can find it. We also need to do this for abstract
13577 instances of inlines, since the spec requires the out-of-line copy
13578 to have the same parent. For local class methods, this doesn't
13579 apply; we just use the old DIE. */
13580 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
13581 && (DECL_ARTIFICIAL (decl)
13582 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
13583 && (get_AT_unsigned (old_die, DW_AT_decl_line)
13584 == (unsigned) s.line))))
13586 subr_die = old_die;
13588 /* Clear out the declaration attribute and the formal parameters.
13589 Do not remove all children, because it is possible that this
13590 declaration die was forced using force_decl_die(). In such
13591 cases die that forced declaration die (e.g. TAG_imported_module)
13592 is one of the children that we do not want to remove. */
13593 remove_AT (subr_die, DW_AT_declaration);
13594 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
13598 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13599 add_AT_specification (subr_die, old_die);
13600 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
13601 add_AT_file (subr_die, DW_AT_decl_file, file_index);
13602 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
13603 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
13608 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13610 if (TREE_PUBLIC (decl))
13611 add_AT_flag (subr_die, DW_AT_external, 1);
13613 add_name_and_src_coords_attributes (subr_die, decl);
13614 if (debug_info_level > DINFO_LEVEL_TERSE)
13616 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
13617 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
13618 0, 0, context_die);
13621 add_pure_or_virtual_attribute (subr_die, decl);
13622 if (DECL_ARTIFICIAL (decl))
13623 add_AT_flag (subr_die, DW_AT_artificial, 1);
13625 if (TREE_PROTECTED (decl))
13626 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
13627 else if (TREE_PRIVATE (decl))
13628 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
13633 if (!old_die || !get_AT (old_die, DW_AT_inline))
13635 add_AT_flag (subr_die, DW_AT_declaration, 1);
13637 /* If this is an explicit function declaration then generate
13638 a DW_AT_explicit attribute. */
13639 if (lang_hooks.decls.function_decl_explicit_p (decl))
13640 add_AT_flag (subr_die, DW_AT_explicit, 1);
13642 /* The first time we see a member function, it is in the context of
13643 the class to which it belongs. We make sure of this by emitting
13644 the class first. The next time is the definition, which is
13645 handled above. The two may come from the same source text.
13647 Note that force_decl_die() forces function declaration die. It is
13648 later reused to represent definition. */
13649 equate_decl_number_to_die (decl, subr_die);
13652 else if (DECL_ABSTRACT (decl))
13654 if (DECL_DECLARED_INLINE_P (decl))
13656 if (cgraph_function_possibly_inlined_p (decl))
13657 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
13659 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
13663 if (cgraph_function_possibly_inlined_p (decl))
13664 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
13666 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
13669 if (DECL_DECLARED_INLINE_P (decl)
13670 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
13671 add_AT_flag (subr_die, DW_AT_artificial, 1);
13673 equate_decl_number_to_die (decl, subr_die);
13675 else if (!DECL_EXTERNAL (decl))
13677 HOST_WIDE_INT cfa_fb_offset;
13679 if (!old_die || !get_AT (old_die, DW_AT_inline))
13680 equate_decl_number_to_die (decl, subr_die);
13682 if (!flag_reorder_blocks_and_partition)
13684 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
13685 current_function_funcdef_no);
13686 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
13687 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
13688 current_function_funcdef_no);
13689 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
13691 add_pubname (decl, subr_die);
13692 add_arange (decl, subr_die);
13695 { /* Do nothing for now; maybe need to duplicate die, one for
13696 hot section and one for cold section, then use the hot/cold
13697 section begin/end labels to generate the aranges... */
13699 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
13700 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
13701 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
13702 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
13704 add_pubname (decl, subr_die);
13705 add_arange (decl, subr_die);
13706 add_arange (decl, subr_die);
13710 #ifdef MIPS_DEBUGGING_INFO
13711 /* Add a reference to the FDE for this routine. */
13712 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
13715 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
13717 /* We define the "frame base" as the function's CFA. This is more
13718 convenient for several reasons: (1) It's stable across the prologue
13719 and epilogue, which makes it better than just a frame pointer,
13720 (2) With dwarf3, there exists a one-byte encoding that allows us
13721 to reference the .debug_frame data by proxy, but failing that,
13722 (3) We can at least reuse the code inspection and interpretation
13723 code that determines the CFA position at various points in the
13725 /* ??? Use some command-line or configury switch to enable the use
13726 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
13727 consumers that understand it; fall back to "pure" dwarf2 and
13728 convert the CFA data into a location list. */
13730 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
13731 if (list->dw_loc_next)
13732 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
13734 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
13737 /* Compute a displacement from the "steady-state frame pointer" to
13738 the CFA. The former is what all stack slots and argument slots
13739 will reference in the rtl; the later is what we've told the
13740 debugger about. We'll need to adjust all frame_base references
13741 by this displacement. */
13742 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
13744 if (cfun->static_chain_decl)
13745 add_AT_location_description (subr_die, DW_AT_static_link,
13746 loc_descriptor_from_tree (cfun->static_chain_decl));
13749 /* Now output descriptions of the arguments for this function. This gets
13750 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
13751 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
13752 `...' at the end of the formal parameter list. In order to find out if
13753 there was a trailing ellipsis or not, we must instead look at the type
13754 associated with the FUNCTION_DECL. This will be a node of type
13755 FUNCTION_TYPE. If the chain of type nodes hanging off of this
13756 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
13757 an ellipsis at the end. */
13759 /* In the case where we are describing a mere function declaration, all we
13760 need to do here (and all we *can* do here) is to describe the *types* of
13761 its formal parameters. */
13762 if (debug_info_level <= DINFO_LEVEL_TERSE)
13764 else if (declaration)
13765 gen_formal_types_die (decl, subr_die);
13768 /* Generate DIEs to represent all known formal parameters. */
13769 tree arg_decls = DECL_ARGUMENTS (decl);
13772 /* When generating DIEs, generate the unspecified_parameters DIE
13773 instead if we come across the arg "__builtin_va_alist" */
13774 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
13775 if (TREE_CODE (parm) == PARM_DECL)
13777 if (DECL_NAME (parm)
13778 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
13779 "__builtin_va_alist"))
13780 gen_unspecified_parameters_die (parm, subr_die);
13782 gen_decl_die (parm, NULL, subr_die);
13785 /* Decide whether we need an unspecified_parameters DIE at the end.
13786 There are 2 more cases to do this for: 1) the ansi ... declaration -
13787 this is detectable when the end of the arg list is not a
13788 void_type_node 2) an unprototyped function declaration (not a
13789 definition). This just means that we have no info about the
13790 parameters at all. */
13791 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
13792 if (fn_arg_types != NULL)
13794 /* This is the prototyped case, check for.... */
13795 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
13796 gen_unspecified_parameters_die (decl, subr_die);
13798 else if (DECL_INITIAL (decl) == NULL_TREE)
13799 gen_unspecified_parameters_die (decl, subr_die);
13802 /* Output Dwarf info for all of the stuff within the body of the function
13803 (if it has one - it may be just a declaration). */
13804 outer_scope = DECL_INITIAL (decl);
13806 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
13807 a function. This BLOCK actually represents the outermost binding contour
13808 for the function, i.e. the contour in which the function's formal
13809 parameters and labels get declared. Curiously, it appears that the front
13810 end doesn't actually put the PARM_DECL nodes for the current function onto
13811 the BLOCK_VARS list for this outer scope, but are strung off of the
13812 DECL_ARGUMENTS list for the function instead.
13814 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
13815 the LABEL_DECL nodes for the function however, and we output DWARF info
13816 for those in decls_for_scope. Just within the `outer_scope' there will be
13817 a BLOCK node representing the function's outermost pair of curly braces,
13818 and any blocks used for the base and member initializers of a C++
13819 constructor function. */
13820 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
13822 /* Emit a DW_TAG_variable DIE for a named return value. */
13823 if (DECL_NAME (DECL_RESULT (decl)))
13824 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
13826 current_function_has_inlines = 0;
13827 decls_for_scope (outer_scope, subr_die, 0);
13829 #if 0 && defined (MIPS_DEBUGGING_INFO)
13830 if (current_function_has_inlines)
13832 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
13833 if (! comp_unit_has_inlines)
13835 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
13836 comp_unit_has_inlines = 1;
13841 /* Add the calling convention attribute if requested. */
13842 add_calling_convention_attribute (subr_die, decl);
13846 /* Returns a hash value for X (which really is a die_struct). */
13849 common_block_die_table_hash (const void *x)
13851 const_dw_die_ref d = (const_dw_die_ref) x;
13852 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
13855 /* Return nonzero if decl_id and die_parent of die_struct X is the same
13856 as decl_id and die_parent of die_struct Y. */
13859 common_block_die_table_eq (const void *x, const void *y)
13861 const_dw_die_ref d = (const_dw_die_ref) x;
13862 const_dw_die_ref e = (const_dw_die_ref) y;
13863 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
13866 /* Generate a DIE to represent a declared data object.
13867 Either DECL or ORIGIN must be non-null. */
13870 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
13874 tree decl_or_origin = decl ? decl : origin;
13875 dw_die_ref var_die;
13876 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
13877 dw_die_ref origin_die;
13878 int declaration = (DECL_EXTERNAL (decl_or_origin)
13879 /* If DECL is COMDAT and has not actually been
13880 emitted, we cannot take its address; there
13881 might end up being no definition anywhere in
13882 the program. For example, consider the C++
13886 struct S { static const int i = 7; };
13891 int f() { return S<int>::i; }
13893 Here, S<int>::i is not DECL_EXTERNAL, but no
13894 definition is required, so the compiler will
13895 not emit a definition. */
13896 || (TREE_CODE (decl_or_origin) == VAR_DECL
13897 && DECL_COMDAT (decl_or_origin)
13898 && !TREE_ASM_WRITTEN (decl_or_origin))
13899 || class_or_namespace_scope_p (context_die));
13902 origin = decl_ultimate_origin (decl);
13904 com_decl = fortran_common (decl_or_origin, &off);
13906 /* Symbol in common gets emitted as a child of the common block, in the form
13907 of a data member. */
13911 dw_die_ref com_die;
13912 dw_loc_descr_ref loc;
13913 die_node com_die_arg;
13915 var_die = lookup_decl_die (decl_or_origin);
13918 if (get_AT (var_die, DW_AT_location) == NULL)
13920 loc = loc_descriptor_from_tree (com_decl);
13925 /* Optimize the common case. */
13926 if (loc->dw_loc_opc == DW_OP_addr
13927 && loc->dw_loc_next == NULL
13928 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr)
13930 loc->dw_loc_oprnd1.v.val_addr
13931 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
13933 add_loc_descr (&loc,
13934 new_loc_descr (DW_OP_plus_uconst,
13937 add_AT_loc (var_die, DW_AT_location, loc);
13938 remove_AT (var_die, DW_AT_declaration);
13944 if (common_block_die_table == NULL)
13945 common_block_die_table
13946 = htab_create_ggc (10, common_block_die_table_hash,
13947 common_block_die_table_eq, NULL);
13949 field = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
13950 com_die_arg.decl_id = DECL_UID (com_decl);
13951 com_die_arg.die_parent = context_die;
13952 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
13953 loc = loc_descriptor_from_tree (com_decl);
13954 if (com_die == NULL)
13957 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
13960 com_die = new_die (DW_TAG_common_block, context_die, decl);
13961 add_name_and_src_coords_attributes (com_die, com_decl);
13964 add_AT_loc (com_die, DW_AT_location, loc);
13965 /* Avoid sharing the same loc descriptor between
13966 DW_TAG_common_block and DW_TAG_variable. */
13967 loc = loc_descriptor_from_tree (com_decl);
13969 else if (DECL_EXTERNAL (decl))
13970 add_AT_flag (com_die, DW_AT_declaration, 1);
13971 add_pubname_string (cnam, com_die); /* ??? needed? */
13972 com_die->decl_id = DECL_UID (com_decl);
13973 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
13974 *slot = (void *) com_die;
13976 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
13978 add_AT_loc (com_die, DW_AT_location, loc);
13979 loc = loc_descriptor_from_tree (com_decl);
13980 remove_AT (com_die, DW_AT_declaration);
13982 var_die = new_die (DW_TAG_variable, com_die, decl);
13983 add_name_and_src_coords_attributes (var_die, decl);
13984 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
13985 TREE_THIS_VOLATILE (decl), context_die);
13986 add_AT_flag (var_die, DW_AT_external, 1);
13991 /* Optimize the common case. */
13992 if (loc->dw_loc_opc == DW_OP_addr
13993 && loc->dw_loc_next == NULL
13994 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
13995 loc->dw_loc_oprnd1.v.val_addr
13996 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
13998 add_loc_descr (&loc, new_loc_descr (DW_OP_plus_uconst,
14001 add_AT_loc (var_die, DW_AT_location, loc);
14003 else if (DECL_EXTERNAL (decl))
14004 add_AT_flag (var_die, DW_AT_declaration, 1);
14005 equate_decl_number_to_die (decl, var_die);
14009 /* If the compiler emitted a definition for the DECL declaration
14010 and if we already emitted a DIE for it, don't emit a second
14011 DIE for it again. */
14014 && old_die->die_parent == context_die)
14017 /* For static data members, the declaration in the class is supposed
14018 to have DW_TAG_member tag; the specification should still be
14019 DW_TAG_variable referencing the DW_TAG_member DIE. */
14020 if (declaration && class_scope_p (context_die))
14021 var_die = new_die (DW_TAG_member, context_die, decl);
14023 var_die = new_die (DW_TAG_variable, context_die, decl);
14026 if (origin != NULL)
14027 origin_die = add_abstract_origin_attribute (var_die, origin);
14029 /* Loop unrolling can create multiple blocks that refer to the same
14030 static variable, so we must test for the DW_AT_declaration flag.
14032 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
14033 copy decls and set the DECL_ABSTRACT flag on them instead of
14036 ??? Duplicated blocks have been rewritten to use .debug_ranges.
14038 ??? The declare_in_namespace support causes us to get two DIEs for one
14039 variable, both of which are declarations. We want to avoid considering
14040 one to be a specification, so we must test that this DIE is not a
14042 else if (old_die && TREE_STATIC (decl) && ! declaration
14043 && get_AT_flag (old_die, DW_AT_declaration) == 1)
14045 /* This is a definition of a C++ class level static. */
14046 add_AT_specification (var_die, old_die);
14047 if (DECL_NAME (decl))
14049 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
14050 struct dwarf_file_data * file_index = lookup_filename (s.file);
14052 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
14053 add_AT_file (var_die, DW_AT_decl_file, file_index);
14055 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
14056 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
14061 tree type = TREE_TYPE (decl);
14063 add_name_and_src_coords_attributes (var_die, decl);
14064 if ((TREE_CODE (decl) == PARM_DECL
14065 || TREE_CODE (decl) == RESULT_DECL)
14066 && DECL_BY_REFERENCE (decl))
14067 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
14069 add_type_attribute (var_die, type, TREE_READONLY (decl),
14070 TREE_THIS_VOLATILE (decl), context_die);
14072 if (TREE_PUBLIC (decl))
14073 add_AT_flag (var_die, DW_AT_external, 1);
14075 if (DECL_ARTIFICIAL (decl))
14076 add_AT_flag (var_die, DW_AT_artificial, 1);
14078 if (TREE_PROTECTED (decl))
14079 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
14080 else if (TREE_PRIVATE (decl))
14081 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
14085 add_AT_flag (var_die, DW_AT_declaration, 1);
14087 if (decl && (DECL_ABSTRACT (decl) || declaration))
14088 equate_decl_number_to_die (decl, var_die);
14091 && (! DECL_ABSTRACT (decl_or_origin)
14092 /* Local static vars are shared between all clones/inlines,
14093 so emit DW_AT_location on the abstract DIE if DECL_RTL is
14095 || (TREE_CODE (decl_or_origin) == VAR_DECL
14096 && TREE_STATIC (decl_or_origin)
14097 && DECL_RTL_SET_P (decl_or_origin)))
14098 /* When abstract origin already has DW_AT_location attribute, no need
14099 to add it again. */
14100 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
14102 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
14103 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
14104 defer_location (decl_or_origin, var_die);
14106 add_location_or_const_value_attribute (var_die,
14109 add_pubname (decl_or_origin, var_die);
14112 tree_add_const_value_attribute (var_die, decl_or_origin);
14115 /* Generate a DIE to represent a named constant. */
14118 gen_const_die (tree decl, dw_die_ref context_die)
14120 dw_die_ref const_die;
14121 tree type = TREE_TYPE (decl);
14123 const_die = new_die (DW_TAG_constant, context_die, decl);
14124 add_name_and_src_coords_attributes (const_die, decl);
14125 add_type_attribute (const_die, type, 1, 0, context_die);
14126 if (TREE_PUBLIC (decl))
14127 add_AT_flag (const_die, DW_AT_external, 1);
14128 if (DECL_ARTIFICIAL (decl))
14129 add_AT_flag (const_die, DW_AT_artificial, 1);
14130 tree_add_const_value_attribute (const_die, decl);
14133 /* Generate a DIE to represent a label identifier. */
14136 gen_label_die (tree decl, dw_die_ref context_die)
14138 tree origin = decl_ultimate_origin (decl);
14139 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
14141 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14143 if (origin != NULL)
14144 add_abstract_origin_attribute (lbl_die, origin);
14146 add_name_and_src_coords_attributes (lbl_die, decl);
14148 if (DECL_ABSTRACT (decl))
14149 equate_decl_number_to_die (decl, lbl_die);
14152 insn = DECL_RTL_IF_SET (decl);
14154 /* Deleted labels are programmer specified labels which have been
14155 eliminated because of various optimizations. We still emit them
14156 here so that it is possible to put breakpoints on them. */
14160 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
14162 /* When optimization is enabled (via -O) some parts of the compiler
14163 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
14164 represent source-level labels which were explicitly declared by
14165 the user. This really shouldn't be happening though, so catch
14166 it if it ever does happen. */
14167 gcc_assert (!INSN_DELETED_P (insn));
14169 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
14170 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
14175 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
14176 attributes to the DIE for a block STMT, to describe where the inlined
14177 function was called from. This is similar to add_src_coords_attributes. */
14180 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
14182 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
14184 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
14185 add_AT_unsigned (die, DW_AT_call_line, s.line);
14189 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
14190 Add low_pc and high_pc attributes to the DIE for a block STMT. */
14193 add_high_low_attributes (tree stmt, dw_die_ref die)
14195 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14197 if (BLOCK_FRAGMENT_CHAIN (stmt))
14201 if (inlined_function_outer_scope_p (stmt))
14203 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14204 BLOCK_NUMBER (stmt));
14205 add_AT_lbl_id (die, DW_AT_entry_pc, label);
14208 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
14210 chain = BLOCK_FRAGMENT_CHAIN (stmt);
14213 add_ranges (chain);
14214 chain = BLOCK_FRAGMENT_CHAIN (chain);
14221 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14222 BLOCK_NUMBER (stmt));
14223 add_AT_lbl_id (die, DW_AT_low_pc, label);
14224 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
14225 BLOCK_NUMBER (stmt));
14226 add_AT_lbl_id (die, DW_AT_high_pc, label);
14230 /* Generate a DIE for a lexical block. */
14233 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
14235 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
14237 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
14238 add_high_low_attributes (stmt, stmt_die);
14240 decls_for_scope (stmt, stmt_die, depth);
14243 /* Generate a DIE for an inlined subprogram. */
14246 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
14248 tree decl = block_ultimate_origin (stmt);
14250 /* Emit info for the abstract instance first, if we haven't yet. We
14251 must emit this even if the block is abstract, otherwise when we
14252 emit the block below (or elsewhere), we may end up trying to emit
14253 a die whose origin die hasn't been emitted, and crashing. */
14254 dwarf2out_abstract_function (decl);
14256 if (! BLOCK_ABSTRACT (stmt))
14258 dw_die_ref subr_die
14259 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
14261 add_abstract_origin_attribute (subr_die, decl);
14262 if (TREE_ASM_WRITTEN (stmt))
14263 add_high_low_attributes (stmt, subr_die);
14264 add_call_src_coords_attributes (stmt, subr_die);
14266 decls_for_scope (stmt, subr_die, depth);
14267 current_function_has_inlines = 1;
14270 /* We may get here if we're the outer block of function A that was
14271 inlined into function B that was inlined into function C. When
14272 generating debugging info for C, dwarf2out_abstract_function(B)
14273 would mark all inlined blocks as abstract, including this one.
14274 So, we wouldn't (and shouldn't) expect labels to be generated
14275 for this one. Instead, just emit debugging info for
14276 declarations within the block. This is particularly important
14277 in the case of initializers of arguments passed from B to us:
14278 if they're statement expressions containing declarations, we
14279 wouldn't generate dies for their abstract variables, and then,
14280 when generating dies for the real variables, we'd die (pun
14282 gen_lexical_block_die (stmt, context_die, depth);
14285 /* Generate a DIE for a field in a record, or structure. */
14288 gen_field_die (tree decl, dw_die_ref context_die)
14290 dw_die_ref decl_die;
14292 if (TREE_TYPE (decl) == error_mark_node)
14295 decl_die = new_die (DW_TAG_member, context_die, decl);
14296 add_name_and_src_coords_attributes (decl_die, decl);
14297 add_type_attribute (decl_die, member_declared_type (decl),
14298 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
14301 if (DECL_BIT_FIELD_TYPE (decl))
14303 add_byte_size_attribute (decl_die, decl);
14304 add_bit_size_attribute (decl_die, decl);
14305 add_bit_offset_attribute (decl_die, decl);
14308 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
14309 add_data_member_location_attribute (decl_die, decl);
14311 if (DECL_ARTIFICIAL (decl))
14312 add_AT_flag (decl_die, DW_AT_artificial, 1);
14314 if (TREE_PROTECTED (decl))
14315 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
14316 else if (TREE_PRIVATE (decl))
14317 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
14319 /* Equate decl number to die, so that we can look up this decl later on. */
14320 equate_decl_number_to_die (decl, decl_die);
14324 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14325 Use modified_type_die instead.
14326 We keep this code here just in case these types of DIEs may be needed to
14327 represent certain things in other languages (e.g. Pascal) someday. */
14330 gen_pointer_type_die (tree type, dw_die_ref context_die)
14333 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
14335 equate_type_number_to_die (type, ptr_die);
14336 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14337 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14340 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14341 Use modified_type_die instead.
14342 We keep this code here just in case these types of DIEs may be needed to
14343 represent certain things in other languages (e.g. Pascal) someday. */
14346 gen_reference_type_die (tree type, dw_die_ref context_die)
14349 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
14351 equate_type_number_to_die (type, ref_die);
14352 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
14353 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14357 /* Generate a DIE for a pointer to a member type. */
14360 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
14363 = new_die (DW_TAG_ptr_to_member_type,
14364 scope_die_for (type, context_die), type);
14366 equate_type_number_to_die (type, ptr_die);
14367 add_AT_die_ref (ptr_die, DW_AT_containing_type,
14368 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
14369 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14372 /* Generate the DIE for the compilation unit. */
14375 gen_compile_unit_die (const char *filename)
14378 char producer[250];
14379 const char *language_string = lang_hooks.name;
14382 die = new_die (DW_TAG_compile_unit, NULL, NULL);
14386 add_name_attribute (die, filename);
14387 /* Don't add cwd for <built-in>. */
14388 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
14389 add_comp_dir_attribute (die);
14392 sprintf (producer, "%s %s", language_string, version_string);
14394 #ifdef MIPS_DEBUGGING_INFO
14395 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
14396 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
14397 not appear in the producer string, the debugger reaches the conclusion
14398 that the object file is stripped and has no debugging information.
14399 To get the MIPS/SGI debugger to believe that there is debugging
14400 information in the object file, we add a -g to the producer string. */
14401 if (debug_info_level > DINFO_LEVEL_TERSE)
14402 strcat (producer, " -g");
14405 add_AT_string (die, DW_AT_producer, producer);
14407 if (strcmp (language_string, "GNU C++") == 0)
14408 language = DW_LANG_C_plus_plus;
14409 else if (strcmp (language_string, "GNU Ada") == 0)
14410 language = DW_LANG_Ada95;
14411 else if (strcmp (language_string, "GNU F77") == 0)
14412 language = DW_LANG_Fortran77;
14413 else if (strcmp (language_string, "GNU Fortran") == 0)
14414 language = DW_LANG_Fortran95;
14415 else if (strcmp (language_string, "GNU Pascal") == 0)
14416 language = DW_LANG_Pascal83;
14417 else if (strcmp (language_string, "GNU Java") == 0)
14418 language = DW_LANG_Java;
14419 else if (strcmp (language_string, "GNU Objective-C") == 0)
14420 language = DW_LANG_ObjC;
14421 else if (strcmp (language_string, "GNU Objective-C++") == 0)
14422 language = DW_LANG_ObjC_plus_plus;
14424 language = DW_LANG_C89;
14426 add_AT_unsigned (die, DW_AT_language, language);
14430 /* Generate the DIE for a base class. */
14433 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
14435 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
14437 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
14438 add_data_member_location_attribute (die, binfo);
14440 if (BINFO_VIRTUAL_P (binfo))
14441 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
14443 if (access == access_public_node)
14444 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
14445 else if (access == access_protected_node)
14446 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
14449 /* Generate a DIE for a class member. */
14452 gen_member_die (tree type, dw_die_ref context_die)
14455 tree binfo = TYPE_BINFO (type);
14458 /* If this is not an incomplete type, output descriptions of each of its
14459 members. Note that as we output the DIEs necessary to represent the
14460 members of this record or union type, we will also be trying to output
14461 DIEs to represent the *types* of those members. However the `type'
14462 function (above) will specifically avoid generating type DIEs for member
14463 types *within* the list of member DIEs for this (containing) type except
14464 for those types (of members) which are explicitly marked as also being
14465 members of this (containing) type themselves. The g++ front- end can
14466 force any given type to be treated as a member of some other (containing)
14467 type by setting the TYPE_CONTEXT of the given (member) type to point to
14468 the TREE node representing the appropriate (containing) type. */
14470 /* First output info about the base classes. */
14473 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
14477 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
14478 gen_inheritance_die (base,
14479 (accesses ? VEC_index (tree, accesses, i)
14480 : access_public_node), context_die);
14483 /* Now output info about the data members and type members. */
14484 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
14486 /* If we thought we were generating minimal debug info for TYPE
14487 and then changed our minds, some of the member declarations
14488 may have already been defined. Don't define them again, but
14489 do put them in the right order. */
14491 child = lookup_decl_die (member);
14493 splice_child_die (context_die, child);
14495 gen_decl_die (member, NULL, context_die);
14498 /* Now output info about the function members (if any). */
14499 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
14501 /* Don't include clones in the member list. */
14502 if (DECL_ABSTRACT_ORIGIN (member))
14505 child = lookup_decl_die (member);
14507 splice_child_die (context_die, child);
14509 gen_decl_die (member, NULL, context_die);
14513 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
14514 is set, we pretend that the type was never defined, so we only get the
14515 member DIEs needed by later specification DIEs. */
14518 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
14519 enum debug_info_usage usage)
14521 dw_die_ref type_die = lookup_type_die (type);
14522 dw_die_ref scope_die = 0;
14524 int complete = (TYPE_SIZE (type)
14525 && (! TYPE_STUB_DECL (type)
14526 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
14527 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
14528 complete = complete && should_emit_struct_debug (type, usage);
14530 if (type_die && ! complete)
14533 if (TYPE_CONTEXT (type) != NULL_TREE
14534 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14535 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
14538 scope_die = scope_die_for (type, context_die);
14540 if (! type_die || (nested && scope_die == comp_unit_die))
14541 /* First occurrence of type or toplevel definition of nested class. */
14543 dw_die_ref old_die = type_die;
14545 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
14546 ? record_type_tag (type) : DW_TAG_union_type,
14548 equate_type_number_to_die (type, type_die);
14550 add_AT_specification (type_die, old_die);
14552 add_name_attribute (type_die, type_tag (type));
14555 remove_AT (type_die, DW_AT_declaration);
14557 /* If this type has been completed, then give it a byte_size attribute and
14558 then give a list of members. */
14559 if (complete && !ns_decl)
14561 /* Prevent infinite recursion in cases where the type of some member of
14562 this type is expressed in terms of this type itself. */
14563 TREE_ASM_WRITTEN (type) = 1;
14564 add_byte_size_attribute (type_die, type);
14565 if (TYPE_STUB_DECL (type) != NULL_TREE)
14566 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
14568 /* If the first reference to this type was as the return type of an
14569 inline function, then it may not have a parent. Fix this now. */
14570 if (type_die->die_parent == NULL)
14571 add_child_die (scope_die, type_die);
14573 push_decl_scope (type);
14574 gen_member_die (type, type_die);
14577 /* GNU extension: Record what type our vtable lives in. */
14578 if (TYPE_VFIELD (type))
14580 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
14582 gen_type_die (vtype, context_die);
14583 add_AT_die_ref (type_die, DW_AT_containing_type,
14584 lookup_type_die (vtype));
14589 add_AT_flag (type_die, DW_AT_declaration, 1);
14591 /* We don't need to do this for function-local types. */
14592 if (TYPE_STUB_DECL (type)
14593 && ! decl_function_context (TYPE_STUB_DECL (type)))
14594 VEC_safe_push (tree, gc, incomplete_types, type);
14597 if (get_AT (type_die, DW_AT_name))
14598 add_pubtype (type, type_die);
14601 /* Generate a DIE for a subroutine _type_. */
14604 gen_subroutine_type_die (tree type, dw_die_ref context_die)
14606 tree return_type = TREE_TYPE (type);
14607 dw_die_ref subr_die
14608 = new_die (DW_TAG_subroutine_type,
14609 scope_die_for (type, context_die), type);
14611 equate_type_number_to_die (type, subr_die);
14612 add_prototyped_attribute (subr_die, type);
14613 add_type_attribute (subr_die, return_type, 0, 0, context_die);
14614 gen_formal_types_die (type, subr_die);
14616 if (get_AT (subr_die, DW_AT_name))
14617 add_pubtype (type, subr_die);
14620 /* Generate a DIE for a type definition. */
14623 gen_typedef_die (tree decl, dw_die_ref context_die)
14625 dw_die_ref type_die;
14628 if (TREE_ASM_WRITTEN (decl))
14631 TREE_ASM_WRITTEN (decl) = 1;
14632 type_die = new_die (DW_TAG_typedef, context_die, decl);
14633 origin = decl_ultimate_origin (decl);
14634 if (origin != NULL)
14635 add_abstract_origin_attribute (type_die, origin);
14640 add_name_and_src_coords_attributes (type_die, decl);
14641 if (DECL_ORIGINAL_TYPE (decl))
14643 type = DECL_ORIGINAL_TYPE (decl);
14645 gcc_assert (type != TREE_TYPE (decl));
14646 equate_type_number_to_die (TREE_TYPE (decl), type_die);
14649 type = TREE_TYPE (decl);
14651 add_type_attribute (type_die, type, TREE_READONLY (decl),
14652 TREE_THIS_VOLATILE (decl), context_die);
14655 if (DECL_ABSTRACT (decl))
14656 equate_decl_number_to_die (decl, type_die);
14658 if (get_AT (type_die, DW_AT_name))
14659 add_pubtype (decl, type_die);
14662 /* Generate a type description DIE. */
14665 gen_type_die_with_usage (tree type, dw_die_ref context_die,
14666 enum debug_info_usage usage)
14669 struct array_descr_info info;
14671 if (type == NULL_TREE || type == error_mark_node)
14674 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
14675 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
14677 if (TREE_ASM_WRITTEN (type))
14680 /* Prevent broken recursion; we can't hand off to the same type. */
14681 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
14683 TREE_ASM_WRITTEN (type) = 1;
14684 gen_decl_die (TYPE_NAME (type), NULL, context_die);
14688 /* If this is an array type with hidden descriptor, handle it first. */
14689 if (!TREE_ASM_WRITTEN (type)
14690 && lang_hooks.types.get_array_descr_info
14691 && lang_hooks.types.get_array_descr_info (type, &info))
14693 gen_descr_array_type_die (type, &info, context_die);
14694 TREE_ASM_WRITTEN (type) = 1;
14698 /* We are going to output a DIE to represent the unqualified version
14699 of this type (i.e. without any const or volatile qualifiers) so
14700 get the main variant (i.e. the unqualified version) of this type
14701 now. (Vectors are special because the debugging info is in the
14702 cloned type itself). */
14703 if (TREE_CODE (type) != VECTOR_TYPE)
14704 type = type_main_variant (type);
14706 if (TREE_ASM_WRITTEN (type))
14709 switch (TREE_CODE (type))
14715 case REFERENCE_TYPE:
14716 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
14717 ensures that the gen_type_die recursion will terminate even if the
14718 type is recursive. Recursive types are possible in Ada. */
14719 /* ??? We could perhaps do this for all types before the switch
14721 TREE_ASM_WRITTEN (type) = 1;
14723 /* For these types, all that is required is that we output a DIE (or a
14724 set of DIEs) to represent the "basis" type. */
14725 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14726 DINFO_USAGE_IND_USE);
14730 /* This code is used for C++ pointer-to-data-member types.
14731 Output a description of the relevant class type. */
14732 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
14733 DINFO_USAGE_IND_USE);
14735 /* Output a description of the type of the object pointed to. */
14736 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14737 DINFO_USAGE_IND_USE);
14739 /* Now output a DIE to represent this pointer-to-data-member type
14741 gen_ptr_to_mbr_type_die (type, context_die);
14744 case FUNCTION_TYPE:
14745 /* Force out return type (in case it wasn't forced out already). */
14746 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14747 DINFO_USAGE_DIR_USE);
14748 gen_subroutine_type_die (type, context_die);
14752 /* Force out return type (in case it wasn't forced out already). */
14753 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14754 DINFO_USAGE_DIR_USE);
14755 gen_subroutine_type_die (type, context_die);
14759 gen_array_type_die (type, context_die);
14763 gen_array_type_die (type, context_die);
14766 case ENUMERAL_TYPE:
14769 case QUAL_UNION_TYPE:
14770 /* If this is a nested type whose containing class hasn't been written
14771 out yet, writing it out will cover this one, too. This does not apply
14772 to instantiations of member class templates; they need to be added to
14773 the containing class as they are generated. FIXME: This hurts the
14774 idea of combining type decls from multiple TUs, since we can't predict
14775 what set of template instantiations we'll get. */
14776 if (TYPE_CONTEXT (type)
14777 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14778 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
14780 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
14782 if (TREE_ASM_WRITTEN (type))
14785 /* If that failed, attach ourselves to the stub. */
14786 push_decl_scope (TYPE_CONTEXT (type));
14787 context_die = lookup_type_die (TYPE_CONTEXT (type));
14792 context_die = declare_in_namespace (type, context_die);
14796 if (TREE_CODE (type) == ENUMERAL_TYPE)
14798 /* This might have been written out by the call to
14799 declare_in_namespace. */
14800 if (!TREE_ASM_WRITTEN (type))
14801 gen_enumeration_type_die (type, context_die);
14804 gen_struct_or_union_type_die (type, context_die, usage);
14809 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
14810 it up if it is ever completed. gen_*_type_die will set it for us
14811 when appropriate. */
14817 case FIXED_POINT_TYPE:
14820 /* No DIEs needed for fundamental types. */
14824 /* No Dwarf representation currently defined. */
14828 gcc_unreachable ();
14831 TREE_ASM_WRITTEN (type) = 1;
14835 gen_type_die (tree type, dw_die_ref context_die)
14837 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
14840 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
14841 things which are local to the given block. */
14844 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
14846 int must_output_die = 0;
14849 /* Ignore blocks that are NULL. */
14850 if (stmt == NULL_TREE)
14853 inlined_func = inlined_function_outer_scope_p (stmt);
14855 /* If the block is one fragment of a non-contiguous block, do not
14856 process the variables, since they will have been done by the
14857 origin block. Do process subblocks. */
14858 if (BLOCK_FRAGMENT_ORIGIN (stmt))
14862 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
14863 gen_block_die (sub, context_die, depth + 1);
14868 /* Determine if we need to output any Dwarf DIEs at all to represent this
14871 /* The outer scopes for inlinings *must* always be represented. We
14872 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
14873 must_output_die = 1;
14876 /* Determine if this block directly contains any "significant"
14877 local declarations which we will need to output DIEs for. */
14878 if (debug_info_level > DINFO_LEVEL_TERSE)
14879 /* We are not in terse mode so *any* local declaration counts
14880 as being a "significant" one. */
14881 must_output_die = ((BLOCK_VARS (stmt) != NULL
14882 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
14883 && (TREE_USED (stmt)
14884 || TREE_ASM_WRITTEN (stmt)
14885 || BLOCK_ABSTRACT (stmt)));
14886 else if ((TREE_USED (stmt)
14887 || TREE_ASM_WRITTEN (stmt)
14888 || BLOCK_ABSTRACT (stmt))
14889 && !dwarf2out_ignore_block (stmt))
14890 must_output_die = 1;
14893 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
14894 DIE for any block which contains no significant local declarations at
14895 all. Rather, in such cases we just call `decls_for_scope' so that any
14896 needed Dwarf info for any sub-blocks will get properly generated. Note
14897 that in terse mode, our definition of what constitutes a "significant"
14898 local declaration gets restricted to include only inlined function
14899 instances and local (nested) function definitions. */
14900 if (must_output_die)
14903 gen_inlined_subroutine_die (stmt, context_die, depth);
14905 gen_lexical_block_die (stmt, context_die, depth);
14908 decls_for_scope (stmt, context_die, depth);
14911 /* Process variable DECL (or variable with origin ORIGIN) within
14912 block STMT and add it to CONTEXT_DIE. */
14914 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
14917 tree decl_or_origin = decl ? decl : origin;
14918 tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
14920 if (ultimate_origin)
14921 origin = ultimate_origin;
14923 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
14924 die = lookup_decl_die (decl_or_origin);
14925 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
14926 && TYPE_DECL_IS_STUB (decl_or_origin))
14927 die = lookup_type_die (TREE_TYPE (decl_or_origin));
14931 if (die != NULL && die->die_parent == NULL)
14932 add_child_die (context_die, die);
14933 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
14934 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
14935 stmt, context_die);
14937 gen_decl_die (decl, origin, context_die);
14940 /* Generate all of the decls declared within a given scope and (recursively)
14941 all of its sub-blocks. */
14944 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
14950 /* Ignore NULL blocks. */
14951 if (stmt == NULL_TREE)
14954 /* Output the DIEs to represent all of the data objects and typedefs
14955 declared directly within this block but not within any nested
14956 sub-blocks. Also, nested function and tag DIEs have been
14957 generated with a parent of NULL; fix that up now. */
14958 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
14959 process_scope_var (stmt, decl, NULL_TREE, context_die);
14960 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
14961 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
14964 /* If we're at -g1, we're not interested in subblocks. */
14965 if (debug_info_level <= DINFO_LEVEL_TERSE)
14968 /* Output the DIEs to represent all sub-blocks (and the items declared
14969 therein) of this block. */
14970 for (subblocks = BLOCK_SUBBLOCKS (stmt);
14972 subblocks = BLOCK_CHAIN (subblocks))
14973 gen_block_die (subblocks, context_die, depth + 1);
14976 /* Is this a typedef we can avoid emitting? */
14979 is_redundant_typedef (const_tree decl)
14981 if (TYPE_DECL_IS_STUB (decl))
14984 if (DECL_ARTIFICIAL (decl)
14985 && DECL_CONTEXT (decl)
14986 && is_tagged_type (DECL_CONTEXT (decl))
14987 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
14988 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
14989 /* Also ignore the artificial member typedef for the class name. */
14995 /* Returns the DIE for a context. */
14997 static inline dw_die_ref
14998 get_context_die (tree context)
15002 /* Find die that represents this context. */
15003 if (TYPE_P (context))
15004 return force_type_die (context);
15006 return force_decl_die (context);
15008 return comp_unit_die;
15011 /* Returns the DIE for decl. A DIE will always be returned. */
15014 force_decl_die (tree decl)
15016 dw_die_ref decl_die;
15017 unsigned saved_external_flag;
15018 tree save_fn = NULL_TREE;
15019 decl_die = lookup_decl_die (decl);
15022 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
15024 decl_die = lookup_decl_die (decl);
15028 switch (TREE_CODE (decl))
15030 case FUNCTION_DECL:
15031 /* Clear current_function_decl, so that gen_subprogram_die thinks
15032 that this is a declaration. At this point, we just want to force
15033 declaration die. */
15034 save_fn = current_function_decl;
15035 current_function_decl = NULL_TREE;
15036 gen_subprogram_die (decl, context_die);
15037 current_function_decl = save_fn;
15041 /* Set external flag to force declaration die. Restore it after
15042 gen_decl_die() call. */
15043 saved_external_flag = DECL_EXTERNAL (decl);
15044 DECL_EXTERNAL (decl) = 1;
15045 gen_decl_die (decl, NULL, context_die);
15046 DECL_EXTERNAL (decl) = saved_external_flag;
15049 case NAMESPACE_DECL:
15050 dwarf2out_decl (decl);
15054 gcc_unreachable ();
15057 /* We should be able to find the DIE now. */
15059 decl_die = lookup_decl_die (decl);
15060 gcc_assert (decl_die);
15066 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
15067 always returned. */
15070 force_type_die (tree type)
15072 dw_die_ref type_die;
15074 type_die = lookup_type_die (type);
15077 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
15079 type_die = modified_type_die (type, TYPE_READONLY (type),
15080 TYPE_VOLATILE (type), context_die);
15081 gcc_assert (type_die);
15086 /* Force out any required namespaces to be able to output DECL,
15087 and return the new context_die for it, if it's changed. */
15090 setup_namespace_context (tree thing, dw_die_ref context_die)
15092 tree context = (DECL_P (thing)
15093 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
15094 if (context && TREE_CODE (context) == NAMESPACE_DECL)
15095 /* Force out the namespace. */
15096 context_die = force_decl_die (context);
15098 return context_die;
15101 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
15102 type) within its namespace, if appropriate.
15104 For compatibility with older debuggers, namespace DIEs only contain
15105 declarations; all definitions are emitted at CU scope. */
15108 declare_in_namespace (tree thing, dw_die_ref context_die)
15110 dw_die_ref ns_context;
15112 if (debug_info_level <= DINFO_LEVEL_TERSE)
15113 return context_die;
15115 /* If this decl is from an inlined function, then don't try to emit it in its
15116 namespace, as we will get confused. It would have already been emitted
15117 when the abstract instance of the inline function was emitted anyways. */
15118 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
15119 return context_die;
15121 ns_context = setup_namespace_context (thing, context_die);
15123 if (ns_context != context_die)
15127 if (DECL_P (thing))
15128 gen_decl_die (thing, NULL, ns_context);
15130 gen_type_die (thing, ns_context);
15132 return context_die;
15135 /* Generate a DIE for a namespace or namespace alias. */
15138 gen_namespace_die (tree decl, dw_die_ref context_die)
15140 dw_die_ref namespace_die;
15142 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
15143 they are an alias of. */
15144 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
15146 /* Output a real namespace or module. */
15147 context_die = setup_namespace_context (decl, comp_unit_die);
15148 namespace_die = new_die (is_fortran ()
15149 ? DW_TAG_module : DW_TAG_namespace,
15150 context_die, decl);
15151 /* For Fortran modules defined in different CU don't add src coords. */
15152 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
15153 add_name_attribute (namespace_die, dwarf2_name (decl, 0));
15155 add_name_and_src_coords_attributes (namespace_die, decl);
15156 if (DECL_EXTERNAL (decl))
15157 add_AT_flag (namespace_die, DW_AT_declaration, 1);
15158 equate_decl_number_to_die (decl, namespace_die);
15162 /* Output a namespace alias. */
15164 /* Force out the namespace we are an alias of, if necessary. */
15165 dw_die_ref origin_die
15166 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
15168 if (DECL_CONTEXT (decl) == NULL_TREE
15169 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
15170 context_die = setup_namespace_context (decl, comp_unit_die);
15171 /* Now create the namespace alias DIE. */
15172 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
15173 add_name_and_src_coords_attributes (namespace_die, decl);
15174 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
15175 equate_decl_number_to_die (decl, namespace_die);
15179 /* Generate Dwarf debug information for a decl described by DECL. */
15182 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
15184 tree decl_or_origin = decl ? decl : origin;
15185 tree class_origin = NULL;
15187 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
15190 switch (TREE_CODE (decl_or_origin))
15196 if (!is_fortran ())
15198 /* The individual enumerators of an enum type get output when we output
15199 the Dwarf representation of the relevant enum type itself. */
15203 /* Emit its type. */
15204 gen_type_die (TREE_TYPE (decl), context_die);
15206 /* And its containing namespace. */
15207 context_die = declare_in_namespace (decl, context_die);
15209 gen_const_die (decl, context_die);
15212 case FUNCTION_DECL:
15213 /* Don't output any DIEs to represent mere function declarations,
15214 unless they are class members or explicit block externs. */
15215 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
15216 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
15217 && (current_function_decl == NULL_TREE
15218 || DECL_ARTIFICIAL (decl_or_origin)))
15223 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
15224 on local redeclarations of global functions. That seems broken. */
15225 if (current_function_decl != decl)
15226 /* This is only a declaration. */;
15229 /* If we're emitting a clone, emit info for the abstract instance. */
15230 if (origin || DECL_ORIGIN (decl) != decl)
15231 dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
15233 /* If we're emitting an out-of-line copy of an inline function,
15234 emit info for the abstract instance and set up to refer to it. */
15235 else if (cgraph_function_possibly_inlined_p (decl)
15236 && ! DECL_ABSTRACT (decl)
15237 && ! class_or_namespace_scope_p (context_die)
15238 /* dwarf2out_abstract_function won't emit a die if this is just
15239 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
15240 that case, because that works only if we have a die. */
15241 && DECL_INITIAL (decl) != NULL_TREE)
15243 dwarf2out_abstract_function (decl);
15244 set_decl_origin_self (decl);
15247 /* Otherwise we're emitting the primary DIE for this decl. */
15248 else if (debug_info_level > DINFO_LEVEL_TERSE)
15250 /* Before we describe the FUNCTION_DECL itself, make sure that we
15251 have described its return type. */
15252 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
15254 /* And its virtual context. */
15255 if (DECL_VINDEX (decl) != NULL_TREE)
15256 gen_type_die (DECL_CONTEXT (decl), context_die);
15258 /* And its containing type. */
15260 origin = decl_class_context (decl);
15261 if (origin != NULL_TREE)
15262 gen_type_die_for_member (origin, decl, context_die);
15264 /* And its containing namespace. */
15265 context_die = declare_in_namespace (decl, context_die);
15268 /* Now output a DIE to represent the function itself. */
15270 gen_subprogram_die (decl, context_die);
15274 /* If we are in terse mode, don't generate any DIEs to represent any
15275 actual typedefs. */
15276 if (debug_info_level <= DINFO_LEVEL_TERSE)
15279 /* In the special case of a TYPE_DECL node representing the declaration
15280 of some type tag, if the given TYPE_DECL is marked as having been
15281 instantiated from some other (original) TYPE_DECL node (e.g. one which
15282 was generated within the original definition of an inline function) we
15283 used to generate a special (abbreviated) DW_TAG_structure_type,
15284 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
15285 should be actually referencing those DIEs, as variable DIEs with that
15286 type would be emitted already in the abstract origin, so it was always
15287 removed during unused type prunning. Don't add anything in this
15289 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
15292 if (is_redundant_typedef (decl))
15293 gen_type_die (TREE_TYPE (decl), context_die);
15295 /* Output a DIE to represent the typedef itself. */
15296 gen_typedef_die (decl, context_die);
15300 if (debug_info_level >= DINFO_LEVEL_NORMAL)
15301 gen_label_die (decl, context_die);
15306 /* If we are in terse mode, don't generate any DIEs to represent any
15307 variable declarations or definitions. */
15308 if (debug_info_level <= DINFO_LEVEL_TERSE)
15311 /* Output any DIEs that are needed to specify the type of this data
15313 if (TREE_CODE (decl_or_origin) == RESULT_DECL
15314 && DECL_BY_REFERENCE (decl_or_origin))
15315 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15317 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15319 /* And its containing type. */
15320 class_origin = decl_class_context (decl_or_origin);
15321 if (class_origin != NULL_TREE)
15322 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
15324 /* And its containing namespace. */
15325 context_die = declare_in_namespace (decl_or_origin, context_die);
15327 /* Now output the DIE to represent the data object itself. This gets
15328 complicated because of the possibility that the VAR_DECL really
15329 represents an inlined instance of a formal parameter for an inline
15332 origin = decl_ultimate_origin (decl);
15333 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
15334 gen_formal_parameter_die (decl, origin, context_die);
15336 gen_variable_die (decl, origin, context_die);
15340 /* Ignore the nameless fields that are used to skip bits but handle C++
15341 anonymous unions and structs. */
15342 if (DECL_NAME (decl) != NULL_TREE
15343 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
15344 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
15346 gen_type_die (member_declared_type (decl), context_die);
15347 gen_field_die (decl, context_die);
15352 if (DECL_BY_REFERENCE (decl_or_origin))
15353 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15355 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15356 gen_formal_parameter_die (decl, origin, context_die);
15359 case NAMESPACE_DECL:
15360 case IMPORTED_DECL:
15361 gen_namespace_die (decl, context_die);
15365 /* Probably some frontend-internal decl. Assume we don't care. */
15366 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
15371 /* Output debug information for global decl DECL. Called from toplev.c after
15372 compilation proper has finished. */
15375 dwarf2out_global_decl (tree decl)
15377 /* Output DWARF2 information for file-scope tentative data object
15378 declarations, file-scope (extern) function declarations (which
15379 had no corresponding body) and file-scope tagged type declarations
15380 and definitions which have not yet been forced out. */
15381 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
15382 dwarf2out_decl (decl);
15385 /* Output debug information for type decl DECL. Called from toplev.c
15386 and from language front ends (to record built-in types). */
15388 dwarf2out_type_decl (tree decl, int local)
15391 dwarf2out_decl (decl);
15394 /* Output debug information for imported module or decl DECL.
15395 NAME is non-NULL name in the lexical block if the decl has been renamed.
15396 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
15397 that DECL belongs to.
15398 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
15400 dwarf2out_imported_module_or_decl_1 (tree decl,
15402 tree lexical_block,
15403 dw_die_ref lexical_block_die)
15405 expanded_location xloc;
15406 dw_die_ref imported_die = NULL;
15407 dw_die_ref at_import_die;
15409 if (TREE_CODE (decl) == IMPORTED_DECL)
15411 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
15412 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
15416 xloc = expand_location (input_location);
15418 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
15420 if (is_base_type (TREE_TYPE (decl)))
15421 at_import_die = base_type_die (TREE_TYPE (decl));
15423 at_import_die = force_type_die (TREE_TYPE (decl));
15424 /* For namespace N { typedef void T; } using N::T; base_type_die
15425 returns NULL, but DW_TAG_imported_declaration requires
15426 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
15427 if (!at_import_die)
15429 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
15430 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
15431 at_import_die = lookup_type_die (TREE_TYPE (decl));
15432 gcc_assert (at_import_die);
15437 at_import_die = lookup_decl_die (decl);
15438 if (!at_import_die)
15440 /* If we're trying to avoid duplicate debug info, we may not have
15441 emitted the member decl for this field. Emit it now. */
15442 if (TREE_CODE (decl) == FIELD_DECL)
15444 tree type = DECL_CONTEXT (decl);
15446 if (TYPE_CONTEXT (type)
15447 && TYPE_P (TYPE_CONTEXT (type))
15448 && !should_emit_struct_debug (TYPE_CONTEXT (type),
15449 DINFO_USAGE_DIR_USE))
15451 gen_type_die_for_member (type, decl,
15452 get_context_die (TYPE_CONTEXT (type)));
15454 at_import_die = force_decl_die (decl);
15458 if (TREE_CODE (decl) == NAMESPACE_DECL)
15459 imported_die = new_die (DW_TAG_imported_module,
15463 imported_die = new_die (DW_TAG_imported_declaration,
15467 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
15468 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
15470 add_AT_string (imported_die, DW_AT_name,
15471 IDENTIFIER_POINTER (name));
15472 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
15475 /* Output debug information for imported module or decl DECL.
15476 NAME is non-NULL name in context if the decl has been renamed.
15477 CHILD is true if decl is one of the renamed decls as part of
15478 importing whole module. */
15481 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
15484 /* dw_die_ref at_import_die; */
15485 dw_die_ref scope_die;
15487 if (debug_info_level <= DINFO_LEVEL_TERSE)
15492 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
15493 We need decl DIE for reference and scope die. First, get DIE for the decl
15496 /* Get the scope die for decl context. Use comp_unit_die for global module
15497 or decl. If die is not found for non globals, force new die. */
15499 && TYPE_P (context)
15500 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
15502 scope_die = get_context_die (context);
15506 gcc_assert (scope_die->die_child);
15507 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
15508 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
15509 scope_die = scope_die->die_child;
15512 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
15513 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
15517 /* Write the debugging output for DECL. */
15520 dwarf2out_decl (tree decl)
15522 dw_die_ref context_die = comp_unit_die;
15524 switch (TREE_CODE (decl))
15529 case FUNCTION_DECL:
15530 /* What we would really like to do here is to filter out all mere
15531 file-scope declarations of file-scope functions which are never
15532 referenced later within this translation unit (and keep all of ones
15533 that *are* referenced later on) but we aren't clairvoyant, so we have
15534 no idea which functions will be referenced in the future (i.e. later
15535 on within the current translation unit). So here we just ignore all
15536 file-scope function declarations which are not also definitions. If
15537 and when the debugger needs to know something about these functions,
15538 it will have to hunt around and find the DWARF information associated
15539 with the definition of the function.
15541 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
15542 nodes represent definitions and which ones represent mere
15543 declarations. We have to check DECL_INITIAL instead. That's because
15544 the C front-end supports some weird semantics for "extern inline"
15545 function definitions. These can get inlined within the current
15546 translation unit (and thus, we need to generate Dwarf info for their
15547 abstract instances so that the Dwarf info for the concrete inlined
15548 instances can have something to refer to) but the compiler never
15549 generates any out-of-lines instances of such things (despite the fact
15550 that they *are* definitions).
15552 The important point is that the C front-end marks these "extern
15553 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
15554 them anyway. Note that the C++ front-end also plays some similar games
15555 for inline function definitions appearing within include files which
15556 also contain `#pragma interface' pragmas. */
15557 if (DECL_INITIAL (decl) == NULL_TREE)
15560 /* If we're a nested function, initially use a parent of NULL; if we're
15561 a plain function, this will be fixed up in decls_for_scope. If
15562 we're a method, it will be ignored, since we already have a DIE. */
15563 if (decl_function_context (decl)
15564 /* But if we're in terse mode, we don't care about scope. */
15565 && debug_info_level > DINFO_LEVEL_TERSE)
15566 context_die = NULL;
15570 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
15571 declaration and if the declaration was never even referenced from
15572 within this entire compilation unit. We suppress these DIEs in
15573 order to save space in the .debug section (by eliminating entries
15574 which are probably useless). Note that we must not suppress
15575 block-local extern declarations (whether used or not) because that
15576 would screw-up the debugger's name lookup mechanism and cause it to
15577 miss things which really ought to be in scope at a given point. */
15578 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
15581 /* For local statics lookup proper context die. */
15582 if (TREE_STATIC (decl) && decl_function_context (decl))
15583 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15585 /* If we are in terse mode, don't generate any DIEs to represent any
15586 variable declarations or definitions. */
15587 if (debug_info_level <= DINFO_LEVEL_TERSE)
15592 if (debug_info_level <= DINFO_LEVEL_TERSE)
15594 if (!is_fortran ())
15596 if (TREE_STATIC (decl) && decl_function_context (decl))
15597 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15600 case NAMESPACE_DECL:
15601 case IMPORTED_DECL:
15602 if (debug_info_level <= DINFO_LEVEL_TERSE)
15604 if (lookup_decl_die (decl) != NULL)
15609 /* Don't emit stubs for types unless they are needed by other DIEs. */
15610 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
15613 /* Don't bother trying to generate any DIEs to represent any of the
15614 normal built-in types for the language we are compiling. */
15615 if (DECL_IS_BUILTIN (decl))
15617 /* OK, we need to generate one for `bool' so GDB knows what type
15618 comparisons have. */
15620 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
15621 && ! DECL_IGNORED_P (decl))
15622 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
15627 /* If we are in terse mode, don't generate any DIEs for types. */
15628 if (debug_info_level <= DINFO_LEVEL_TERSE)
15631 /* If we're a function-scope tag, initially use a parent of NULL;
15632 this will be fixed up in decls_for_scope. */
15633 if (decl_function_context (decl))
15634 context_die = NULL;
15642 gen_decl_die (decl, NULL, context_die);
15645 /* Output a marker (i.e. a label) for the beginning of the generated code for
15646 a lexical block. */
15649 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
15650 unsigned int blocknum)
15652 switch_to_section (current_function_section ());
15653 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
15656 /* Output a marker (i.e. a label) for the end of the generated code for a
15660 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
15662 switch_to_section (current_function_section ());
15663 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
15666 /* Returns nonzero if it is appropriate not to emit any debugging
15667 information for BLOCK, because it doesn't contain any instructions.
15669 Don't allow this for blocks with nested functions or local classes
15670 as we would end up with orphans, and in the presence of scheduling
15671 we may end up calling them anyway. */
15674 dwarf2out_ignore_block (const_tree block)
15679 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
15680 if (TREE_CODE (decl) == FUNCTION_DECL
15681 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15683 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
15685 decl = BLOCK_NONLOCALIZED_VAR (block, i);
15686 if (TREE_CODE (decl) == FUNCTION_DECL
15687 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15694 /* Hash table routines for file_hash. */
15697 file_table_eq (const void *p1_p, const void *p2_p)
15699 const struct dwarf_file_data *const p1 =
15700 (const struct dwarf_file_data *) p1_p;
15701 const char *const p2 = (const char *) p2_p;
15702 return strcmp (p1->filename, p2) == 0;
15706 file_table_hash (const void *p_p)
15708 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
15709 return htab_hash_string (p->filename);
15712 /* Lookup FILE_NAME (in the list of filenames that we know about here in
15713 dwarf2out.c) and return its "index". The index of each (known) filename is
15714 just a unique number which is associated with only that one filename. We
15715 need such numbers for the sake of generating labels (in the .debug_sfnames
15716 section) and references to those files numbers (in the .debug_srcinfo
15717 and.debug_macinfo sections). If the filename given as an argument is not
15718 found in our current list, add it to the list and assign it the next
15719 available unique index number. In order to speed up searches, we remember
15720 the index of the filename was looked up last. This handles the majority of
15723 static struct dwarf_file_data *
15724 lookup_filename (const char *file_name)
15727 struct dwarf_file_data * created;
15729 /* Check to see if the file name that was searched on the previous
15730 call matches this file name. If so, return the index. */
15731 if (file_table_last_lookup
15732 && (file_name == file_table_last_lookup->filename
15733 || strcmp (file_table_last_lookup->filename, file_name) == 0))
15734 return file_table_last_lookup;
15736 /* Didn't match the previous lookup, search the table. */
15737 slot = htab_find_slot_with_hash (file_table, file_name,
15738 htab_hash_string (file_name), INSERT);
15740 return (struct dwarf_file_data *) *slot;
15742 created = GGC_NEW (struct dwarf_file_data);
15743 created->filename = file_name;
15744 created->emitted_number = 0;
15749 /* If the assembler will construct the file table, then translate the compiler
15750 internal file table number into the assembler file table number, and emit
15751 a .file directive if we haven't already emitted one yet. The file table
15752 numbers are different because we prune debug info for unused variables and
15753 types, which may include filenames. */
15756 maybe_emit_file (struct dwarf_file_data * fd)
15758 if (! fd->emitted_number)
15760 if (last_emitted_file)
15761 fd->emitted_number = last_emitted_file->emitted_number + 1;
15763 fd->emitted_number = 1;
15764 last_emitted_file = fd;
15766 if (DWARF2_ASM_LINE_DEBUG_INFO)
15768 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
15769 output_quoted_string (asm_out_file,
15770 remap_debug_filename (fd->filename));
15771 fputc ('\n', asm_out_file);
15775 return fd->emitted_number;
15778 /* Replace DW_AT_name for the decl with name. */
15781 dwarf2out_set_name (tree decl, tree name)
15786 die = TYPE_SYMTAB_DIE (decl);
15790 attr = get_AT (die, DW_AT_name);
15793 struct indirect_string_node *node;
15795 node = find_AT_string (dwarf2_name (name, 0));
15796 /* replace the string. */
15797 attr->dw_attr_val.v.val_str = node;
15801 add_name_attribute (die, dwarf2_name (name, 0));
15803 /* Called by the final INSN scan whenever we see a var location. We
15804 use it to drop labels in the right places, and throw the location in
15805 our lookup table. */
15808 dwarf2out_var_location (rtx loc_note)
15810 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
15811 struct var_loc_node *newloc;
15813 static rtx last_insn;
15814 static const char *last_label;
15817 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
15819 prev_insn = PREV_INSN (loc_note);
15821 newloc = GGC_CNEW (struct var_loc_node);
15822 /* If the insn we processed last time is the previous insn
15823 and it is also a var location note, use the label we emitted
15825 if (last_insn != NULL_RTX
15826 && last_insn == prev_insn
15827 && NOTE_P (prev_insn)
15828 && NOTE_KIND (prev_insn) == NOTE_INSN_VAR_LOCATION)
15830 newloc->label = last_label;
15834 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
15835 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
15837 newloc->label = ggc_strdup (loclabel);
15839 newloc->var_loc_note = loc_note;
15840 newloc->next = NULL;
15842 if (cfun && in_cold_section_p)
15843 newloc->section_label = crtl->subsections.cold_section_label;
15845 newloc->section_label = text_section_label;
15847 last_insn = loc_note;
15848 last_label = newloc->label;
15849 decl = NOTE_VAR_LOCATION_DECL (loc_note);
15850 add_var_loc_to_decl (decl, newloc);
15853 /* We need to reset the locations at the beginning of each
15854 function. We can't do this in the end_function hook, because the
15855 declarations that use the locations won't have been output when
15856 that hook is called. Also compute have_multiple_function_sections here. */
15859 dwarf2out_begin_function (tree fun)
15861 htab_empty (decl_loc_table);
15863 if (function_section (fun) != text_section)
15864 have_multiple_function_sections = true;
15866 dwarf2out_note_section_used ();
15869 /* Output a label to mark the beginning of a source code line entry
15870 and record information relating to this source line, in
15871 'line_info_table' for later output of the .debug_line section. */
15874 dwarf2out_source_line (unsigned int line, const char *filename)
15876 if (debug_info_level >= DINFO_LEVEL_NORMAL
15879 int file_num = maybe_emit_file (lookup_filename (filename));
15881 switch_to_section (current_function_section ());
15883 /* If requested, emit something human-readable. */
15884 if (flag_debug_asm)
15885 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
15888 if (DWARF2_ASM_LINE_DEBUG_INFO)
15890 /* Emit the .loc directive understood by GNU as. */
15891 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
15893 /* Indicate that line number info exists. */
15894 line_info_table_in_use++;
15896 else if (function_section (current_function_decl) != text_section)
15898 dw_separate_line_info_ref line_info;
15899 targetm.asm_out.internal_label (asm_out_file,
15900 SEPARATE_LINE_CODE_LABEL,
15901 separate_line_info_table_in_use);
15903 /* Expand the line info table if necessary. */
15904 if (separate_line_info_table_in_use
15905 == separate_line_info_table_allocated)
15907 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15908 separate_line_info_table
15909 = GGC_RESIZEVEC (dw_separate_line_info_entry,
15910 separate_line_info_table,
15911 separate_line_info_table_allocated);
15912 memset (separate_line_info_table
15913 + separate_line_info_table_in_use,
15915 (LINE_INFO_TABLE_INCREMENT
15916 * sizeof (dw_separate_line_info_entry)));
15919 /* Add the new entry at the end of the line_info_table. */
15921 = &separate_line_info_table[separate_line_info_table_in_use++];
15922 line_info->dw_file_num = file_num;
15923 line_info->dw_line_num = line;
15924 line_info->function = current_function_funcdef_no;
15928 dw_line_info_ref line_info;
15930 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
15931 line_info_table_in_use);
15933 /* Expand the line info table if necessary. */
15934 if (line_info_table_in_use == line_info_table_allocated)
15936 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15938 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
15939 line_info_table_allocated);
15940 memset (line_info_table + line_info_table_in_use, 0,
15941 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
15944 /* Add the new entry at the end of the line_info_table. */
15945 line_info = &line_info_table[line_info_table_in_use++];
15946 line_info->dw_file_num = file_num;
15947 line_info->dw_line_num = line;
15952 /* Record the beginning of a new source file. */
15955 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
15957 if (flag_eliminate_dwarf2_dups)
15959 /* Record the beginning of the file for break_out_includes. */
15960 dw_die_ref bincl_die;
15962 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
15963 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
15966 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15968 int file_num = maybe_emit_file (lookup_filename (filename));
15970 switch_to_section (debug_macinfo_section);
15971 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
15972 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
15975 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
15979 /* Record the end of a source file. */
15982 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
15984 if (flag_eliminate_dwarf2_dups)
15985 /* Record the end of the file for break_out_includes. */
15986 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
15988 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15990 switch_to_section (debug_macinfo_section);
15991 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
15995 /* Called from debug_define in toplev.c. The `buffer' parameter contains
15996 the tail part of the directive line, i.e. the part which is past the
15997 initial whitespace, #, whitespace, directive-name, whitespace part. */
16000 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
16001 const char *buffer ATTRIBUTE_UNUSED)
16003 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16005 switch_to_section (debug_macinfo_section);
16006 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
16007 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
16008 dw2_asm_output_nstring (buffer, -1, "The macro");
16012 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
16013 the tail part of the directive line, i.e. the part which is past the
16014 initial whitespace, #, whitespace, directive-name, whitespace part. */
16017 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
16018 const char *buffer ATTRIBUTE_UNUSED)
16020 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16022 switch_to_section (debug_macinfo_section);
16023 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
16024 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
16025 dw2_asm_output_nstring (buffer, -1, "The macro");
16029 /* Set up for Dwarf output at the start of compilation. */
16032 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
16034 /* Allocate the file_table. */
16035 file_table = htab_create_ggc (50, file_table_hash,
16036 file_table_eq, NULL);
16038 /* Allocate the decl_die_table. */
16039 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
16040 decl_die_table_eq, NULL);
16042 /* Allocate the decl_loc_table. */
16043 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
16044 decl_loc_table_eq, NULL);
16046 /* Allocate the initial hunk of the decl_scope_table. */
16047 decl_scope_table = VEC_alloc (tree, gc, 256);
16049 /* Allocate the initial hunk of the abbrev_die_table. */
16050 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
16051 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
16052 /* Zero-th entry is allocated, but unused. */
16053 abbrev_die_table_in_use = 1;
16055 /* Allocate the initial hunk of the line_info_table. */
16056 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
16057 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
16059 /* Zero-th entry is allocated, but unused. */
16060 line_info_table_in_use = 1;
16062 /* Allocate the pubtypes and pubnames vectors. */
16063 pubname_table = VEC_alloc (pubname_entry, gc, 32);
16064 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
16066 /* Generate the initial DIE for the .debug section. Note that the (string)
16067 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
16068 will (typically) be a relative pathname and that this pathname should be
16069 taken as being relative to the directory from which the compiler was
16070 invoked when the given (base) source file was compiled. We will fill
16071 in this value in dwarf2out_finish. */
16072 comp_unit_die = gen_compile_unit_die (NULL);
16074 incomplete_types = VEC_alloc (tree, gc, 64);
16076 used_rtx_array = VEC_alloc (rtx, gc, 32);
16078 debug_info_section = get_section (DEBUG_INFO_SECTION,
16079 SECTION_DEBUG, NULL);
16080 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
16081 SECTION_DEBUG, NULL);
16082 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
16083 SECTION_DEBUG, NULL);
16084 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
16085 SECTION_DEBUG, NULL);
16086 debug_line_section = get_section (DEBUG_LINE_SECTION,
16087 SECTION_DEBUG, NULL);
16088 debug_loc_section = get_section (DEBUG_LOC_SECTION,
16089 SECTION_DEBUG, NULL);
16090 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
16091 SECTION_DEBUG, NULL);
16092 #ifdef DEBUG_PUBTYPES_SECTION
16093 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
16094 SECTION_DEBUG, NULL);
16096 debug_str_section = get_section (DEBUG_STR_SECTION,
16097 DEBUG_STR_SECTION_FLAGS, NULL);
16098 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
16099 SECTION_DEBUG, NULL);
16100 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
16101 SECTION_DEBUG, NULL);
16103 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
16104 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
16105 DEBUG_ABBREV_SECTION_LABEL, 0);
16106 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
16107 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
16108 COLD_TEXT_SECTION_LABEL, 0);
16109 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
16111 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
16112 DEBUG_INFO_SECTION_LABEL, 0);
16113 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
16114 DEBUG_LINE_SECTION_LABEL, 0);
16115 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
16116 DEBUG_RANGES_SECTION_LABEL, 0);
16117 switch_to_section (debug_abbrev_section);
16118 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
16119 switch_to_section (debug_info_section);
16120 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
16121 switch_to_section (debug_line_section);
16122 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
16124 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16126 switch_to_section (debug_macinfo_section);
16127 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
16128 DEBUG_MACINFO_SECTION_LABEL, 0);
16129 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
16132 switch_to_section (text_section);
16133 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
16134 if (flag_reorder_blocks_and_partition)
16136 cold_text_section = unlikely_text_section ();
16137 switch_to_section (cold_text_section);
16138 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
16142 /* A helper function for dwarf2out_finish called through
16143 ht_forall. Emit one queued .debug_str string. */
16146 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
16148 struct indirect_string_node *node = (struct indirect_string_node *) *h;
16150 if (node->form == DW_FORM_strp)
16152 switch_to_section (debug_str_section);
16153 ASM_OUTPUT_LABEL (asm_out_file, node->label);
16154 assemble_string (node->str, strlen (node->str) + 1);
16160 #if ENABLE_ASSERT_CHECKING
16161 /* Verify that all marks are clear. */
16164 verify_marks_clear (dw_die_ref die)
16168 gcc_assert (! die->die_mark);
16169 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
16171 #endif /* ENABLE_ASSERT_CHECKING */
16173 /* Clear the marks for a die and its children.
16174 Be cool if the mark isn't set. */
16177 prune_unmark_dies (dw_die_ref die)
16183 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
16186 /* Given DIE that we're marking as used, find any other dies
16187 it references as attributes and mark them as used. */
16190 prune_unused_types_walk_attribs (dw_die_ref die)
16195 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16197 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
16199 /* A reference to another DIE.
16200 Make sure that it will get emitted. */
16201 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
16203 /* Set the string's refcount to 0 so that prune_unused_types_mark
16204 accounts properly for it. */
16205 if (AT_class (a) == dw_val_class_str)
16206 a->dw_attr_val.v.val_str->refcount = 0;
16211 /* Mark DIE as being used. If DOKIDS is true, then walk down
16212 to DIE's children. */
16215 prune_unused_types_mark (dw_die_ref die, int dokids)
16219 if (die->die_mark == 0)
16221 /* We haven't done this node yet. Mark it as used. */
16224 /* We also have to mark its parents as used.
16225 (But we don't want to mark our parents' kids due to this.) */
16226 if (die->die_parent)
16227 prune_unused_types_mark (die->die_parent, 0);
16229 /* Mark any referenced nodes. */
16230 prune_unused_types_walk_attribs (die);
16232 /* If this node is a specification,
16233 also mark the definition, if it exists. */
16234 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
16235 prune_unused_types_mark (die->die_definition, 1);
16238 if (dokids && die->die_mark != 2)
16240 /* We need to walk the children, but haven't done so yet.
16241 Remember that we've walked the kids. */
16244 /* If this is an array type, we need to make sure our
16245 kids get marked, even if they're types. */
16246 if (die->die_tag == DW_TAG_array_type)
16247 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
16249 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16253 /* For local classes, look if any static member functions were emitted
16254 and if so, mark them. */
16257 prune_unused_types_walk_local_classes (dw_die_ref die)
16261 if (die->die_mark == 2)
16264 switch (die->die_tag)
16266 case DW_TAG_structure_type:
16267 case DW_TAG_union_type:
16268 case DW_TAG_class_type:
16271 case DW_TAG_subprogram:
16272 if (!get_AT_flag (die, DW_AT_declaration)
16273 || die->die_definition != NULL)
16274 prune_unused_types_mark (die, 1);
16281 /* Mark children. */
16282 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
16285 /* Walk the tree DIE and mark types that we actually use. */
16288 prune_unused_types_walk (dw_die_ref die)
16292 /* Don't do anything if this node is already marked and
16293 children have been marked as well. */
16294 if (die->die_mark == 2)
16297 switch (die->die_tag)
16299 case DW_TAG_structure_type:
16300 case DW_TAG_union_type:
16301 case DW_TAG_class_type:
16302 if (die->die_perennial_p)
16305 for (c = die->die_parent; c; c = c->die_parent)
16306 if (c->die_tag == DW_TAG_subprogram)
16309 /* Finding used static member functions inside of classes
16310 is needed just for local classes, because for other classes
16311 static member function DIEs with DW_AT_specification
16312 are emitted outside of the DW_TAG_*_type. If we ever change
16313 it, we'd need to call this even for non-local classes. */
16315 prune_unused_types_walk_local_classes (die);
16317 /* It's a type node --- don't mark it. */
16320 case DW_TAG_const_type:
16321 case DW_TAG_packed_type:
16322 case DW_TAG_pointer_type:
16323 case DW_TAG_reference_type:
16324 case DW_TAG_volatile_type:
16325 case DW_TAG_typedef:
16326 case DW_TAG_array_type:
16327 case DW_TAG_interface_type:
16328 case DW_TAG_friend:
16329 case DW_TAG_variant_part:
16330 case DW_TAG_enumeration_type:
16331 case DW_TAG_subroutine_type:
16332 case DW_TAG_string_type:
16333 case DW_TAG_set_type:
16334 case DW_TAG_subrange_type:
16335 case DW_TAG_ptr_to_member_type:
16336 case DW_TAG_file_type:
16337 if (die->die_perennial_p)
16340 /* It's a type node --- don't mark it. */
16344 /* Mark everything else. */
16348 if (die->die_mark == 0)
16352 /* Now, mark any dies referenced from here. */
16353 prune_unused_types_walk_attribs (die);
16358 /* Mark children. */
16359 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16362 /* Increment the string counts on strings referred to from DIE's
16366 prune_unused_types_update_strings (dw_die_ref die)
16371 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16372 if (AT_class (a) == dw_val_class_str)
16374 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
16376 /* Avoid unnecessarily putting strings that are used less than
16377 twice in the hash table. */
16379 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
16382 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
16383 htab_hash_string (s->str),
16385 gcc_assert (*slot == NULL);
16391 /* Remove from the tree DIE any dies that aren't marked. */
16394 prune_unused_types_prune (dw_die_ref die)
16398 gcc_assert (die->die_mark);
16399 prune_unused_types_update_strings (die);
16401 if (! die->die_child)
16404 c = die->die_child;
16406 dw_die_ref prev = c;
16407 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
16408 if (c == die->die_child)
16410 /* No marked children between 'prev' and the end of the list. */
16412 /* No marked children at all. */
16413 die->die_child = NULL;
16416 prev->die_sib = c->die_sib;
16417 die->die_child = prev;
16422 if (c != prev->die_sib)
16424 prune_unused_types_prune (c);
16425 } while (c != die->die_child);
16429 /* Remove dies representing declarations that we never use. */
16432 prune_unused_types (void)
16435 limbo_die_node *node;
16438 #if ENABLE_ASSERT_CHECKING
16439 /* All the marks should already be clear. */
16440 verify_marks_clear (comp_unit_die);
16441 for (node = limbo_die_list; node; node = node->next)
16442 verify_marks_clear (node->die);
16443 #endif /* ENABLE_ASSERT_CHECKING */
16445 /* Set the mark on nodes that are actually used. */
16446 prune_unused_types_walk (comp_unit_die);
16447 for (node = limbo_die_list; node; node = node->next)
16448 prune_unused_types_walk (node->die);
16450 /* Also set the mark on nodes referenced from the
16451 pubname_table or arange_table. */
16452 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
16453 prune_unused_types_mark (pub->die, 1);
16454 for (i = 0; i < arange_table_in_use; i++)
16455 prune_unused_types_mark (arange_table[i], 1);
16457 /* Get rid of nodes that aren't marked; and update the string counts. */
16458 if (debug_str_hash)
16459 htab_empty (debug_str_hash);
16460 prune_unused_types_prune (comp_unit_die);
16461 for (node = limbo_die_list; node; node = node->next)
16462 prune_unused_types_prune (node->die);
16464 /* Leave the marks clear. */
16465 prune_unmark_dies (comp_unit_die);
16466 for (node = limbo_die_list; node; node = node->next)
16467 prune_unmark_dies (node->die);
16470 /* Set the parameter to true if there are any relative pathnames in
16473 file_table_relative_p (void ** slot, void *param)
16475 bool *p = (bool *) param;
16476 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
16477 if (!IS_ABSOLUTE_PATH (d->filename))
16485 /* Output stuff that dwarf requires at the end of every file,
16486 and generate the DWARF-2 debugging info. */
16489 dwarf2out_finish (const char *filename)
16491 limbo_die_node *node, *next_node;
16492 dw_die_ref die = 0;
16495 /* Add the name for the main input file now. We delayed this from
16496 dwarf2out_init to avoid complications with PCH. */
16497 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
16498 if (!IS_ABSOLUTE_PATH (filename))
16499 add_comp_dir_attribute (comp_unit_die);
16500 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
16503 htab_traverse (file_table, file_table_relative_p, &p);
16505 add_comp_dir_attribute (comp_unit_die);
16508 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
16510 add_location_or_const_value_attribute (
16511 VEC_index (deferred_locations, deferred_locations_list, i)->die,
16512 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
16516 /* Traverse the limbo die list, and add parent/child links. The only
16517 dies without parents that should be here are concrete instances of
16518 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
16519 For concrete instances, we can get the parent die from the abstract
16521 for (node = limbo_die_list; node; node = next_node)
16523 next_node = node->next;
16526 if (die->die_parent == NULL)
16528 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
16531 add_child_die (origin->die_parent, die);
16532 else if (die == comp_unit_die)
16534 else if (errorcount > 0 || sorrycount > 0)
16535 /* It's OK to be confused by errors in the input. */
16536 add_child_die (comp_unit_die, die);
16539 /* In certain situations, the lexical block containing a
16540 nested function can be optimized away, which results
16541 in the nested function die being orphaned. Likewise
16542 with the return type of that nested function. Force
16543 this to be a child of the containing function.
16545 It may happen that even the containing function got fully
16546 inlined and optimized out. In that case we are lost and
16547 assign the empty child. This should not be big issue as
16548 the function is likely unreachable too. */
16549 tree context = NULL_TREE;
16551 gcc_assert (node->created_for);
16553 if (DECL_P (node->created_for))
16554 context = DECL_CONTEXT (node->created_for);
16555 else if (TYPE_P (node->created_for))
16556 context = TYPE_CONTEXT (node->created_for);
16558 gcc_assert (context
16559 && (TREE_CODE (context) == FUNCTION_DECL
16560 || TREE_CODE (context) == NAMESPACE_DECL));
16562 origin = lookup_decl_die (context);
16564 add_child_die (origin, die);
16566 add_child_die (comp_unit_die, die);
16571 limbo_die_list = NULL;
16573 /* Walk through the list of incomplete types again, trying once more to
16574 emit full debugging info for them. */
16575 retry_incomplete_types ();
16577 if (flag_eliminate_unused_debug_types)
16578 prune_unused_types ();
16580 /* Generate separate CUs for each of the include files we've seen.
16581 They will go into limbo_die_list. */
16582 if (flag_eliminate_dwarf2_dups)
16583 break_out_includes (comp_unit_die);
16585 /* Traverse the DIE's and add add sibling attributes to those DIE's
16586 that have children. */
16587 add_sibling_attributes (comp_unit_die);
16588 for (node = limbo_die_list; node; node = node->next)
16589 add_sibling_attributes (node->die);
16591 /* Output a terminator label for the .text section. */
16592 switch_to_section (text_section);
16593 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
16594 if (flag_reorder_blocks_and_partition)
16596 switch_to_section (unlikely_text_section ());
16597 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
16600 /* We can only use the low/high_pc attributes if all of the code was
16602 if (!have_multiple_function_sections)
16604 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
16605 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
16610 unsigned fde_idx = 0;
16612 /* We need to give .debug_loc and .debug_ranges an appropriate
16613 "base address". Use zero so that these addresses become
16614 absolute. Historically, we've emitted the unexpected
16615 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
16616 Emit both to give time for other tools to adapt. */
16617 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
16618 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
16620 add_AT_range_list (comp_unit_die, DW_AT_ranges,
16621 add_ranges_by_labels (text_section_label,
16623 if (flag_reorder_blocks_and_partition)
16624 add_ranges_by_labels (cold_text_section_label,
16627 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
16629 dw_fde_ref fde = &fde_table[fde_idx];
16631 if (fde->dw_fde_switched_sections)
16633 add_ranges_by_labels (fde->dw_fde_hot_section_label,
16634 fde->dw_fde_hot_section_end_label);
16635 add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
16636 fde->dw_fde_unlikely_section_end_label);
16639 add_ranges_by_labels (fde->dw_fde_begin,
16646 /* Output location list section if necessary. */
16647 if (have_location_lists)
16649 /* Output the location lists info. */
16650 switch_to_section (debug_loc_section);
16651 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
16652 DEBUG_LOC_SECTION_LABEL, 0);
16653 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
16654 output_location_lists (die);
16657 if (debug_info_level >= DINFO_LEVEL_NORMAL)
16658 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
16659 debug_line_section_label);
16661 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16662 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
16664 /* Output all of the compilation units. We put the main one last so that
16665 the offsets are available to output_pubnames. */
16666 for (node = limbo_die_list; node; node = node->next)
16667 output_comp_unit (node->die, 0);
16669 /* Output the main compilation unit if non-empty or if .debug_macinfo
16670 has been emitted. */
16671 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
16673 /* Output the abbreviation table. */
16674 switch_to_section (debug_abbrev_section);
16675 output_abbrev_section ();
16677 /* Output public names table if necessary. */
16678 if (!VEC_empty (pubname_entry, pubname_table))
16680 switch_to_section (debug_pubnames_section);
16681 output_pubnames (pubname_table);
16684 #ifdef DEBUG_PUBTYPES_SECTION
16685 /* Output public types table if necessary. */
16686 if (!VEC_empty (pubname_entry, pubtype_table))
16688 switch_to_section (debug_pubtypes_section);
16689 output_pubnames (pubtype_table);
16693 /* Output the address range information. We only put functions in the arange
16694 table, so don't write it out if we don't have any. */
16695 if (fde_table_in_use)
16697 switch_to_section (debug_aranges_section);
16701 /* Output ranges section if necessary. */
16702 if (ranges_table_in_use)
16704 switch_to_section (debug_ranges_section);
16705 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
16709 /* Output the source line correspondence table. We must do this
16710 even if there is no line information. Otherwise, on an empty
16711 translation unit, we will generate a present, but empty,
16712 .debug_info section. IRIX 6.5 `nm' will then complain when
16713 examining the file. This is done late so that any filenames
16714 used by the debug_info section are marked as 'used'. */
16715 if (! DWARF2_ASM_LINE_DEBUG_INFO)
16717 switch_to_section (debug_line_section);
16718 output_line_info ();
16721 /* Have to end the macro section. */
16722 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16724 switch_to_section (debug_macinfo_section);
16725 dw2_asm_output_data (1, 0, "End compilation unit");
16728 /* If we emitted any DW_FORM_strp form attribute, output the string
16730 if (debug_str_hash)
16731 htab_traverse (debug_str_hash, output_indirect_string, NULL);
16735 /* This should never be used, but its address is needed for comparisons. */
16736 const struct gcc_debug_hooks dwarf2_debug_hooks;
16738 #endif /* DWARF2_DEBUGGING_INFO */
16740 #include "gt-dwarf2out.h"