1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* TODO: Emit .debug_line header even when there are no functions, since
25 the file numbers are used by .debug_info. Alternately, leave
26 out locations for types and decls.
27 Avoid talking about ctors and op= for PODs.
28 Factor out common prologue sequences into multiple CIEs. */
30 /* The first part of this file deals with the DWARF 2 frame unwind
31 information, which is also used by the GCC efficient exception handling
32 mechanism. The second part, controlled only by an #ifdef
33 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
36 /* DWARF2 Abbreviation Glossary:
38 CFA = Canonical Frame Address
39 a fixed address on the stack which identifies a call frame.
40 We define it to be the value of SP just before the call insn.
41 The CFA register and offset, which may change during the course
42 of the function, are used to calculate its value at runtime.
44 CFI = Call Frame Instruction
45 an instruction for the DWARF2 abstract machine
47 CIE = Common Information Entry
48 information describing information common to one or more FDEs
50 DIE = Debugging Information Entry
52 FDE = Frame Description Entry
53 information describing the stack call frame, in particular,
54 how to restore registers
56 DW_CFA_... = DWARF2 CFA call frame instruction
57 DW_TAG_... = DWARF2 DIE tag */
61 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
85 #include "diagnostic.h"
88 #include "langhooks.h"
93 #ifdef DWARF2_DEBUGGING_INFO
94 static void dwarf2out_source_line (unsigned int, const char *);
97 #ifndef DWARF2_FRAME_INFO
98 # ifdef DWARF2_DEBUGGING_INFO
99 # define DWARF2_FRAME_INFO \
100 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
102 # define DWARF2_FRAME_INFO 0
106 /* Map register numbers held in the call frame info that gcc has
107 collected using DWARF_FRAME_REGNUM to those that should be output in
108 .debug_frame and .eh_frame. */
109 #ifndef DWARF2_FRAME_REG_OUT
110 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
113 /* Save the result of dwarf2out_do_frame across PCH. */
114 static GTY(()) bool saved_do_cfi_asm = 0;
116 /* Decide whether we want to emit frame unwind information for the current
120 dwarf2out_do_frame (void)
122 /* We want to emit correct CFA location expressions or lists, so we
123 have to return true if we're going to output debug info, even if
124 we're not going to output frame or unwind info. */
125 return (write_symbols == DWARF2_DEBUG
126 || write_symbols == VMS_AND_DWARF2_DEBUG
127 || DWARF2_FRAME_INFO || saved_do_cfi_asm
128 #ifdef DWARF2_UNWIND_INFO
129 || (DWARF2_UNWIND_INFO
130 && (flag_unwind_tables
131 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
136 /* Decide whether to emit frame unwind via assembler directives. */
139 dwarf2out_do_cfi_asm (void)
143 #ifdef MIPS_DEBUGGING_INFO
146 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
148 if (saved_do_cfi_asm || !eh_personality_libfunc)
150 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
153 /* Make sure the personality encoding is one the assembler can support.
154 In particular, aligned addresses can't be handled. */
155 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
156 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
158 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
159 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
162 saved_do_cfi_asm = true;
166 /* The size of the target's pointer type. */
168 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
171 /* Array of RTXes referenced by the debugging information, which therefore
172 must be kept around forever. */
173 static GTY(()) VEC(rtx,gc) *used_rtx_array;
175 /* A pointer to the base of a list of incomplete types which might be
176 completed at some later time. incomplete_types_list needs to be a
177 VEC(tree,gc) because we want to tell the garbage collector about
179 static GTY(()) VEC(tree,gc) *incomplete_types;
181 /* A pointer to the base of a table of references to declaration
182 scopes. This table is a display which tracks the nesting
183 of declaration scopes at the current scope and containing
184 scopes. This table is used to find the proper place to
185 define type declaration DIE's. */
186 static GTY(()) VEC(tree,gc) *decl_scope_table;
188 /* Pointers to various DWARF2 sections. */
189 static GTY(()) section *debug_info_section;
190 static GTY(()) section *debug_abbrev_section;
191 static GTY(()) section *debug_aranges_section;
192 static GTY(()) section *debug_macinfo_section;
193 static GTY(()) section *debug_line_section;
194 static GTY(()) section *debug_loc_section;
195 static GTY(()) section *debug_pubnames_section;
196 static GTY(()) section *debug_pubtypes_section;
197 static GTY(()) section *debug_str_section;
198 static GTY(()) section *debug_ranges_section;
199 static GTY(()) section *debug_frame_section;
201 /* How to start an assembler comment. */
202 #ifndef ASM_COMMENT_START
203 #define ASM_COMMENT_START ";#"
206 typedef struct dw_cfi_struct *dw_cfi_ref;
207 typedef struct dw_fde_struct *dw_fde_ref;
208 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
210 /* Call frames are described using a sequence of Call Frame
211 Information instructions. The register number, offset
212 and address fields are provided as possible operands;
213 their use is selected by the opcode field. */
215 enum dw_cfi_oprnd_type {
217 dw_cfi_oprnd_reg_num,
223 typedef union dw_cfi_oprnd_struct GTY(())
225 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
226 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
227 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
228 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
232 typedef struct dw_cfi_struct GTY(())
234 dw_cfi_ref dw_cfi_next;
235 enum dwarf_call_frame_info dw_cfi_opc;
236 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
238 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
243 /* This is how we define the location of the CFA. We use to handle it
244 as REG + OFFSET all the time, but now it can be more complex.
245 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
246 Instead of passing around REG and OFFSET, we pass a copy
247 of this structure. */
248 typedef struct cfa_loc GTY(())
250 HOST_WIDE_INT offset;
251 HOST_WIDE_INT base_offset;
253 int indirect; /* 1 if CFA is accessed via a dereference. */
256 /* All call frame descriptions (FDE's) in the GCC generated DWARF
257 refer to a single Common Information Entry (CIE), defined at
258 the beginning of the .debug_frame section. This use of a single
259 CIE obviates the need to keep track of multiple CIE's
260 in the DWARF generation routines below. */
262 typedef struct dw_fde_struct GTY(())
265 const char *dw_fde_begin;
266 const char *dw_fde_current_label;
267 const char *dw_fde_end;
268 const char *dw_fde_hot_section_label;
269 const char *dw_fde_hot_section_end_label;
270 const char *dw_fde_unlikely_section_label;
271 const char *dw_fde_unlikely_section_end_label;
272 bool dw_fde_switched_sections;
273 dw_cfi_ref dw_fde_cfi;
274 unsigned funcdef_number;
275 HOST_WIDE_INT stack_realignment;
276 /* Dynamic realign argument pointer register. */
277 unsigned int drap_reg;
278 /* Virtual dynamic realign argument pointer register. */
279 unsigned int vdrap_reg;
280 unsigned all_throwers_are_sibcalls : 1;
281 unsigned nothrow : 1;
282 unsigned uses_eh_lsda : 1;
283 /* Whether we did stack realign in this call frame. */
284 unsigned stack_realign : 1;
285 /* Whether dynamic realign argument pointer register has been saved. */
286 unsigned drap_reg_saved: 1;
290 /* Maximum size (in bytes) of an artificially generated label. */
291 #define MAX_ARTIFICIAL_LABEL_BYTES 30
293 /* The size of addresses as they appear in the Dwarf 2 data.
294 Some architectures use word addresses to refer to code locations,
295 but Dwarf 2 info always uses byte addresses. On such machines,
296 Dwarf 2 addresses need to be larger than the architecture's
298 #ifndef DWARF2_ADDR_SIZE
299 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
302 /* The size in bytes of a DWARF field indicating an offset or length
303 relative to a debug info section, specified to be 4 bytes in the
304 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
307 #ifndef DWARF_OFFSET_SIZE
308 #define DWARF_OFFSET_SIZE 4
311 /* According to the (draft) DWARF 3 specification, the initial length
312 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
313 bytes are 0xffffffff, followed by the length stored in the next 8
316 However, the SGI/MIPS ABI uses an initial length which is equal to
317 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
319 #ifndef DWARF_INITIAL_LENGTH_SIZE
320 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
323 #define DWARF_VERSION 2
325 /* Round SIZE up to the nearest BOUNDARY. */
326 #define DWARF_ROUND(SIZE,BOUNDARY) \
327 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
329 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
330 #ifndef DWARF_CIE_DATA_ALIGNMENT
331 #ifdef STACK_GROWS_DOWNWARD
332 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
334 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
338 /* CIE identifier. */
339 #if HOST_BITS_PER_WIDE_INT >= 64
340 #define DWARF_CIE_ID \
341 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
343 #define DWARF_CIE_ID DW_CIE_ID
346 /* A pointer to the base of a table that contains frame description
347 information for each routine. */
348 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
350 /* Number of elements currently allocated for fde_table. */
351 static GTY(()) unsigned fde_table_allocated;
353 /* Number of elements in fde_table currently in use. */
354 static GTY(()) unsigned fde_table_in_use;
356 /* Size (in elements) of increments by which we may expand the
358 #define FDE_TABLE_INCREMENT 256
360 /* Get the current fde_table entry we should use. */
362 static inline dw_fde_ref
365 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
368 /* A list of call frame insns for the CIE. */
369 static GTY(()) dw_cfi_ref cie_cfi_head;
371 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
372 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
373 attribute that accelerates the lookup of the FDE associated
374 with the subprogram. This variable holds the table index of the FDE
375 associated with the current function (body) definition. */
376 static unsigned current_funcdef_fde;
379 struct indirect_string_node GTY(())
382 unsigned int refcount;
387 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
389 static GTY(()) int dw2_string_counter;
390 static GTY(()) unsigned long dwarf2out_cfi_label_num;
392 /* True if the compilation unit places functions in more than one section. */
393 static GTY(()) bool have_multiple_function_sections = false;
395 /* Whether the default text and cold text sections have been used at all. */
397 static GTY(()) bool text_section_used = false;
398 static GTY(()) bool cold_text_section_used = false;
400 /* The default cold text section. */
401 static GTY(()) section *cold_text_section;
403 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
405 /* Forward declarations for functions defined in this file. */
407 static char *stripattributes (const char *);
408 static const char *dwarf_cfi_name (unsigned);
409 static dw_cfi_ref new_cfi (void);
410 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
411 static void add_fde_cfi (const char *, dw_cfi_ref);
412 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
413 static void lookup_cfa (dw_cfa_location *);
414 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
415 #ifdef DWARF2_UNWIND_INFO
416 static void initial_return_save (rtx);
418 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
420 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
421 static void output_cfi_directive (dw_cfi_ref);
422 static void output_call_frame_info (int);
423 static void dwarf2out_note_section_used (void);
424 static void dwarf2out_stack_adjust (rtx, bool);
425 static void dwarf2out_args_size_adjust (HOST_WIDE_INT, const char *);
426 static void flush_queued_reg_saves (void);
427 static bool clobbers_queued_reg_save (const_rtx);
428 static void dwarf2out_frame_debug_expr (rtx, const char *);
430 /* Support for complex CFA locations. */
431 static void output_cfa_loc (dw_cfi_ref);
432 static void output_cfa_loc_raw (dw_cfi_ref);
433 static void get_cfa_from_loc_descr (dw_cfa_location *,
434 struct dw_loc_descr_struct *);
435 static struct dw_loc_descr_struct *build_cfa_loc
436 (dw_cfa_location *, HOST_WIDE_INT);
437 static struct dw_loc_descr_struct *build_cfa_aligned_loc
438 (HOST_WIDE_INT, HOST_WIDE_INT);
439 static void def_cfa_1 (const char *, dw_cfa_location *);
441 /* How to start an assembler comment. */
442 #ifndef ASM_COMMENT_START
443 #define ASM_COMMENT_START ";#"
446 /* Data and reference forms for relocatable data. */
447 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
448 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
450 #ifndef DEBUG_FRAME_SECTION
451 #define DEBUG_FRAME_SECTION ".debug_frame"
454 #ifndef FUNC_BEGIN_LABEL
455 #define FUNC_BEGIN_LABEL "LFB"
458 #ifndef FUNC_END_LABEL
459 #define FUNC_END_LABEL "LFE"
462 #ifndef FRAME_BEGIN_LABEL
463 #define FRAME_BEGIN_LABEL "Lframe"
465 #define CIE_AFTER_SIZE_LABEL "LSCIE"
466 #define CIE_END_LABEL "LECIE"
467 #define FDE_LABEL "LSFDE"
468 #define FDE_AFTER_SIZE_LABEL "LASFDE"
469 #define FDE_END_LABEL "LEFDE"
470 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
471 #define LINE_NUMBER_END_LABEL "LELT"
472 #define LN_PROLOG_AS_LABEL "LASLTP"
473 #define LN_PROLOG_END_LABEL "LELTP"
474 #define DIE_LABEL_PREFIX "DW"
476 /* The DWARF 2 CFA column which tracks the return address. Normally this
477 is the column for PC, or the first column after all of the hard
479 #ifndef DWARF_FRAME_RETURN_COLUMN
481 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
483 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
487 /* The mapping from gcc register number to DWARF 2 CFA column number. By
488 default, we just provide columns for all registers. */
489 #ifndef DWARF_FRAME_REGNUM
490 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
493 /* Hook used by __throw. */
496 expand_builtin_dwarf_sp_column (void)
498 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
499 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
502 /* Return a pointer to a copy of the section string name S with all
503 attributes stripped off, and an asterisk prepended (for assemble_name). */
506 stripattributes (const char *s)
508 char *stripped = XNEWVEC (char, strlen (s) + 2);
513 while (*s && *s != ',')
520 /* MEM is a memory reference for the register size table, each element of
521 which has mode MODE. Initialize column C as a return address column. */
524 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
526 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
527 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
528 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
531 /* Generate code to initialize the register size table. */
534 expand_builtin_init_dwarf_reg_sizes (tree address)
537 enum machine_mode mode = TYPE_MODE (char_type_node);
538 rtx addr = expand_normal (address);
539 rtx mem = gen_rtx_MEM (BLKmode, addr);
540 bool wrote_return_column = false;
542 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
544 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
546 if (rnum < DWARF_FRAME_REGISTERS)
548 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
549 enum machine_mode save_mode = reg_raw_mode[i];
552 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
553 save_mode = choose_hard_reg_mode (i, 1, true);
554 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
556 if (save_mode == VOIDmode)
558 wrote_return_column = true;
560 size = GET_MODE_SIZE (save_mode);
564 emit_move_insn (adjust_address (mem, mode, offset),
565 gen_int_mode (size, mode));
569 if (!wrote_return_column)
570 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
572 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
573 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
576 targetm.init_dwarf_reg_sizes_extra (address);
579 /* Convert a DWARF call frame info. operation to its string name */
582 dwarf_cfi_name (unsigned int cfi_opc)
586 case DW_CFA_advance_loc:
587 return "DW_CFA_advance_loc";
589 return "DW_CFA_offset";
591 return "DW_CFA_restore";
595 return "DW_CFA_set_loc";
596 case DW_CFA_advance_loc1:
597 return "DW_CFA_advance_loc1";
598 case DW_CFA_advance_loc2:
599 return "DW_CFA_advance_loc2";
600 case DW_CFA_advance_loc4:
601 return "DW_CFA_advance_loc4";
602 case DW_CFA_offset_extended:
603 return "DW_CFA_offset_extended";
604 case DW_CFA_restore_extended:
605 return "DW_CFA_restore_extended";
606 case DW_CFA_undefined:
607 return "DW_CFA_undefined";
608 case DW_CFA_same_value:
609 return "DW_CFA_same_value";
610 case DW_CFA_register:
611 return "DW_CFA_register";
612 case DW_CFA_remember_state:
613 return "DW_CFA_remember_state";
614 case DW_CFA_restore_state:
615 return "DW_CFA_restore_state";
617 return "DW_CFA_def_cfa";
618 case DW_CFA_def_cfa_register:
619 return "DW_CFA_def_cfa_register";
620 case DW_CFA_def_cfa_offset:
621 return "DW_CFA_def_cfa_offset";
624 case DW_CFA_def_cfa_expression:
625 return "DW_CFA_def_cfa_expression";
626 case DW_CFA_expression:
627 return "DW_CFA_expression";
628 case DW_CFA_offset_extended_sf:
629 return "DW_CFA_offset_extended_sf";
630 case DW_CFA_def_cfa_sf:
631 return "DW_CFA_def_cfa_sf";
632 case DW_CFA_def_cfa_offset_sf:
633 return "DW_CFA_def_cfa_offset_sf";
635 /* SGI/MIPS specific */
636 case DW_CFA_MIPS_advance_loc8:
637 return "DW_CFA_MIPS_advance_loc8";
640 case DW_CFA_GNU_window_save:
641 return "DW_CFA_GNU_window_save";
642 case DW_CFA_GNU_args_size:
643 return "DW_CFA_GNU_args_size";
644 case DW_CFA_GNU_negative_offset_extended:
645 return "DW_CFA_GNU_negative_offset_extended";
648 return "DW_CFA_<unknown>";
652 /* Return a pointer to a newly allocated Call Frame Instruction. */
654 static inline dw_cfi_ref
657 dw_cfi_ref cfi = GGC_NEW (dw_cfi_node);
659 cfi->dw_cfi_next = NULL;
660 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
661 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
666 /* Add a Call Frame Instruction to list of instructions. */
669 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
672 dw_fde_ref fde = current_fde ();
674 /* When DRAP is used, CFA is defined with an expression. Redefine
675 CFA may lead to a different CFA value. */
676 if (fde && fde->drap_reg != INVALID_REGNUM)
677 switch (cfi->dw_cfi_opc)
679 case DW_CFA_def_cfa_register:
680 case DW_CFA_def_cfa_offset:
681 case DW_CFA_def_cfa_offset_sf:
683 case DW_CFA_def_cfa_sf:
690 /* Find the end of the chain. */
691 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
697 /* Generate a new label for the CFI info to refer to. */
700 dwarf2out_cfi_label (void)
702 static char label[20];
704 if (dwarf2out_do_cfi_asm ())
706 /* In this case, we will be emitting the asm directive instead of
707 the label, so just return a placeholder to keep the rest of the
709 strcpy (label, "<do not output>");
713 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
714 ASM_OUTPUT_LABEL (asm_out_file, label);
720 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
721 or to the CIE if LABEL is NULL. */
724 add_fde_cfi (const char *label, dw_cfi_ref cfi)
726 dw_cfi_ref *list_head = &cie_cfi_head;
728 if (dwarf2out_do_cfi_asm ())
732 output_cfi_directive (cfi);
734 /* We still have to add the cfi to the list so that
735 lookup_cfa works later on. */
736 list_head = ¤t_fde ()->dw_fde_cfi;
738 /* ??? If this is a CFI for the CIE, we don't emit. This
739 assumes that the standard CIE contents that the assembler
740 uses matches the standard CIE contents that the compiler
741 uses. This is probably a bad assumption. I'm not quite
742 sure how to address this for now. */
746 dw_fde_ref fde = current_fde ();
748 gcc_assert (fde != NULL);
751 label = dwarf2out_cfi_label ();
753 if (fde->dw_fde_current_label == NULL
754 || strcmp (label, fde->dw_fde_current_label) != 0)
758 label = xstrdup (label);
760 /* Set the location counter to the new label. */
762 /* If we have a current label, advance from there, otherwise
763 set the location directly using set_loc. */
764 xcfi->dw_cfi_opc = fde->dw_fde_current_label
765 ? DW_CFA_advance_loc4
767 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
768 add_cfi (&fde->dw_fde_cfi, xcfi);
770 fde->dw_fde_current_label = label;
773 list_head = &fde->dw_fde_cfi;
776 add_cfi (list_head, cfi);
779 /* Subroutine of lookup_cfa. */
782 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
784 switch (cfi->dw_cfi_opc)
786 case DW_CFA_def_cfa_offset:
787 case DW_CFA_def_cfa_offset_sf:
788 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
790 case DW_CFA_def_cfa_register:
791 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
794 case DW_CFA_def_cfa_sf:
795 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
796 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
798 case DW_CFA_def_cfa_expression:
799 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
806 /* Find the previous value for the CFA. */
809 lookup_cfa (dw_cfa_location *loc)
814 loc->reg = INVALID_REGNUM;
817 loc->base_offset = 0;
819 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
820 lookup_cfa_1 (cfi, loc);
822 fde = current_fde ();
824 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
825 lookup_cfa_1 (cfi, loc);
828 /* The current rule for calculating the DWARF2 canonical frame address. */
829 static dw_cfa_location cfa;
831 /* The register used for saving registers to the stack, and its offset
833 static dw_cfa_location cfa_store;
835 /* The running total of the size of arguments pushed onto the stack. */
836 static HOST_WIDE_INT args_size;
838 /* The last args_size we actually output. */
839 static HOST_WIDE_INT old_args_size;
841 /* Entry point to update the canonical frame address (CFA).
842 LABEL is passed to add_fde_cfi. The value of CFA is now to be
843 calculated from REG+OFFSET. */
846 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
853 def_cfa_1 (label, &loc);
856 /* Determine if two dw_cfa_location structures define the same data. */
859 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
861 return (loc1->reg == loc2->reg
862 && loc1->offset == loc2->offset
863 && loc1->indirect == loc2->indirect
864 && (loc1->indirect == 0
865 || loc1->base_offset == loc2->base_offset));
868 /* This routine does the actual work. The CFA is now calculated from
869 the dw_cfa_location structure. */
872 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
875 dw_cfa_location old_cfa, loc;
880 if (cfa_store.reg == loc.reg && loc.indirect == 0)
881 cfa_store.offset = loc.offset;
883 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
884 lookup_cfa (&old_cfa);
886 /* If nothing changed, no need to issue any call frame instructions. */
887 if (cfa_equal_p (&loc, &old_cfa))
892 if (loc.reg == old_cfa.reg && !loc.indirect)
894 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
895 the CFA register did not change but the offset did. The data
896 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
897 in the assembler via the .cfi_def_cfa_offset directive. */
899 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
901 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
902 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
905 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
906 else if (loc.offset == old_cfa.offset
907 && old_cfa.reg != INVALID_REGNUM
910 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
911 indicating the CFA register has changed to <register> but the
912 offset has not changed. */
913 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
914 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
918 else if (loc.indirect == 0)
920 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
921 indicating the CFA register has changed to <register> with
922 the specified offset. The data factoring for DW_CFA_def_cfa_sf
923 happens in output_cfi, or in the assembler via the .cfi_def_cfa
926 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
928 cfi->dw_cfi_opc = DW_CFA_def_cfa;
929 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
930 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
934 /* Construct a DW_CFA_def_cfa_expression instruction to
935 calculate the CFA using a full location expression since no
936 register-offset pair is available. */
937 struct dw_loc_descr_struct *loc_list;
939 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
940 loc_list = build_cfa_loc (&loc, 0);
941 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
944 add_fde_cfi (label, cfi);
947 /* Add the CFI for saving a register. REG is the CFA column number.
948 LABEL is passed to add_fde_cfi.
949 If SREG is -1, the register is saved at OFFSET from the CFA;
950 otherwise it is saved in SREG. */
953 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
955 dw_cfi_ref cfi = new_cfi ();
956 dw_fde_ref fde = current_fde ();
958 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
960 /* When stack is aligned, store REG using DW_CFA_expression with
963 && fde->stack_realign
964 && sreg == INVALID_REGNUM)
966 cfi->dw_cfi_opc = DW_CFA_expression;
967 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = reg;
968 cfi->dw_cfi_oprnd1.dw_cfi_loc
969 = build_cfa_aligned_loc (offset, fde->stack_realignment);
971 else if (sreg == INVALID_REGNUM)
974 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
975 else if (reg & ~0x3f)
976 cfi->dw_cfi_opc = DW_CFA_offset_extended;
978 cfi->dw_cfi_opc = DW_CFA_offset;
979 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
981 else if (sreg == reg)
982 cfi->dw_cfi_opc = DW_CFA_same_value;
985 cfi->dw_cfi_opc = DW_CFA_register;
986 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
989 add_fde_cfi (label, cfi);
992 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
993 This CFI tells the unwinder that it needs to restore the window registers
994 from the previous frame's window save area.
996 ??? Perhaps we should note in the CIE where windows are saved (instead of
997 assuming 0(cfa)) and what registers are in the window. */
1000 dwarf2out_window_save (const char *label)
1002 dw_cfi_ref cfi = new_cfi ();
1004 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1005 add_fde_cfi (label, cfi);
1008 /* Add a CFI to update the running total of the size of arguments
1009 pushed onto the stack. */
1012 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1016 if (size == old_args_size)
1019 old_args_size = size;
1022 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1023 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1024 add_fde_cfi (label, cfi);
1027 /* Entry point for saving a register to the stack. REG is the GCC register
1028 number. LABEL and OFFSET are passed to reg_save. */
1031 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1033 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1036 /* Entry point for saving the return address in the stack.
1037 LABEL and OFFSET are passed to reg_save. */
1040 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1042 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1045 /* Entry point for saving the return address in a register.
1046 LABEL and SREG are passed to reg_save. */
1049 dwarf2out_return_reg (const char *label, unsigned int sreg)
1051 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1054 #ifdef DWARF2_UNWIND_INFO
1055 /* Record the initial position of the return address. RTL is
1056 INCOMING_RETURN_ADDR_RTX. */
1059 initial_return_save (rtx rtl)
1061 unsigned int reg = INVALID_REGNUM;
1062 HOST_WIDE_INT offset = 0;
1064 switch (GET_CODE (rtl))
1067 /* RA is in a register. */
1068 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1072 /* RA is on the stack. */
1073 rtl = XEXP (rtl, 0);
1074 switch (GET_CODE (rtl))
1077 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1082 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1083 offset = INTVAL (XEXP (rtl, 1));
1087 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1088 offset = -INTVAL (XEXP (rtl, 1));
1098 /* The return address is at some offset from any value we can
1099 actually load. For instance, on the SPARC it is in %i7+8. Just
1100 ignore the offset for now; it doesn't matter for unwinding frames. */
1101 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1102 initial_return_save (XEXP (rtl, 0));
1109 if (reg != DWARF_FRAME_RETURN_COLUMN)
1110 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1114 /* Given a SET, calculate the amount of stack adjustment it
1117 static HOST_WIDE_INT
1118 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1119 HOST_WIDE_INT cur_offset)
1121 const_rtx src = SET_SRC (pattern);
1122 const_rtx dest = SET_DEST (pattern);
1123 HOST_WIDE_INT offset = 0;
1126 if (dest == stack_pointer_rtx)
1128 code = GET_CODE (src);
1130 /* Assume (set (reg sp) (reg whatever)) sets args_size
1132 if (code == REG && src != stack_pointer_rtx)
1134 offset = -cur_args_size;
1135 #ifndef STACK_GROWS_DOWNWARD
1138 return offset - cur_offset;
1141 if (! (code == PLUS || code == MINUS)
1142 || XEXP (src, 0) != stack_pointer_rtx
1143 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1146 /* (set (reg sp) (plus (reg sp) (const_int))) */
1147 offset = INTVAL (XEXP (src, 1));
1153 if (MEM_P (src) && !MEM_P (dest))
1157 /* (set (mem (pre_dec (reg sp))) (foo)) */
1158 src = XEXP (dest, 0);
1159 code = GET_CODE (src);
1165 if (XEXP (src, 0) == stack_pointer_rtx)
1167 rtx val = XEXP (XEXP (src, 1), 1);
1168 /* We handle only adjustments by constant amount. */
1169 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1170 && GET_CODE (val) == CONST_INT);
1171 offset = -INTVAL (val);
1178 if (XEXP (src, 0) == stack_pointer_rtx)
1180 offset = GET_MODE_SIZE (GET_MODE (dest));
1187 if (XEXP (src, 0) == stack_pointer_rtx)
1189 offset = -GET_MODE_SIZE (GET_MODE (dest));
1204 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1205 indexed by INSN_UID. */
1207 static HOST_WIDE_INT *barrier_args_size;
1209 /* Helper function for compute_barrier_args_size. Handle one insn. */
1211 static HOST_WIDE_INT
1212 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1213 VEC (rtx, heap) **next)
1215 HOST_WIDE_INT offset = 0;
1218 if (! RTX_FRAME_RELATED_P (insn))
1220 if (prologue_epilogue_contains (insn)
1221 || sibcall_epilogue_contains (insn))
1223 else if (GET_CODE (PATTERN (insn)) == SET)
1224 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1225 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1226 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1228 /* There may be stack adjustments inside compound insns. Search
1230 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1231 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1232 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1233 cur_args_size, offset);
1238 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1242 expr = XEXP (expr, 0);
1243 if (GET_CODE (expr) == PARALLEL
1244 || GET_CODE (expr) == SEQUENCE)
1245 for (i = 1; i < XVECLEN (expr, 0); i++)
1247 rtx elem = XVECEXP (expr, 0, i);
1249 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1250 offset += stack_adjust_offset (elem, cur_args_size, offset);
1255 #ifndef STACK_GROWS_DOWNWARD
1259 cur_args_size += offset;
1260 if (cur_args_size < 0)
1265 rtx dest = JUMP_LABEL (insn);
1269 if (barrier_args_size [INSN_UID (dest)] < 0)
1271 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1272 VEC_safe_push (rtx, heap, *next, dest);
1277 return cur_args_size;
1280 /* Walk the whole function and compute args_size on BARRIERs. */
1283 compute_barrier_args_size (void)
1285 int max_uid = get_max_uid (), i;
1287 VEC (rtx, heap) *worklist, *next, *tmp;
1289 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1290 for (i = 0; i < max_uid; i++)
1291 barrier_args_size[i] = -1;
1293 worklist = VEC_alloc (rtx, heap, 20);
1294 next = VEC_alloc (rtx, heap, 20);
1295 insn = get_insns ();
1296 barrier_args_size[INSN_UID (insn)] = 0;
1297 VEC_quick_push (rtx, worklist, insn);
1300 while (!VEC_empty (rtx, worklist))
1302 rtx prev, body, first_insn;
1303 HOST_WIDE_INT cur_args_size;
1305 first_insn = insn = VEC_pop (rtx, worklist);
1306 cur_args_size = barrier_args_size[INSN_UID (insn)];
1307 prev = prev_nonnote_insn (insn);
1308 if (prev && BARRIER_P (prev))
1309 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1311 for (; insn; insn = NEXT_INSN (insn))
1313 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1315 if (BARRIER_P (insn))
1320 if (insn == first_insn)
1322 else if (barrier_args_size[INSN_UID (insn)] < 0)
1324 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1329 /* The insns starting with this label have been
1330 already scanned or are in the worklist. */
1335 body = PATTERN (insn);
1336 if (GET_CODE (body) == SEQUENCE)
1338 HOST_WIDE_INT dest_args_size = cur_args_size;
1339 for (i = 1; i < XVECLEN (body, 0); i++)
1340 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1341 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1343 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1344 dest_args_size, &next);
1347 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1348 cur_args_size, &next);
1350 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1351 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1352 dest_args_size, &next);
1355 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1356 cur_args_size, &next);
1360 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1364 if (VEC_empty (rtx, next))
1367 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1371 VEC_truncate (rtx, next, 0);
1374 VEC_free (rtx, heap, worklist);
1375 VEC_free (rtx, heap, next);
1379 /* Check INSN to see if it looks like a push or a stack adjustment, and
1380 make a note of it if it does. EH uses this information to find out how
1381 much extra space it needs to pop off the stack. */
1384 dwarf2out_stack_adjust (rtx insn, bool after_p)
1386 HOST_WIDE_INT offset;
1390 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1391 with this function. Proper support would require all frame-related
1392 insns to be marked, and to be able to handle saving state around
1393 epilogues textually in the middle of the function. */
1394 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1397 /* If INSN is an instruction from target of an annulled branch, the
1398 effects are for the target only and so current argument size
1399 shouldn't change at all. */
1401 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1402 && INSN_FROM_TARGET_P (insn))
1405 /* If only calls can throw, and we have a frame pointer,
1406 save up adjustments until we see the CALL_INSN. */
1407 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1409 if (CALL_P (insn) && !after_p)
1411 /* Extract the size of the args from the CALL rtx itself. */
1412 insn = PATTERN (insn);
1413 if (GET_CODE (insn) == PARALLEL)
1414 insn = XVECEXP (insn, 0, 0);
1415 if (GET_CODE (insn) == SET)
1416 insn = SET_SRC (insn);
1417 gcc_assert (GET_CODE (insn) == CALL);
1418 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1423 if (CALL_P (insn) && !after_p)
1425 if (!flag_asynchronous_unwind_tables)
1426 dwarf2out_args_size ("", args_size);
1429 else if (BARRIER_P (insn))
1431 /* Don't call compute_barrier_args_size () if the only
1432 BARRIER is at the end of function. */
1433 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1434 compute_barrier_args_size ();
1435 if (barrier_args_size == NULL)
1439 offset = barrier_args_size[INSN_UID (insn)];
1444 offset -= args_size;
1445 #ifndef STACK_GROWS_DOWNWARD
1449 else if (GET_CODE (PATTERN (insn)) == SET)
1450 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1451 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1452 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1454 /* There may be stack adjustments inside compound insns. Search
1456 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1457 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1458 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1467 label = dwarf2out_cfi_label ();
1468 dwarf2out_args_size_adjust (offset, label);
1471 /* Adjust args_size based on stack adjustment OFFSET. */
1474 dwarf2out_args_size_adjust (HOST_WIDE_INT offset, const char *label)
1476 if (cfa.reg == STACK_POINTER_REGNUM)
1477 cfa.offset += offset;
1479 if (cfa_store.reg == STACK_POINTER_REGNUM)
1480 cfa_store.offset += offset;
1482 #ifndef STACK_GROWS_DOWNWARD
1486 args_size += offset;
1490 def_cfa_1 (label, &cfa);
1491 if (flag_asynchronous_unwind_tables)
1492 dwarf2out_args_size (label, args_size);
1497 /* We delay emitting a register save until either (a) we reach the end
1498 of the prologue or (b) the register is clobbered. This clusters
1499 register saves so that there are fewer pc advances. */
1501 struct queued_reg_save GTY(())
1503 struct queued_reg_save *next;
1505 HOST_WIDE_INT cfa_offset;
1509 static GTY(()) struct queued_reg_save *queued_reg_saves;
1511 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1512 struct reg_saved_in_data GTY(()) {
1517 /* A list of registers saved in other registers.
1518 The list intentionally has a small maximum capacity of 4; if your
1519 port needs more than that, you might consider implementing a
1520 more efficient data structure. */
1521 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1522 static GTY(()) size_t num_regs_saved_in_regs;
1524 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1525 static const char *last_reg_save_label;
1527 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1528 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1531 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1533 struct queued_reg_save *q;
1535 /* Duplicates waste space, but it's also necessary to remove them
1536 for correctness, since the queue gets output in reverse
1538 for (q = queued_reg_saves; q != NULL; q = q->next)
1539 if (REGNO (q->reg) == REGNO (reg))
1544 q = GGC_NEW (struct queued_reg_save);
1545 q->next = queued_reg_saves;
1546 queued_reg_saves = q;
1550 q->cfa_offset = offset;
1551 q->saved_reg = sreg;
1553 last_reg_save_label = label;
1556 /* Output all the entries in QUEUED_REG_SAVES. */
1559 flush_queued_reg_saves (void)
1561 struct queued_reg_save *q;
1563 for (q = queued_reg_saves; q; q = q->next)
1566 unsigned int reg, sreg;
1568 for (i = 0; i < num_regs_saved_in_regs; i++)
1569 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1571 if (q->saved_reg && i == num_regs_saved_in_regs)
1573 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1574 num_regs_saved_in_regs++;
1576 if (i != num_regs_saved_in_regs)
1578 regs_saved_in_regs[i].orig_reg = q->reg;
1579 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1582 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1584 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1586 sreg = INVALID_REGNUM;
1587 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1590 queued_reg_saves = NULL;
1591 last_reg_save_label = NULL;
1594 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1595 location for? Or, does it clobber a register which we've previously
1596 said that some other register is saved in, and for which we now
1597 have a new location for? */
1600 clobbers_queued_reg_save (const_rtx insn)
1602 struct queued_reg_save *q;
1604 for (q = queued_reg_saves; q; q = q->next)
1607 if (modified_in_p (q->reg, insn))
1609 for (i = 0; i < num_regs_saved_in_regs; i++)
1610 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1611 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1618 /* Entry point for saving the first register into the second. */
1621 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1624 unsigned int regno, sregno;
1626 for (i = 0; i < num_regs_saved_in_regs; i++)
1627 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1629 if (i == num_regs_saved_in_regs)
1631 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1632 num_regs_saved_in_regs++;
1634 regs_saved_in_regs[i].orig_reg = reg;
1635 regs_saved_in_regs[i].saved_in_reg = sreg;
1637 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1638 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1639 reg_save (label, regno, sregno, 0);
1642 /* What register, if any, is currently saved in REG? */
1645 reg_saved_in (rtx reg)
1647 unsigned int regn = REGNO (reg);
1649 struct queued_reg_save *q;
1651 for (q = queued_reg_saves; q; q = q->next)
1652 if (q->saved_reg && regn == REGNO (q->saved_reg))
1655 for (i = 0; i < num_regs_saved_in_regs; i++)
1656 if (regs_saved_in_regs[i].saved_in_reg
1657 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1658 return regs_saved_in_regs[i].orig_reg;
1664 /* A temporary register holding an integral value used in adjusting SP
1665 or setting up the store_reg. The "offset" field holds the integer
1666 value, not an offset. */
1667 static dw_cfa_location cfa_temp;
1669 /* Record call frame debugging information for an expression EXPR,
1670 which either sets SP or FP (adjusting how we calculate the frame
1671 address) or saves a register to the stack or another register.
1672 LABEL indicates the address of EXPR.
1674 This function encodes a state machine mapping rtxes to actions on
1675 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1676 users need not read the source code.
1678 The High-Level Picture
1680 Changes in the register we use to calculate the CFA: Currently we
1681 assume that if you copy the CFA register into another register, we
1682 should take the other one as the new CFA register; this seems to
1683 work pretty well. If it's wrong for some target, it's simple
1684 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1686 Changes in the register we use for saving registers to the stack:
1687 This is usually SP, but not always. Again, we deduce that if you
1688 copy SP into another register (and SP is not the CFA register),
1689 then the new register is the one we will be using for register
1690 saves. This also seems to work.
1692 Register saves: There's not much guesswork about this one; if
1693 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1694 register save, and the register used to calculate the destination
1695 had better be the one we think we're using for this purpose.
1696 It's also assumed that a copy from a call-saved register to another
1697 register is saving that register if RTX_FRAME_RELATED_P is set on
1698 that instruction. If the copy is from a call-saved register to
1699 the *same* register, that means that the register is now the same
1700 value as in the caller.
1702 Except: If the register being saved is the CFA register, and the
1703 offset is nonzero, we are saving the CFA, so we assume we have to
1704 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1705 the intent is to save the value of SP from the previous frame.
1707 In addition, if a register has previously been saved to a different
1710 Invariants / Summaries of Rules
1712 cfa current rule for calculating the CFA. It usually
1713 consists of a register and an offset.
1714 cfa_store register used by prologue code to save things to the stack
1715 cfa_store.offset is the offset from the value of
1716 cfa_store.reg to the actual CFA
1717 cfa_temp register holding an integral value. cfa_temp.offset
1718 stores the value, which will be used to adjust the
1719 stack pointer. cfa_temp is also used like cfa_store,
1720 to track stores to the stack via fp or a temp reg.
1722 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1723 with cfa.reg as the first operand changes the cfa.reg and its
1724 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1727 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1728 expression yielding a constant. This sets cfa_temp.reg
1729 and cfa_temp.offset.
1731 Rule 5: Create a new register cfa_store used to save items to the
1734 Rules 10-14: Save a register to the stack. Define offset as the
1735 difference of the original location and cfa_store's
1736 location (or cfa_temp's location if cfa_temp is used).
1738 Rules 16-20: If AND operation happens on sp in prologue, we assume
1739 stack is realigned. We will use a group of DW_OP_XXX
1740 expressions to represent the location of the stored
1741 register instead of CFA+offset.
1745 "{a,b}" indicates a choice of a xor b.
1746 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1749 (set <reg1> <reg2>:cfa.reg)
1750 effects: cfa.reg = <reg1>
1751 cfa.offset unchanged
1752 cfa_temp.reg = <reg1>
1753 cfa_temp.offset = cfa.offset
1756 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1757 {<const_int>,<reg>:cfa_temp.reg}))
1758 effects: cfa.reg = sp if fp used
1759 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1760 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1761 if cfa_store.reg==sp
1764 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1765 effects: cfa.reg = fp
1766 cfa_offset += +/- <const_int>
1769 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1770 constraints: <reg1> != fp
1772 effects: cfa.reg = <reg1>
1773 cfa_temp.reg = <reg1>
1774 cfa_temp.offset = cfa.offset
1777 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1778 constraints: <reg1> != fp
1780 effects: cfa_store.reg = <reg1>
1781 cfa_store.offset = cfa.offset - cfa_temp.offset
1784 (set <reg> <const_int>)
1785 effects: cfa_temp.reg = <reg>
1786 cfa_temp.offset = <const_int>
1789 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1790 effects: cfa_temp.reg = <reg1>
1791 cfa_temp.offset |= <const_int>
1794 (set <reg> (high <exp>))
1798 (set <reg> (lo_sum <exp> <const_int>))
1799 effects: cfa_temp.reg = <reg>
1800 cfa_temp.offset = <const_int>
1803 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1804 effects: cfa_store.offset -= <const_int>
1805 cfa.offset = cfa_store.offset if cfa.reg == sp
1807 cfa.base_offset = -cfa_store.offset
1810 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1811 effects: cfa_store.offset += -/+ mode_size(mem)
1812 cfa.offset = cfa_store.offset if cfa.reg == sp
1814 cfa.base_offset = -cfa_store.offset
1817 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1820 effects: cfa.reg = <reg1>
1821 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1824 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1825 effects: cfa.reg = <reg1>
1826 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1829 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1830 effects: cfa.reg = <reg1>
1831 cfa.base_offset = -cfa_temp.offset
1832 cfa_temp.offset -= mode_size(mem)
1835 (set <reg> {unspec, unspec_volatile})
1836 effects: target-dependent
1839 (set sp (and: sp <const_int>))
1840 constraints: cfa_store.reg == sp
1841 effects: current_fde.stack_realign = 1
1842 cfa_store.offset = 0
1843 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
1846 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
1847 effects: cfa_store.offset += -/+ mode_size(mem)
1850 (set (mem ({pre_inc, pre_dec} sp)) fp)
1851 constraints: fde->stack_realign == 1
1852 effects: cfa_store.offset = 0
1853 cfa.reg != HARD_FRAME_POINTER_REGNUM
1856 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
1857 constraints: fde->stack_realign == 1
1859 && cfa.indirect == 0
1860 && cfa.reg != HARD_FRAME_POINTER_REGNUM
1861 effects: Use DW_CFA_def_cfa_expression to define cfa
1862 cfa.reg == fde->drap_reg
1865 (set reg fde->drap_reg)
1866 constraints: fde->vdrap_reg == INVALID_REGNUM
1867 effects: fde->vdrap_reg = reg.
1868 (set mem fde->drap_reg)
1869 constraints: fde->drap_reg_saved == 1
1873 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1875 rtx src, dest, span;
1876 HOST_WIDE_INT offset;
1879 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1880 the PARALLEL independently. The first element is always processed if
1881 it is a SET. This is for backward compatibility. Other elements
1882 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1883 flag is set in them. */
1884 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1887 int limit = XVECLEN (expr, 0);
1890 /* PARALLELs have strict read-modify-write semantics, so we
1891 ought to evaluate every rvalue before changing any lvalue.
1892 It's cumbersome to do that in general, but there's an
1893 easy approximation that is enough for all current users:
1894 handle register saves before register assignments. */
1895 if (GET_CODE (expr) == PARALLEL)
1896 for (par_index = 0; par_index < limit; par_index++)
1898 elem = XVECEXP (expr, 0, par_index);
1899 if (GET_CODE (elem) == SET
1900 && MEM_P (SET_DEST (elem))
1901 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1902 dwarf2out_frame_debug_expr (elem, label);
1905 for (par_index = 0; par_index < limit; par_index++)
1907 elem = XVECEXP (expr, 0, par_index);
1908 if (GET_CODE (elem) == SET
1909 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
1910 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
1911 dwarf2out_frame_debug_expr (elem, label);
1912 else if (GET_CODE (elem) == SET
1914 && !RTX_FRAME_RELATED_P (elem))
1916 /* Stack adjustment combining might combine some post-prologue
1917 stack adjustment into a prologue stack adjustment. */
1918 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
1921 dwarf2out_args_size_adjust (offset, label);
1927 gcc_assert (GET_CODE (expr) == SET);
1929 src = SET_SRC (expr);
1930 dest = SET_DEST (expr);
1934 rtx rsi = reg_saved_in (src);
1939 fde = current_fde ();
1941 if (GET_CODE (src) == REG
1943 && fde->drap_reg == REGNO (src)
1944 && (fde->drap_reg_saved
1945 || GET_CODE (dest) == REG))
1948 /* If we are saving dynamic realign argument pointer to a
1949 register, the destination is virtual dynamic realign
1950 argument pointer. It may be used to access argument. */
1951 if (GET_CODE (dest) == REG)
1953 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
1954 fde->vdrap_reg = REGNO (dest);
1959 switch (GET_CODE (dest))
1962 switch (GET_CODE (src))
1964 /* Setting FP from SP. */
1966 if (cfa.reg == (unsigned) REGNO (src))
1969 /* Update the CFA rule wrt SP or FP. Make sure src is
1970 relative to the current CFA register.
1972 We used to require that dest be either SP or FP, but the
1973 ARM copies SP to a temporary register, and from there to
1974 FP. So we just rely on the backends to only set
1975 RTX_FRAME_RELATED_P on appropriate insns. */
1976 cfa.reg = REGNO (dest);
1977 cfa_temp.reg = cfa.reg;
1978 cfa_temp.offset = cfa.offset;
1982 /* Saving a register in a register. */
1983 gcc_assert (!fixed_regs [REGNO (dest)]
1984 /* For the SPARC and its register window. */
1985 || (DWARF_FRAME_REGNUM (REGNO (src))
1986 == DWARF_FRAME_RETURN_COLUMN));
1988 /* After stack is aligned, we can only save SP in FP
1989 if drap register is used. In this case, we have
1990 to restore stack pointer with the CFA value and we
1991 don't generate this DWARF information. */
1993 && fde->stack_realign
1994 && REGNO (src) == STACK_POINTER_REGNUM)
1995 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
1996 && fde->drap_reg != INVALID_REGNUM
1997 && cfa.reg != REGNO (src));
1999 queue_reg_save (label, src, dest, 0);
2006 if (dest == stack_pointer_rtx)
2010 switch (GET_CODE (XEXP (src, 1)))
2013 offset = INTVAL (XEXP (src, 1));
2016 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2018 offset = cfa_temp.offset;
2024 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2026 /* Restoring SP from FP in the epilogue. */
2027 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2028 cfa.reg = STACK_POINTER_REGNUM;
2030 else if (GET_CODE (src) == LO_SUM)
2031 /* Assume we've set the source reg of the LO_SUM from sp. */
2034 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2036 if (GET_CODE (src) != MINUS)
2038 if (cfa.reg == STACK_POINTER_REGNUM)
2039 cfa.offset += offset;
2040 if (cfa_store.reg == STACK_POINTER_REGNUM)
2041 cfa_store.offset += offset;
2043 else if (dest == hard_frame_pointer_rtx)
2046 /* Either setting the FP from an offset of the SP,
2047 or adjusting the FP */
2048 gcc_assert (frame_pointer_needed);
2050 gcc_assert (REG_P (XEXP (src, 0))
2051 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2052 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2053 offset = INTVAL (XEXP (src, 1));
2054 if (GET_CODE (src) != MINUS)
2056 cfa.offset += offset;
2057 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2061 gcc_assert (GET_CODE (src) != MINUS);
2064 if (REG_P (XEXP (src, 0))
2065 && REGNO (XEXP (src, 0)) == cfa.reg
2066 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2068 /* Setting a temporary CFA register that will be copied
2069 into the FP later on. */
2070 offset = - INTVAL (XEXP (src, 1));
2071 cfa.offset += offset;
2072 cfa.reg = REGNO (dest);
2073 /* Or used to save regs to the stack. */
2074 cfa_temp.reg = cfa.reg;
2075 cfa_temp.offset = cfa.offset;
2079 else if (REG_P (XEXP (src, 0))
2080 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2081 && XEXP (src, 1) == stack_pointer_rtx)
2083 /* Setting a scratch register that we will use instead
2084 of SP for saving registers to the stack. */
2085 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2086 cfa_store.reg = REGNO (dest);
2087 cfa_store.offset = cfa.offset - cfa_temp.offset;
2091 else if (GET_CODE (src) == LO_SUM
2092 && GET_CODE (XEXP (src, 1)) == CONST_INT)
2094 cfa_temp.reg = REGNO (dest);
2095 cfa_temp.offset = INTVAL (XEXP (src, 1));
2104 cfa_temp.reg = REGNO (dest);
2105 cfa_temp.offset = INTVAL (src);
2110 gcc_assert (REG_P (XEXP (src, 0))
2111 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2112 && GET_CODE (XEXP (src, 1)) == CONST_INT);
2114 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2115 cfa_temp.reg = REGNO (dest);
2116 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2119 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2120 which will fill in all of the bits. */
2127 case UNSPEC_VOLATILE:
2128 gcc_assert (targetm.dwarf_handle_frame_unspec);
2129 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2134 /* If this AND operation happens on stack pointer in prologue,
2135 we assume the stack is realigned and we extract the
2137 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2139 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2140 fde->stack_realign = 1;
2141 fde->stack_realignment = INTVAL (XEXP (src, 1));
2142 cfa_store.offset = 0;
2144 if (cfa.reg != STACK_POINTER_REGNUM
2145 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2146 fde->drap_reg = cfa.reg;
2154 def_cfa_1 (label, &cfa);
2159 /* Saving a register to the stack. Make sure dest is relative to the
2161 switch (GET_CODE (XEXP (dest, 0)))
2166 /* We can't handle variable size modifications. */
2167 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2169 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2171 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2172 && cfa_store.reg == STACK_POINTER_REGNUM);
2174 cfa_store.offset += offset;
2175 if (cfa.reg == STACK_POINTER_REGNUM)
2176 cfa.offset = cfa_store.offset;
2178 offset = -cfa_store.offset;
2184 offset = GET_MODE_SIZE (GET_MODE (dest));
2185 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2188 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2189 == STACK_POINTER_REGNUM)
2190 && cfa_store.reg == STACK_POINTER_REGNUM);
2192 cfa_store.offset += offset;
2194 /* Rule 18: If stack is aligned, we will use FP as a
2195 reference to represent the address of the stored
2198 && fde->stack_realign
2199 && src == hard_frame_pointer_rtx)
2201 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2202 cfa_store.offset = 0;
2205 if (cfa.reg == STACK_POINTER_REGNUM)
2206 cfa.offset = cfa_store.offset;
2208 offset = -cfa_store.offset;
2212 /* With an offset. */
2219 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT
2220 && REG_P (XEXP (XEXP (dest, 0), 0)));
2221 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2222 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2225 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2227 if (cfa_store.reg == (unsigned) regno)
2228 offset -= cfa_store.offset;
2231 gcc_assert (cfa_temp.reg == (unsigned) regno);
2232 offset -= cfa_temp.offset;
2238 /* Without an offset. */
2241 int regno = REGNO (XEXP (dest, 0));
2243 if (cfa_store.reg == (unsigned) regno)
2244 offset = -cfa_store.offset;
2247 gcc_assert (cfa_temp.reg == (unsigned) regno);
2248 offset = -cfa_temp.offset;
2255 gcc_assert (cfa_temp.reg
2256 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2257 offset = -cfa_temp.offset;
2258 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2266 /* If the source operand of this MEM operation is not a
2267 register, basically the source is return address. Here
2268 we only care how much stack grew and we don't save it. */
2272 if (REGNO (src) != STACK_POINTER_REGNUM
2273 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2274 && (unsigned) REGNO (src) == cfa.reg)
2276 /* We're storing the current CFA reg into the stack. */
2278 if (cfa.offset == 0)
2281 /* If stack is aligned, putting CFA reg into stack means
2282 we can no longer use reg + offset to represent CFA.
2283 Here we use DW_CFA_def_cfa_expression instead. The
2284 result of this expression equals to the original CFA
2287 && fde->stack_realign
2288 && cfa.indirect == 0
2289 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2291 dw_cfa_location cfa_exp;
2293 gcc_assert (fde->drap_reg == cfa.reg);
2295 cfa_exp.indirect = 1;
2296 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2297 cfa_exp.base_offset = offset;
2300 fde->drap_reg_saved = 1;
2302 def_cfa_1 (label, &cfa_exp);
2306 /* If the source register is exactly the CFA, assume
2307 we're saving SP like any other register; this happens
2309 def_cfa_1 (label, &cfa);
2310 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2315 /* Otherwise, we'll need to look in the stack to
2316 calculate the CFA. */
2317 rtx x = XEXP (dest, 0);
2321 gcc_assert (REG_P (x));
2323 cfa.reg = REGNO (x);
2324 cfa.base_offset = offset;
2326 def_cfa_1 (label, &cfa);
2331 def_cfa_1 (label, &cfa);
2333 span = targetm.dwarf_register_span (src);
2336 queue_reg_save (label, src, NULL_RTX, offset);
2339 /* We have a PARALLEL describing where the contents of SRC
2340 live. Queue register saves for each piece of the
2344 HOST_WIDE_INT span_offset = offset;
2346 gcc_assert (GET_CODE (span) == PARALLEL);
2348 limit = XVECLEN (span, 0);
2349 for (par_index = 0; par_index < limit; par_index++)
2351 rtx elem = XVECEXP (span, 0, par_index);
2353 queue_reg_save (label, elem, NULL_RTX, span_offset);
2354 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2365 /* Record call frame debugging information for INSN, which either
2366 sets SP or FP (adjusting how we calculate the frame address) or saves a
2367 register to the stack. If INSN is NULL_RTX, initialize our state.
2369 If AFTER_P is false, we're being called before the insn is emitted,
2370 otherwise after. Call instructions get invoked twice. */
2373 dwarf2out_frame_debug (rtx insn, bool after_p)
2378 if (insn == NULL_RTX)
2382 /* Flush any queued register saves. */
2383 flush_queued_reg_saves ();
2385 /* Set up state for generating call frame debug info. */
2388 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2390 cfa.reg = STACK_POINTER_REGNUM;
2393 cfa_temp.offset = 0;
2395 for (i = 0; i < num_regs_saved_in_regs; i++)
2397 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2398 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2400 num_regs_saved_in_regs = 0;
2402 if (barrier_args_size)
2404 XDELETEVEC (barrier_args_size);
2405 barrier_args_size = NULL;
2410 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2411 flush_queued_reg_saves ();
2413 if (! RTX_FRAME_RELATED_P (insn))
2415 if (!ACCUMULATE_OUTGOING_ARGS)
2416 dwarf2out_stack_adjust (insn, after_p);
2420 label = dwarf2out_cfi_label ();
2421 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
2423 insn = XEXP (src, 0);
2425 insn = PATTERN (insn);
2427 dwarf2out_frame_debug_expr (insn, label);
2432 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2433 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2434 (enum dwarf_call_frame_info cfi);
2436 static enum dw_cfi_oprnd_type
2437 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2442 case DW_CFA_GNU_window_save:
2443 return dw_cfi_oprnd_unused;
2445 case DW_CFA_set_loc:
2446 case DW_CFA_advance_loc1:
2447 case DW_CFA_advance_loc2:
2448 case DW_CFA_advance_loc4:
2449 case DW_CFA_MIPS_advance_loc8:
2450 return dw_cfi_oprnd_addr;
2453 case DW_CFA_offset_extended:
2454 case DW_CFA_def_cfa:
2455 case DW_CFA_offset_extended_sf:
2456 case DW_CFA_def_cfa_sf:
2457 case DW_CFA_restore_extended:
2458 case DW_CFA_undefined:
2459 case DW_CFA_same_value:
2460 case DW_CFA_def_cfa_register:
2461 case DW_CFA_register:
2462 return dw_cfi_oprnd_reg_num;
2464 case DW_CFA_def_cfa_offset:
2465 case DW_CFA_GNU_args_size:
2466 case DW_CFA_def_cfa_offset_sf:
2467 return dw_cfi_oprnd_offset;
2469 case DW_CFA_def_cfa_expression:
2470 case DW_CFA_expression:
2471 return dw_cfi_oprnd_loc;
2478 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2479 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2480 (enum dwarf_call_frame_info cfi);
2482 static enum dw_cfi_oprnd_type
2483 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2487 case DW_CFA_def_cfa:
2488 case DW_CFA_def_cfa_sf:
2490 case DW_CFA_offset_extended_sf:
2491 case DW_CFA_offset_extended:
2492 return dw_cfi_oprnd_offset;
2494 case DW_CFA_register:
2495 return dw_cfi_oprnd_reg_num;
2498 return dw_cfi_oprnd_unused;
2502 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2504 /* Switch to eh_frame_section. If we don't have an eh_frame_section,
2505 switch to the data section instead, and write out a synthetic label
2509 switch_to_eh_frame_section (void)
2513 #ifdef EH_FRAME_SECTION_NAME
2514 if (eh_frame_section == 0)
2518 if (EH_TABLES_CAN_BE_READ_ONLY)
2524 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2526 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2528 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2530 flags = ((! flag_pic
2531 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
2532 && (fde_encoding & 0x70) != DW_EH_PE_aligned
2533 && (per_encoding & 0x70) != DW_EH_PE_absptr
2534 && (per_encoding & 0x70) != DW_EH_PE_aligned
2535 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
2536 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
2537 ? 0 : SECTION_WRITE);
2540 flags = SECTION_WRITE;
2541 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
2545 if (eh_frame_section)
2546 switch_to_section (eh_frame_section);
2549 /* We have no special eh_frame section. Put the information in
2550 the data section and emit special labels to guide collect2. */
2551 switch_to_section (data_section);
2552 label = get_file_function_name ("F");
2553 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2554 targetm.asm_out.globalize_label (asm_out_file,
2555 IDENTIFIER_POINTER (label));
2556 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
2560 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
2562 static HOST_WIDE_INT
2563 div_data_align (HOST_WIDE_INT off)
2565 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
2566 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
2570 /* Output a Call Frame Information opcode and its operand(s). */
2573 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2578 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2579 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2580 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2581 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2582 ((unsigned HOST_WIDE_INT)
2583 cfi->dw_cfi_oprnd1.dw_cfi_offset));
2584 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2586 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2587 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2588 "DW_CFA_offset, column 0x%lx", r);
2589 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2590 dw2_asm_output_data_uleb128 (off, NULL);
2592 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2594 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2595 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2596 "DW_CFA_restore, column 0x%lx", r);
2600 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2601 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2603 switch (cfi->dw_cfi_opc)
2605 case DW_CFA_set_loc:
2607 dw2_asm_output_encoded_addr_rtx (
2608 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2609 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2612 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2613 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2614 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2617 case DW_CFA_advance_loc1:
2618 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2619 fde->dw_fde_current_label, NULL);
2620 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2623 case DW_CFA_advance_loc2:
2624 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2625 fde->dw_fde_current_label, NULL);
2626 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2629 case DW_CFA_advance_loc4:
2630 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2631 fde->dw_fde_current_label, NULL);
2632 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2635 case DW_CFA_MIPS_advance_loc8:
2636 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2637 fde->dw_fde_current_label, NULL);
2638 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2641 case DW_CFA_offset_extended:
2642 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2643 dw2_asm_output_data_uleb128 (r, NULL);
2644 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2645 dw2_asm_output_data_uleb128 (off, NULL);
2648 case DW_CFA_def_cfa:
2649 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2650 dw2_asm_output_data_uleb128 (r, NULL);
2651 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2654 case DW_CFA_offset_extended_sf:
2655 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2656 dw2_asm_output_data_uleb128 (r, NULL);
2657 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2658 dw2_asm_output_data_sleb128 (off, NULL);
2661 case DW_CFA_def_cfa_sf:
2662 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2663 dw2_asm_output_data_uleb128 (r, NULL);
2664 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
2665 dw2_asm_output_data_sleb128 (off, NULL);
2668 case DW_CFA_restore_extended:
2669 case DW_CFA_undefined:
2670 case DW_CFA_same_value:
2671 case DW_CFA_def_cfa_register:
2672 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2673 dw2_asm_output_data_uleb128 (r, NULL);
2676 case DW_CFA_register:
2677 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2678 dw2_asm_output_data_uleb128 (r, NULL);
2679 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2680 dw2_asm_output_data_uleb128 (r, NULL);
2683 case DW_CFA_def_cfa_offset:
2684 case DW_CFA_GNU_args_size:
2685 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2688 case DW_CFA_def_cfa_offset_sf:
2689 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
2690 dw2_asm_output_data_sleb128 (off, NULL);
2693 case DW_CFA_GNU_window_save:
2696 case DW_CFA_def_cfa_expression:
2697 case DW_CFA_expression:
2698 output_cfa_loc (cfi);
2701 case DW_CFA_GNU_negative_offset_extended:
2702 /* Obsoleted by DW_CFA_offset_extended_sf. */
2711 /* Similar, but do it via assembler directives instead. */
2714 output_cfi_directive (dw_cfi_ref cfi)
2716 unsigned long r, r2;
2718 switch (cfi->dw_cfi_opc)
2720 case DW_CFA_advance_loc:
2721 case DW_CFA_advance_loc1:
2722 case DW_CFA_advance_loc2:
2723 case DW_CFA_advance_loc4:
2724 case DW_CFA_MIPS_advance_loc8:
2725 case DW_CFA_set_loc:
2726 /* Should only be created by add_fde_cfi in a code path not
2727 followed when emitting via directives. The assembler is
2728 going to take care of this for us. */
2732 case DW_CFA_offset_extended:
2733 case DW_CFA_offset_extended_sf:
2734 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2735 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
2736 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
2739 case DW_CFA_restore:
2740 case DW_CFA_restore_extended:
2741 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2742 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
2745 case DW_CFA_undefined:
2746 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2747 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
2750 case DW_CFA_same_value:
2751 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2752 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
2755 case DW_CFA_def_cfa:
2756 case DW_CFA_def_cfa_sf:
2757 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2758 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
2759 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
2762 case DW_CFA_def_cfa_register:
2763 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2764 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
2767 case DW_CFA_register:
2768 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 0);
2769 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 0);
2770 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
2773 case DW_CFA_def_cfa_offset:
2774 case DW_CFA_def_cfa_offset_sf:
2775 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
2776 HOST_WIDE_INT_PRINT_DEC"\n",
2777 cfi->dw_cfi_oprnd1.dw_cfi_offset);
2780 case DW_CFA_GNU_args_size:
2781 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size);
2782 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
2784 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
2785 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
2786 fputc ('\n', asm_out_file);
2789 case DW_CFA_GNU_window_save:
2790 fprintf (asm_out_file, "\t.cfi_window_save\n");
2793 case DW_CFA_def_cfa_expression:
2794 case DW_CFA_expression:
2795 fprintf (asm_out_file, "\t.cfi_escape 0x%x,", cfi->dw_cfi_opc);
2796 output_cfa_loc_raw (cfi);
2797 fputc ('\n', asm_out_file);
2805 /* Output the call frame information used to record information
2806 that relates to calculating the frame pointer, and records the
2807 location of saved registers. */
2810 output_call_frame_info (int for_eh)
2815 char l1[20], l2[20], section_start_label[20];
2816 bool any_lsda_needed = false;
2817 char augmentation[6];
2818 int augmentation_size;
2819 int fde_encoding = DW_EH_PE_absptr;
2820 int per_encoding = DW_EH_PE_absptr;
2821 int lsda_encoding = DW_EH_PE_absptr;
2824 /* Don't emit a CIE if there won't be any FDEs. */
2825 if (fde_table_in_use == 0)
2828 /* Nothing to do if the assembler's doing it all. */
2829 if (dwarf2out_do_cfi_asm ())
2832 /* If we make FDEs linkonce, we may have to emit an empty label for
2833 an FDE that wouldn't otherwise be emitted. We want to avoid
2834 having an FDE kept around when the function it refers to is
2835 discarded. Example where this matters: a primary function
2836 template in C++ requires EH information, but an explicit
2837 specialization doesn't. */
2838 if (TARGET_USES_WEAK_UNWIND_INFO
2839 && ! flag_asynchronous_unwind_tables
2842 for (i = 0; i < fde_table_in_use; i++)
2843 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2844 && !fde_table[i].uses_eh_lsda
2845 && ! DECL_WEAK (fde_table[i].decl))
2846 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2847 for_eh, /* empty */ 1);
2849 /* If we don't have any functions we'll want to unwind out of, don't
2850 emit any EH unwind information. Note that if exceptions aren't
2851 enabled, we won't have collected nothrow information, and if we
2852 asked for asynchronous tables, we always want this info. */
2855 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2857 for (i = 0; i < fde_table_in_use; i++)
2858 if (fde_table[i].uses_eh_lsda)
2859 any_eh_needed = any_lsda_needed = true;
2860 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2861 any_eh_needed = true;
2862 else if (! fde_table[i].nothrow
2863 && ! fde_table[i].all_throwers_are_sibcalls)
2864 any_eh_needed = true;
2866 if (! any_eh_needed)
2870 /* We're going to be generating comments, so turn on app. */
2875 switch_to_eh_frame_section ();
2878 if (!debug_frame_section)
2879 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
2880 SECTION_DEBUG, NULL);
2881 switch_to_section (debug_frame_section);
2884 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2885 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2887 /* Output the CIE. */
2888 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2889 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2890 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
2891 dw2_asm_output_data (4, 0xffffffff,
2892 "Initial length escape value indicating 64-bit DWARF extension");
2893 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2894 "Length of Common Information Entry");
2895 ASM_OUTPUT_LABEL (asm_out_file, l1);
2897 /* Now that the CIE pointer is PC-relative for EH,
2898 use 0 to identify the CIE. */
2899 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2900 (for_eh ? 0 : DWARF_CIE_ID),
2901 "CIE Identifier Tag");
2903 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2905 augmentation[0] = 0;
2906 augmentation_size = 0;
2912 z Indicates that a uleb128 is present to size the
2913 augmentation section.
2914 L Indicates the encoding (and thus presence) of
2915 an LSDA pointer in the FDE augmentation.
2916 R Indicates a non-default pointer encoding for
2918 P Indicates the presence of an encoding + language
2919 personality routine in the CIE augmentation. */
2921 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2922 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2923 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2925 p = augmentation + 1;
2926 if (eh_personality_libfunc)
2929 augmentation_size += 1 + size_of_encoded_value (per_encoding);
2930 assemble_external_libcall (eh_personality_libfunc);
2932 if (any_lsda_needed)
2935 augmentation_size += 1;
2937 if (fde_encoding != DW_EH_PE_absptr)
2940 augmentation_size += 1;
2942 if (p > augmentation + 1)
2944 augmentation[0] = 'z';
2948 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2949 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2951 int offset = ( 4 /* Length */
2953 + 1 /* CIE version */
2954 + strlen (augmentation) + 1 /* Augmentation */
2955 + size_of_uleb128 (1) /* Code alignment */
2956 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2958 + 1 /* Augmentation size */
2959 + 1 /* Personality encoding */ );
2960 int pad = -offset & (PTR_SIZE - 1);
2962 augmentation_size += pad;
2964 /* Augmentations should be small, so there's scarce need to
2965 iterate for a solution. Die if we exceed one uleb128 byte. */
2966 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2970 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2971 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2972 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2973 "CIE Data Alignment Factor");
2975 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2976 if (DW_CIE_VERSION == 1)
2977 dw2_asm_output_data (1, return_reg, "CIE RA Column");
2979 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2981 if (augmentation[0])
2983 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2984 if (eh_personality_libfunc)
2986 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2987 eh_data_format_name (per_encoding));
2988 dw2_asm_output_encoded_addr_rtx (per_encoding,
2989 eh_personality_libfunc,
2993 if (any_lsda_needed)
2994 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2995 eh_data_format_name (lsda_encoding));
2997 if (fde_encoding != DW_EH_PE_absptr)
2998 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2999 eh_data_format_name (fde_encoding));
3002 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3003 output_cfi (cfi, NULL, for_eh);
3005 /* Pad the CIE out to an address sized boundary. */
3006 ASM_OUTPUT_ALIGN (asm_out_file,
3007 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3008 ASM_OUTPUT_LABEL (asm_out_file, l2);
3010 /* Loop through all of the FDE's. */
3011 for (i = 0; i < fde_table_in_use; i++)
3013 fde = &fde_table[i];
3015 /* Don't emit EH unwind info for leaf functions that don't need it. */
3016 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
3017 && (fde->nothrow || fde->all_throwers_are_sibcalls)
3018 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
3019 && !fde->uses_eh_lsda)
3022 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
3023 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
3024 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
3025 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
3026 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3027 dw2_asm_output_data (4, 0xffffffff,
3028 "Initial length escape value indicating 64-bit DWARF extension");
3029 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3031 ASM_OUTPUT_LABEL (asm_out_file, l1);
3034 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3036 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3037 debug_frame_section, "FDE CIE offset");
3041 if (fde->dw_fde_switched_sections)
3043 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
3044 fde->dw_fde_unlikely_section_label);
3045 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
3046 fde->dw_fde_hot_section_label);
3047 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
3048 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
3049 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
3050 "FDE initial location");
3051 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3052 fde->dw_fde_hot_section_end_label,
3053 fde->dw_fde_hot_section_label,
3054 "FDE address range");
3055 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
3056 "FDE initial location");
3057 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3058 fde->dw_fde_unlikely_section_end_label,
3059 fde->dw_fde_unlikely_section_label,
3060 "FDE address range");
3064 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
3065 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3066 dw2_asm_output_encoded_addr_rtx (fde_encoding,
3069 "FDE initial location");
3070 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3071 fde->dw_fde_end, fde->dw_fde_begin,
3072 "FDE address range");
3077 if (fde->dw_fde_switched_sections)
3079 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3080 fde->dw_fde_hot_section_label,
3081 "FDE initial location");
3082 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3083 fde->dw_fde_hot_section_end_label,
3084 fde->dw_fde_hot_section_label,
3085 "FDE address range");
3086 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3087 fde->dw_fde_unlikely_section_label,
3088 "FDE initial location");
3089 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3090 fde->dw_fde_unlikely_section_end_label,
3091 fde->dw_fde_unlikely_section_label,
3092 "FDE address range");
3096 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
3097 "FDE initial location");
3098 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
3099 fde->dw_fde_end, fde->dw_fde_begin,
3100 "FDE address range");
3104 if (augmentation[0])
3106 if (any_lsda_needed)
3108 int size = size_of_encoded_value (lsda_encoding);
3110 if (lsda_encoding == DW_EH_PE_aligned)
3112 int offset = ( 4 /* Length */
3113 + 4 /* CIE offset */
3114 + 2 * size_of_encoded_value (fde_encoding)
3115 + 1 /* Augmentation size */ );
3116 int pad = -offset & (PTR_SIZE - 1);
3119 gcc_assert (size_of_uleb128 (size) == 1);
3122 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3124 if (fde->uses_eh_lsda)
3126 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
3127 fde->funcdef_number);
3128 dw2_asm_output_encoded_addr_rtx (
3129 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
3130 false, "Language Specific Data Area");
3134 if (lsda_encoding == DW_EH_PE_aligned)
3135 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3137 (size_of_encoded_value (lsda_encoding), 0,
3138 "Language Specific Data Area (none)");
3142 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3145 /* Loop through the Call Frame Instructions associated with
3147 fde->dw_fde_current_label = fde->dw_fde_begin;
3148 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3149 output_cfi (cfi, fde, for_eh);
3151 /* Pad the FDE out to an address sized boundary. */
3152 ASM_OUTPUT_ALIGN (asm_out_file,
3153 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3154 ASM_OUTPUT_LABEL (asm_out_file, l2);
3157 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3158 dw2_asm_output_data (4, 0, "End of Table");
3159 #ifdef MIPS_DEBUGGING_INFO
3160 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3161 get a value of 0. Putting .align 0 after the label fixes it. */
3162 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3165 /* Turn off app to make assembly quicker. */
3170 /* Output a marker (i.e. a label) for the beginning of a function, before
3174 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3175 const char *file ATTRIBUTE_UNUSED)
3177 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3181 current_function_func_begin_label = NULL;
3183 #ifdef TARGET_UNWIND_INFO
3184 /* ??? current_function_func_begin_label is also used by except.c
3185 for call-site information. We must emit this label if it might
3187 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3188 && ! dwarf2out_do_frame ())
3191 if (! dwarf2out_do_frame ())
3195 switch_to_section (function_section (current_function_decl));
3196 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3197 current_function_funcdef_no);
3198 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3199 current_function_funcdef_no);
3200 dup_label = xstrdup (label);
3201 current_function_func_begin_label = dup_label;
3203 #ifdef TARGET_UNWIND_INFO
3204 /* We can elide the fde allocation if we're not emitting debug info. */
3205 if (! dwarf2out_do_frame ())
3209 /* Expand the fde table if necessary. */
3210 if (fde_table_in_use == fde_table_allocated)
3212 fde_table_allocated += FDE_TABLE_INCREMENT;
3213 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3214 memset (fde_table + fde_table_in_use, 0,
3215 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3218 /* Record the FDE associated with this function. */
3219 current_funcdef_fde = fde_table_in_use;
3221 /* Add the new FDE at the end of the fde_table. */
3222 fde = &fde_table[fde_table_in_use++];
3223 fde->decl = current_function_decl;
3224 fde->dw_fde_begin = dup_label;
3225 fde->dw_fde_current_label = dup_label;
3226 fde->dw_fde_hot_section_label = NULL;
3227 fde->dw_fde_hot_section_end_label = NULL;
3228 fde->dw_fde_unlikely_section_label = NULL;
3229 fde->dw_fde_unlikely_section_end_label = NULL;
3230 fde->dw_fde_switched_sections = false;
3231 fde->dw_fde_end = NULL;
3232 fde->dw_fde_cfi = NULL;
3233 fde->funcdef_number = current_function_funcdef_no;
3234 fde->nothrow = TREE_NOTHROW (current_function_decl);
3235 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3236 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3237 fde->drap_reg = INVALID_REGNUM;
3238 fde->vdrap_reg = INVALID_REGNUM;
3240 args_size = old_args_size = 0;
3242 /* We only want to output line number information for the genuine dwarf2
3243 prologue case, not the eh frame case. */
3244 #ifdef DWARF2_DEBUGGING_INFO
3246 dwarf2out_source_line (line, file);
3249 if (dwarf2out_do_cfi_asm ())
3254 fprintf (asm_out_file, "\t.cfi_startproc\n");
3256 if (eh_personality_libfunc)
3258 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3259 ref = eh_personality_libfunc;
3261 /* ??? The GAS support isn't entirely consistent. We have to
3262 handle indirect support ourselves, but PC-relative is done
3263 in the assembler. Further, the assembler can't handle any
3264 of the weirder relocation types. */
3265 if (enc & DW_EH_PE_indirect)
3266 ref = dw2_force_const_mem (ref, true);
3268 fprintf (asm_out_file, "\t.cfi_personality 0x%x,", enc);
3269 output_addr_const (asm_out_file, ref);
3270 fputc ('\n', asm_out_file);
3273 if (crtl->uses_eh_lsda)
3277 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3278 ASM_GENERATE_INTERNAL_LABEL (lab, "LLSDA",
3279 current_function_funcdef_no);
3280 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3281 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3283 if (enc & DW_EH_PE_indirect)
3284 ref = dw2_force_const_mem (ref, true);
3286 fprintf (asm_out_file, "\t.cfi_lsda 0x%x,", enc);
3287 output_addr_const (asm_out_file, ref);
3288 fputc ('\n', asm_out_file);
3293 /* Output a marker (i.e. a label) for the absolute end of the generated code
3294 for a function definition. This gets called *after* the epilogue code has
3298 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
3299 const char *file ATTRIBUTE_UNUSED)
3302 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3304 if (dwarf2out_do_cfi_asm ())
3305 fprintf (asm_out_file, "\t.cfi_endproc\n");
3307 /* Output a label to mark the endpoint of the code generated for this
3309 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
3310 current_function_funcdef_no);
3311 ASM_OUTPUT_LABEL (asm_out_file, label);
3312 fde = current_fde ();
3313 gcc_assert (fde != NULL);
3314 fde->dw_fde_end = xstrdup (label);
3318 dwarf2out_frame_init (void)
3320 /* Allocate the initial hunk of the fde_table. */
3321 fde_table = GGC_CNEWVEC (dw_fde_node, FDE_TABLE_INCREMENT);
3322 fde_table_allocated = FDE_TABLE_INCREMENT;
3323 fde_table_in_use = 0;
3325 /* Generate the CFA instructions common to all FDE's. Do it now for the
3326 sake of lookup_cfa. */
3328 /* On entry, the Canonical Frame Address is at SP. */
3329 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
3331 #ifdef DWARF2_UNWIND_INFO
3332 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
3333 initial_return_save (INCOMING_RETURN_ADDR_RTX);
3338 dwarf2out_frame_finish (void)
3340 /* Output call frame information. */
3341 if (DWARF2_FRAME_INFO)
3342 output_call_frame_info (0);
3344 #ifndef TARGET_UNWIND_INFO
3345 /* Output another copy for the unwinder. */
3346 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
3347 output_call_frame_info (1);
3351 /* Note that the current function section is being used for code. */
3354 dwarf2out_note_section_used (void)
3356 section *sec = current_function_section ();
3357 if (sec == text_section)
3358 text_section_used = true;
3359 else if (sec == cold_text_section)
3360 cold_text_section_used = true;
3364 dwarf2out_switch_text_section (void)
3366 dw_fde_ref fde = current_fde ();
3368 gcc_assert (cfun && fde);
3370 fde->dw_fde_switched_sections = true;
3371 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
3372 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
3373 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
3374 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
3375 have_multiple_function_sections = true;
3377 /* Reset the current label on switching text sections, so that we
3378 don't attempt to advance_loc4 between labels in different sections. */
3379 fde->dw_fde_current_label = NULL;
3381 /* There is no need to mark used sections when not debugging. */
3382 if (cold_text_section != NULL)
3383 dwarf2out_note_section_used ();
3387 /* And now, the subset of the debugging information support code necessary
3388 for emitting location expressions. */
3390 /* Data about a single source file. */
3391 struct dwarf_file_data GTY(())
3393 const char * filename;
3397 /* We need some way to distinguish DW_OP_addr with a direct symbol
3398 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
3399 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
3402 typedef struct dw_val_struct *dw_val_ref;
3403 typedef struct die_struct *dw_die_ref;
3404 typedef const struct die_struct *const_dw_die_ref;
3405 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
3406 typedef struct dw_loc_list_struct *dw_loc_list_ref;
3408 typedef struct deferred_locations_struct GTY(())
3412 } deferred_locations;
3414 DEF_VEC_O(deferred_locations);
3415 DEF_VEC_ALLOC_O(deferred_locations,gc);
3417 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
3419 /* Each DIE may have a series of attribute/value pairs. Values
3420 can take on several forms. The forms that are used in this
3421 implementation are listed below. */
3426 dw_val_class_offset,
3428 dw_val_class_loc_list,
3429 dw_val_class_range_list,
3431 dw_val_class_unsigned_const,
3432 dw_val_class_long_long,
3435 dw_val_class_die_ref,
3436 dw_val_class_fde_ref,
3437 dw_val_class_lbl_id,
3438 dw_val_class_lineptr,
3440 dw_val_class_macptr,
3444 /* Describe a double word constant value. */
3445 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
3447 typedef struct dw_long_long_struct GTY(())
3454 /* Describe a floating point constant value, or a vector constant value. */
3456 typedef struct dw_vec_struct GTY(())
3458 unsigned char * GTY((length ("%h.length"))) array;
3464 /* The dw_val_node describes an attribute's value, as it is
3465 represented internally. */
3467 typedef struct dw_val_struct GTY(())
3469 enum dw_val_class val_class;
3470 union dw_val_struct_union
3472 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
3473 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
3474 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
3475 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
3476 HOST_WIDE_INT GTY ((default)) val_int;
3477 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
3478 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
3479 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
3480 struct dw_val_die_union
3484 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
3485 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
3486 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
3487 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
3488 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
3489 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
3491 GTY ((desc ("%1.val_class"))) v;
3495 /* Locations in memory are described using a sequence of stack machine
3498 typedef struct dw_loc_descr_struct GTY(())
3500 dw_loc_descr_ref dw_loc_next;
3501 enum dwarf_location_atom dw_loc_opc;
3502 dw_val_node dw_loc_oprnd1;
3503 dw_val_node dw_loc_oprnd2;
3508 /* Location lists are ranges + location descriptions for that range,
3509 so you can track variables that are in different places over
3510 their entire life. */
3511 typedef struct dw_loc_list_struct GTY(())
3513 dw_loc_list_ref dw_loc_next;
3514 const char *begin; /* Label for begin address of range */
3515 const char *end; /* Label for end address of range */
3516 char *ll_symbol; /* Label for beginning of location list.
3517 Only on head of list */
3518 const char *section; /* Section this loclist is relative to */
3519 dw_loc_descr_ref expr;
3522 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
3524 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
3526 /* Convert a DWARF stack opcode into its string name. */
3529 dwarf_stack_op_name (unsigned int op)
3534 case INTERNAL_DW_OP_tls_addr:
3535 return "DW_OP_addr";
3537 return "DW_OP_deref";
3539 return "DW_OP_const1u";
3541 return "DW_OP_const1s";
3543 return "DW_OP_const2u";
3545 return "DW_OP_const2s";
3547 return "DW_OP_const4u";
3549 return "DW_OP_const4s";
3551 return "DW_OP_const8u";
3553 return "DW_OP_const8s";
3555 return "DW_OP_constu";
3557 return "DW_OP_consts";
3561 return "DW_OP_drop";
3563 return "DW_OP_over";
3565 return "DW_OP_pick";
3567 return "DW_OP_swap";
3571 return "DW_OP_xderef";
3579 return "DW_OP_minus";
3591 return "DW_OP_plus";
3592 case DW_OP_plus_uconst:
3593 return "DW_OP_plus_uconst";
3599 return "DW_OP_shra";
3617 return "DW_OP_skip";
3619 return "DW_OP_lit0";
3621 return "DW_OP_lit1";
3623 return "DW_OP_lit2";
3625 return "DW_OP_lit3";
3627 return "DW_OP_lit4";
3629 return "DW_OP_lit5";
3631 return "DW_OP_lit6";
3633 return "DW_OP_lit7";
3635 return "DW_OP_lit8";
3637 return "DW_OP_lit9";
3639 return "DW_OP_lit10";
3641 return "DW_OP_lit11";
3643 return "DW_OP_lit12";
3645 return "DW_OP_lit13";
3647 return "DW_OP_lit14";
3649 return "DW_OP_lit15";
3651 return "DW_OP_lit16";
3653 return "DW_OP_lit17";
3655 return "DW_OP_lit18";
3657 return "DW_OP_lit19";
3659 return "DW_OP_lit20";
3661 return "DW_OP_lit21";
3663 return "DW_OP_lit22";
3665 return "DW_OP_lit23";
3667 return "DW_OP_lit24";
3669 return "DW_OP_lit25";
3671 return "DW_OP_lit26";
3673 return "DW_OP_lit27";
3675 return "DW_OP_lit28";
3677 return "DW_OP_lit29";
3679 return "DW_OP_lit30";
3681 return "DW_OP_lit31";
3683 return "DW_OP_reg0";
3685 return "DW_OP_reg1";
3687 return "DW_OP_reg2";
3689 return "DW_OP_reg3";
3691 return "DW_OP_reg4";
3693 return "DW_OP_reg5";
3695 return "DW_OP_reg6";
3697 return "DW_OP_reg7";
3699 return "DW_OP_reg8";
3701 return "DW_OP_reg9";
3703 return "DW_OP_reg10";
3705 return "DW_OP_reg11";
3707 return "DW_OP_reg12";
3709 return "DW_OP_reg13";
3711 return "DW_OP_reg14";
3713 return "DW_OP_reg15";
3715 return "DW_OP_reg16";
3717 return "DW_OP_reg17";
3719 return "DW_OP_reg18";
3721 return "DW_OP_reg19";
3723 return "DW_OP_reg20";
3725 return "DW_OP_reg21";
3727 return "DW_OP_reg22";
3729 return "DW_OP_reg23";
3731 return "DW_OP_reg24";
3733 return "DW_OP_reg25";
3735 return "DW_OP_reg26";
3737 return "DW_OP_reg27";
3739 return "DW_OP_reg28";
3741 return "DW_OP_reg29";
3743 return "DW_OP_reg30";
3745 return "DW_OP_reg31";
3747 return "DW_OP_breg0";
3749 return "DW_OP_breg1";
3751 return "DW_OP_breg2";
3753 return "DW_OP_breg3";
3755 return "DW_OP_breg4";
3757 return "DW_OP_breg5";
3759 return "DW_OP_breg6";
3761 return "DW_OP_breg7";
3763 return "DW_OP_breg8";
3765 return "DW_OP_breg9";
3767 return "DW_OP_breg10";
3769 return "DW_OP_breg11";
3771 return "DW_OP_breg12";
3773 return "DW_OP_breg13";
3775 return "DW_OP_breg14";
3777 return "DW_OP_breg15";
3779 return "DW_OP_breg16";
3781 return "DW_OP_breg17";
3783 return "DW_OP_breg18";
3785 return "DW_OP_breg19";
3787 return "DW_OP_breg20";
3789 return "DW_OP_breg21";
3791 return "DW_OP_breg22";
3793 return "DW_OP_breg23";
3795 return "DW_OP_breg24";
3797 return "DW_OP_breg25";
3799 return "DW_OP_breg26";
3801 return "DW_OP_breg27";
3803 return "DW_OP_breg28";
3805 return "DW_OP_breg29";
3807 return "DW_OP_breg30";
3809 return "DW_OP_breg31";
3811 return "DW_OP_regx";
3813 return "DW_OP_fbreg";
3815 return "DW_OP_bregx";
3817 return "DW_OP_piece";
3818 case DW_OP_deref_size:
3819 return "DW_OP_deref_size";
3820 case DW_OP_xderef_size:
3821 return "DW_OP_xderef_size";
3824 case DW_OP_push_object_address:
3825 return "DW_OP_push_object_address";
3827 return "DW_OP_call2";
3829 return "DW_OP_call4";
3830 case DW_OP_call_ref:
3831 return "DW_OP_call_ref";
3832 case DW_OP_GNU_push_tls_address:
3833 return "DW_OP_GNU_push_tls_address";
3834 case DW_OP_GNU_uninit:
3835 return "DW_OP_GNU_uninit";
3837 return "OP_<unknown>";
3841 /* Return a pointer to a newly allocated location description. Location
3842 descriptions are simple expression terms that can be strung
3843 together to form more complicated location (address) descriptions. */
3845 static inline dw_loc_descr_ref
3846 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3847 unsigned HOST_WIDE_INT oprnd2)
3849 dw_loc_descr_ref descr = GGC_CNEW (dw_loc_descr_node);
3851 descr->dw_loc_opc = op;
3852 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3853 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3854 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3855 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3860 /* Return a pointer to a newly allocated location description for
3863 static inline dw_loc_descr_ref
3864 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
3869 return new_loc_descr (DW_OP_breg0 + reg, offset, 0);
3871 return new_loc_descr (DW_OP_bregx, reg, offset);
3874 return new_loc_descr (DW_OP_reg0 + reg, 0, 0);
3876 return new_loc_descr (DW_OP_regx, reg, 0);
3879 /* Add a location description term to a location description expression. */
3882 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3884 dw_loc_descr_ref *d;
3886 /* Find the end of the chain. */
3887 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3893 /* Return the size of a location descriptor. */
3895 static unsigned long
3896 size_of_loc_descr (dw_loc_descr_ref loc)
3898 unsigned long size = 1;
3900 switch (loc->dw_loc_opc)
3903 case INTERNAL_DW_OP_tls_addr:
3904 size += DWARF2_ADDR_SIZE;
3923 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3926 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3931 case DW_OP_plus_uconst:
3932 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3970 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3973 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3976 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3979 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3980 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3983 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3985 case DW_OP_deref_size:
3986 case DW_OP_xderef_size:
3995 case DW_OP_call_ref:
3996 size += DWARF2_ADDR_SIZE;
4005 /* Return the size of a series of location descriptors. */
4007 static unsigned long
4008 size_of_locs (dw_loc_descr_ref loc)
4013 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4014 field, to avoid writing to a PCH file. */
4015 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4017 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4019 size += size_of_loc_descr (l);
4024 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4026 l->dw_loc_addr = size;
4027 size += size_of_loc_descr (l);
4033 /* Output location description stack opcode's operands (if any). */
4036 output_loc_operands (dw_loc_descr_ref loc)
4038 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4039 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4041 switch (loc->dw_loc_opc)
4043 #ifdef DWARF2_DEBUGGING_INFO
4045 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
4049 dw2_asm_output_data (2, val1->v.val_int, NULL);
4053 dw2_asm_output_data (4, val1->v.val_int, NULL);
4057 gcc_assert (HOST_BITS_PER_LONG >= 64);
4058 dw2_asm_output_data (8, val1->v.val_int, NULL);
4065 gcc_assert (val1->val_class == dw_val_class_loc);
4066 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4068 dw2_asm_output_data (2, offset, NULL);
4081 /* We currently don't make any attempt to make sure these are
4082 aligned properly like we do for the main unwind info, so
4083 don't support emitting things larger than a byte if we're
4084 only doing unwinding. */
4089 dw2_asm_output_data (1, val1->v.val_int, NULL);
4092 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4095 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4098 dw2_asm_output_data (1, val1->v.val_int, NULL);
4100 case DW_OP_plus_uconst:
4101 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4135 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4138 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4141 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
4144 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4145 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
4148 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4150 case DW_OP_deref_size:
4151 case DW_OP_xderef_size:
4152 dw2_asm_output_data (1, val1->v.val_int, NULL);
4155 case INTERNAL_DW_OP_tls_addr:
4156 if (targetm.asm_out.output_dwarf_dtprel)
4158 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
4161 fputc ('\n', asm_out_file);
4168 /* Other codes have no operands. */
4173 /* Output a sequence of location operations. */
4176 output_loc_sequence (dw_loc_descr_ref loc)
4178 for (; loc != NULL; loc = loc->dw_loc_next)
4180 /* Output the opcode. */
4181 dw2_asm_output_data (1, loc->dw_loc_opc,
4182 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
4184 /* Output the operand(s) (if any). */
4185 output_loc_operands (loc);
4189 /* Output location description stack opcode's operands (if any).
4190 The output is single bytes on a line, suitable for .cfi_escape. */
4193 output_loc_operands_raw (dw_loc_descr_ref loc)
4195 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4196 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4198 switch (loc->dw_loc_opc)
4201 /* We cannot output addresses in .cfi_escape, only bytes. */
4207 case DW_OP_deref_size:
4208 case DW_OP_xderef_size:
4209 fputc (',', asm_out_file);
4210 dw2_asm_output_data_raw (1, val1->v.val_int);
4215 fputc (',', asm_out_file);
4216 dw2_asm_output_data_raw (2, val1->v.val_int);
4221 fputc (',', asm_out_file);
4222 dw2_asm_output_data_raw (4, val1->v.val_int);
4227 gcc_assert (HOST_BITS_PER_LONG >= 64);
4228 fputc (',', asm_out_file);
4229 dw2_asm_output_data_raw (8, val1->v.val_int);
4237 gcc_assert (val1->val_class == dw_val_class_loc);
4238 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4240 fputc (',', asm_out_file);
4241 dw2_asm_output_data_raw (2, offset);
4246 case DW_OP_plus_uconst:
4249 fputc (',', asm_out_file);
4250 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4287 fputc (',', asm_out_file);
4288 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
4292 fputc (',', asm_out_file);
4293 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
4294 fputc (',', asm_out_file);
4295 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
4298 case INTERNAL_DW_OP_tls_addr:
4302 /* Other codes have no operands. */
4308 output_loc_sequence_raw (dw_loc_descr_ref loc)
4312 /* Output the opcode. */
4313 fprintf (asm_out_file, "0x%x", loc->dw_loc_opc);
4314 output_loc_operands_raw (loc);
4316 if (!loc->dw_loc_next)
4318 loc = loc->dw_loc_next;
4320 fputc (',', asm_out_file);
4324 /* This routine will generate the correct assembly data for a location
4325 description based on a cfi entry with a complex address. */
4328 output_cfa_loc (dw_cfi_ref cfi)
4330 dw_loc_descr_ref loc;
4333 if (cfi->dw_cfi_opc == DW_CFA_expression)
4334 dw2_asm_output_data (1, cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL);
4336 /* Output the size of the block. */
4337 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4338 size = size_of_locs (loc);
4339 dw2_asm_output_data_uleb128 (size, NULL);
4341 /* Now output the operations themselves. */
4342 output_loc_sequence (loc);
4345 /* Similar, but used for .cfi_escape. */
4348 output_cfa_loc_raw (dw_cfi_ref cfi)
4350 dw_loc_descr_ref loc;
4353 if (cfi->dw_cfi_opc == DW_CFA_expression)
4354 fprintf (asm_out_file, "0x%x,", cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
4356 /* Output the size of the block. */
4357 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
4358 size = size_of_locs (loc);
4359 dw2_asm_output_data_uleb128_raw (size);
4360 fputc (',', asm_out_file);
4362 /* Now output the operations themselves. */
4363 output_loc_sequence_raw (loc);
4366 /* This function builds a dwarf location descriptor sequence from a
4367 dw_cfa_location, adding the given OFFSET to the result of the
4370 static struct dw_loc_descr_struct *
4371 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
4373 struct dw_loc_descr_struct *head, *tmp;
4375 offset += cfa->offset;
4379 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
4380 head->dw_loc_oprnd1.val_class = dw_val_class_const;
4381 tmp = new_loc_descr (DW_OP_deref, 0, 0);
4382 add_loc_descr (&head, tmp);
4385 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4386 add_loc_descr (&head, tmp);
4390 head = new_reg_loc_descr (cfa->reg, offset);
4395 /* This function builds a dwarf location descriptor sequence for
4396 the address at OFFSET from the CFA when stack is aligned to
4399 static struct dw_loc_descr_struct *
4400 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
4402 struct dw_loc_descr_struct *head;
4403 unsigned int dwarf_fp
4404 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
4406 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
4407 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
4409 head = new_reg_loc_descr (dwarf_fp, 0);
4410 add_loc_descr (&head, int_loc_descriptor (alignment));
4411 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
4413 add_loc_descr (&head, int_loc_descriptor (offset));
4414 add_loc_descr (&head, new_loc_descr (DW_OP_plus, 0, 0));
4417 head = new_reg_loc_descr (dwarf_fp, offset);
4421 /* This function fills in aa dw_cfa_location structure from a dwarf location
4422 descriptor sequence. */
4425 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
4427 struct dw_loc_descr_struct *ptr;
4429 cfa->base_offset = 0;
4433 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
4435 enum dwarf_location_atom op = ptr->dw_loc_opc;
4471 cfa->reg = op - DW_OP_reg0;
4474 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4508 cfa->reg = op - DW_OP_breg0;
4509 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
4512 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
4513 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
4518 case DW_OP_plus_uconst:
4519 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
4522 internal_error ("DW_LOC_OP %s not implemented",
4523 dwarf_stack_op_name (ptr->dw_loc_opc));
4527 #endif /* .debug_frame support */
4529 /* And now, the support for symbolic debugging information. */
4530 #ifdef DWARF2_DEBUGGING_INFO
4532 /* .debug_str support. */
4533 static int output_indirect_string (void **, void *);
4535 static void dwarf2out_init (const char *);
4536 static void dwarf2out_finish (const char *);
4537 static void dwarf2out_define (unsigned int, const char *);
4538 static void dwarf2out_undef (unsigned int, const char *);
4539 static void dwarf2out_start_source_file (unsigned, const char *);
4540 static void dwarf2out_end_source_file (unsigned);
4541 static void dwarf2out_begin_block (unsigned, unsigned);
4542 static void dwarf2out_end_block (unsigned, unsigned);
4543 static bool dwarf2out_ignore_block (const_tree);
4544 static void dwarf2out_global_decl (tree);
4545 static void dwarf2out_type_decl (tree, int);
4546 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
4547 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
4549 static void dwarf2out_abstract_function (tree);
4550 static void dwarf2out_var_location (rtx);
4551 static void dwarf2out_begin_function (tree);
4553 /* The debug hooks structure. */
4555 const struct gcc_debug_hooks dwarf2_debug_hooks =
4561 dwarf2out_start_source_file,
4562 dwarf2out_end_source_file,
4563 dwarf2out_begin_block,
4564 dwarf2out_end_block,
4565 dwarf2out_ignore_block,
4566 dwarf2out_source_line,
4567 dwarf2out_begin_prologue,
4568 debug_nothing_int_charstar, /* end_prologue */
4569 dwarf2out_end_epilogue,
4570 dwarf2out_begin_function,
4571 debug_nothing_int, /* end_function */
4572 dwarf2out_decl, /* function_decl */
4573 dwarf2out_global_decl,
4574 dwarf2out_type_decl, /* type_decl */
4575 dwarf2out_imported_module_or_decl,
4576 debug_nothing_tree, /* deferred_inline_function */
4577 /* The DWARF 2 backend tries to reduce debugging bloat by not
4578 emitting the abstract description of inline functions until
4579 something tries to reference them. */
4580 dwarf2out_abstract_function, /* outlining_inline_function */
4581 debug_nothing_rtx, /* label */
4582 debug_nothing_int, /* handle_pch */
4583 dwarf2out_var_location,
4584 dwarf2out_switch_text_section,
4585 1 /* start_end_main_source_file */
4589 /* NOTE: In the comments in this file, many references are made to
4590 "Debugging Information Entries". This term is abbreviated as `DIE'
4591 throughout the remainder of this file. */
4593 /* An internal representation of the DWARF output is built, and then
4594 walked to generate the DWARF debugging info. The walk of the internal
4595 representation is done after the entire program has been compiled.
4596 The types below are used to describe the internal representation. */
4598 /* Various DIE's use offsets relative to the beginning of the
4599 .debug_info section to refer to each other. */
4601 typedef long int dw_offset;
4603 /* Define typedefs here to avoid circular dependencies. */
4605 typedef struct dw_attr_struct *dw_attr_ref;
4606 typedef struct dw_line_info_struct *dw_line_info_ref;
4607 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
4608 typedef struct pubname_struct *pubname_ref;
4609 typedef struct dw_ranges_struct *dw_ranges_ref;
4610 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
4612 /* Each entry in the line_info_table maintains the file and
4613 line number associated with the label generated for that
4614 entry. The label gives the PC value associated with
4615 the line number entry. */
4617 typedef struct dw_line_info_struct GTY(())
4619 unsigned long dw_file_num;
4620 unsigned long dw_line_num;
4624 /* Line information for functions in separate sections; each one gets its
4626 typedef struct dw_separate_line_info_struct GTY(())
4628 unsigned long dw_file_num;
4629 unsigned long dw_line_num;
4630 unsigned long function;
4632 dw_separate_line_info_entry;
4634 /* Each DIE attribute has a field specifying the attribute kind,
4635 a link to the next attribute in the chain, and an attribute value.
4636 Attributes are typically linked below the DIE they modify. */
4638 typedef struct dw_attr_struct GTY(())
4640 enum dwarf_attribute dw_attr;
4641 dw_val_node dw_attr_val;
4645 DEF_VEC_O(dw_attr_node);
4646 DEF_VEC_ALLOC_O(dw_attr_node,gc);
4648 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
4649 The children of each node form a circular list linked by
4650 die_sib. die_child points to the node *before* the "first" child node. */
4652 typedef struct die_struct GTY((chain_circular ("%h.die_sib")))
4654 enum dwarf_tag die_tag;
4656 VEC(dw_attr_node,gc) * die_attr;
4657 dw_die_ref die_parent;
4658 dw_die_ref die_child;
4660 dw_die_ref die_definition; /* ref from a specification to its definition */
4661 dw_offset die_offset;
4662 unsigned long die_abbrev;
4664 /* Die is used and must not be pruned as unused. */
4665 int die_perennial_p;
4666 unsigned int decl_id;
4670 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
4671 #define FOR_EACH_CHILD(die, c, expr) do { \
4672 c = die->die_child; \
4676 } while (c != die->die_child); \
4679 /* The pubname structure */
4681 typedef struct pubname_struct GTY(())
4688 DEF_VEC_O(pubname_entry);
4689 DEF_VEC_ALLOC_O(pubname_entry, gc);
4691 struct dw_ranges_struct GTY(())
4693 /* If this is positive, it's a block number, otherwise it's a
4694 bitwise-negated index into dw_ranges_by_label. */
4698 struct dw_ranges_by_label_struct GTY(())
4704 /* The limbo die list structure. */
4705 typedef struct limbo_die_struct GTY(())
4709 struct limbo_die_struct *next;
4713 /* How to start an assembler comment. */
4714 #ifndef ASM_COMMENT_START
4715 #define ASM_COMMENT_START ";#"
4718 /* Define a macro which returns nonzero for a TYPE_DECL which was
4719 implicitly generated for a tagged type.
4721 Note that unlike the gcc front end (which generates a NULL named
4722 TYPE_DECL node for each complete tagged type, each array type, and
4723 each function type node created) the g++ front end generates a
4724 _named_ TYPE_DECL node for each tagged type node created.
4725 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
4726 generate a DW_TAG_typedef DIE for them. */
4728 #define TYPE_DECL_IS_STUB(decl) \
4729 (DECL_NAME (decl) == NULL_TREE \
4730 || (DECL_ARTIFICIAL (decl) \
4731 && is_tagged_type (TREE_TYPE (decl)) \
4732 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
4733 /* This is necessary for stub decls that \
4734 appear in nested inline functions. */ \
4735 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
4736 && (decl_ultimate_origin (decl) \
4737 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
4739 /* Information concerning the compilation unit's programming
4740 language, and compiler version. */
4742 /* Fixed size portion of the DWARF compilation unit header. */
4743 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
4744 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
4746 /* Fixed size portion of public names info. */
4747 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
4749 /* Fixed size portion of the address range info. */
4750 #define DWARF_ARANGES_HEADER_SIZE \
4751 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4752 DWARF2_ADDR_SIZE * 2) \
4753 - DWARF_INITIAL_LENGTH_SIZE)
4755 /* Size of padding portion in the address range info. It must be
4756 aligned to twice the pointer size. */
4757 #define DWARF_ARANGES_PAD_SIZE \
4758 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4759 DWARF2_ADDR_SIZE * 2) \
4760 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
4762 /* Use assembler line directives if available. */
4763 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
4764 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
4765 #define DWARF2_ASM_LINE_DEBUG_INFO 1
4767 #define DWARF2_ASM_LINE_DEBUG_INFO 0
4771 /* Minimum line offset in a special line info. opcode.
4772 This value was chosen to give a reasonable range of values. */
4773 #define DWARF_LINE_BASE -10
4775 /* First special line opcode - leave room for the standard opcodes. */
4776 #define DWARF_LINE_OPCODE_BASE 10
4778 /* Range of line offsets in a special line info. opcode. */
4779 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
4781 /* Flag that indicates the initial value of the is_stmt_start flag.
4782 In the present implementation, we do not mark any lines as
4783 the beginning of a source statement, because that information
4784 is not made available by the GCC front-end. */
4785 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
4787 #ifdef DWARF2_DEBUGGING_INFO
4788 /* This location is used by calc_die_sizes() to keep track
4789 the offset of each DIE within the .debug_info section. */
4790 static unsigned long next_die_offset;
4793 /* Record the root of the DIE's built for the current compilation unit. */
4794 static GTY(()) dw_die_ref comp_unit_die;
4796 /* A list of DIEs with a NULL parent waiting to be relocated. */
4797 static GTY(()) limbo_die_node *limbo_die_list;
4799 /* Filenames referenced by this compilation unit. */
4800 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
4802 /* A hash table of references to DIE's that describe declarations.
4803 The key is a DECL_UID() which is a unique number identifying each decl. */
4804 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
4806 /* A hash table of references to DIE's that describe COMMON blocks.
4807 The key is DECL_UID() ^ die_parent. */
4808 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
4810 /* Node of the variable location list. */
4811 struct var_loc_node GTY ((chain_next ("%h.next")))
4813 rtx GTY (()) var_loc_note;
4814 const char * GTY (()) label;
4815 const char * GTY (()) section_label;
4816 struct var_loc_node * GTY (()) next;
4819 /* Variable location list. */
4820 struct var_loc_list_def GTY (())
4822 struct var_loc_node * GTY (()) first;
4824 /* Do not mark the last element of the chained list because
4825 it is marked through the chain. */
4826 struct var_loc_node * GTY ((skip ("%h"))) last;
4828 /* DECL_UID of the variable decl. */
4829 unsigned int decl_id;
4831 typedef struct var_loc_list_def var_loc_list;
4834 /* Table of decl location linked lists. */
4835 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
4837 /* A pointer to the base of a list of references to DIE's that
4838 are uniquely identified by their tag, presence/absence of
4839 children DIE's, and list of attribute/value pairs. */
4840 static GTY((length ("abbrev_die_table_allocated")))
4841 dw_die_ref *abbrev_die_table;
4843 /* Number of elements currently allocated for abbrev_die_table. */
4844 static GTY(()) unsigned abbrev_die_table_allocated;
4846 /* Number of elements in type_die_table currently in use. */
4847 static GTY(()) unsigned abbrev_die_table_in_use;
4849 /* Size (in elements) of increments by which we may expand the
4850 abbrev_die_table. */
4851 #define ABBREV_DIE_TABLE_INCREMENT 256
4853 /* A pointer to the base of a table that contains line information
4854 for each source code line in .text in the compilation unit. */
4855 static GTY((length ("line_info_table_allocated")))
4856 dw_line_info_ref line_info_table;
4858 /* Number of elements currently allocated for line_info_table. */
4859 static GTY(()) unsigned line_info_table_allocated;
4861 /* Number of elements in line_info_table currently in use. */
4862 static GTY(()) unsigned line_info_table_in_use;
4864 /* A pointer to the base of a table that contains line information
4865 for each source code line outside of .text in the compilation unit. */
4866 static GTY ((length ("separate_line_info_table_allocated")))
4867 dw_separate_line_info_ref separate_line_info_table;
4869 /* Number of elements currently allocated for separate_line_info_table. */
4870 static GTY(()) unsigned separate_line_info_table_allocated;
4872 /* Number of elements in separate_line_info_table currently in use. */
4873 static GTY(()) unsigned separate_line_info_table_in_use;
4875 /* Size (in elements) of increments by which we may expand the
4877 #define LINE_INFO_TABLE_INCREMENT 1024
4879 /* A pointer to the base of a table that contains a list of publicly
4880 accessible names. */
4881 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
4883 /* A pointer to the base of a table that contains a list of publicly
4884 accessible types. */
4885 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
4887 /* Array of dies for which we should generate .debug_arange info. */
4888 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
4890 /* Number of elements currently allocated for arange_table. */
4891 static GTY(()) unsigned arange_table_allocated;
4893 /* Number of elements in arange_table currently in use. */
4894 static GTY(()) unsigned arange_table_in_use;
4896 /* Size (in elements) of increments by which we may expand the
4898 #define ARANGE_TABLE_INCREMENT 64
4900 /* Array of dies for which we should generate .debug_ranges info. */
4901 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
4903 /* Number of elements currently allocated for ranges_table. */
4904 static GTY(()) unsigned ranges_table_allocated;
4906 /* Number of elements in ranges_table currently in use. */
4907 static GTY(()) unsigned ranges_table_in_use;
4909 /* Array of pairs of labels referenced in ranges_table. */
4910 static GTY ((length ("ranges_by_label_allocated")))
4911 dw_ranges_by_label_ref ranges_by_label;
4913 /* Number of elements currently allocated for ranges_by_label. */
4914 static GTY(()) unsigned ranges_by_label_allocated;
4916 /* Number of elements in ranges_by_label currently in use. */
4917 static GTY(()) unsigned ranges_by_label_in_use;
4919 /* Size (in elements) of increments by which we may expand the
4921 #define RANGES_TABLE_INCREMENT 64
4923 /* Whether we have location lists that need outputting */
4924 static GTY(()) bool have_location_lists;
4926 /* Unique label counter. */
4927 static GTY(()) unsigned int loclabel_num;
4929 #ifdef DWARF2_DEBUGGING_INFO
4930 /* Record whether the function being analyzed contains inlined functions. */
4931 static int current_function_has_inlines;
4933 #if 0 && defined (MIPS_DEBUGGING_INFO)
4934 static int comp_unit_has_inlines;
4937 /* The last file entry emitted by maybe_emit_file(). */
4938 static GTY(()) struct dwarf_file_data * last_emitted_file;
4940 /* Number of internal labels generated by gen_internal_sym(). */
4941 static GTY(()) int label_num;
4943 /* Cached result of previous call to lookup_filename. */
4944 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
4946 #ifdef DWARF2_DEBUGGING_INFO
4948 /* Offset from the "steady-state frame pointer" to the frame base,
4949 within the current function. */
4950 static HOST_WIDE_INT frame_pointer_fb_offset;
4952 /* Forward declarations for functions defined in this file. */
4954 static int is_pseudo_reg (const_rtx);
4955 static tree type_main_variant (tree);
4956 static int is_tagged_type (const_tree);
4957 static const char *dwarf_tag_name (unsigned);
4958 static const char *dwarf_attr_name (unsigned);
4959 static const char *dwarf_form_name (unsigned);
4960 static tree decl_ultimate_origin (const_tree);
4961 static tree decl_class_context (tree);
4962 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
4963 static inline enum dw_val_class AT_class (dw_attr_ref);
4964 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
4965 static inline unsigned AT_flag (dw_attr_ref);
4966 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
4967 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
4968 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
4969 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
4970 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
4972 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
4973 unsigned int, unsigned char *);
4974 static hashval_t debug_str_do_hash (const void *);
4975 static int debug_str_eq (const void *, const void *);
4976 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
4977 static inline const char *AT_string (dw_attr_ref);
4978 static int AT_string_form (dw_attr_ref);
4979 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
4980 static void add_AT_specification (dw_die_ref, dw_die_ref);
4981 static inline dw_die_ref AT_ref (dw_attr_ref);
4982 static inline int AT_ref_external (dw_attr_ref);
4983 static inline void set_AT_ref_external (dw_attr_ref, int);
4984 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
4985 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
4986 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
4987 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
4989 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
4990 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
4991 static inline rtx AT_addr (dw_attr_ref);
4992 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
4993 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
4994 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
4995 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
4996 unsigned HOST_WIDE_INT);
4997 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
4999 static inline const char *AT_lbl (dw_attr_ref);
5000 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
5001 static const char *get_AT_low_pc (dw_die_ref);
5002 static const char *get_AT_hi_pc (dw_die_ref);
5003 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
5004 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
5005 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
5006 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
5007 static bool is_c_family (void);
5008 static bool is_cxx (void);
5009 static bool is_java (void);
5010 static bool is_fortran (void);
5011 static bool is_ada (void);
5012 static void remove_AT (dw_die_ref, enum dwarf_attribute);
5013 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
5014 static void add_child_die (dw_die_ref, dw_die_ref);
5015 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
5016 static dw_die_ref lookup_type_die (tree);
5017 static void equate_type_number_to_die (tree, dw_die_ref);
5018 static hashval_t decl_die_table_hash (const void *);
5019 static int decl_die_table_eq (const void *, const void *);
5020 static dw_die_ref lookup_decl_die (tree);
5021 static hashval_t common_block_die_table_hash (const void *);
5022 static int common_block_die_table_eq (const void *, const void *);
5023 static hashval_t decl_loc_table_hash (const void *);
5024 static int decl_loc_table_eq (const void *, const void *);
5025 static var_loc_list *lookup_decl_loc (const_tree);
5026 static void equate_decl_number_to_die (tree, dw_die_ref);
5027 static void add_var_loc_to_decl (tree, struct var_loc_node *);
5028 static void print_spaces (FILE *);
5029 static void print_die (dw_die_ref, FILE *);
5030 static void print_dwarf_line_table (FILE *);
5031 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
5032 static dw_die_ref pop_compile_unit (dw_die_ref);
5033 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
5034 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
5035 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
5036 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
5037 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
5038 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
5039 static int same_die_p (dw_die_ref, dw_die_ref, int *);
5040 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
5041 static void compute_section_prefix (dw_die_ref);
5042 static int is_type_die (dw_die_ref);
5043 static int is_comdat_die (dw_die_ref);
5044 static int is_symbol_die (dw_die_ref);
5045 static void assign_symbol_names (dw_die_ref);
5046 static void break_out_includes (dw_die_ref);
5047 static hashval_t htab_cu_hash (const void *);
5048 static int htab_cu_eq (const void *, const void *);
5049 static void htab_cu_del (void *);
5050 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
5051 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
5052 static void add_sibling_attributes (dw_die_ref);
5053 static void build_abbrev_table (dw_die_ref);
5054 static void output_location_lists (dw_die_ref);
5055 static int constant_size (unsigned HOST_WIDE_INT);
5056 static unsigned long size_of_die (dw_die_ref);
5057 static void calc_die_sizes (dw_die_ref);
5058 static void mark_dies (dw_die_ref);
5059 static void unmark_dies (dw_die_ref);
5060 static void unmark_all_dies (dw_die_ref);
5061 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
5062 static unsigned long size_of_aranges (void);
5063 static enum dwarf_form value_format (dw_attr_ref);
5064 static void output_value_format (dw_attr_ref);
5065 static void output_abbrev_section (void);
5066 static void output_die_symbol (dw_die_ref);
5067 static void output_die (dw_die_ref);
5068 static void output_compilation_unit_header (void);
5069 static void output_comp_unit (dw_die_ref, int);
5070 static const char *dwarf2_name (tree, int);
5071 static void add_pubname (tree, dw_die_ref);
5072 static void add_pubname_string (const char *, dw_die_ref);
5073 static void add_pubtype (tree, dw_die_ref);
5074 static void output_pubnames (VEC (pubname_entry,gc) *);
5075 static void add_arange (tree, dw_die_ref);
5076 static void output_aranges (void);
5077 static unsigned int add_ranges_num (int);
5078 static unsigned int add_ranges (const_tree);
5079 static unsigned int add_ranges_by_labels (const char *, const char *);
5080 static void output_ranges (void);
5081 static void output_line_info (void);
5082 static void output_file_names (void);
5083 static dw_die_ref base_type_die (tree);
5084 static int is_base_type (tree);
5085 static bool is_subrange_type (const_tree);
5086 static dw_die_ref subrange_type_die (tree, dw_die_ref);
5087 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
5088 static int type_is_enum (const_tree);
5089 static unsigned int dbx_reg_number (const_rtx);
5090 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
5091 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
5092 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
5093 enum var_init_status);
5094 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
5095 enum var_init_status);
5096 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
5097 enum var_init_status);
5098 static int is_based_loc (const_rtx);
5099 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
5100 enum var_init_status);
5101 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
5102 enum var_init_status);
5103 static dw_loc_descr_ref loc_descriptor (rtx, enum var_init_status);
5104 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
5105 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
5106 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
5107 static tree field_type (const_tree);
5108 static unsigned int simple_type_align_in_bits (const_tree);
5109 static unsigned int simple_decl_align_in_bits (const_tree);
5110 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
5111 static HOST_WIDE_INT field_byte_offset (const_tree);
5112 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
5114 static void add_data_member_location_attribute (dw_die_ref, tree);
5115 static void add_const_value_attribute (dw_die_ref, rtx);
5116 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
5117 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
5118 static void insert_float (const_rtx, unsigned char *);
5119 static rtx rtl_for_decl_location (tree);
5120 static void add_location_or_const_value_attribute (dw_die_ref, tree,
5121 enum dwarf_attribute);
5122 static void tree_add_const_value_attribute (dw_die_ref, tree);
5123 static void add_name_attribute (dw_die_ref, const char *);
5124 static void add_comp_dir_attribute (dw_die_ref);
5125 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
5126 static void add_subscript_info (dw_die_ref, tree, bool);
5127 static void add_byte_size_attribute (dw_die_ref, tree);
5128 static void add_bit_offset_attribute (dw_die_ref, tree);
5129 static void add_bit_size_attribute (dw_die_ref, tree);
5130 static void add_prototyped_attribute (dw_die_ref, tree);
5131 static void add_abstract_origin_attribute (dw_die_ref, tree);
5132 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
5133 static void add_src_coords_attributes (dw_die_ref, tree);
5134 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
5135 static void push_decl_scope (tree);
5136 static void pop_decl_scope (void);
5137 static dw_die_ref scope_die_for (tree, dw_die_ref);
5138 static inline int local_scope_p (dw_die_ref);
5139 static inline int class_or_namespace_scope_p (dw_die_ref);
5140 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
5141 static void add_calling_convention_attribute (dw_die_ref, tree);
5142 static const char *type_tag (const_tree);
5143 static tree member_declared_type (const_tree);
5145 static const char *decl_start_label (tree);
5147 static void gen_array_type_die (tree, dw_die_ref);
5148 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
5150 static void gen_entry_point_die (tree, dw_die_ref);
5152 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
5153 static void gen_inlined_structure_type_die (tree, dw_die_ref);
5154 static void gen_inlined_union_type_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_tagged_type_instantiation_die (tree, dw_die_ref);
5176 static void gen_block_die (tree, dw_die_ref, int);
5177 static void decls_for_scope (tree, dw_die_ref, int);
5178 static int is_redundant_typedef (const_tree);
5179 static void gen_namespace_die (tree);
5180 static void gen_decl_die (tree, tree, dw_die_ref);
5181 static dw_die_ref force_decl_die (tree);
5182 static dw_die_ref force_type_die (tree);
5183 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
5184 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
5185 static struct dwarf_file_data * lookup_filename (const char *);
5186 static void retry_incomplete_types (void);
5187 static void gen_type_die_for_member (tree, tree, dw_die_ref);
5188 static void splice_child_die (dw_die_ref, dw_die_ref);
5189 static int file_info_cmp (const void *, const void *);
5190 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
5191 const char *, const char *, unsigned);
5192 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
5193 const char *, const char *,
5195 static void output_loc_list (dw_loc_list_ref);
5196 static char *gen_internal_sym (const char *);
5198 static void prune_unmark_dies (dw_die_ref);
5199 static void prune_unused_types_mark (dw_die_ref, int);
5200 static void prune_unused_types_walk (dw_die_ref);
5201 static void prune_unused_types_walk_attribs (dw_die_ref);
5202 static void prune_unused_types_prune (dw_die_ref);
5203 static void prune_unused_types (void);
5204 static int maybe_emit_file (struct dwarf_file_data *fd);
5206 /* Section names used to hold DWARF debugging information. */
5207 #ifndef DEBUG_INFO_SECTION
5208 #define DEBUG_INFO_SECTION ".debug_info"
5210 #ifndef DEBUG_ABBREV_SECTION
5211 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
5213 #ifndef DEBUG_ARANGES_SECTION
5214 #define DEBUG_ARANGES_SECTION ".debug_aranges"
5216 #ifndef DEBUG_MACINFO_SECTION
5217 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
5219 #ifndef DEBUG_LINE_SECTION
5220 #define DEBUG_LINE_SECTION ".debug_line"
5222 #ifndef DEBUG_LOC_SECTION
5223 #define DEBUG_LOC_SECTION ".debug_loc"
5225 #ifndef DEBUG_PUBNAMES_SECTION
5226 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
5228 #ifndef DEBUG_STR_SECTION
5229 #define DEBUG_STR_SECTION ".debug_str"
5231 #ifndef DEBUG_RANGES_SECTION
5232 #define DEBUG_RANGES_SECTION ".debug_ranges"
5235 /* Standard ELF section names for compiled code and data. */
5236 #ifndef TEXT_SECTION_NAME
5237 #define TEXT_SECTION_NAME ".text"
5240 /* Section flags for .debug_str section. */
5241 #define DEBUG_STR_SECTION_FLAGS \
5242 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
5243 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
5246 /* Labels we insert at beginning sections we can reference instead of
5247 the section names themselves. */
5249 #ifndef TEXT_SECTION_LABEL
5250 #define TEXT_SECTION_LABEL "Ltext"
5252 #ifndef COLD_TEXT_SECTION_LABEL
5253 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
5255 #ifndef DEBUG_LINE_SECTION_LABEL
5256 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
5258 #ifndef DEBUG_INFO_SECTION_LABEL
5259 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
5261 #ifndef DEBUG_ABBREV_SECTION_LABEL
5262 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
5264 #ifndef DEBUG_LOC_SECTION_LABEL
5265 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
5267 #ifndef DEBUG_RANGES_SECTION_LABEL
5268 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
5270 #ifndef DEBUG_MACINFO_SECTION_LABEL
5271 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
5274 /* Definitions of defaults for formats and names of various special
5275 (artificial) labels which may be generated within this file (when the -g
5276 options is used and DWARF2_DEBUGGING_INFO is in effect.
5277 If necessary, these may be overridden from within the tm.h file, but
5278 typically, overriding these defaults is unnecessary. */
5280 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5281 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5282 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5283 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
5284 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5285 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5286 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5287 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5288 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
5289 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
5291 #ifndef TEXT_END_LABEL
5292 #define TEXT_END_LABEL "Letext"
5294 #ifndef COLD_END_LABEL
5295 #define COLD_END_LABEL "Letext_cold"
5297 #ifndef BLOCK_BEGIN_LABEL
5298 #define BLOCK_BEGIN_LABEL "LBB"
5300 #ifndef BLOCK_END_LABEL
5301 #define BLOCK_END_LABEL "LBE"
5303 #ifndef LINE_CODE_LABEL
5304 #define LINE_CODE_LABEL "LM"
5306 #ifndef SEPARATE_LINE_CODE_LABEL
5307 #define SEPARATE_LINE_CODE_LABEL "LSM"
5311 /* We allow a language front-end to designate a function that is to be
5312 called to "demangle" any name before it is put into a DIE. */
5314 static const char *(*demangle_name_func) (const char *);
5317 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
5319 demangle_name_func = func;
5322 /* Test if rtl node points to a pseudo register. */
5325 is_pseudo_reg (const_rtx rtl)
5327 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
5328 || (GET_CODE (rtl) == SUBREG
5329 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
5332 /* Return a reference to a type, with its const and volatile qualifiers
5336 type_main_variant (tree type)
5338 type = TYPE_MAIN_VARIANT (type);
5340 /* ??? There really should be only one main variant among any group of
5341 variants of a given type (and all of the MAIN_VARIANT values for all
5342 members of the group should point to that one type) but sometimes the C
5343 front-end messes this up for array types, so we work around that bug
5345 if (TREE_CODE (type) == ARRAY_TYPE)
5346 while (type != TYPE_MAIN_VARIANT (type))
5347 type = TYPE_MAIN_VARIANT (type);
5352 /* Return nonzero if the given type node represents a tagged type. */
5355 is_tagged_type (const_tree type)
5357 enum tree_code code = TREE_CODE (type);
5359 return (code == RECORD_TYPE || code == UNION_TYPE
5360 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
5363 /* Convert a DIE tag into its string name. */
5366 dwarf_tag_name (unsigned int tag)
5370 case DW_TAG_padding:
5371 return "DW_TAG_padding";
5372 case DW_TAG_array_type:
5373 return "DW_TAG_array_type";
5374 case DW_TAG_class_type:
5375 return "DW_TAG_class_type";
5376 case DW_TAG_entry_point:
5377 return "DW_TAG_entry_point";
5378 case DW_TAG_enumeration_type:
5379 return "DW_TAG_enumeration_type";
5380 case DW_TAG_formal_parameter:
5381 return "DW_TAG_formal_parameter";
5382 case DW_TAG_imported_declaration:
5383 return "DW_TAG_imported_declaration";
5385 return "DW_TAG_label";
5386 case DW_TAG_lexical_block:
5387 return "DW_TAG_lexical_block";
5389 return "DW_TAG_member";
5390 case DW_TAG_pointer_type:
5391 return "DW_TAG_pointer_type";
5392 case DW_TAG_reference_type:
5393 return "DW_TAG_reference_type";
5394 case DW_TAG_compile_unit:
5395 return "DW_TAG_compile_unit";
5396 case DW_TAG_string_type:
5397 return "DW_TAG_string_type";
5398 case DW_TAG_structure_type:
5399 return "DW_TAG_structure_type";
5400 case DW_TAG_subroutine_type:
5401 return "DW_TAG_subroutine_type";
5402 case DW_TAG_typedef:
5403 return "DW_TAG_typedef";
5404 case DW_TAG_union_type:
5405 return "DW_TAG_union_type";
5406 case DW_TAG_unspecified_parameters:
5407 return "DW_TAG_unspecified_parameters";
5408 case DW_TAG_variant:
5409 return "DW_TAG_variant";
5410 case DW_TAG_common_block:
5411 return "DW_TAG_common_block";
5412 case DW_TAG_common_inclusion:
5413 return "DW_TAG_common_inclusion";
5414 case DW_TAG_inheritance:
5415 return "DW_TAG_inheritance";
5416 case DW_TAG_inlined_subroutine:
5417 return "DW_TAG_inlined_subroutine";
5419 return "DW_TAG_module";
5420 case DW_TAG_ptr_to_member_type:
5421 return "DW_TAG_ptr_to_member_type";
5422 case DW_TAG_set_type:
5423 return "DW_TAG_set_type";
5424 case DW_TAG_subrange_type:
5425 return "DW_TAG_subrange_type";
5426 case DW_TAG_with_stmt:
5427 return "DW_TAG_with_stmt";
5428 case DW_TAG_access_declaration:
5429 return "DW_TAG_access_declaration";
5430 case DW_TAG_base_type:
5431 return "DW_TAG_base_type";
5432 case DW_TAG_catch_block:
5433 return "DW_TAG_catch_block";
5434 case DW_TAG_const_type:
5435 return "DW_TAG_const_type";
5436 case DW_TAG_constant:
5437 return "DW_TAG_constant";
5438 case DW_TAG_enumerator:
5439 return "DW_TAG_enumerator";
5440 case DW_TAG_file_type:
5441 return "DW_TAG_file_type";
5443 return "DW_TAG_friend";
5444 case DW_TAG_namelist:
5445 return "DW_TAG_namelist";
5446 case DW_TAG_namelist_item:
5447 return "DW_TAG_namelist_item";
5448 case DW_TAG_packed_type:
5449 return "DW_TAG_packed_type";
5450 case DW_TAG_subprogram:
5451 return "DW_TAG_subprogram";
5452 case DW_TAG_template_type_param:
5453 return "DW_TAG_template_type_param";
5454 case DW_TAG_template_value_param:
5455 return "DW_TAG_template_value_param";
5456 case DW_TAG_thrown_type:
5457 return "DW_TAG_thrown_type";
5458 case DW_TAG_try_block:
5459 return "DW_TAG_try_block";
5460 case DW_TAG_variant_part:
5461 return "DW_TAG_variant_part";
5462 case DW_TAG_variable:
5463 return "DW_TAG_variable";
5464 case DW_TAG_volatile_type:
5465 return "DW_TAG_volatile_type";
5466 case DW_TAG_dwarf_procedure:
5467 return "DW_TAG_dwarf_procedure";
5468 case DW_TAG_restrict_type:
5469 return "DW_TAG_restrict_type";
5470 case DW_TAG_interface_type:
5471 return "DW_TAG_interface_type";
5472 case DW_TAG_namespace:
5473 return "DW_TAG_namespace";
5474 case DW_TAG_imported_module:
5475 return "DW_TAG_imported_module";
5476 case DW_TAG_unspecified_type:
5477 return "DW_TAG_unspecified_type";
5478 case DW_TAG_partial_unit:
5479 return "DW_TAG_partial_unit";
5480 case DW_TAG_imported_unit:
5481 return "DW_TAG_imported_unit";
5482 case DW_TAG_condition:
5483 return "DW_TAG_condition";
5484 case DW_TAG_shared_type:
5485 return "DW_TAG_shared_type";
5486 case DW_TAG_MIPS_loop:
5487 return "DW_TAG_MIPS_loop";
5488 case DW_TAG_format_label:
5489 return "DW_TAG_format_label";
5490 case DW_TAG_function_template:
5491 return "DW_TAG_function_template";
5492 case DW_TAG_class_template:
5493 return "DW_TAG_class_template";
5494 case DW_TAG_GNU_BINCL:
5495 return "DW_TAG_GNU_BINCL";
5496 case DW_TAG_GNU_EINCL:
5497 return "DW_TAG_GNU_EINCL";
5499 return "DW_TAG_<unknown>";
5503 /* Convert a DWARF attribute code into its string name. */
5506 dwarf_attr_name (unsigned int attr)
5511 return "DW_AT_sibling";
5512 case DW_AT_location:
5513 return "DW_AT_location";
5515 return "DW_AT_name";
5516 case DW_AT_ordering:
5517 return "DW_AT_ordering";
5518 case DW_AT_subscr_data:
5519 return "DW_AT_subscr_data";
5520 case DW_AT_byte_size:
5521 return "DW_AT_byte_size";
5522 case DW_AT_bit_offset:
5523 return "DW_AT_bit_offset";
5524 case DW_AT_bit_size:
5525 return "DW_AT_bit_size";
5526 case DW_AT_element_list:
5527 return "DW_AT_element_list";
5528 case DW_AT_stmt_list:
5529 return "DW_AT_stmt_list";
5531 return "DW_AT_low_pc";
5533 return "DW_AT_high_pc";
5534 case DW_AT_language:
5535 return "DW_AT_language";
5537 return "DW_AT_member";
5539 return "DW_AT_discr";
5540 case DW_AT_discr_value:
5541 return "DW_AT_discr_value";
5542 case DW_AT_visibility:
5543 return "DW_AT_visibility";
5545 return "DW_AT_import";
5546 case DW_AT_string_length:
5547 return "DW_AT_string_length";
5548 case DW_AT_common_reference:
5549 return "DW_AT_common_reference";
5550 case DW_AT_comp_dir:
5551 return "DW_AT_comp_dir";
5552 case DW_AT_const_value:
5553 return "DW_AT_const_value";
5554 case DW_AT_containing_type:
5555 return "DW_AT_containing_type";
5556 case DW_AT_default_value:
5557 return "DW_AT_default_value";
5559 return "DW_AT_inline";
5560 case DW_AT_is_optional:
5561 return "DW_AT_is_optional";
5562 case DW_AT_lower_bound:
5563 return "DW_AT_lower_bound";
5564 case DW_AT_producer:
5565 return "DW_AT_producer";
5566 case DW_AT_prototyped:
5567 return "DW_AT_prototyped";
5568 case DW_AT_return_addr:
5569 return "DW_AT_return_addr";
5570 case DW_AT_start_scope:
5571 return "DW_AT_start_scope";
5572 case DW_AT_bit_stride:
5573 return "DW_AT_bit_stride";
5574 case DW_AT_upper_bound:
5575 return "DW_AT_upper_bound";
5576 case DW_AT_abstract_origin:
5577 return "DW_AT_abstract_origin";
5578 case DW_AT_accessibility:
5579 return "DW_AT_accessibility";
5580 case DW_AT_address_class:
5581 return "DW_AT_address_class";
5582 case DW_AT_artificial:
5583 return "DW_AT_artificial";
5584 case DW_AT_base_types:
5585 return "DW_AT_base_types";
5586 case DW_AT_calling_convention:
5587 return "DW_AT_calling_convention";
5589 return "DW_AT_count";
5590 case DW_AT_data_member_location:
5591 return "DW_AT_data_member_location";
5592 case DW_AT_decl_column:
5593 return "DW_AT_decl_column";
5594 case DW_AT_decl_file:
5595 return "DW_AT_decl_file";
5596 case DW_AT_decl_line:
5597 return "DW_AT_decl_line";
5598 case DW_AT_declaration:
5599 return "DW_AT_declaration";
5600 case DW_AT_discr_list:
5601 return "DW_AT_discr_list";
5602 case DW_AT_encoding:
5603 return "DW_AT_encoding";
5604 case DW_AT_external:
5605 return "DW_AT_external";
5606 case DW_AT_frame_base:
5607 return "DW_AT_frame_base";
5609 return "DW_AT_friend";
5610 case DW_AT_identifier_case:
5611 return "DW_AT_identifier_case";
5612 case DW_AT_macro_info:
5613 return "DW_AT_macro_info";
5614 case DW_AT_namelist_items:
5615 return "DW_AT_namelist_items";
5616 case DW_AT_priority:
5617 return "DW_AT_priority";
5619 return "DW_AT_segment";
5620 case DW_AT_specification:
5621 return "DW_AT_specification";
5622 case DW_AT_static_link:
5623 return "DW_AT_static_link";
5625 return "DW_AT_type";
5626 case DW_AT_use_location:
5627 return "DW_AT_use_location";
5628 case DW_AT_variable_parameter:
5629 return "DW_AT_variable_parameter";
5630 case DW_AT_virtuality:
5631 return "DW_AT_virtuality";
5632 case DW_AT_vtable_elem_location:
5633 return "DW_AT_vtable_elem_location";
5635 case DW_AT_allocated:
5636 return "DW_AT_allocated";
5637 case DW_AT_associated:
5638 return "DW_AT_associated";
5639 case DW_AT_data_location:
5640 return "DW_AT_data_location";
5641 case DW_AT_byte_stride:
5642 return "DW_AT_byte_stride";
5643 case DW_AT_entry_pc:
5644 return "DW_AT_entry_pc";
5645 case DW_AT_use_UTF8:
5646 return "DW_AT_use_UTF8";
5647 case DW_AT_extension:
5648 return "DW_AT_extension";
5650 return "DW_AT_ranges";
5651 case DW_AT_trampoline:
5652 return "DW_AT_trampoline";
5653 case DW_AT_call_column:
5654 return "DW_AT_call_column";
5655 case DW_AT_call_file:
5656 return "DW_AT_call_file";
5657 case DW_AT_call_line:
5658 return "DW_AT_call_line";
5660 case DW_AT_MIPS_fde:
5661 return "DW_AT_MIPS_fde";
5662 case DW_AT_MIPS_loop_begin:
5663 return "DW_AT_MIPS_loop_begin";
5664 case DW_AT_MIPS_tail_loop_begin:
5665 return "DW_AT_MIPS_tail_loop_begin";
5666 case DW_AT_MIPS_epilog_begin:
5667 return "DW_AT_MIPS_epilog_begin";
5668 case DW_AT_MIPS_loop_unroll_factor:
5669 return "DW_AT_MIPS_loop_unroll_factor";
5670 case DW_AT_MIPS_software_pipeline_depth:
5671 return "DW_AT_MIPS_software_pipeline_depth";
5672 case DW_AT_MIPS_linkage_name:
5673 return "DW_AT_MIPS_linkage_name";
5674 case DW_AT_MIPS_stride:
5675 return "DW_AT_MIPS_stride";
5676 case DW_AT_MIPS_abstract_name:
5677 return "DW_AT_MIPS_abstract_name";
5678 case DW_AT_MIPS_clone_origin:
5679 return "DW_AT_MIPS_clone_origin";
5680 case DW_AT_MIPS_has_inlines:
5681 return "DW_AT_MIPS_has_inlines";
5683 case DW_AT_sf_names:
5684 return "DW_AT_sf_names";
5685 case DW_AT_src_info:
5686 return "DW_AT_src_info";
5687 case DW_AT_mac_info:
5688 return "DW_AT_mac_info";
5689 case DW_AT_src_coords:
5690 return "DW_AT_src_coords";
5691 case DW_AT_body_begin:
5692 return "DW_AT_body_begin";
5693 case DW_AT_body_end:
5694 return "DW_AT_body_end";
5695 case DW_AT_GNU_vector:
5696 return "DW_AT_GNU_vector";
5698 case DW_AT_VMS_rtnbeg_pd_address:
5699 return "DW_AT_VMS_rtnbeg_pd_address";
5702 return "DW_AT_<unknown>";
5706 /* Convert a DWARF value form code into its string name. */
5709 dwarf_form_name (unsigned int form)
5714 return "DW_FORM_addr";
5715 case DW_FORM_block2:
5716 return "DW_FORM_block2";
5717 case DW_FORM_block4:
5718 return "DW_FORM_block4";
5720 return "DW_FORM_data2";
5722 return "DW_FORM_data4";
5724 return "DW_FORM_data8";
5725 case DW_FORM_string:
5726 return "DW_FORM_string";
5728 return "DW_FORM_block";
5729 case DW_FORM_block1:
5730 return "DW_FORM_block1";
5732 return "DW_FORM_data1";
5734 return "DW_FORM_flag";
5736 return "DW_FORM_sdata";
5738 return "DW_FORM_strp";
5740 return "DW_FORM_udata";
5741 case DW_FORM_ref_addr:
5742 return "DW_FORM_ref_addr";
5744 return "DW_FORM_ref1";
5746 return "DW_FORM_ref2";
5748 return "DW_FORM_ref4";
5750 return "DW_FORM_ref8";
5751 case DW_FORM_ref_udata:
5752 return "DW_FORM_ref_udata";
5753 case DW_FORM_indirect:
5754 return "DW_FORM_indirect";
5756 return "DW_FORM_<unknown>";
5760 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
5761 instance of an inlined instance of a decl which is local to an inline
5762 function, so we have to trace all of the way back through the origin chain
5763 to find out what sort of node actually served as the original seed for the
5767 decl_ultimate_origin (const_tree decl)
5769 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
5772 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
5773 nodes in the function to point to themselves; ignore that if
5774 we're trying to output the abstract instance of this function. */
5775 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
5778 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
5779 most distant ancestor, this should never happen. */
5780 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
5782 return DECL_ABSTRACT_ORIGIN (decl);
5785 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
5786 of a virtual function may refer to a base class, so we check the 'this'
5790 decl_class_context (tree decl)
5792 tree context = NULL_TREE;
5794 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
5795 context = DECL_CONTEXT (decl);
5797 context = TYPE_MAIN_VARIANT
5798 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
5800 if (context && !TYPE_P (context))
5801 context = NULL_TREE;
5806 /* Add an attribute/value pair to a DIE. */
5809 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
5811 /* Maybe this should be an assert? */
5815 if (die->die_attr == NULL)
5816 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
5817 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
5820 static inline enum dw_val_class
5821 AT_class (dw_attr_ref a)
5823 return a->dw_attr_val.val_class;
5826 /* Add a flag value attribute to a DIE. */
5829 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
5833 attr.dw_attr = attr_kind;
5834 attr.dw_attr_val.val_class = dw_val_class_flag;
5835 attr.dw_attr_val.v.val_flag = flag;
5836 add_dwarf_attr (die, &attr);
5839 static inline unsigned
5840 AT_flag (dw_attr_ref a)
5842 gcc_assert (a && AT_class (a) == dw_val_class_flag);
5843 return a->dw_attr_val.v.val_flag;
5846 /* Add a signed integer attribute value to a DIE. */
5849 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
5853 attr.dw_attr = attr_kind;
5854 attr.dw_attr_val.val_class = dw_val_class_const;
5855 attr.dw_attr_val.v.val_int = int_val;
5856 add_dwarf_attr (die, &attr);
5859 static inline HOST_WIDE_INT
5860 AT_int (dw_attr_ref a)
5862 gcc_assert (a && AT_class (a) == dw_val_class_const);
5863 return a->dw_attr_val.v.val_int;
5866 /* Add an unsigned integer attribute value to a DIE. */
5869 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
5870 unsigned HOST_WIDE_INT unsigned_val)
5874 attr.dw_attr = attr_kind;
5875 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
5876 attr.dw_attr_val.v.val_unsigned = unsigned_val;
5877 add_dwarf_attr (die, &attr);
5880 static inline unsigned HOST_WIDE_INT
5881 AT_unsigned (dw_attr_ref a)
5883 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
5884 return a->dw_attr_val.v.val_unsigned;
5887 /* Add an unsigned double integer attribute value to a DIE. */
5890 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
5891 long unsigned int val_hi, long unsigned int val_low)
5895 attr.dw_attr = attr_kind;
5896 attr.dw_attr_val.val_class = dw_val_class_long_long;
5897 attr.dw_attr_val.v.val_long_long.hi = val_hi;
5898 attr.dw_attr_val.v.val_long_long.low = val_low;
5899 add_dwarf_attr (die, &attr);
5902 /* Add a floating point attribute value to a DIE and return it. */
5905 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
5906 unsigned int length, unsigned int elt_size, unsigned char *array)
5910 attr.dw_attr = attr_kind;
5911 attr.dw_attr_val.val_class = dw_val_class_vec;
5912 attr.dw_attr_val.v.val_vec.length = length;
5913 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
5914 attr.dw_attr_val.v.val_vec.array = array;
5915 add_dwarf_attr (die, &attr);
5918 /* Hash and equality functions for debug_str_hash. */
5921 debug_str_do_hash (const void *x)
5923 return htab_hash_string (((const struct indirect_string_node *)x)->str);
5927 debug_str_eq (const void *x1, const void *x2)
5929 return strcmp ((((const struct indirect_string_node *)x1)->str),
5930 (const char *)x2) == 0;
5933 /* Add a string attribute value to a DIE. */
5936 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
5939 struct indirect_string_node *node;
5942 if (! debug_str_hash)
5943 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
5944 debug_str_eq, NULL);
5946 slot = htab_find_slot_with_hash (debug_str_hash, str,
5947 htab_hash_string (str), INSERT);
5950 node = (struct indirect_string_node *)
5951 ggc_alloc_cleared (sizeof (struct indirect_string_node));
5952 node->str = ggc_strdup (str);
5956 node = (struct indirect_string_node *) *slot;
5960 attr.dw_attr = attr_kind;
5961 attr.dw_attr_val.val_class = dw_val_class_str;
5962 attr.dw_attr_val.v.val_str = node;
5963 add_dwarf_attr (die, &attr);
5966 static inline const char *
5967 AT_string (dw_attr_ref a)
5969 gcc_assert (a && AT_class (a) == dw_val_class_str);
5970 return a->dw_attr_val.v.val_str->str;
5973 /* Find out whether a string should be output inline in DIE
5974 or out-of-line in .debug_str section. */
5977 AT_string_form (dw_attr_ref a)
5979 struct indirect_string_node *node;
5983 gcc_assert (a && AT_class (a) == dw_val_class_str);
5985 node = a->dw_attr_val.v.val_str;
5989 len = strlen (node->str) + 1;
5991 /* If the string is shorter or equal to the size of the reference, it is
5992 always better to put it inline. */
5993 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5994 return node->form = DW_FORM_string;
5996 /* If we cannot expect the linker to merge strings in .debug_str
5997 section, only put it into .debug_str if it is worth even in this
5999 if ((debug_str_section->common.flags & SECTION_MERGE) == 0
6000 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
6001 return node->form = DW_FORM_string;
6003 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
6004 ++dw2_string_counter;
6005 node->label = xstrdup (label);
6007 return node->form = DW_FORM_strp;
6010 /* Add a DIE reference attribute value to a DIE. */
6013 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
6017 attr.dw_attr = attr_kind;
6018 attr.dw_attr_val.val_class = dw_val_class_die_ref;
6019 attr.dw_attr_val.v.val_die_ref.die = targ_die;
6020 attr.dw_attr_val.v.val_die_ref.external = 0;
6021 add_dwarf_attr (die, &attr);
6024 /* Add an AT_specification attribute to a DIE, and also make the back
6025 pointer from the specification to the definition. */
6028 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
6030 add_AT_die_ref (die, DW_AT_specification, targ_die);
6031 gcc_assert (!targ_die->die_definition);
6032 targ_die->die_definition = die;
6035 static inline dw_die_ref
6036 AT_ref (dw_attr_ref a)
6038 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6039 return a->dw_attr_val.v.val_die_ref.die;
6043 AT_ref_external (dw_attr_ref a)
6045 if (a && AT_class (a) == dw_val_class_die_ref)
6046 return a->dw_attr_val.v.val_die_ref.external;
6052 set_AT_ref_external (dw_attr_ref a, int i)
6054 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
6055 a->dw_attr_val.v.val_die_ref.external = i;
6058 /* Add an FDE reference attribute value to a DIE. */
6061 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
6065 attr.dw_attr = attr_kind;
6066 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
6067 attr.dw_attr_val.v.val_fde_index = targ_fde;
6068 add_dwarf_attr (die, &attr);
6071 /* Add a location description attribute value to a DIE. */
6074 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
6078 attr.dw_attr = attr_kind;
6079 attr.dw_attr_val.val_class = dw_val_class_loc;
6080 attr.dw_attr_val.v.val_loc = loc;
6081 add_dwarf_attr (die, &attr);
6084 static inline dw_loc_descr_ref
6085 AT_loc (dw_attr_ref a)
6087 gcc_assert (a && AT_class (a) == dw_val_class_loc);
6088 return a->dw_attr_val.v.val_loc;
6092 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
6096 attr.dw_attr = attr_kind;
6097 attr.dw_attr_val.val_class = dw_val_class_loc_list;
6098 attr.dw_attr_val.v.val_loc_list = loc_list;
6099 add_dwarf_attr (die, &attr);
6100 have_location_lists = true;
6103 static inline dw_loc_list_ref
6104 AT_loc_list (dw_attr_ref a)
6106 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
6107 return a->dw_attr_val.v.val_loc_list;
6110 /* Add an address constant attribute value to a DIE. */
6113 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
6117 attr.dw_attr = attr_kind;
6118 attr.dw_attr_val.val_class = dw_val_class_addr;
6119 attr.dw_attr_val.v.val_addr = addr;
6120 add_dwarf_attr (die, &attr);
6123 /* Get the RTX from to an address DIE attribute. */
6126 AT_addr (dw_attr_ref a)
6128 gcc_assert (a && AT_class (a) == dw_val_class_addr);
6129 return a->dw_attr_val.v.val_addr;
6132 /* Add a file attribute value to a DIE. */
6135 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
6136 struct dwarf_file_data *fd)
6140 attr.dw_attr = attr_kind;
6141 attr.dw_attr_val.val_class = dw_val_class_file;
6142 attr.dw_attr_val.v.val_file = fd;
6143 add_dwarf_attr (die, &attr);
6146 /* Get the dwarf_file_data from a file DIE attribute. */
6148 static inline struct dwarf_file_data *
6149 AT_file (dw_attr_ref a)
6151 gcc_assert (a && AT_class (a) == dw_val_class_file);
6152 return a->dw_attr_val.v.val_file;
6155 /* Add a label identifier attribute value to a DIE. */
6158 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
6162 attr.dw_attr = attr_kind;
6163 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
6164 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
6165 add_dwarf_attr (die, &attr);
6168 /* Add a section offset attribute value to a DIE, an offset into the
6169 debug_line section. */
6172 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6177 attr.dw_attr = attr_kind;
6178 attr.dw_attr_val.val_class = dw_val_class_lineptr;
6179 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6180 add_dwarf_attr (die, &attr);
6183 /* Add a section offset attribute value to a DIE, an offset into the
6184 debug_macinfo section. */
6187 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
6192 attr.dw_attr = attr_kind;
6193 attr.dw_attr_val.val_class = dw_val_class_macptr;
6194 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
6195 add_dwarf_attr (die, &attr);
6198 /* Add an offset attribute value to a DIE. */
6201 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
6202 unsigned HOST_WIDE_INT offset)
6206 attr.dw_attr = attr_kind;
6207 attr.dw_attr_val.val_class = dw_val_class_offset;
6208 attr.dw_attr_val.v.val_offset = offset;
6209 add_dwarf_attr (die, &attr);
6212 /* Add an range_list attribute value to a DIE. */
6215 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
6216 long unsigned int offset)
6220 attr.dw_attr = attr_kind;
6221 attr.dw_attr_val.val_class = dw_val_class_range_list;
6222 attr.dw_attr_val.v.val_offset = offset;
6223 add_dwarf_attr (die, &attr);
6226 static inline const char *
6227 AT_lbl (dw_attr_ref a)
6229 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
6230 || AT_class (a) == dw_val_class_lineptr
6231 || AT_class (a) == dw_val_class_macptr));
6232 return a->dw_attr_val.v.val_lbl_id;
6235 /* Get the attribute of type attr_kind. */
6238 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6242 dw_die_ref spec = NULL;
6247 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6248 if (a->dw_attr == attr_kind)
6250 else if (a->dw_attr == DW_AT_specification
6251 || a->dw_attr == DW_AT_abstract_origin)
6255 return get_AT (spec, attr_kind);
6260 /* Return the "low pc" attribute value, typically associated with a subprogram
6261 DIE. Return null if the "low pc" attribute is either not present, or if it
6262 cannot be represented as an assembler label identifier. */
6264 static inline const char *
6265 get_AT_low_pc (dw_die_ref die)
6267 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
6269 return a ? AT_lbl (a) : NULL;
6272 /* Return the "high pc" attribute value, typically associated with a subprogram
6273 DIE. Return null if the "high pc" attribute is either not present, or if it
6274 cannot be represented as an assembler label identifier. */
6276 static inline const char *
6277 get_AT_hi_pc (dw_die_ref die)
6279 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
6281 return a ? AT_lbl (a) : NULL;
6284 /* Return the value of the string attribute designated by ATTR_KIND, or
6285 NULL if it is not present. */
6287 static inline const char *
6288 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
6290 dw_attr_ref a = get_AT (die, attr_kind);
6292 return a ? AT_string (a) : NULL;
6295 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
6296 if it is not present. */
6299 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
6301 dw_attr_ref a = get_AT (die, attr_kind);
6303 return a ? AT_flag (a) : 0;
6306 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
6307 if it is not present. */
6309 static inline unsigned
6310 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
6312 dw_attr_ref a = get_AT (die, attr_kind);
6314 return a ? AT_unsigned (a) : 0;
6317 static inline dw_die_ref
6318 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
6320 dw_attr_ref a = get_AT (die, attr_kind);
6322 return a ? AT_ref (a) : NULL;
6325 static inline struct dwarf_file_data *
6326 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
6328 dw_attr_ref a = get_AT (die, attr_kind);
6330 return a ? AT_file (a) : NULL;
6333 /* Return TRUE if the language is C or C++. */
6338 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6340 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_ObjC
6341 || lang == DW_LANG_C99
6342 || lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus);
6345 /* Return TRUE if the language is C++. */
6350 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6352 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
6355 /* Return TRUE if the language is Fortran. */
6360 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6362 return (lang == DW_LANG_Fortran77
6363 || lang == DW_LANG_Fortran90
6364 || lang == DW_LANG_Fortran95);
6367 /* Return TRUE if the language is Java. */
6372 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6374 return lang == DW_LANG_Java;
6377 /* Return TRUE if the language is Ada. */
6382 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
6384 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
6387 /* Remove the specified attribute if present. */
6390 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
6398 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6399 if (a->dw_attr == attr_kind)
6401 if (AT_class (a) == dw_val_class_str)
6402 if (a->dw_attr_val.v.val_str->refcount)
6403 a->dw_attr_val.v.val_str->refcount--;
6405 /* VEC_ordered_remove should help reduce the number of abbrevs
6407 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
6412 /* Remove CHILD from its parent. PREV must have the property that
6413 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
6416 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
6418 gcc_assert (child->die_parent == prev->die_parent);
6419 gcc_assert (prev->die_sib == child);
6422 gcc_assert (child->die_parent->die_child == child);
6426 prev->die_sib = child->die_sib;
6427 if (child->die_parent->die_child == child)
6428 child->die_parent->die_child = prev;
6431 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
6435 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
6441 dw_die_ref prev = c;
6443 while (c->die_tag == tag)
6445 remove_child_with_prev (c, prev);
6446 /* Might have removed every child. */
6447 if (c == c->die_sib)
6451 } while (c != die->die_child);
6454 /* Add a CHILD_DIE as the last child of DIE. */
6457 add_child_die (dw_die_ref die, dw_die_ref child_die)
6459 /* FIXME this should probably be an assert. */
6460 if (! die || ! child_die)
6462 gcc_assert (die != child_die);
6464 child_die->die_parent = die;
6467 child_die->die_sib = die->die_child->die_sib;
6468 die->die_child->die_sib = child_die;
6471 child_die->die_sib = child_die;
6472 die->die_child = child_die;
6475 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
6476 is the specification, to the end of PARENT's list of children.
6477 This is done by removing and re-adding it. */
6480 splice_child_die (dw_die_ref parent, dw_die_ref child)
6484 /* We want the declaration DIE from inside the class, not the
6485 specification DIE at toplevel. */
6486 if (child->die_parent != parent)
6488 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
6494 gcc_assert (child->die_parent == parent
6495 || (child->die_parent
6496 == get_AT_ref (parent, DW_AT_specification)));
6498 for (p = child->die_parent->die_child; ; p = p->die_sib)
6499 if (p->die_sib == child)
6501 remove_child_with_prev (child, p);
6505 add_child_die (parent, child);
6508 /* Return a pointer to a newly created DIE node. */
6510 static inline dw_die_ref
6511 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
6513 dw_die_ref die = GGC_CNEW (die_node);
6515 die->die_tag = tag_value;
6517 if (parent_die != NULL)
6518 add_child_die (parent_die, die);
6521 limbo_die_node *limbo_node;
6523 limbo_node = GGC_CNEW (limbo_die_node);
6524 limbo_node->die = die;
6525 limbo_node->created_for = t;
6526 limbo_node->next = limbo_die_list;
6527 limbo_die_list = limbo_node;
6533 /* Return the DIE associated with the given type specifier. */
6535 static inline dw_die_ref
6536 lookup_type_die (tree type)
6538 return TYPE_SYMTAB_DIE (type);
6541 /* Equate a DIE to a given type specifier. */
6544 equate_type_number_to_die (tree type, dw_die_ref type_die)
6546 TYPE_SYMTAB_DIE (type) = type_die;
6549 /* Returns a hash value for X (which really is a die_struct). */
6552 decl_die_table_hash (const void *x)
6554 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
6557 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
6560 decl_die_table_eq (const void *x, const void *y)
6562 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
6565 /* Return the DIE associated with a given declaration. */
6567 static inline dw_die_ref
6568 lookup_decl_die (tree decl)
6570 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
6573 /* Returns a hash value for X (which really is a var_loc_list). */
6576 decl_loc_table_hash (const void *x)
6578 return (hashval_t) ((const var_loc_list *) x)->decl_id;
6581 /* Return nonzero if decl_id of var_loc_list X is the same as
6585 decl_loc_table_eq (const void *x, const void *y)
6587 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
6590 /* Return the var_loc list associated with a given declaration. */
6592 static inline var_loc_list *
6593 lookup_decl_loc (const_tree decl)
6595 return (var_loc_list *)
6596 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
6599 /* Equate a DIE to a particular declaration. */
6602 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
6604 unsigned int decl_id = DECL_UID (decl);
6607 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
6609 decl_die->decl_id = decl_id;
6612 /* Add a variable location node to the linked list for DECL. */
6615 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
6617 unsigned int decl_id = DECL_UID (decl);
6621 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
6624 temp = GGC_CNEW (var_loc_list);
6625 temp->decl_id = decl_id;
6629 temp = (var_loc_list *) *slot;
6633 /* If the current location is the same as the end of the list,
6634 and either both or neither of the locations is uninitialized,
6635 we have nothing to do. */
6636 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
6637 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
6638 || ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6639 != NOTE_VAR_LOCATION_STATUS (loc->var_loc_note))
6640 && ((NOTE_VAR_LOCATION_STATUS (temp->last->var_loc_note)
6641 == VAR_INIT_STATUS_UNINITIALIZED)
6642 || (NOTE_VAR_LOCATION_STATUS (loc->var_loc_note)
6643 == VAR_INIT_STATUS_UNINITIALIZED))))
6645 /* Add LOC to the end of list and update LAST. */
6646 temp->last->next = loc;
6650 /* Do not add empty location to the beginning of the list. */
6651 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
6658 /* Keep track of the number of spaces used to indent the
6659 output of the debugging routines that print the structure of
6660 the DIE internal representation. */
6661 static int print_indent;
6663 /* Indent the line the number of spaces given by print_indent. */
6666 print_spaces (FILE *outfile)
6668 fprintf (outfile, "%*s", print_indent, "");
6671 /* Print the information associated with a given DIE, and its children.
6672 This routine is a debugging aid only. */
6675 print_die (dw_die_ref die, FILE *outfile)
6681 print_spaces (outfile);
6682 fprintf (outfile, "DIE %4ld: %s\n",
6683 die->die_offset, dwarf_tag_name (die->die_tag));
6684 print_spaces (outfile);
6685 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
6686 fprintf (outfile, " offset: %ld\n", die->die_offset);
6688 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6690 print_spaces (outfile);
6691 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
6693 switch (AT_class (a))
6695 case dw_val_class_addr:
6696 fprintf (outfile, "address");
6698 case dw_val_class_offset:
6699 fprintf (outfile, "offset");
6701 case dw_val_class_loc:
6702 fprintf (outfile, "location descriptor");
6704 case dw_val_class_loc_list:
6705 fprintf (outfile, "location list -> label:%s",
6706 AT_loc_list (a)->ll_symbol);
6708 case dw_val_class_range_list:
6709 fprintf (outfile, "range list");
6711 case dw_val_class_const:
6712 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
6714 case dw_val_class_unsigned_const:
6715 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
6717 case dw_val_class_long_long:
6718 fprintf (outfile, "constant (%lu,%lu)",
6719 a->dw_attr_val.v.val_long_long.hi,
6720 a->dw_attr_val.v.val_long_long.low);
6722 case dw_val_class_vec:
6723 fprintf (outfile, "floating-point or vector constant");
6725 case dw_val_class_flag:
6726 fprintf (outfile, "%u", AT_flag (a));
6728 case dw_val_class_die_ref:
6729 if (AT_ref (a) != NULL)
6731 if (AT_ref (a)->die_symbol)
6732 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
6734 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
6737 fprintf (outfile, "die -> <null>");
6739 case dw_val_class_lbl_id:
6740 case dw_val_class_lineptr:
6741 case dw_val_class_macptr:
6742 fprintf (outfile, "label: %s", AT_lbl (a));
6744 case dw_val_class_str:
6745 if (AT_string (a) != NULL)
6746 fprintf (outfile, "\"%s\"", AT_string (a));
6748 fprintf (outfile, "<null>");
6750 case dw_val_class_file:
6751 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
6752 AT_file (a)->emitted_number);
6758 fprintf (outfile, "\n");
6761 if (die->die_child != NULL)
6764 FOR_EACH_CHILD (die, c, print_die (c, outfile));
6767 if (print_indent == 0)
6768 fprintf (outfile, "\n");
6771 /* Print the contents of the source code line number correspondence table.
6772 This routine is a debugging aid only. */
6775 print_dwarf_line_table (FILE *outfile)
6778 dw_line_info_ref line_info;
6780 fprintf (outfile, "\n\nDWARF source line information\n");
6781 for (i = 1; i < line_info_table_in_use; i++)
6783 line_info = &line_info_table[i];
6784 fprintf (outfile, "%5d: %4ld %6ld\n", i,
6785 line_info->dw_file_num,
6786 line_info->dw_line_num);
6789 fprintf (outfile, "\n\n");
6792 /* Print the information collected for a given DIE. */
6795 debug_dwarf_die (dw_die_ref die)
6797 print_die (die, stderr);
6800 /* Print all DWARF information collected for the compilation unit.
6801 This routine is a debugging aid only. */
6807 print_die (comp_unit_die, stderr);
6808 if (! DWARF2_ASM_LINE_DEBUG_INFO)
6809 print_dwarf_line_table (stderr);
6812 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
6813 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
6814 DIE that marks the start of the DIEs for this include file. */
6817 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
6819 const char *filename = get_AT_string (bincl_die, DW_AT_name);
6820 dw_die_ref new_unit = gen_compile_unit_die (filename);
6822 new_unit->die_sib = old_unit;
6826 /* Close an include-file CU and reopen the enclosing one. */
6829 pop_compile_unit (dw_die_ref old_unit)
6831 dw_die_ref new_unit = old_unit->die_sib;
6833 old_unit->die_sib = NULL;
6837 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6838 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6840 /* Calculate the checksum of a location expression. */
6843 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
6845 CHECKSUM (loc->dw_loc_opc);
6846 CHECKSUM (loc->dw_loc_oprnd1);
6847 CHECKSUM (loc->dw_loc_oprnd2);
6850 /* Calculate the checksum of an attribute. */
6853 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
6855 dw_loc_descr_ref loc;
6858 CHECKSUM (at->dw_attr);
6860 /* We don't care that this was compiled with a different compiler
6861 snapshot; if the output is the same, that's what matters. */
6862 if (at->dw_attr == DW_AT_producer)
6865 switch (AT_class (at))
6867 case dw_val_class_const:
6868 CHECKSUM (at->dw_attr_val.v.val_int);
6870 case dw_val_class_unsigned_const:
6871 CHECKSUM (at->dw_attr_val.v.val_unsigned);
6873 case dw_val_class_long_long:
6874 CHECKSUM (at->dw_attr_val.v.val_long_long);
6876 case dw_val_class_vec:
6877 CHECKSUM (at->dw_attr_val.v.val_vec);
6879 case dw_val_class_flag:
6880 CHECKSUM (at->dw_attr_val.v.val_flag);
6882 case dw_val_class_str:
6883 CHECKSUM_STRING (AT_string (at));
6886 case dw_val_class_addr:
6888 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6889 CHECKSUM_STRING (XSTR (r, 0));
6892 case dw_val_class_offset:
6893 CHECKSUM (at->dw_attr_val.v.val_offset);
6896 case dw_val_class_loc:
6897 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6898 loc_checksum (loc, ctx);
6901 case dw_val_class_die_ref:
6902 die_checksum (AT_ref (at), ctx, mark);
6905 case dw_val_class_fde_ref:
6906 case dw_val_class_lbl_id:
6907 case dw_val_class_lineptr:
6908 case dw_val_class_macptr:
6911 case dw_val_class_file:
6912 CHECKSUM_STRING (AT_file (at)->filename);
6920 /* Calculate the checksum of a DIE. */
6923 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6929 /* To avoid infinite recursion. */
6932 CHECKSUM (die->die_mark);
6935 die->die_mark = ++(*mark);
6937 CHECKSUM (die->die_tag);
6939 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
6940 attr_checksum (a, ctx, mark);
6942 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6946 #undef CHECKSUM_STRING
6948 /* Do the location expressions look same? */
6950 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
6952 return loc1->dw_loc_opc == loc2->dw_loc_opc
6953 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
6954 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
6957 /* Do the values look the same? */
6959 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
6961 dw_loc_descr_ref loc1, loc2;
6964 if (v1->val_class != v2->val_class)
6967 switch (v1->val_class)
6969 case dw_val_class_const:
6970 return v1->v.val_int == v2->v.val_int;
6971 case dw_val_class_unsigned_const:
6972 return v1->v.val_unsigned == v2->v.val_unsigned;
6973 case dw_val_class_long_long:
6974 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6975 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6976 case dw_val_class_vec:
6977 if (v1->v.val_vec.length != v2->v.val_vec.length
6978 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6980 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6981 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6984 case dw_val_class_flag:
6985 return v1->v.val_flag == v2->v.val_flag;
6986 case dw_val_class_str:
6987 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6989 case dw_val_class_addr:
6990 r1 = v1->v.val_addr;
6991 r2 = v2->v.val_addr;
6992 if (GET_CODE (r1) != GET_CODE (r2))
6994 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6995 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6997 case dw_val_class_offset:
6998 return v1->v.val_offset == v2->v.val_offset;
7000 case dw_val_class_loc:
7001 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
7003 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7004 if (!same_loc_p (loc1, loc2, mark))
7006 return !loc1 && !loc2;
7008 case dw_val_class_die_ref:
7009 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7011 case dw_val_class_fde_ref:
7012 case dw_val_class_lbl_id:
7013 case dw_val_class_lineptr:
7014 case dw_val_class_macptr:
7017 case dw_val_class_file:
7018 return v1->v.val_file == v2->v.val_file;
7025 /* Do the attributes look the same? */
7028 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
7030 if (at1->dw_attr != at2->dw_attr)
7033 /* We don't care that this was compiled with a different compiler
7034 snapshot; if the output is the same, that's what matters. */
7035 if (at1->dw_attr == DW_AT_producer)
7038 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7041 /* Do the dies look the same? */
7044 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7050 /* To avoid infinite recursion. */
7052 return die1->die_mark == die2->die_mark;
7053 die1->die_mark = die2->die_mark = ++(*mark);
7055 if (die1->die_tag != die2->die_tag)
7058 if (VEC_length (dw_attr_node, die1->die_attr)
7059 != VEC_length (dw_attr_node, die2->die_attr))
7062 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
7063 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
7066 c1 = die1->die_child;
7067 c2 = die2->die_child;
7076 if (!same_die_p (c1, c2, mark))
7080 if (c1 == die1->die_child)
7082 if (c2 == die2->die_child)
7092 /* Do the dies look the same? Wrapper around same_die_p. */
7095 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
7098 int ret = same_die_p (die1, die2, &mark);
7100 unmark_all_dies (die1);
7101 unmark_all_dies (die2);
7106 /* The prefix to attach to symbols on DIEs in the current comdat debug
7108 static char *comdat_symbol_id;
7110 /* The index of the current symbol within the current comdat CU. */
7111 static unsigned int comdat_symbol_number;
7113 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7114 children, and set comdat_symbol_id accordingly. */
7117 compute_section_prefix (dw_die_ref unit_die)
7119 const char *die_name = get_AT_string (unit_die, DW_AT_name);
7120 const char *base = die_name ? lbasename (die_name) : "anonymous";
7121 char *name = XALLOCAVEC (char, strlen (base) + 64);
7124 unsigned char checksum[16];
7127 /* Compute the checksum of the DIE, then append part of it as hex digits to
7128 the name filename of the unit. */
7130 md5_init_ctx (&ctx);
7132 die_checksum (unit_die, &ctx, &mark);
7133 unmark_all_dies (unit_die);
7134 md5_finish_ctx (&ctx, checksum);
7136 sprintf (name, "%s.", base);
7137 clean_symbol_name (name);
7139 p = name + strlen (name);
7140 for (i = 0; i < 4; i++)
7142 sprintf (p, "%.2x", checksum[i]);
7146 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
7147 comdat_symbol_number = 0;
7150 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7153 is_type_die (dw_die_ref die)
7155 switch (die->die_tag)
7157 case DW_TAG_array_type:
7158 case DW_TAG_class_type:
7159 case DW_TAG_interface_type:
7160 case DW_TAG_enumeration_type:
7161 case DW_TAG_pointer_type:
7162 case DW_TAG_reference_type:
7163 case DW_TAG_string_type:
7164 case DW_TAG_structure_type:
7165 case DW_TAG_subroutine_type:
7166 case DW_TAG_union_type:
7167 case DW_TAG_ptr_to_member_type:
7168 case DW_TAG_set_type:
7169 case DW_TAG_subrange_type:
7170 case DW_TAG_base_type:
7171 case DW_TAG_const_type:
7172 case DW_TAG_file_type:
7173 case DW_TAG_packed_type:
7174 case DW_TAG_volatile_type:
7175 case DW_TAG_typedef:
7182 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7183 Basically, we want to choose the bits that are likely to be shared between
7184 compilations (types) and leave out the bits that are specific to individual
7185 compilations (functions). */
7188 is_comdat_die (dw_die_ref c)
7190 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7191 we do for stabs. The advantage is a greater likelihood of sharing between
7192 objects that don't include headers in the same order (and therefore would
7193 put the base types in a different comdat). jason 8/28/00 */
7195 if (c->die_tag == DW_TAG_base_type)
7198 if (c->die_tag == DW_TAG_pointer_type
7199 || c->die_tag == DW_TAG_reference_type
7200 || c->die_tag == DW_TAG_const_type
7201 || c->die_tag == DW_TAG_volatile_type)
7203 dw_die_ref t = get_AT_ref (c, DW_AT_type);
7205 return t ? is_comdat_die (t) : 0;
7208 return is_type_die (c);
7211 /* Returns 1 iff C is the sort of DIE that might be referred to from another
7212 compilation unit. */
7215 is_symbol_die (dw_die_ref c)
7217 return (is_type_die (c)
7218 || (get_AT (c, DW_AT_declaration)
7219 && !get_AT (c, DW_AT_specification))
7220 || c->die_tag == DW_TAG_namespace
7221 || c->die_tag == DW_TAG_module);
7225 gen_internal_sym (const char *prefix)
7229 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
7230 return xstrdup (buf);
7233 /* Assign symbols to all worthy DIEs under DIE. */
7236 assign_symbol_names (dw_die_ref die)
7240 if (is_symbol_die (die))
7242 if (comdat_symbol_id)
7244 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
7246 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
7247 comdat_symbol_id, comdat_symbol_number++);
7248 die->die_symbol = xstrdup (p);
7251 die->die_symbol = gen_internal_sym ("LDIE");
7254 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
7257 struct cu_hash_table_entry
7260 unsigned min_comdat_num, max_comdat_num;
7261 struct cu_hash_table_entry *next;
7264 /* Routines to manipulate hash table of CUs. */
7266 htab_cu_hash (const void *of)
7268 const struct cu_hash_table_entry *const entry =
7269 (const struct cu_hash_table_entry *) of;
7271 return htab_hash_string (entry->cu->die_symbol);
7275 htab_cu_eq (const void *of1, const void *of2)
7277 const struct cu_hash_table_entry *const entry1 =
7278 (const struct cu_hash_table_entry *) of1;
7279 const struct die_struct *const entry2 = (const struct die_struct *) of2;
7281 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
7285 htab_cu_del (void *what)
7287 struct cu_hash_table_entry *next,
7288 *entry = (struct cu_hash_table_entry *) what;
7298 /* Check whether we have already seen this CU and set up SYM_NUM
7301 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
7303 struct cu_hash_table_entry dummy;
7304 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
7306 dummy.max_comdat_num = 0;
7308 slot = (struct cu_hash_table_entry **)
7309 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7313 for (; entry; last = entry, entry = entry->next)
7315 if (same_die_p_wrap (cu, entry->cu))
7321 *sym_num = entry->min_comdat_num;
7325 entry = XCNEW (struct cu_hash_table_entry);
7327 entry->min_comdat_num = *sym_num = last->max_comdat_num;
7328 entry->next = *slot;
7334 /* Record SYM_NUM to record of CU in HTABLE. */
7336 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
7338 struct cu_hash_table_entry **slot, *entry;
7340 slot = (struct cu_hash_table_entry **)
7341 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
7345 entry->max_comdat_num = sym_num;
7348 /* Traverse the DIE (which is always comp_unit_die), and set up
7349 additional compilation units for each of the include files we see
7350 bracketed by BINCL/EINCL. */
7353 break_out_includes (dw_die_ref die)
7356 dw_die_ref unit = NULL;
7357 limbo_die_node *node, **pnode;
7358 htab_t cu_hash_table;
7362 dw_die_ref prev = c;
7364 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
7365 || (unit && is_comdat_die (c)))
7367 dw_die_ref next = c->die_sib;
7369 /* This DIE is for a secondary CU; remove it from the main one. */
7370 remove_child_with_prev (c, prev);
7372 if (c->die_tag == DW_TAG_GNU_BINCL)
7373 unit = push_new_compile_unit (unit, c);
7374 else if (c->die_tag == DW_TAG_GNU_EINCL)
7375 unit = pop_compile_unit (unit);
7377 add_child_die (unit, c);
7379 if (c == die->die_child)
7382 } while (c != die->die_child);
7385 /* We can only use this in debugging, since the frontend doesn't check
7386 to make sure that we leave every include file we enter. */
7390 assign_symbol_names (die);
7391 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
7392 for (node = limbo_die_list, pnode = &limbo_die_list;
7398 compute_section_prefix (node->die);
7399 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
7400 &comdat_symbol_number);
7401 assign_symbol_names (node->die);
7403 *pnode = node->next;
7406 pnode = &node->next;
7407 record_comdat_symbol_number (node->die, cu_hash_table,
7408 comdat_symbol_number);
7411 htab_delete (cu_hash_table);
7414 /* Traverse the DIE and add a sibling attribute if it may have the
7415 effect of speeding up access to siblings. To save some space,
7416 avoid generating sibling attributes for DIE's without children. */
7419 add_sibling_attributes (dw_die_ref die)
7423 if (! die->die_child)
7426 if (die->die_parent && die != die->die_parent->die_child)
7427 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
7429 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
7432 /* Output all location lists for the DIE and its children. */
7435 output_location_lists (dw_die_ref die)
7441 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7442 if (AT_class (a) == dw_val_class_loc_list)
7443 output_loc_list (AT_loc_list (a));
7445 FOR_EACH_CHILD (die, c, output_location_lists (c));
7448 /* The format of each DIE (and its attribute value pairs) is encoded in an
7449 abbreviation table. This routine builds the abbreviation table and assigns
7450 a unique abbreviation id for each abbreviation entry. The children of each
7451 die are visited recursively. */
7454 build_abbrev_table (dw_die_ref die)
7456 unsigned long abbrev_id;
7457 unsigned int n_alloc;
7462 /* Scan the DIE references, and mark as external any that refer to
7463 DIEs from other CUs (i.e. those which are not marked). */
7464 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7465 if (AT_class (a) == dw_val_class_die_ref
7466 && AT_ref (a)->die_mark == 0)
7468 gcc_assert (AT_ref (a)->die_symbol);
7470 set_AT_ref_external (a, 1);
7473 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7475 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7476 dw_attr_ref die_a, abbrev_a;
7480 if (abbrev->die_tag != die->die_tag)
7482 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
7485 if (VEC_length (dw_attr_node, abbrev->die_attr)
7486 != VEC_length (dw_attr_node, die->die_attr))
7489 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
7491 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
7492 if ((abbrev_a->dw_attr != die_a->dw_attr)
7493 || (value_format (abbrev_a) != value_format (die_a)))
7503 if (abbrev_id >= abbrev_die_table_in_use)
7505 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
7507 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
7508 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
7511 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
7512 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
7513 abbrev_die_table_allocated = n_alloc;
7516 ++abbrev_die_table_in_use;
7517 abbrev_die_table[abbrev_id] = die;
7520 die->die_abbrev = abbrev_id;
7521 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
7524 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7527 constant_size (unsigned HOST_WIDE_INT value)
7534 log = floor_log2 (value);
7537 log = 1 << (floor_log2 (log) + 1);
7542 /* Return the size of a DIE as it is represented in the
7543 .debug_info section. */
7545 static unsigned long
7546 size_of_die (dw_die_ref die)
7548 unsigned long size = 0;
7552 size += size_of_uleb128 (die->die_abbrev);
7553 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7555 switch (AT_class (a))
7557 case dw_val_class_addr:
7558 size += DWARF2_ADDR_SIZE;
7560 case dw_val_class_offset:
7561 size += DWARF_OFFSET_SIZE;
7563 case dw_val_class_loc:
7565 unsigned long lsize = size_of_locs (AT_loc (a));
7568 size += constant_size (lsize);
7572 case dw_val_class_loc_list:
7573 size += DWARF_OFFSET_SIZE;
7575 case dw_val_class_range_list:
7576 size += DWARF_OFFSET_SIZE;
7578 case dw_val_class_const:
7579 size += size_of_sleb128 (AT_int (a));
7581 case dw_val_class_unsigned_const:
7582 size += constant_size (AT_unsigned (a));
7584 case dw_val_class_long_long:
7585 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
7587 case dw_val_class_vec:
7588 size += constant_size (a->dw_attr_val.v.val_vec.length
7589 * a->dw_attr_val.v.val_vec.elt_size)
7590 + a->dw_attr_val.v.val_vec.length
7591 * a->dw_attr_val.v.val_vec.elt_size; /* block */
7593 case dw_val_class_flag:
7596 case dw_val_class_die_ref:
7597 if (AT_ref_external (a))
7598 size += DWARF2_ADDR_SIZE;
7600 size += DWARF_OFFSET_SIZE;
7602 case dw_val_class_fde_ref:
7603 size += DWARF_OFFSET_SIZE;
7605 case dw_val_class_lbl_id:
7606 size += DWARF2_ADDR_SIZE;
7608 case dw_val_class_lineptr:
7609 case dw_val_class_macptr:
7610 size += DWARF_OFFSET_SIZE;
7612 case dw_val_class_str:
7613 if (AT_string_form (a) == DW_FORM_strp)
7614 size += DWARF_OFFSET_SIZE;
7616 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
7618 case dw_val_class_file:
7619 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
7629 /* Size the debugging information associated with a given DIE. Visits the
7630 DIE's children recursively. Updates the global variable next_die_offset, on
7631 each time through. Uses the current value of next_die_offset to update the
7632 die_offset field in each DIE. */
7635 calc_die_sizes (dw_die_ref die)
7639 die->die_offset = next_die_offset;
7640 next_die_offset += size_of_die (die);
7642 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
7644 if (die->die_child != NULL)
7645 /* Count the null byte used to terminate sibling lists. */
7646 next_die_offset += 1;
7649 /* Set the marks for a die and its children. We do this so
7650 that we know whether or not a reference needs to use FORM_ref_addr; only
7651 DIEs in the same CU will be marked. We used to clear out the offset
7652 and use that as the flag, but ran into ordering problems. */
7655 mark_dies (dw_die_ref die)
7659 gcc_assert (!die->die_mark);
7662 FOR_EACH_CHILD (die, c, mark_dies (c));
7665 /* Clear the marks for a die and its children. */
7668 unmark_dies (dw_die_ref die)
7672 gcc_assert (die->die_mark);
7675 FOR_EACH_CHILD (die, c, unmark_dies (c));
7678 /* Clear the marks for a die, its children and referred dies. */
7681 unmark_all_dies (dw_die_ref die)
7691 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
7693 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7694 if (AT_class (a) == dw_val_class_die_ref)
7695 unmark_all_dies (AT_ref (a));
7698 /* Return the size of the .debug_pubnames or .debug_pubtypes table
7699 generated for the compilation unit. */
7701 static unsigned long
7702 size_of_pubnames (VEC (pubname_entry, gc) * names)
7708 size = DWARF_PUBNAMES_HEADER_SIZE;
7709 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
7710 if (names != pubtype_table
7711 || p->die->die_offset != 0
7712 || !flag_eliminate_unused_debug_types)
7713 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
7715 size += DWARF_OFFSET_SIZE;
7719 /* Return the size of the information in the .debug_aranges section. */
7721 static unsigned long
7722 size_of_aranges (void)
7726 size = DWARF_ARANGES_HEADER_SIZE;
7728 /* Count the address/length pair for this compilation unit. */
7729 if (text_section_used)
7730 size += 2 * DWARF2_ADDR_SIZE;
7731 if (cold_text_section_used)
7732 size += 2 * DWARF2_ADDR_SIZE;
7733 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
7735 /* Count the two zero words used to terminated the address range table. */
7736 size += 2 * DWARF2_ADDR_SIZE;
7740 /* Select the encoding of an attribute value. */
7742 static enum dwarf_form
7743 value_format (dw_attr_ref a)
7745 switch (a->dw_attr_val.val_class)
7747 case dw_val_class_addr:
7748 return DW_FORM_addr;
7749 case dw_val_class_range_list:
7750 case dw_val_class_offset:
7751 case dw_val_class_loc_list:
7752 switch (DWARF_OFFSET_SIZE)
7755 return DW_FORM_data4;
7757 return DW_FORM_data8;
7761 case dw_val_class_loc:
7762 switch (constant_size (size_of_locs (AT_loc (a))))
7765 return DW_FORM_block1;
7767 return DW_FORM_block2;
7771 case dw_val_class_const:
7772 return DW_FORM_sdata;
7773 case dw_val_class_unsigned_const:
7774 switch (constant_size (AT_unsigned (a)))
7777 return DW_FORM_data1;
7779 return DW_FORM_data2;
7781 return DW_FORM_data4;
7783 return DW_FORM_data8;
7787 case dw_val_class_long_long:
7788 return DW_FORM_block1;
7789 case dw_val_class_vec:
7790 switch (constant_size (a->dw_attr_val.v.val_vec.length
7791 * a->dw_attr_val.v.val_vec.elt_size))
7794 return DW_FORM_block1;
7796 return DW_FORM_block2;
7798 return DW_FORM_block4;
7802 case dw_val_class_flag:
7803 return DW_FORM_flag;
7804 case dw_val_class_die_ref:
7805 if (AT_ref_external (a))
7806 return DW_FORM_ref_addr;
7809 case dw_val_class_fde_ref:
7810 return DW_FORM_data;
7811 case dw_val_class_lbl_id:
7812 return DW_FORM_addr;
7813 case dw_val_class_lineptr:
7814 case dw_val_class_macptr:
7815 return DW_FORM_data;
7816 case dw_val_class_str:
7817 return AT_string_form (a);
7818 case dw_val_class_file:
7819 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
7822 return DW_FORM_data1;
7824 return DW_FORM_data2;
7826 return DW_FORM_data4;
7836 /* Output the encoding of an attribute value. */
7839 output_value_format (dw_attr_ref a)
7841 enum dwarf_form form = value_format (a);
7843 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
7846 /* Output the .debug_abbrev section which defines the DIE abbreviation
7850 output_abbrev_section (void)
7852 unsigned long abbrev_id;
7854 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
7856 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
7860 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
7861 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
7862 dwarf_tag_name (abbrev->die_tag));
7864 if (abbrev->die_child != NULL)
7865 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
7867 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
7869 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
7872 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
7873 dwarf_attr_name (a_attr->dw_attr));
7874 output_value_format (a_attr);
7877 dw2_asm_output_data (1, 0, NULL);
7878 dw2_asm_output_data (1, 0, NULL);
7881 /* Terminate the table. */
7882 dw2_asm_output_data (1, 0, NULL);
7885 /* Output a symbol we can use to refer to this DIE from another CU. */
7888 output_die_symbol (dw_die_ref die)
7890 char *sym = die->die_symbol;
7895 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
7896 /* We make these global, not weak; if the target doesn't support
7897 .linkonce, it doesn't support combining the sections, so debugging
7899 targetm.asm_out.globalize_label (asm_out_file, sym);
7901 ASM_OUTPUT_LABEL (asm_out_file, sym);
7904 /* Return a new location list, given the begin and end range, and the
7905 expression. gensym tells us whether to generate a new internal symbol for
7906 this location list node, which is done for the head of the list only. */
7908 static inline dw_loc_list_ref
7909 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
7910 const char *section, unsigned int gensym)
7912 dw_loc_list_ref retlist = GGC_CNEW (dw_loc_list_node);
7914 retlist->begin = begin;
7916 retlist->expr = expr;
7917 retlist->section = section;
7919 retlist->ll_symbol = gen_internal_sym ("LLST");
7924 /* Add a location description expression to a location list. */
7927 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
7928 const char *begin, const char *end,
7929 const char *section)
7933 /* Find the end of the chain. */
7934 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
7937 /* Add a new location list node to the list. */
7938 *d = new_loc_list (descr, begin, end, section, 0);
7941 /* Output the location list given to us. */
7944 output_loc_list (dw_loc_list_ref list_head)
7946 dw_loc_list_ref curr = list_head;
7948 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
7950 /* Walk the location list, and output each range + expression. */
7951 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
7954 /* Don't output an entry that starts and ends at the same address. */
7955 if (strcmp (curr->begin, curr->end) == 0)
7957 if (!have_multiple_function_sections)
7959 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
7960 "Location list begin address (%s)",
7961 list_head->ll_symbol);
7962 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
7963 "Location list end address (%s)",
7964 list_head->ll_symbol);
7968 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
7969 "Location list begin address (%s)",
7970 list_head->ll_symbol);
7971 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
7972 "Location list end address (%s)",
7973 list_head->ll_symbol);
7975 size = size_of_locs (curr->expr);
7977 /* Output the block length for this list of location operations. */
7978 gcc_assert (size <= 0xffff);
7979 dw2_asm_output_data (2, size, "%s", "Location expression size");
7981 output_loc_sequence (curr->expr);
7984 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7985 "Location list terminator begin (%s)",
7986 list_head->ll_symbol);
7987 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
7988 "Location list terminator end (%s)",
7989 list_head->ll_symbol);
7992 /* Output the DIE and its attributes. Called recursively to generate
7993 the definitions of each child DIE. */
7996 output_die (dw_die_ref die)
8003 /* If someone in another CU might refer to us, set up a symbol for
8004 them to point to. */
8005 if (die->die_symbol)
8006 output_die_symbol (die);
8008 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
8009 (unsigned long)die->die_offset,
8010 dwarf_tag_name (die->die_tag));
8012 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8014 const char *name = dwarf_attr_name (a->dw_attr);
8016 switch (AT_class (a))
8018 case dw_val_class_addr:
8019 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
8022 case dw_val_class_offset:
8023 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
8027 case dw_val_class_range_list:
8029 char *p = strchr (ranges_section_label, '\0');
8031 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
8032 a->dw_attr_val.v.val_offset);
8033 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
8034 debug_ranges_section, "%s", name);
8039 case dw_val_class_loc:
8040 size = size_of_locs (AT_loc (a));
8042 /* Output the block length for this list of location operations. */
8043 dw2_asm_output_data (constant_size (size), size, "%s", name);
8045 output_loc_sequence (AT_loc (a));
8048 case dw_val_class_const:
8049 /* ??? It would be slightly more efficient to use a scheme like is
8050 used for unsigned constants below, but gdb 4.x does not sign
8051 extend. Gdb 5.x does sign extend. */
8052 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
8055 case dw_val_class_unsigned_const:
8056 dw2_asm_output_data (constant_size (AT_unsigned (a)),
8057 AT_unsigned (a), "%s", name);
8060 case dw_val_class_long_long:
8062 unsigned HOST_WIDE_INT first, second;
8064 dw2_asm_output_data (1,
8065 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8068 if (WORDS_BIG_ENDIAN)
8070 first = a->dw_attr_val.v.val_long_long.hi;
8071 second = a->dw_attr_val.v.val_long_long.low;
8075 first = a->dw_attr_val.v.val_long_long.low;
8076 second = a->dw_attr_val.v.val_long_long.hi;
8079 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8080 first, "long long constant");
8081 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
8086 case dw_val_class_vec:
8088 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
8089 unsigned int len = a->dw_attr_val.v.val_vec.length;
8093 dw2_asm_output_data (constant_size (len * elt_size),
8094 len * elt_size, "%s", name);
8095 if (elt_size > sizeof (HOST_WIDE_INT))
8100 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
8103 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
8104 "fp or vector constant word %u", i);
8108 case dw_val_class_flag:
8109 dw2_asm_output_data (1, AT_flag (a), "%s", name);
8112 case dw_val_class_loc_list:
8114 char *sym = AT_loc_list (a)->ll_symbol;
8117 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
8122 case dw_val_class_die_ref:
8123 if (AT_ref_external (a))
8125 char *sym = AT_ref (a)->die_symbol;
8128 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, debug_info_section,
8133 gcc_assert (AT_ref (a)->die_offset);
8134 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
8139 case dw_val_class_fde_ref:
8143 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
8144 a->dw_attr_val.v.val_fde_index * 2);
8145 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
8150 case dw_val_class_lbl_id:
8151 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
8154 case dw_val_class_lineptr:
8155 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8156 debug_line_section, "%s", name);
8159 case dw_val_class_macptr:
8160 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
8161 debug_macinfo_section, "%s", name);
8164 case dw_val_class_str:
8165 if (AT_string_form (a) == DW_FORM_strp)
8166 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
8167 a->dw_attr_val.v.val_str->label,
8169 "%s: \"%s\"", name, AT_string (a));
8171 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
8174 case dw_val_class_file:
8176 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
8178 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
8179 a->dw_attr_val.v.val_file->filename);
8188 FOR_EACH_CHILD (die, c, output_die (c));
8190 /* Add null byte to terminate sibling list. */
8191 if (die->die_child != NULL)
8192 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
8193 (unsigned long) die->die_offset);
8196 /* Output the compilation unit that appears at the beginning of the
8197 .debug_info section, and precedes the DIE descriptions. */
8200 output_compilation_unit_header (void)
8202 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8203 dw2_asm_output_data (4, 0xffffffff,
8204 "Initial length escape value indicating 64-bit DWARF extension");
8205 dw2_asm_output_data (DWARF_OFFSET_SIZE,
8206 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
8207 "Length of Compilation Unit Info");
8208 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
8209 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
8210 debug_abbrev_section,
8211 "Offset Into Abbrev. Section");
8212 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
8215 /* Output the compilation unit DIE and its children. */
8218 output_comp_unit (dw_die_ref die, int output_if_empty)
8220 const char *secname;
8223 /* Unless we are outputting main CU, we may throw away empty ones. */
8224 if (!output_if_empty && die->die_child == NULL)
8227 /* Even if there are no children of this DIE, we must output the information
8228 about the compilation unit. Otherwise, on an empty translation unit, we
8229 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8230 will then complain when examining the file. First mark all the DIEs in
8231 this CU so we know which get local refs. */
8234 build_abbrev_table (die);
8236 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8237 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
8238 calc_die_sizes (die);
8240 oldsym = die->die_symbol;
8243 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
8245 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
8247 die->die_symbol = NULL;
8248 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
8251 switch_to_section (debug_info_section);
8253 /* Output debugging information. */
8254 output_compilation_unit_header ();
8257 /* Leave the marks on the main CU, so we can check them in
8262 die->die_symbol = oldsym;
8266 /* Return the DWARF2/3 pubname associated with a decl. */
8269 dwarf2_name (tree decl, int scope)
8271 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
8274 /* Add a new entry to .debug_pubnames if appropriate. */
8277 add_pubname_string (const char *str, dw_die_ref die)
8282 e.name = xstrdup (str);
8283 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
8287 add_pubname (tree decl, dw_die_ref die)
8290 if (TREE_PUBLIC (decl))
8291 add_pubname_string (dwarf2_name (decl, 1), die);
8294 /* Add a new entry to .debug_pubtypes if appropriate. */
8297 add_pubtype (tree decl, dw_die_ref die)
8302 if ((TREE_PUBLIC (decl)
8303 || die->die_parent == comp_unit_die)
8304 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
8309 if (TYPE_NAME (decl))
8311 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
8312 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
8313 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
8314 && DECL_NAME (TYPE_NAME (decl)))
8315 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
8317 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
8321 e.name = xstrdup (dwarf2_name (decl, 1));
8323 /* If we don't have a name for the type, there's no point in adding
8325 if (e.name && e.name[0] != '\0')
8326 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
8330 /* Output the public names table used to speed up access to externally
8331 visible names; or the public types table used to find type definitions. */
8334 output_pubnames (VEC (pubname_entry, gc) * names)
8337 unsigned long pubnames_length = size_of_pubnames (names);
8340 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8341 dw2_asm_output_data (4, 0xffffffff,
8342 "Initial length escape value indicating 64-bit DWARF extension");
8343 if (names == pubname_table)
8344 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8345 "Length of Public Names Info");
8347 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
8348 "Length of Public Type Names Info");
8349 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8350 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8352 "Offset of Compilation Unit Info");
8353 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
8354 "Compilation Unit Length");
8356 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
8358 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8359 if (names == pubname_table)
8360 gcc_assert (pub->die->die_mark);
8362 if (names != pubtype_table
8363 || pub->die->die_offset != 0
8364 || !flag_eliminate_unused_debug_types)
8366 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
8369 dw2_asm_output_nstring (pub->name, -1, "external name");
8373 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
8376 /* Add a new entry to .debug_aranges if appropriate. */
8379 add_arange (tree decl, dw_die_ref die)
8381 if (! DECL_SECTION_NAME (decl))
8384 if (arange_table_in_use == arange_table_allocated)
8386 arange_table_allocated += ARANGE_TABLE_INCREMENT;
8387 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
8388 arange_table_allocated);
8389 memset (arange_table + arange_table_in_use, 0,
8390 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
8393 arange_table[arange_table_in_use++] = die;
8396 /* Output the information that goes into the .debug_aranges table.
8397 Namely, define the beginning and ending address range of the
8398 text section generated for this compilation unit. */
8401 output_aranges (void)
8404 unsigned long aranges_length = size_of_aranges ();
8406 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8407 dw2_asm_output_data (4, 0xffffffff,
8408 "Initial length escape value indicating 64-bit DWARF extension");
8409 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
8410 "Length of Address Ranges Info");
8411 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8412 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
8414 "Offset of Compilation Unit Info");
8415 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
8416 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8418 /* We need to align to twice the pointer size here. */
8419 if (DWARF_ARANGES_PAD_SIZE)
8421 /* Pad using a 2 byte words so that padding is correct for any
8423 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8424 2 * DWARF2_ADDR_SIZE);
8425 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
8426 dw2_asm_output_data (2, 0, NULL);
8429 /* It is necessary not to output these entries if the sections were
8430 not used; if the sections were not used, the length will be 0 and
8431 the address may end up as 0 if the section is discarded by ld
8432 --gc-sections, leaving an invalid (0, 0) entry that can be
8433 confused with the terminator. */
8434 if (text_section_used)
8436 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
8437 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
8438 text_section_label, "Length");
8440 if (cold_text_section_used)
8442 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
8444 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
8445 cold_text_section_label, "Length");
8448 for (i = 0; i < arange_table_in_use; i++)
8450 dw_die_ref die = arange_table[i];
8452 /* We shouldn't see aranges for DIEs outside of the main CU. */
8453 gcc_assert (die->die_mark);
8455 if (die->die_tag == DW_TAG_subprogram)
8457 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
8459 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
8460 get_AT_low_pc (die), "Length");
8464 /* A static variable; extract the symbol from DW_AT_location.
8465 Note that this code isn't currently hit, as we only emit
8466 aranges for functions (jason 9/23/99). */
8467 dw_attr_ref a = get_AT (die, DW_AT_location);
8468 dw_loc_descr_ref loc;
8470 gcc_assert (a && AT_class (a) == dw_val_class_loc);
8473 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
8475 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
8476 loc->dw_loc_oprnd1.v.val_addr, "Address");
8477 dw2_asm_output_data (DWARF2_ADDR_SIZE,
8478 get_AT_unsigned (die, DW_AT_byte_size),
8483 /* Output the terminator words. */
8484 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8485 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8488 /* Add a new entry to .debug_ranges. Return the offset at which it
8492 add_ranges_num (int num)
8494 unsigned int in_use = ranges_table_in_use;
8496 if (in_use == ranges_table_allocated)
8498 ranges_table_allocated += RANGES_TABLE_INCREMENT;
8499 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
8500 ranges_table_allocated);
8501 memset (ranges_table + ranges_table_in_use, 0,
8502 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
8505 ranges_table[in_use].num = num;
8506 ranges_table_in_use = in_use + 1;
8508 return in_use * 2 * DWARF2_ADDR_SIZE;
8511 /* Add a new entry to .debug_ranges corresponding to a block, or a
8512 range terminator if BLOCK is NULL. */
8515 add_ranges (const_tree block)
8517 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
8520 /* Add a new entry to .debug_ranges corresponding to a pair of
8524 add_ranges_by_labels (const char *begin, const char *end)
8526 unsigned int in_use = ranges_by_label_in_use;
8528 if (in_use == ranges_by_label_allocated)
8530 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
8531 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
8533 ranges_by_label_allocated);
8534 memset (ranges_by_label + ranges_by_label_in_use, 0,
8535 RANGES_TABLE_INCREMENT
8536 * sizeof (struct dw_ranges_by_label_struct));
8539 ranges_by_label[in_use].begin = begin;
8540 ranges_by_label[in_use].end = end;
8541 ranges_by_label_in_use = in_use + 1;
8543 return add_ranges_num (-(int)in_use - 1);
8547 output_ranges (void)
8550 static const char *const start_fmt = "Offset 0x%x";
8551 const char *fmt = start_fmt;
8553 for (i = 0; i < ranges_table_in_use; i++)
8555 int block_num = ranges_table[i].num;
8559 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
8560 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
8562 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
8563 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
8565 /* If all code is in the text section, then the compilation
8566 unit base address defaults to DW_AT_low_pc, which is the
8567 base of the text section. */
8568 if (!have_multiple_function_sections)
8570 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
8572 fmt, i * 2 * DWARF2_ADDR_SIZE);
8573 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
8574 text_section_label, NULL);
8577 /* Otherwise, the compilation unit base address is zero,
8578 which allows us to use absolute addresses, and not worry
8579 about whether the target supports cross-section
8583 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
8584 fmt, i * 2 * DWARF2_ADDR_SIZE);
8585 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
8591 /* Negative block_num stands for an index into ranges_by_label. */
8592 else if (block_num < 0)
8594 int lab_idx = - block_num - 1;
8596 if (!have_multiple_function_sections)
8600 /* If we ever use add_ranges_by_labels () for a single
8601 function section, all we have to do is to take out
8603 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8604 ranges_by_label[lab_idx].begin,
8606 fmt, i * 2 * DWARF2_ADDR_SIZE);
8607 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
8608 ranges_by_label[lab_idx].end,
8609 text_section_label, NULL);
8614 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8615 ranges_by_label[lab_idx].begin,
8616 fmt, i * 2 * DWARF2_ADDR_SIZE);
8617 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
8618 ranges_by_label[lab_idx].end,
8624 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8625 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
8631 /* Data structure containing information about input files. */
8634 const char *path; /* Complete file name. */
8635 const char *fname; /* File name part. */
8636 int length; /* Length of entire string. */
8637 struct dwarf_file_data * file_idx; /* Index in input file table. */
8638 int dir_idx; /* Index in directory table. */
8641 /* Data structure containing information about directories with source
8645 const char *path; /* Path including directory name. */
8646 int length; /* Path length. */
8647 int prefix; /* Index of directory entry which is a prefix. */
8648 int count; /* Number of files in this directory. */
8649 int dir_idx; /* Index of directory used as base. */
8652 /* Callback function for file_info comparison. We sort by looking at
8653 the directories in the path. */
8656 file_info_cmp (const void *p1, const void *p2)
8658 const struct file_info *const s1 = (const struct file_info *) p1;
8659 const struct file_info *const s2 = (const struct file_info *) p2;
8660 const unsigned char *cp1;
8661 const unsigned char *cp2;
8663 /* Take care of file names without directories. We need to make sure that
8664 we return consistent values to qsort since some will get confused if
8665 we return the same value when identical operands are passed in opposite
8666 orders. So if neither has a directory, return 0 and otherwise return
8667 1 or -1 depending on which one has the directory. */
8668 if ((s1->path == s1->fname || s2->path == s2->fname))
8669 return (s2->path == s2->fname) - (s1->path == s1->fname);
8671 cp1 = (const unsigned char *) s1->path;
8672 cp2 = (const unsigned char *) s2->path;
8678 /* Reached the end of the first path? If so, handle like above. */
8679 if ((cp1 == (const unsigned char *) s1->fname)
8680 || (cp2 == (const unsigned char *) s2->fname))
8681 return ((cp2 == (const unsigned char *) s2->fname)
8682 - (cp1 == (const unsigned char *) s1->fname));
8684 /* Character of current path component the same? */
8685 else if (*cp1 != *cp2)
8690 struct file_name_acquire_data
8692 struct file_info *files;
8697 /* Traversal function for the hash table. */
8700 file_name_acquire (void ** slot, void *data)
8702 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
8703 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
8704 struct file_info *fi;
8707 gcc_assert (fnad->max_files >= d->emitted_number);
8709 if (! d->emitted_number)
8712 gcc_assert (fnad->max_files != fnad->used_files);
8714 fi = fnad->files + fnad->used_files++;
8716 /* Skip all leading "./". */
8718 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
8721 /* Create a new array entry. */
8723 fi->length = strlen (f);
8726 /* Search for the file name part. */
8727 f = strrchr (f, DIR_SEPARATOR);
8728 #if defined (DIR_SEPARATOR_2)
8730 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
8734 if (f == NULL || f < g)
8740 fi->fname = f == NULL ? fi->path : f + 1;
8744 /* Output the directory table and the file name table. We try to minimize
8745 the total amount of memory needed. A heuristic is used to avoid large
8746 slowdowns with many input files. */
8749 output_file_names (void)
8751 struct file_name_acquire_data fnad;
8753 struct file_info *files;
8754 struct dir_info *dirs;
8763 if (!last_emitted_file)
8765 dw2_asm_output_data (1, 0, "End directory table");
8766 dw2_asm_output_data (1, 0, "End file name table");
8770 numfiles = last_emitted_file->emitted_number;
8772 /* Allocate the various arrays we need. */
8773 files = XALLOCAVEC (struct file_info, numfiles);
8774 dirs = XALLOCAVEC (struct dir_info, numfiles);
8777 fnad.used_files = 0;
8778 fnad.max_files = numfiles;
8779 htab_traverse (file_table, file_name_acquire, &fnad);
8780 gcc_assert (fnad.used_files == fnad.max_files);
8782 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
8784 /* Find all the different directories used. */
8785 dirs[0].path = files[0].path;
8786 dirs[0].length = files[0].fname - files[0].path;
8787 dirs[0].prefix = -1;
8789 dirs[0].dir_idx = 0;
8790 files[0].dir_idx = 0;
8793 for (i = 1; i < numfiles; i++)
8794 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
8795 && memcmp (dirs[ndirs - 1].path, files[i].path,
8796 dirs[ndirs - 1].length) == 0)
8798 /* Same directory as last entry. */
8799 files[i].dir_idx = ndirs - 1;
8800 ++dirs[ndirs - 1].count;
8806 /* This is a new directory. */
8807 dirs[ndirs].path = files[i].path;
8808 dirs[ndirs].length = files[i].fname - files[i].path;
8809 dirs[ndirs].count = 1;
8810 dirs[ndirs].dir_idx = ndirs;
8811 files[i].dir_idx = ndirs;
8813 /* Search for a prefix. */
8814 dirs[ndirs].prefix = -1;
8815 for (j = 0; j < ndirs; j++)
8816 if (dirs[j].length < dirs[ndirs].length
8817 && dirs[j].length > 1
8818 && (dirs[ndirs].prefix == -1
8819 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
8820 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
8821 dirs[ndirs].prefix = j;
8826 /* Now to the actual work. We have to find a subset of the directories which
8827 allow expressing the file name using references to the directory table
8828 with the least amount of characters. We do not do an exhaustive search
8829 where we would have to check out every combination of every single
8830 possible prefix. Instead we use a heuristic which provides nearly optimal
8831 results in most cases and never is much off. */
8832 saved = XALLOCAVEC (int, ndirs);
8833 savehere = XALLOCAVEC (int, ndirs);
8835 memset (saved, '\0', ndirs * sizeof (saved[0]));
8836 for (i = 0; i < ndirs; i++)
8841 /* We can always save some space for the current directory. But this
8842 does not mean it will be enough to justify adding the directory. */
8843 savehere[i] = dirs[i].length;
8844 total = (savehere[i] - saved[i]) * dirs[i].count;
8846 for (j = i + 1; j < ndirs; j++)
8849 if (saved[j] < dirs[i].length)
8851 /* Determine whether the dirs[i] path is a prefix of the
8856 while (k != -1 && k != (int) i)
8861 /* Yes it is. We can possibly save some memory by
8862 writing the filenames in dirs[j] relative to
8864 savehere[j] = dirs[i].length;
8865 total += (savehere[j] - saved[j]) * dirs[j].count;
8870 /* Check whether we can save enough to justify adding the dirs[i]
8872 if (total > dirs[i].length + 1)
8874 /* It's worthwhile adding. */
8875 for (j = i; j < ndirs; j++)
8876 if (savehere[j] > 0)
8878 /* Remember how much we saved for this directory so far. */
8879 saved[j] = savehere[j];
8881 /* Remember the prefix directory. */
8882 dirs[j].dir_idx = i;
8887 /* Emit the directory name table. */
8889 idx_offset = dirs[0].length > 0 ? 1 : 0;
8890 for (i = 1 - idx_offset; i < ndirs; i++)
8891 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
8892 "Directory Entry: 0x%x", i + idx_offset);
8894 dw2_asm_output_data (1, 0, "End directory table");
8896 /* We have to emit them in the order of emitted_number since that's
8897 used in the debug info generation. To do this efficiently we
8898 generate a back-mapping of the indices first. */
8899 backmap = XALLOCAVEC (int, numfiles);
8900 for (i = 0; i < numfiles; i++)
8901 backmap[files[i].file_idx->emitted_number - 1] = i;
8903 /* Now write all the file names. */
8904 for (i = 0; i < numfiles; i++)
8906 int file_idx = backmap[i];
8907 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
8909 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
8910 "File Entry: 0x%x", (unsigned) i + 1);
8912 /* Include directory index. */
8913 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
8915 /* Modification time. */
8916 dw2_asm_output_data_uleb128 (0, NULL);
8918 /* File length in bytes. */
8919 dw2_asm_output_data_uleb128 (0, NULL);
8922 dw2_asm_output_data (1, 0, "End file name table");
8926 /* Output the source line number correspondence information. This
8927 information goes into the .debug_line section. */
8930 output_line_info (void)
8932 char l1[20], l2[20], p1[20], p2[20];
8933 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8934 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
8937 unsigned long lt_index;
8938 unsigned long current_line;
8941 unsigned long current_file;
8942 unsigned long function;
8944 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
8945 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
8946 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
8947 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
8949 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
8950 dw2_asm_output_data (4, 0xffffffff,
8951 "Initial length escape value indicating 64-bit DWARF extension");
8952 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
8953 "Length of Source Line Info");
8954 ASM_OUTPUT_LABEL (asm_out_file, l1);
8956 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
8957 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
8958 ASM_OUTPUT_LABEL (asm_out_file, p1);
8960 /* Define the architecture-dependent minimum instruction length (in
8961 bytes). In this implementation of DWARF, this field is used for
8962 information purposes only. Since GCC generates assembly language,
8963 we have no a priori knowledge of how many instruction bytes are
8964 generated for each source line, and therefore can use only the
8965 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
8966 commands. Accordingly, we fix this as `1', which is "correct
8967 enough" for all architectures, and don't let the target override. */
8968 dw2_asm_output_data (1, 1,
8969 "Minimum Instruction Length");
8971 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
8972 "Default is_stmt_start flag");
8973 dw2_asm_output_data (1, DWARF_LINE_BASE,
8974 "Line Base Value (Special Opcodes)");
8975 dw2_asm_output_data (1, DWARF_LINE_RANGE,
8976 "Line Range Value (Special Opcodes)");
8977 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
8978 "Special Opcode Base");
8980 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
8984 case DW_LNS_advance_pc:
8985 case DW_LNS_advance_line:
8986 case DW_LNS_set_file:
8987 case DW_LNS_set_column:
8988 case DW_LNS_fixed_advance_pc:
8996 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
9000 /* Write out the information about the files we use. */
9001 output_file_names ();
9002 ASM_OUTPUT_LABEL (asm_out_file, p2);
9004 /* We used to set the address register to the first location in the text
9005 section here, but that didn't accomplish anything since we already
9006 have a line note for the opening brace of the first function. */
9008 /* Generate the line number to PC correspondence table, encoded as
9009 a series of state machine operations. */
9013 if (cfun && in_cold_section_p)
9014 strcpy (prev_line_label, crtl->subsections.cold_section_label);
9016 strcpy (prev_line_label, text_section_label);
9017 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
9019 dw_line_info_ref line_info = &line_info_table[lt_index];
9022 /* Disable this optimization for now; GDB wants to see two line notes
9023 at the beginning of a function so it can find the end of the
9026 /* Don't emit anything for redundant notes. Just updating the
9027 address doesn't accomplish anything, because we already assume
9028 that anything after the last address is this line. */
9029 if (line_info->dw_line_num == current_line
9030 && line_info->dw_file_num == current_file)
9034 /* Emit debug info for the address of the current line.
9036 Unfortunately, we have little choice here currently, and must always
9037 use the most general form. GCC does not know the address delta
9038 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9039 attributes which will give an upper bound on the address range. We
9040 could perhaps use length attributes to determine when it is safe to
9041 use DW_LNS_fixed_advance_pc. */
9043 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
9046 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
9047 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9048 "DW_LNS_fixed_advance_pc");
9049 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9053 /* This can handle any delta. This takes
9054 4+DWARF2_ADDR_SIZE bytes. */
9055 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9056 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9057 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9058 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9061 strcpy (prev_line_label, line_label);
9063 /* Emit debug info for the source file of the current line, if
9064 different from the previous line. */
9065 if (line_info->dw_file_num != current_file)
9067 current_file = line_info->dw_file_num;
9068 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9069 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9072 /* Emit debug info for the current line number, choosing the encoding
9073 that uses the least amount of space. */
9074 if (line_info->dw_line_num != current_line)
9076 line_offset = line_info->dw_line_num - current_line;
9077 line_delta = line_offset - DWARF_LINE_BASE;
9078 current_line = line_info->dw_line_num;
9079 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9080 /* This can handle deltas from -10 to 234, using the current
9081 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
9083 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9084 "line %lu", current_line);
9087 /* This can handle any delta. This takes at least 4 bytes,
9088 depending on the value being encoded. */
9089 dw2_asm_output_data (1, DW_LNS_advance_line,
9090 "advance to line %lu", current_line);
9091 dw2_asm_output_data_sleb128 (line_offset, NULL);
9092 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9096 /* We still need to start a new row, so output a copy insn. */
9097 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9100 /* Emit debug info for the address of the end of the function. */
9103 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9104 "DW_LNS_fixed_advance_pc");
9105 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
9109 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9110 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9111 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9112 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
9115 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9116 dw2_asm_output_data_uleb128 (1, NULL);
9117 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9122 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
9124 dw_separate_line_info_ref line_info
9125 = &separate_line_info_table[lt_index];
9128 /* Don't emit anything for redundant notes. */
9129 if (line_info->dw_line_num == current_line
9130 && line_info->dw_file_num == current_file
9131 && line_info->function == function)
9135 /* Emit debug info for the address of the current line. If this is
9136 a new function, or the first line of a function, then we need
9137 to handle it differently. */
9138 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
9140 if (function != line_info->function)
9142 function = line_info->function;
9144 /* Set the address register to the first line in the function. */
9145 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9146 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9147 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9148 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9152 /* ??? See the DW_LNS_advance_pc comment above. */
9155 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9156 "DW_LNS_fixed_advance_pc");
9157 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9161 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9162 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9163 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9164 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9168 strcpy (prev_line_label, line_label);
9170 /* Emit debug info for the source file of the current line, if
9171 different from the previous line. */
9172 if (line_info->dw_file_num != current_file)
9174 current_file = line_info->dw_file_num;
9175 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
9176 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
9179 /* Emit debug info for the current line number, choosing the encoding
9180 that uses the least amount of space. */
9181 if (line_info->dw_line_num != current_line)
9183 line_offset = line_info->dw_line_num - current_line;
9184 line_delta = line_offset - DWARF_LINE_BASE;
9185 current_line = line_info->dw_line_num;
9186 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
9187 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
9188 "line %lu", current_line);
9191 dw2_asm_output_data (1, DW_LNS_advance_line,
9192 "advance to line %lu", current_line);
9193 dw2_asm_output_data_sleb128 (line_offset, NULL);
9194 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9198 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
9206 /* If we're done with a function, end its sequence. */
9207 if (lt_index == separate_line_info_table_in_use
9208 || separate_line_info_table[lt_index].function != function)
9213 /* Emit debug info for the address of the end of the function. */
9214 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
9217 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
9218 "DW_LNS_fixed_advance_pc");
9219 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
9223 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9224 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
9225 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
9226 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
9229 /* Output the marker for the end of this sequence. */
9230 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9231 dw2_asm_output_data_uleb128 (1, NULL);
9232 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
9236 /* Output the marker for the end of the line number info. */
9237 ASM_OUTPUT_LABEL (asm_out_file, l2);
9240 /* Given a pointer to a tree node for some base type, return a pointer to
9241 a DIE that describes the given type.
9243 This routine must only be called for GCC type nodes that correspond to
9244 Dwarf base (fundamental) types. */
9247 base_type_die (tree type)
9249 dw_die_ref base_type_result;
9250 enum dwarf_type encoding;
9252 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
9255 switch (TREE_CODE (type))
9258 if (TYPE_STRING_FLAG (type))
9260 if (TYPE_UNSIGNED (type))
9261 encoding = DW_ATE_unsigned_char;
9263 encoding = DW_ATE_signed_char;
9265 else if (TYPE_UNSIGNED (type))
9266 encoding = DW_ATE_unsigned;
9268 encoding = DW_ATE_signed;
9272 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
9273 encoding = DW_ATE_decimal_float;
9275 encoding = DW_ATE_float;
9278 case FIXED_POINT_TYPE:
9279 if (TYPE_UNSIGNED (type))
9280 encoding = DW_ATE_unsigned_fixed;
9282 encoding = DW_ATE_signed_fixed;
9285 /* Dwarf2 doesn't know anything about complex ints, so use
9286 a user defined type for it. */
9288 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
9289 encoding = DW_ATE_complex_float;
9291 encoding = DW_ATE_lo_user;
9295 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9296 encoding = DW_ATE_boolean;
9300 /* No other TREE_CODEs are Dwarf fundamental types. */
9304 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
9306 /* This probably indicates a bug. */
9307 if (! TYPE_NAME (type))
9308 add_name_attribute (base_type_result, "__unknown__");
9310 add_AT_unsigned (base_type_result, DW_AT_byte_size,
9311 int_size_in_bytes (type));
9312 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
9314 return base_type_result;
9317 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9318 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9321 is_base_type (tree type)
9323 switch (TREE_CODE (type))
9329 case FIXED_POINT_TYPE:
9337 case QUAL_UNION_TYPE:
9342 case REFERENCE_TYPE:
9355 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9356 node, return the size in bits for the type if it is a constant, or else
9357 return the alignment for the type if the type's size is not constant, or
9358 else return BITS_PER_WORD if the type actually turns out to be an
9361 static inline unsigned HOST_WIDE_INT
9362 simple_type_size_in_bits (const_tree type)
9364 if (TREE_CODE (type) == ERROR_MARK)
9365 return BITS_PER_WORD;
9366 else if (TYPE_SIZE (type) == NULL_TREE)
9368 else if (host_integerp (TYPE_SIZE (type), 1))
9369 return tree_low_cst (TYPE_SIZE (type), 1);
9371 return TYPE_ALIGN (type);
9374 /* Return true if the debug information for the given type should be
9375 emitted as a subrange type. */
9378 is_subrange_type (const_tree type)
9380 tree subtype = TREE_TYPE (type);
9382 /* Subrange types are identified by the fact that they are integer
9383 types, and that they have a subtype which is either an integer type
9384 or an enumeral type. */
9386 if (TREE_CODE (type) != INTEGER_TYPE
9387 || subtype == NULL_TREE)
9390 if (TREE_CODE (subtype) != INTEGER_TYPE
9391 && TREE_CODE (subtype) != ENUMERAL_TYPE
9392 && TREE_CODE (subtype) != BOOLEAN_TYPE)
9395 if (TREE_CODE (type) == TREE_CODE (subtype)
9396 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
9397 && TYPE_MIN_VALUE (type) != NULL
9398 && TYPE_MIN_VALUE (subtype) != NULL
9399 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
9400 && TYPE_MAX_VALUE (type) != NULL
9401 && TYPE_MAX_VALUE (subtype) != NULL
9402 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
9404 /* The type and its subtype have the same representation. If in
9405 addition the two types also have the same name, then the given
9406 type is not a subrange type, but rather a plain base type. */
9407 /* FIXME: brobecker/2004-03-22:
9408 Sizetype INTEGER_CSTs nodes are canonicalized. It should
9409 therefore be sufficient to check the TYPE_SIZE node pointers
9410 rather than checking the actual size. Unfortunately, we have
9411 found some cases, such as in the Ada "integer" type, where
9412 this is not the case. Until this problem is solved, we need to
9413 keep checking the actual size. */
9414 tree type_name = TYPE_NAME (type);
9415 tree subtype_name = TYPE_NAME (subtype);
9417 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
9418 type_name = DECL_NAME (type_name);
9420 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
9421 subtype_name = DECL_NAME (subtype_name);
9423 if (type_name == subtype_name)
9430 /* Given a pointer to a tree node for a subrange type, return a pointer
9431 to a DIE that describes the given type. */
9434 subrange_type_die (tree type, dw_die_ref context_die)
9436 dw_die_ref subrange_die;
9437 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
9439 if (context_die == NULL)
9440 context_die = comp_unit_die;
9442 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
9444 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
9446 /* The size of the subrange type and its base type do not match,
9447 so we need to generate a size attribute for the subrange type. */
9448 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
9451 if (TYPE_MIN_VALUE (type) != NULL)
9452 add_bound_info (subrange_die, DW_AT_lower_bound,
9453 TYPE_MIN_VALUE (type));
9454 if (TYPE_MAX_VALUE (type) != NULL)
9455 add_bound_info (subrange_die, DW_AT_upper_bound,
9456 TYPE_MAX_VALUE (type));
9458 return subrange_die;
9461 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9462 entry that chains various modifiers in front of the given type. */
9465 modified_type_die (tree type, int is_const_type, int is_volatile_type,
9466 dw_die_ref context_die)
9468 enum tree_code code = TREE_CODE (type);
9469 dw_die_ref mod_type_die;
9470 dw_die_ref sub_die = NULL;
9471 tree item_type = NULL;
9472 tree qualified_type;
9475 if (code == ERROR_MARK)
9478 /* See if we already have the appropriately qualified variant of
9481 = get_qualified_type (type,
9482 ((is_const_type ? TYPE_QUAL_CONST : 0)
9483 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
9485 /* If we do, then we can just use its DIE, if it exists. */
9488 mod_type_die = lookup_type_die (qualified_type);
9490 return mod_type_die;
9493 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
9495 /* Handle C typedef types. */
9496 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
9498 tree dtype = TREE_TYPE (name);
9500 if (qualified_type == dtype)
9502 /* For a named type, use the typedef. */
9503 gen_type_die (qualified_type, context_die);
9504 return lookup_type_die (qualified_type);
9506 else if (is_const_type < TYPE_READONLY (dtype)
9507 || is_volatile_type < TYPE_VOLATILE (dtype)
9508 || (is_const_type <= TYPE_READONLY (dtype)
9509 && is_volatile_type <= TYPE_VOLATILE (dtype)
9510 && DECL_ORIGINAL_TYPE (name) != type))
9511 /* cv-unqualified version of named type. Just use the unnamed
9512 type to which it refers. */
9513 return modified_type_die (DECL_ORIGINAL_TYPE (name),
9514 is_const_type, is_volatile_type,
9516 /* Else cv-qualified version of named type; fall through. */
9521 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
9522 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
9524 else if (is_volatile_type)
9526 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
9527 sub_die = modified_type_die (type, 0, 0, context_die);
9529 else if (code == POINTER_TYPE)
9531 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
9532 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9533 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9534 item_type = TREE_TYPE (type);
9536 else if (code == REFERENCE_TYPE)
9538 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
9539 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
9540 simple_type_size_in_bits (type) / BITS_PER_UNIT);
9541 item_type = TREE_TYPE (type);
9543 else if (is_subrange_type (type))
9545 mod_type_die = subrange_type_die (type, context_die);
9546 item_type = TREE_TYPE (type);
9548 else if (is_base_type (type))
9549 mod_type_die = base_type_die (type);
9552 gen_type_die (type, context_die);
9554 /* We have to get the type_main_variant here (and pass that to the
9555 `lookup_type_die' routine) because the ..._TYPE node we have
9556 might simply be a *copy* of some original type node (where the
9557 copy was created to help us keep track of typedef names) and
9558 that copy might have a different TYPE_UID from the original
9560 if (TREE_CODE (type) != VECTOR_TYPE)
9561 return lookup_type_die (type_main_variant (type));
9563 /* Vectors have the debugging information in the type,
9564 not the main variant. */
9565 return lookup_type_die (type);
9568 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9569 don't output a DW_TAG_typedef, since there isn't one in the
9570 user's program; just attach a DW_AT_name to the type. */
9572 && (TREE_CODE (name) != TYPE_DECL
9573 || (TREE_TYPE (name) == qualified_type && DECL_NAME (name))))
9575 if (TREE_CODE (name) == TYPE_DECL)
9576 /* Could just call add_name_and_src_coords_attributes here,
9577 but since this is a builtin type it doesn't have any
9578 useful source coordinates anyway. */
9579 name = DECL_NAME (name);
9580 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
9584 equate_type_number_to_die (qualified_type, mod_type_die);
9587 /* We must do this after the equate_type_number_to_die call, in case
9588 this is a recursive type. This ensures that the modified_type_die
9589 recursion will terminate even if the type is recursive. Recursive
9590 types are possible in Ada. */
9591 sub_die = modified_type_die (item_type,
9592 TYPE_READONLY (item_type),
9593 TYPE_VOLATILE (item_type),
9596 if (sub_die != NULL)
9597 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
9599 return mod_type_die;
9602 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
9603 an enumerated type. */
9606 type_is_enum (const_tree type)
9608 return TREE_CODE (type) == ENUMERAL_TYPE;
9611 /* Return the DBX register number described by a given RTL node. */
9614 dbx_reg_number (const_rtx rtl)
9616 unsigned regno = REGNO (rtl);
9618 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
9620 #ifdef LEAF_REG_REMAP
9621 if (current_function_uses_only_leaf_regs)
9623 int leaf_reg = LEAF_REG_REMAP (regno);
9625 regno = (unsigned) leaf_reg;
9629 return DBX_REGISTER_NUMBER (regno);
9632 /* Optionally add a DW_OP_piece term to a location description expression.
9633 DW_OP_piece is only added if the location description expression already
9634 doesn't end with DW_OP_piece. */
9637 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
9639 dw_loc_descr_ref loc;
9641 if (*list_head != NULL)
9643 /* Find the end of the chain. */
9644 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
9647 if (loc->dw_loc_opc != DW_OP_piece)
9648 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
9652 /* Return a location descriptor that designates a machine register or
9653 zero if there is none. */
9655 static dw_loc_descr_ref
9656 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
9660 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
9663 regs = targetm.dwarf_register_span (rtl);
9665 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
9666 return multiple_reg_loc_descriptor (rtl, regs, initialized);
9668 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
9671 /* Return a location descriptor that designates a machine register for
9672 a given hard register number. */
9674 static dw_loc_descr_ref
9675 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
9677 dw_loc_descr_ref reg_loc_descr = new_reg_loc_descr (regno, 0);
9679 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9680 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9682 return reg_loc_descr;
9685 /* Given an RTL of a register, return a location descriptor that
9686 designates a value that spans more than one register. */
9688 static dw_loc_descr_ref
9689 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
9690 enum var_init_status initialized)
9694 dw_loc_descr_ref loc_result = NULL;
9697 #ifdef LEAF_REG_REMAP
9698 if (current_function_uses_only_leaf_regs)
9700 int leaf_reg = LEAF_REG_REMAP (reg);
9702 reg = (unsigned) leaf_reg;
9705 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
9706 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
9708 /* Simple, contiguous registers. */
9709 if (regs == NULL_RTX)
9711 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
9718 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
9719 VAR_INIT_STATUS_INITIALIZED);
9720 add_loc_descr (&loc_result, t);
9721 add_loc_descr_op_piece (&loc_result, size);
9727 /* Now onto stupid register sets in non contiguous locations. */
9729 gcc_assert (GET_CODE (regs) == PARALLEL);
9731 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9734 for (i = 0; i < XVECLEN (regs, 0); ++i)
9738 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
9739 VAR_INIT_STATUS_INITIALIZED);
9740 add_loc_descr (&loc_result, t);
9741 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
9742 add_loc_descr_op_piece (&loc_result, size);
9745 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9746 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9750 #endif /* DWARF2_DEBUGGING_INFO */
9752 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
9754 /* Return a location descriptor that designates a constant. */
9756 static dw_loc_descr_ref
9757 int_loc_descriptor (HOST_WIDE_INT i)
9759 enum dwarf_location_atom op;
9761 /* Pick the smallest representation of a constant, rather than just
9762 defaulting to the LEB encoding. */
9766 op = DW_OP_lit0 + i;
9769 else if (i <= 0xffff)
9771 else if (HOST_BITS_PER_WIDE_INT == 32
9781 else if (i >= -0x8000)
9783 else if (HOST_BITS_PER_WIDE_INT == 32
9784 || i >= -0x80000000)
9790 return new_loc_descr (op, i, 0);
9794 #ifdef DWARF2_DEBUGGING_INFO
9796 /* Return a location descriptor that designates a base+offset location. */
9798 static dw_loc_descr_ref
9799 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
9800 enum var_init_status initialized)
9803 dw_loc_descr_ref result;
9804 dw_fde_ref fde = current_fde ();
9806 /* We only use "frame base" when we're sure we're talking about the
9807 post-prologue local stack frame. We do this by *not* running
9808 register elimination until this point, and recognizing the special
9809 argument pointer and soft frame pointer rtx's. */
9810 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
9812 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
9816 if (GET_CODE (elim) == PLUS)
9818 offset += INTVAL (XEXP (elim, 1));
9819 elim = XEXP (elim, 0);
9821 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
9822 && (elim == hard_frame_pointer_rtx
9823 || elim == stack_pointer_rtx))
9824 || elim == (frame_pointer_needed
9825 ? hard_frame_pointer_rtx
9826 : stack_pointer_rtx));
9828 /* If drap register is used to align stack, use frame
9829 pointer + offset to access stack variables. If stack
9830 is aligned without drap, use stack pointer + offset to
9831 access stack variables. */
9832 if (crtl->stack_realign_tried
9833 && cfa.reg == HARD_FRAME_POINTER_REGNUM
9834 && reg == frame_pointer_rtx)
9837 = DWARF_FRAME_REGNUM (cfa.indirect
9838 ? HARD_FRAME_POINTER_REGNUM
9839 : STACK_POINTER_REGNUM);
9840 return new_reg_loc_descr (base_reg, offset);
9843 offset += frame_pointer_fb_offset;
9844 return new_loc_descr (DW_OP_fbreg, offset, 0);
9848 && fde->drap_reg != INVALID_REGNUM
9849 && (fde->drap_reg == REGNO (reg)
9850 || fde->vdrap_reg == REGNO (reg)))
9852 /* Use cfa+offset to represent the location of arguments passed
9853 on stack when drap is used to align stack. */
9854 return new_loc_descr (DW_OP_fbreg, offset, 0);
9857 regno = dbx_reg_number (reg);
9859 result = new_loc_descr (DW_OP_breg0 + regno, offset, 0);
9861 result = new_loc_descr (DW_OP_bregx, regno, offset);
9863 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
9864 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9869 /* Return true if this RTL expression describes a base+offset calculation. */
9872 is_based_loc (const_rtx rtl)
9874 return (GET_CODE (rtl) == PLUS
9875 && ((REG_P (XEXP (rtl, 0))
9876 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
9877 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
9880 /* Return a descriptor that describes the concatenation of N locations
9881 used to form the address of a memory location. */
9883 static dw_loc_descr_ref
9884 concatn_mem_loc_descriptor (rtx concatn, enum machine_mode mode,
9885 enum var_init_status initialized)
9888 dw_loc_descr_ref cc_loc_result = NULL;
9889 unsigned int n = XVECLEN (concatn, 0);
9891 for (i = 0; i < n; ++i)
9893 dw_loc_descr_ref ref;
9894 rtx x = XVECEXP (concatn, 0, i);
9896 ref = mem_loc_descriptor (x, mode, VAR_INIT_STATUS_INITIALIZED);
9900 add_loc_descr (&cc_loc_result, ref);
9901 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
9904 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
9905 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
9907 return cc_loc_result;
9910 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
9913 static dw_loc_descr_ref
9914 tls_mem_loc_descriptor (rtx mem)
9917 dw_loc_descr_ref loc_result, loc_result2;
9919 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
9922 base = get_base_address (MEM_EXPR (mem));
9924 || TREE_CODE (base) != VAR_DECL
9925 || !DECL_THREAD_LOCAL_P (base))
9928 loc_result = loc_descriptor_from_tree_1 (MEM_EXPR (mem), 2);
9929 if (loc_result == NULL)
9932 if (INTVAL (MEM_OFFSET (mem)))
9934 if (INTVAL (MEM_OFFSET (mem)) >= 0)
9935 add_loc_descr (&loc_result,
9936 new_loc_descr (DW_OP_plus_uconst,
9937 INTVAL (MEM_OFFSET (mem)), 0));
9940 loc_result2 = mem_loc_descriptor (MEM_OFFSET (mem), GET_MODE (mem),
9941 VAR_INIT_STATUS_INITIALIZED);
9942 if (loc_result2 == 0)
9944 add_loc_descr (&loc_result, loc_result2);
9945 add_loc_descr (&loc_result, new_loc_descr (DW_OP_plus, 0, 0));
9952 /* The following routine converts the RTL for a variable or parameter
9953 (resident in memory) into an equivalent Dwarf representation of a
9954 mechanism for getting the address of that same variable onto the top of a
9955 hypothetical "address evaluation" stack.
9957 When creating memory location descriptors, we are effectively transforming
9958 the RTL for a memory-resident object into its Dwarf postfix expression
9959 equivalent. This routine recursively descends an RTL tree, turning
9960 it into Dwarf postfix code as it goes.
9962 MODE is the mode of the memory reference, needed to handle some
9963 autoincrement addressing modes.
9965 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
9966 location list for RTL.
9968 Return 0 if we can't represent the location. */
9970 static dw_loc_descr_ref
9971 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
9972 enum var_init_status initialized)
9974 dw_loc_descr_ref mem_loc_result = NULL;
9975 enum dwarf_location_atom op;
9977 /* Note that for a dynamically sized array, the location we will generate a
9978 description of here will be the lowest numbered location which is
9979 actually within the array. That's *not* necessarily the same as the
9980 zeroth element of the array. */
9982 rtl = targetm.delegitimize_address (rtl);
9984 switch (GET_CODE (rtl))
9989 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
9990 just fall into the SUBREG code. */
9992 /* ... fall through ... */
9995 /* The case of a subreg may arise when we have a local (register)
9996 variable or a formal (register) parameter which doesn't quite fill
9997 up an entire register. For now, just assume that it is
9998 legitimate to make the Dwarf info refer to the whole register which
9999 contains the given subreg. */
10000 rtl = XEXP (rtl, 0);
10002 /* ... fall through ... */
10005 /* Whenever a register number forms a part of the description of the
10006 method for calculating the (dynamic) address of a memory resident
10007 object, DWARF rules require the register number be referred to as
10008 a "base register". This distinction is not based in any way upon
10009 what category of register the hardware believes the given register
10010 belongs to. This is strictly DWARF terminology we're dealing with
10011 here. Note that in cases where the location of a memory-resident
10012 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
10013 OP_CONST (0)) the actual DWARF location descriptor that we generate
10014 may just be OP_BASEREG (basereg). This may look deceptively like
10015 the object in question was allocated to a register (rather than in
10016 memory) so DWARF consumers need to be aware of the subtle
10017 distinction between OP_REG and OP_BASEREG. */
10018 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
10019 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
10020 else if (stack_realign_drap
10022 && crtl->args.internal_arg_pointer == rtl
10023 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
10025 /* If RTL is internal_arg_pointer, which has been optimized
10026 out, use DRAP instead. */
10027 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
10028 VAR_INIT_STATUS_INITIALIZED);
10033 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10034 VAR_INIT_STATUS_INITIALIZED);
10035 if (mem_loc_result == NULL)
10036 mem_loc_result = tls_mem_loc_descriptor (rtl);
10037 if (mem_loc_result != 0)
10038 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
10042 rtl = XEXP (rtl, 1);
10044 /* ... fall through ... */
10047 /* Some ports can transform a symbol ref into a label ref, because
10048 the symbol ref is too far away and has to be dumped into a constant
10052 /* Alternatively, the symbol in the constant pool might be referenced
10053 by a different symbol. */
10054 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
10057 rtx tmp = get_pool_constant_mark (rtl, &marked);
10059 if (GET_CODE (tmp) == SYMBOL_REF)
10062 if (CONSTANT_POOL_ADDRESS_P (tmp))
10063 get_pool_constant_mark (tmp, &marked);
10068 /* If all references to this pool constant were optimized away,
10069 it was not output and thus we can't represent it.
10070 FIXME: might try to use DW_OP_const_value here, though
10071 DW_OP_piece complicates it. */
10076 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
10077 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
10078 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
10079 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
10083 /* Extract the PLUS expression nested inside and fall into
10084 PLUS code below. */
10085 rtl = XEXP (rtl, 1);
10090 /* Turn these into a PLUS expression and fall into the PLUS code
10092 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
10093 GEN_INT (GET_CODE (rtl) == PRE_INC
10094 ? GET_MODE_UNIT_SIZE (mode)
10095 : -GET_MODE_UNIT_SIZE (mode)));
10097 /* ... fall through ... */
10101 if (is_based_loc (rtl))
10102 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
10103 INTVAL (XEXP (rtl, 1)),
10104 VAR_INIT_STATUS_INITIALIZED);
10107 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
10108 VAR_INIT_STATUS_INITIALIZED);
10109 if (mem_loc_result == 0)
10112 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
10113 && INTVAL (XEXP (rtl, 1)) >= 0)
10114 add_loc_descr (&mem_loc_result,
10115 new_loc_descr (DW_OP_plus_uconst,
10116 INTVAL (XEXP (rtl, 1)), 0));
10119 dw_loc_descr_ref mem_loc_result2
10120 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10121 VAR_INIT_STATUS_INITIALIZED);
10122 if (mem_loc_result2 == 0)
10124 add_loc_descr (&mem_loc_result, mem_loc_result2);
10125 add_loc_descr (&mem_loc_result,
10126 new_loc_descr (DW_OP_plus, 0, 0));
10131 /* If a pseudo-reg is optimized away, it is possible for it to
10132 be replaced with a MEM containing a multiply or shift. */
10151 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
10152 VAR_INIT_STATUS_INITIALIZED);
10153 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
10154 VAR_INIT_STATUS_INITIALIZED);
10156 if (op0 == 0 || op1 == 0)
10159 mem_loc_result = op0;
10160 add_loc_descr (&mem_loc_result, op1);
10161 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
10166 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
10170 mem_loc_result = concatn_mem_loc_descriptor (rtl, mode,
10171 VAR_INIT_STATUS_INITIALIZED);
10175 /* If delegitimize_address couldn't do anything with the UNSPEC, we
10176 can't express it in the debug info. This can happen e.g. with some
10181 gcc_unreachable ();
10184 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10185 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10187 return mem_loc_result;
10190 /* Return a descriptor that describes the concatenation of two locations.
10191 This is typically a complex variable. */
10193 static dw_loc_descr_ref
10194 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
10196 dw_loc_descr_ref cc_loc_result = NULL;
10197 dw_loc_descr_ref x0_ref = loc_descriptor (x0, VAR_INIT_STATUS_INITIALIZED);
10198 dw_loc_descr_ref x1_ref = loc_descriptor (x1, VAR_INIT_STATUS_INITIALIZED);
10200 if (x0_ref == 0 || x1_ref == 0)
10203 cc_loc_result = x0_ref;
10204 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
10206 add_loc_descr (&cc_loc_result, x1_ref);
10207 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
10209 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
10210 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10212 return cc_loc_result;
10215 /* Return a descriptor that describes the concatenation of N
10218 static dw_loc_descr_ref
10219 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
10222 dw_loc_descr_ref cc_loc_result = NULL;
10223 unsigned int n = XVECLEN (concatn, 0);
10225 for (i = 0; i < n; ++i)
10227 dw_loc_descr_ref ref;
10228 rtx x = XVECEXP (concatn, 0, i);
10230 ref = loc_descriptor (x, VAR_INIT_STATUS_INITIALIZED);
10234 add_loc_descr (&cc_loc_result, ref);
10235 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
10238 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
10239 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
10241 return cc_loc_result;
10244 /* Output a proper Dwarf location descriptor for a variable or parameter
10245 which is either allocated in a register or in a memory location. For a
10246 register, we just generate an OP_REG and the register number. For a
10247 memory location we provide a Dwarf postfix expression describing how to
10248 generate the (dynamic) address of the object onto the address stack.
10250 If we don't know how to describe it, return 0. */
10252 static dw_loc_descr_ref
10253 loc_descriptor (rtx rtl, enum var_init_status initialized)
10255 dw_loc_descr_ref loc_result = NULL;
10257 switch (GET_CODE (rtl))
10260 /* The case of a subreg may arise when we have a local (register)
10261 variable or a formal (register) parameter which doesn't quite fill
10262 up an entire register. For now, just assume that it is
10263 legitimate to make the Dwarf info refer to the whole register which
10264 contains the given subreg. */
10265 rtl = SUBREG_REG (rtl);
10267 /* ... fall through ... */
10270 loc_result = reg_loc_descriptor (rtl, initialized);
10274 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
10276 if (loc_result == NULL)
10277 loc_result = tls_mem_loc_descriptor (rtl);
10281 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
10286 loc_result = concatn_loc_descriptor (rtl, initialized);
10291 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
10293 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0), initialized);
10297 rtl = XEXP (rtl, 1);
10302 rtvec par_elems = XVEC (rtl, 0);
10303 int num_elem = GET_NUM_ELEM (par_elems);
10304 enum machine_mode mode;
10307 /* Create the first one, so we have something to add to. */
10308 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
10310 if (loc_result == NULL)
10312 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
10313 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10314 for (i = 1; i < num_elem; i++)
10316 dw_loc_descr_ref temp;
10318 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
10322 add_loc_descr (&loc_result, temp);
10323 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
10324 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
10330 gcc_unreachable ();
10336 /* Similar, but generate the descriptor from trees instead of rtl. This comes
10337 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
10338 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
10339 top-level invocation, and we require the address of LOC; is 0 if we require
10340 the value of LOC. */
10342 static dw_loc_descr_ref
10343 loc_descriptor_from_tree_1 (tree loc, int want_address)
10345 dw_loc_descr_ref ret, ret1;
10346 int have_address = 0;
10347 enum dwarf_location_atom op;
10349 /* ??? Most of the time we do not take proper care for sign/zero
10350 extending the values properly. Hopefully this won't be a real
10353 switch (TREE_CODE (loc))
10358 case PLACEHOLDER_EXPR:
10359 /* This case involves extracting fields from an object to determine the
10360 position of other fields. We don't try to encode this here. The
10361 only user of this is Ada, which encodes the needed information using
10362 the names of types. */
10368 case PREINCREMENT_EXPR:
10369 case PREDECREMENT_EXPR:
10370 case POSTINCREMENT_EXPR:
10371 case POSTDECREMENT_EXPR:
10372 /* There are no opcodes for these operations. */
10376 /* If we already want an address, there's nothing we can do. */
10380 /* Otherwise, process the argument and look for the address. */
10381 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
10384 if (DECL_THREAD_LOCAL_P (loc))
10388 unsigned second_op;
10390 if (targetm.have_tls)
10392 /* If this is not defined, we have no way to emit the
10394 if (!targetm.asm_out.output_dwarf_dtprel)
10397 /* The way DW_OP_GNU_push_tls_address is specified, we
10398 can only look up addresses of objects in the current
10400 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
10402 first_op = INTERNAL_DW_OP_tls_addr;
10403 second_op = DW_OP_GNU_push_tls_address;
10407 if (!targetm.emutls.debug_form_tls_address)
10409 loc = emutls_decl (loc);
10410 first_op = DW_OP_addr;
10411 second_op = DW_OP_form_tls_address;
10414 rtl = rtl_for_decl_location (loc);
10415 if (rtl == NULL_RTX)
10420 rtl = XEXP (rtl, 0);
10421 if (! CONSTANT_P (rtl))
10424 ret = new_loc_descr (first_op, 0, 0);
10425 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10426 ret->dw_loc_oprnd1.v.val_addr = rtl;
10428 ret1 = new_loc_descr (second_op, 0, 0);
10429 add_loc_descr (&ret, ret1);
10437 if (DECL_HAS_VALUE_EXPR_P (loc))
10438 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
10443 case FUNCTION_DECL:
10445 rtx rtl = rtl_for_decl_location (loc);
10447 if (rtl == NULL_RTX)
10449 else if (GET_CODE (rtl) == CONST_INT)
10451 HOST_WIDE_INT val = INTVAL (rtl);
10452 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
10453 val &= GET_MODE_MASK (DECL_MODE (loc));
10454 ret = int_loc_descriptor (val);
10456 else if (GET_CODE (rtl) == CONST_STRING)
10458 else if (CONSTANT_P (rtl))
10460 ret = new_loc_descr (DW_OP_addr, 0, 0);
10461 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
10462 ret->dw_loc_oprnd1.v.val_addr = rtl;
10466 enum machine_mode mode;
10468 /* Certain constructs can only be represented at top-level. */
10469 if (want_address == 2)
10470 return loc_descriptor (rtl, VAR_INIT_STATUS_INITIALIZED);
10472 mode = GET_MODE (rtl);
10475 rtl = XEXP (rtl, 0);
10478 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10484 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10488 case COMPOUND_EXPR:
10489 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
10492 case VIEW_CONVERT_EXPR:
10495 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
10497 case COMPONENT_REF:
10498 case BIT_FIELD_REF:
10500 case ARRAY_RANGE_REF:
10503 HOST_WIDE_INT bitsize, bitpos, bytepos;
10504 enum machine_mode mode;
10506 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
10508 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
10509 &unsignedp, &volatilep, false);
10514 ret = loc_descriptor_from_tree_1 (obj, 1);
10516 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
10519 if (offset != NULL_TREE)
10521 /* Variable offset. */
10522 ret1 = loc_descriptor_from_tree_1 (offset, 0);
10525 add_loc_descr (&ret, ret1);
10526 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10529 bytepos = bitpos / BITS_PER_UNIT;
10531 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
10532 else if (bytepos < 0)
10534 add_loc_descr (&ret, int_loc_descriptor (bytepos));
10535 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
10543 if (host_integerp (loc, 0))
10544 ret = int_loc_descriptor (tree_low_cst (loc, 0));
10551 /* Get an RTL for this, if something has been emitted. */
10552 rtx rtl = lookup_constant_def (loc);
10553 enum machine_mode mode;
10555 if (!rtl || !MEM_P (rtl))
10557 mode = GET_MODE (rtl);
10558 rtl = XEXP (rtl, 0);
10559 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
10564 case TRUTH_AND_EXPR:
10565 case TRUTH_ANDIF_EXPR:
10570 case TRUTH_XOR_EXPR:
10575 case TRUTH_OR_EXPR:
10576 case TRUTH_ORIF_EXPR:
10581 case FLOOR_DIV_EXPR:
10582 case CEIL_DIV_EXPR:
10583 case ROUND_DIV_EXPR:
10584 case TRUNC_DIV_EXPR:
10592 case FLOOR_MOD_EXPR:
10593 case CEIL_MOD_EXPR:
10594 case ROUND_MOD_EXPR:
10595 case TRUNC_MOD_EXPR:
10608 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
10611 case POINTER_PLUS_EXPR:
10613 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
10614 && host_integerp (TREE_OPERAND (loc, 1), 0))
10616 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10620 add_loc_descr (&ret,
10621 new_loc_descr (DW_OP_plus_uconst,
10622 tree_low_cst (TREE_OPERAND (loc, 1),
10632 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10639 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10646 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10653 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
10668 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10669 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10670 if (ret == 0 || ret1 == 0)
10673 add_loc_descr (&ret, ret1);
10674 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10677 case TRUTH_NOT_EXPR:
10691 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10695 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
10701 const enum tree_code code =
10702 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
10704 loc = build3 (COND_EXPR, TREE_TYPE (loc),
10705 build2 (code, integer_type_node,
10706 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
10707 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
10710 /* ... fall through ... */
10714 dw_loc_descr_ref lhs
10715 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
10716 dw_loc_descr_ref rhs
10717 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
10718 dw_loc_descr_ref bra_node, jump_node, tmp;
10720 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
10721 if (ret == 0 || lhs == 0 || rhs == 0)
10724 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
10725 add_loc_descr (&ret, bra_node);
10727 add_loc_descr (&ret, rhs);
10728 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
10729 add_loc_descr (&ret, jump_node);
10731 add_loc_descr (&ret, lhs);
10732 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10733 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
10735 /* ??? Need a node to point the skip at. Use a nop. */
10736 tmp = new_loc_descr (DW_OP_nop, 0, 0);
10737 add_loc_descr (&ret, tmp);
10738 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
10739 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
10743 case FIX_TRUNC_EXPR:
10747 /* Leave front-end specific codes as simply unknown. This comes
10748 up, for instance, with the C STMT_EXPR. */
10749 if ((unsigned int) TREE_CODE (loc)
10750 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
10753 #ifdef ENABLE_CHECKING
10754 /* Otherwise this is a generic code; we should just lists all of
10755 these explicitly. We forgot one. */
10756 gcc_unreachable ();
10758 /* In a release build, we want to degrade gracefully: better to
10759 generate incomplete debugging information than to crash. */
10764 /* Show if we can't fill the request for an address. */
10765 if (want_address && !have_address)
10768 /* If we've got an address and don't want one, dereference. */
10769 if (!want_address && have_address && ret)
10771 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
10773 if (size > DWARF2_ADDR_SIZE || size == -1)
10775 else if (size == DWARF2_ADDR_SIZE)
10778 op = DW_OP_deref_size;
10780 add_loc_descr (&ret, new_loc_descr (op, size, 0));
10786 static inline dw_loc_descr_ref
10787 loc_descriptor_from_tree (tree loc)
10789 return loc_descriptor_from_tree_1 (loc, 2);
10792 /* Given a value, round it up to the lowest multiple of `boundary'
10793 which is not less than the value itself. */
10795 static inline HOST_WIDE_INT
10796 ceiling (HOST_WIDE_INT value, unsigned int boundary)
10798 return (((value + boundary - 1) / boundary) * boundary);
10801 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
10802 pointer to the declared type for the relevant field variable, or return
10803 `integer_type_node' if the given node turns out to be an
10804 ERROR_MARK node. */
10807 field_type (const_tree decl)
10811 if (TREE_CODE (decl) == ERROR_MARK)
10812 return integer_type_node;
10814 type = DECL_BIT_FIELD_TYPE (decl);
10815 if (type == NULL_TREE)
10816 type = TREE_TYPE (decl);
10821 /* Given a pointer to a tree node, return the alignment in bits for
10822 it, or else return BITS_PER_WORD if the node actually turns out to
10823 be an ERROR_MARK node. */
10825 static inline unsigned
10826 simple_type_align_in_bits (const_tree type)
10828 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
10831 static inline unsigned
10832 simple_decl_align_in_bits (const_tree decl)
10834 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
10837 /* Return the result of rounding T up to ALIGN. */
10839 static inline HOST_WIDE_INT
10840 round_up_to_align (HOST_WIDE_INT t, unsigned int align)
10842 /* We must be careful if T is negative because HOST_WIDE_INT can be
10843 either "above" or "below" unsigned int as per the C promotion
10844 rules, depending on the host, thus making the signedness of the
10845 direct multiplication and division unpredictable. */
10846 unsigned HOST_WIDE_INT u = (unsigned HOST_WIDE_INT) t;
10852 return (HOST_WIDE_INT) u;
10855 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
10856 lowest addressed byte of the "containing object" for the given FIELD_DECL,
10857 or return 0 if we are unable to determine what that offset is, either
10858 because the argument turns out to be a pointer to an ERROR_MARK node, or
10859 because the offset is actually variable. (We can't handle the latter case
10862 static HOST_WIDE_INT
10863 field_byte_offset (const_tree decl)
10865 HOST_WIDE_INT object_offset_in_bits;
10866 HOST_WIDE_INT bitpos_int;
10868 if (TREE_CODE (decl) == ERROR_MARK)
10871 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
10873 /* We cannot yet cope with fields whose positions are variable, so
10874 for now, when we see such things, we simply return 0. Someday, we may
10875 be able to handle such cases, but it will be damn difficult. */
10876 if (! host_integerp (bit_position (decl), 0))
10879 bitpos_int = int_bit_position (decl);
10881 #ifdef PCC_BITFIELD_TYPE_MATTERS
10882 if (PCC_BITFIELD_TYPE_MATTERS)
10885 tree field_size_tree;
10886 HOST_WIDE_INT deepest_bitpos;
10887 unsigned HOST_WIDE_INT field_size_in_bits;
10888 unsigned int type_align_in_bits;
10889 unsigned int decl_align_in_bits;
10890 unsigned HOST_WIDE_INT type_size_in_bits;
10892 type = field_type (decl);
10893 field_size_tree = DECL_SIZE (decl);
10895 /* The size could be unspecified if there was an error, or for
10896 a flexible array member. */
10897 if (! field_size_tree)
10898 field_size_tree = bitsize_zero_node;
10900 /* If we don't know the size of the field, pretend it's a full word. */
10901 if (host_integerp (field_size_tree, 1))
10902 field_size_in_bits = tree_low_cst (field_size_tree, 1);
10904 field_size_in_bits = BITS_PER_WORD;
10906 type_size_in_bits = simple_type_size_in_bits (type);
10907 type_align_in_bits = simple_type_align_in_bits (type);
10908 decl_align_in_bits = simple_decl_align_in_bits (decl);
10910 /* The GCC front-end doesn't make any attempt to keep track of the
10911 starting bit offset (relative to the start of the containing
10912 structure type) of the hypothetical "containing object" for a
10913 bit-field. Thus, when computing the byte offset value for the
10914 start of the "containing object" of a bit-field, we must deduce
10915 this information on our own. This can be rather tricky to do in
10916 some cases. For example, handling the following structure type
10917 definition when compiling for an i386/i486 target (which only
10918 aligns long long's to 32-bit boundaries) can be very tricky:
10920 struct S { int field1; long long field2:31; };
10922 Fortunately, there is a simple rule-of-thumb which can be used
10923 in such cases. When compiling for an i386/i486, GCC will
10924 allocate 8 bytes for the structure shown above. It decides to
10925 do this based upon one simple rule for bit-field allocation.
10926 GCC allocates each "containing object" for each bit-field at
10927 the first (i.e. lowest addressed) legitimate alignment boundary
10928 (based upon the required minimum alignment for the declared
10929 type of the field) which it can possibly use, subject to the
10930 condition that there is still enough available space remaining
10931 in the containing object (when allocated at the selected point)
10932 to fully accommodate all of the bits of the bit-field itself.
10934 This simple rule makes it obvious why GCC allocates 8 bytes for
10935 each object of the structure type shown above. When looking
10936 for a place to allocate the "containing object" for `field2',
10937 the compiler simply tries to allocate a 64-bit "containing
10938 object" at each successive 32-bit boundary (starting at zero)
10939 until it finds a place to allocate that 64- bit field such that
10940 at least 31 contiguous (and previously unallocated) bits remain
10941 within that selected 64 bit field. (As it turns out, for the
10942 example above, the compiler finds it is OK to allocate the
10943 "containing object" 64-bit field at bit-offset zero within the
10946 Here we attempt to work backwards from the limited set of facts
10947 we're given, and we try to deduce from those facts, where GCC
10948 must have believed that the containing object started (within
10949 the structure type). The value we deduce is then used (by the
10950 callers of this routine) to generate DW_AT_location and
10951 DW_AT_bit_offset attributes for fields (both bit-fields and, in
10952 the case of DW_AT_location, regular fields as well). */
10954 /* Figure out the bit-distance from the start of the structure to
10955 the "deepest" bit of the bit-field. */
10956 deepest_bitpos = bitpos_int + field_size_in_bits;
10958 /* This is the tricky part. Use some fancy footwork to deduce
10959 where the lowest addressed bit of the containing object must
10961 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10963 /* Round up to type_align by default. This works best for
10965 object_offset_in_bits
10966 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
10968 if (object_offset_in_bits > bitpos_int)
10970 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
10972 /* Round up to decl_align instead. */
10973 object_offset_in_bits
10974 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
10979 object_offset_in_bits = bitpos_int;
10981 return object_offset_in_bits / BITS_PER_UNIT;
10984 /* The following routines define various Dwarf attributes and any data
10985 associated with them. */
10987 /* Add a location description attribute value to a DIE.
10989 This emits location attributes suitable for whole variables and
10990 whole parameters. Note that the location attributes for struct fields are
10991 generated by the routine `data_member_location_attribute' below. */
10994 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
10995 dw_loc_descr_ref descr)
10998 add_AT_loc (die, attr_kind, descr);
11001 /* Attach the specialized form of location attribute used for data members of
11002 struct and union types. In the special case of a FIELD_DECL node which
11003 represents a bit-field, the "offset" part of this special location
11004 descriptor must indicate the distance in bytes from the lowest-addressed
11005 byte of the containing struct or union type to the lowest-addressed byte of
11006 the "containing object" for the bit-field. (See the `field_byte_offset'
11009 For any given bit-field, the "containing object" is a hypothetical object
11010 (of some integral or enum type) within which the given bit-field lives. The
11011 type of this hypothetical "containing object" is always the same as the
11012 declared type of the individual bit-field itself (for GCC anyway... the
11013 DWARF spec doesn't actually mandate this). Note that it is the size (in
11014 bytes) of the hypothetical "containing object" which will be given in the
11015 DW_AT_byte_size attribute for this bit-field. (See the
11016 `byte_size_attribute' function below.) It is also used when calculating the
11017 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
11018 function below.) */
11021 add_data_member_location_attribute (dw_die_ref die, tree decl)
11023 HOST_WIDE_INT offset;
11024 dw_loc_descr_ref loc_descr = 0;
11026 if (TREE_CODE (decl) == TREE_BINFO)
11028 /* We're working on the TAG_inheritance for a base class. */
11029 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
11031 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
11032 aren't at a fixed offset from all (sub)objects of the same
11033 type. We need to extract the appropriate offset from our
11034 vtable. The following dwarf expression means
11036 BaseAddr = ObAddr + *((*ObAddr) - Offset)
11038 This is specific to the V3 ABI, of course. */
11040 dw_loc_descr_ref tmp;
11042 /* Make a copy of the object address. */
11043 tmp = new_loc_descr (DW_OP_dup, 0, 0);
11044 add_loc_descr (&loc_descr, tmp);
11046 /* Extract the vtable address. */
11047 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11048 add_loc_descr (&loc_descr, tmp);
11050 /* Calculate the address of the offset. */
11051 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
11052 gcc_assert (offset < 0);
11054 tmp = int_loc_descriptor (-offset);
11055 add_loc_descr (&loc_descr, tmp);
11056 tmp = new_loc_descr (DW_OP_minus, 0, 0);
11057 add_loc_descr (&loc_descr, tmp);
11059 /* Extract the offset. */
11060 tmp = new_loc_descr (DW_OP_deref, 0, 0);
11061 add_loc_descr (&loc_descr, tmp);
11063 /* Add it to the object address. */
11064 tmp = new_loc_descr (DW_OP_plus, 0, 0);
11065 add_loc_descr (&loc_descr, tmp);
11068 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
11071 offset = field_byte_offset (decl);
11075 enum dwarf_location_atom op;
11077 /* The DWARF2 standard says that we should assume that the structure
11078 address is already on the stack, so we can specify a structure field
11079 address by using DW_OP_plus_uconst. */
11081 #ifdef MIPS_DEBUGGING_INFO
11082 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
11083 operator correctly. It works only if we leave the offset on the
11087 op = DW_OP_plus_uconst;
11090 loc_descr = new_loc_descr (op, offset, 0);
11093 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
11096 /* Writes integer values to dw_vec_const array. */
11099 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
11103 *dest++ = val & 0xff;
11109 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
11111 static HOST_WIDE_INT
11112 extract_int (const unsigned char *src, unsigned int size)
11114 HOST_WIDE_INT val = 0;
11120 val |= *--src & 0xff;
11126 /* Writes floating point values to dw_vec_const array. */
11129 insert_float (const_rtx rtl, unsigned char *array)
11131 REAL_VALUE_TYPE rv;
11135 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
11136 real_to_target (val, &rv, GET_MODE (rtl));
11138 /* real_to_target puts 32-bit pieces in each long. Pack them. */
11139 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
11141 insert_int (val[i], 4, array);
11146 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
11147 does not have a "location" either in memory or in a register. These
11148 things can arise in GNU C when a constant is passed as an actual parameter
11149 to an inlined function. They can also arise in C++ where declared
11150 constants do not necessarily get memory "homes". */
11153 add_const_value_attribute (dw_die_ref die, rtx rtl)
11155 switch (GET_CODE (rtl))
11159 HOST_WIDE_INT val = INTVAL (rtl);
11162 add_AT_int (die, DW_AT_const_value, val);
11164 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
11169 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
11170 floating-point constant. A CONST_DOUBLE is used whenever the
11171 constant requires more than one word in order to be adequately
11172 represented. We output CONST_DOUBLEs as blocks. */
11174 enum machine_mode mode = GET_MODE (rtl);
11176 if (SCALAR_FLOAT_MODE_P (mode))
11178 unsigned int length = GET_MODE_SIZE (mode);
11179 unsigned char *array = GGC_NEWVEC (unsigned char, length);
11181 insert_float (rtl, array);
11182 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
11186 /* ??? We really should be using HOST_WIDE_INT throughout. */
11187 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
11189 add_AT_long_long (die, DW_AT_const_value,
11190 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
11197 enum machine_mode mode = GET_MODE (rtl);
11198 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
11199 unsigned int length = CONST_VECTOR_NUNITS (rtl);
11200 unsigned char *array = GGC_NEWVEC (unsigned char, length * elt_size);
11204 switch (GET_MODE_CLASS (mode))
11206 case MODE_VECTOR_INT:
11207 for (i = 0, p = array; i < length; i++, p += elt_size)
11209 rtx elt = CONST_VECTOR_ELT (rtl, i);
11210 HOST_WIDE_INT lo, hi;
11212 switch (GET_CODE (elt))
11220 lo = CONST_DOUBLE_LOW (elt);
11221 hi = CONST_DOUBLE_HIGH (elt);
11225 gcc_unreachable ();
11228 if (elt_size <= sizeof (HOST_WIDE_INT))
11229 insert_int (lo, elt_size, p);
11232 unsigned char *p0 = p;
11233 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
11235 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
11236 if (WORDS_BIG_ENDIAN)
11241 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
11242 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
11247 case MODE_VECTOR_FLOAT:
11248 for (i = 0, p = array; i < length; i++, p += elt_size)
11250 rtx elt = CONST_VECTOR_ELT (rtl, i);
11251 insert_float (elt, p);
11256 gcc_unreachable ();
11259 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
11264 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
11270 add_AT_addr (die, DW_AT_const_value, rtl);
11271 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
11275 /* In cases where an inlined instance of an inline function is passed
11276 the address of an `auto' variable (which is local to the caller) we
11277 can get a situation where the DECL_RTL of the artificial local
11278 variable (for the inlining) which acts as a stand-in for the
11279 corresponding formal parameter (of the inline function) will look
11280 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
11281 exactly a compile-time constant expression, but it isn't the address
11282 of the (artificial) local variable either. Rather, it represents the
11283 *value* which the artificial local variable always has during its
11284 lifetime. We currently have no way to represent such quasi-constant
11285 values in Dwarf, so for now we just punt and generate nothing. */
11289 /* No other kinds of rtx should be possible here. */
11290 gcc_unreachable ();
11295 /* Determine whether the evaluation of EXPR references any variables
11296 or functions which aren't otherwise used (and therefore may not be
11299 reference_to_unused (tree * tp, int * walk_subtrees,
11300 void * data ATTRIBUTE_UNUSED)
11302 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
11303 *walk_subtrees = 0;
11305 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
11306 && ! TREE_ASM_WRITTEN (*tp))
11308 /* ??? The C++ FE emits debug information for using decls, so
11309 putting gcc_unreachable here falls over. See PR31899. For now
11310 be conservative. */
11311 else if (!cgraph_global_info_ready
11312 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
11314 else if (DECL_P (*tp) && TREE_CODE (*tp) == VAR_DECL)
11316 struct varpool_node *node = varpool_node (*tp);
11320 else if (DECL_P (*tp) && TREE_CODE (*tp) == FUNCTION_DECL
11321 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
11323 struct cgraph_node *node = cgraph_node (*tp);
11327 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
11333 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
11334 for use in a later add_const_value_attribute call. */
11337 rtl_for_decl_init (tree init, tree type)
11339 rtx rtl = NULL_RTX;
11341 /* If a variable is initialized with a string constant without embedded
11342 zeros, build CONST_STRING. */
11343 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
11345 tree enttype = TREE_TYPE (type);
11346 tree domain = TYPE_DOMAIN (type);
11347 enum machine_mode mode = TYPE_MODE (enttype);
11349 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
11351 && integer_zerop (TYPE_MIN_VALUE (domain))
11352 && compare_tree_int (TYPE_MAX_VALUE (domain),
11353 TREE_STRING_LENGTH (init) - 1) == 0
11354 && ((size_t) TREE_STRING_LENGTH (init)
11355 == strlen (TREE_STRING_POINTER (init)) + 1))
11356 rtl = gen_rtx_CONST_STRING (VOIDmode,
11357 ggc_strdup (TREE_STRING_POINTER (init)));
11359 /* Other aggregates, and complex values, could be represented using
11361 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
11363 /* Vectors only work if their mode is supported by the target.
11364 FIXME: generic vectors ought to work too. */
11365 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
11367 /* If the initializer is something that we know will expand into an
11368 immediate RTL constant, expand it now. We must be careful not to
11369 reference variables which won't be output. */
11370 else if (initializer_constant_valid_p (init, type)
11371 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
11373 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
11375 if (TREE_CODE (type) == VECTOR_TYPE)
11376 switch (TREE_CODE (init))
11381 if (TREE_CONSTANT (init))
11383 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
11384 bool constant_p = true;
11386 unsigned HOST_WIDE_INT ix;
11388 /* Even when ctor is constant, it might contain non-*_CST
11389 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
11390 belong into VECTOR_CST nodes. */
11391 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
11392 if (!CONSTANT_CLASS_P (value))
11394 constant_p = false;
11400 init = build_vector_from_ctor (type, elts);
11410 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
11412 /* If expand_expr returns a MEM, it wasn't immediate. */
11413 gcc_assert (!rtl || !MEM_P (rtl));
11419 /* Generate RTL for the variable DECL to represent its location. */
11422 rtl_for_decl_location (tree decl)
11426 /* Here we have to decide where we are going to say the parameter "lives"
11427 (as far as the debugger is concerned). We only have a couple of
11428 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
11430 DECL_RTL normally indicates where the parameter lives during most of the
11431 activation of the function. If optimization is enabled however, this
11432 could be either NULL or else a pseudo-reg. Both of those cases indicate
11433 that the parameter doesn't really live anywhere (as far as the code
11434 generation parts of GCC are concerned) during most of the function's
11435 activation. That will happen (for example) if the parameter is never
11436 referenced within the function.
11438 We could just generate a location descriptor here for all non-NULL
11439 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
11440 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
11441 where DECL_RTL is NULL or is a pseudo-reg.
11443 Note however that we can only get away with using DECL_INCOMING_RTL as
11444 a backup substitute for DECL_RTL in certain limited cases. In cases
11445 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
11446 we can be sure that the parameter was passed using the same type as it is
11447 declared to have within the function, and that its DECL_INCOMING_RTL
11448 points us to a place where a value of that type is passed.
11450 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
11451 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
11452 because in these cases DECL_INCOMING_RTL points us to a value of some
11453 type which is *different* from the type of the parameter itself. Thus,
11454 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
11455 such cases, the debugger would end up (for example) trying to fetch a
11456 `float' from a place which actually contains the first part of a
11457 `double'. That would lead to really incorrect and confusing
11458 output at debug-time.
11460 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
11461 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
11462 are a couple of exceptions however. On little-endian machines we can
11463 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
11464 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
11465 an integral type that is smaller than TREE_TYPE (decl). These cases arise
11466 when (on a little-endian machine) a non-prototyped function has a
11467 parameter declared to be of type `short' or `char'. In such cases,
11468 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
11469 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
11470 passed `int' value. If the debugger then uses that address to fetch
11471 a `short' or a `char' (on a little-endian machine) the result will be
11472 the correct data, so we allow for such exceptional cases below.
11474 Note that our goal here is to describe the place where the given formal
11475 parameter lives during most of the function's activation (i.e. between the
11476 end of the prologue and the start of the epilogue). We'll do that as best
11477 as we can. Note however that if the given formal parameter is modified
11478 sometime during the execution of the function, then a stack backtrace (at
11479 debug-time) will show the function as having been called with the *new*
11480 value rather than the value which was originally passed in. This happens
11481 rarely enough that it is not a major problem, but it *is* a problem, and
11482 I'd like to fix it.
11484 A future version of dwarf2out.c may generate two additional attributes for
11485 any given DW_TAG_formal_parameter DIE which will describe the "passed
11486 type" and the "passed location" for the given formal parameter in addition
11487 to the attributes we now generate to indicate the "declared type" and the
11488 "active location" for each parameter. This additional set of attributes
11489 could be used by debuggers for stack backtraces. Separately, note that
11490 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
11491 This happens (for example) for inlined-instances of inline function formal
11492 parameters which are never referenced. This really shouldn't be
11493 happening. All PARM_DECL nodes should get valid non-NULL
11494 DECL_INCOMING_RTL values. FIXME. */
11496 /* Use DECL_RTL as the "location" unless we find something better. */
11497 rtl = DECL_RTL_IF_SET (decl);
11499 /* When generating abstract instances, ignore everything except
11500 constants, symbols living in memory, and symbols living in
11501 fixed registers. */
11502 if (! reload_completed)
11505 && (CONSTANT_P (rtl)
11507 && CONSTANT_P (XEXP (rtl, 0)))
11509 && TREE_CODE (decl) == VAR_DECL
11510 && TREE_STATIC (decl))))
11512 rtl = targetm.delegitimize_address (rtl);
11517 else if (TREE_CODE (decl) == PARM_DECL)
11519 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
11521 tree declared_type = TREE_TYPE (decl);
11522 tree passed_type = DECL_ARG_TYPE (decl);
11523 enum machine_mode dmode = TYPE_MODE (declared_type);
11524 enum machine_mode pmode = TYPE_MODE (passed_type);
11526 /* This decl represents a formal parameter which was optimized out.
11527 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
11528 all cases where (rtl == NULL_RTX) just below. */
11529 if (dmode == pmode)
11530 rtl = DECL_INCOMING_RTL (decl);
11531 else if (SCALAR_INT_MODE_P (dmode)
11532 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
11533 && DECL_INCOMING_RTL (decl))
11535 rtx inc = DECL_INCOMING_RTL (decl);
11538 else if (MEM_P (inc))
11540 if (BYTES_BIG_ENDIAN)
11541 rtl = adjust_address_nv (inc, dmode,
11542 GET_MODE_SIZE (pmode)
11543 - GET_MODE_SIZE (dmode));
11550 /* If the parm was passed in registers, but lives on the stack, then
11551 make a big endian correction if the mode of the type of the
11552 parameter is not the same as the mode of the rtl. */
11553 /* ??? This is the same series of checks that are made in dbxout.c before
11554 we reach the big endian correction code there. It isn't clear if all
11555 of these checks are necessary here, but keeping them all is the safe
11557 else if (MEM_P (rtl)
11558 && XEXP (rtl, 0) != const0_rtx
11559 && ! CONSTANT_P (XEXP (rtl, 0))
11560 /* Not passed in memory. */
11561 && !MEM_P (DECL_INCOMING_RTL (decl))
11562 /* Not passed by invisible reference. */
11563 && (!REG_P (XEXP (rtl, 0))
11564 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
11565 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
11566 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
11567 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
11570 /* Big endian correction check. */
11571 && BYTES_BIG_ENDIAN
11572 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
11573 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
11576 int offset = (UNITS_PER_WORD
11577 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
11579 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11580 plus_constant (XEXP (rtl, 0), offset));
11583 else if (TREE_CODE (decl) == VAR_DECL
11586 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
11587 && BYTES_BIG_ENDIAN)
11589 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
11590 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
11592 /* If a variable is declared "register" yet is smaller than
11593 a register, then if we store the variable to memory, it
11594 looks like we're storing a register-sized value, when in
11595 fact we are not. We need to adjust the offset of the
11596 storage location to reflect the actual value's bytes,
11597 else gdb will not be able to display it. */
11599 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
11600 plus_constant (XEXP (rtl, 0), rsize-dsize));
11603 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
11604 and will have been substituted directly into all expressions that use it.
11605 C does not have such a concept, but C++ and other languages do. */
11606 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
11607 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
11610 rtl = targetm.delegitimize_address (rtl);
11612 /* If we don't look past the constant pool, we risk emitting a
11613 reference to a constant pool entry that isn't referenced from
11614 code, and thus is not emitted. */
11616 rtl = avoid_constant_pool_reference (rtl);
11621 /* We need to figure out what section we should use as the base for the
11622 address ranges where a given location is valid.
11623 1. If this particular DECL has a section associated with it, use that.
11624 2. If this function has a section associated with it, use that.
11625 3. Otherwise, use the text section.
11626 XXX: If you split a variable across multiple sections, we won't notice. */
11628 static const char *
11629 secname_for_decl (const_tree decl)
11631 const char *secname;
11633 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
11635 tree sectree = DECL_SECTION_NAME (decl);
11636 secname = TREE_STRING_POINTER (sectree);
11638 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
11640 tree sectree = DECL_SECTION_NAME (current_function_decl);
11641 secname = TREE_STRING_POINTER (sectree);
11643 else if (cfun && in_cold_section_p)
11644 secname = crtl->subsections.cold_section_label;
11646 secname = text_section_label;
11651 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
11652 returned. If so, the decl for the COMMON block is returned, and the
11653 value is the offset into the common block for the symbol. */
11656 fortran_common (tree decl, HOST_WIDE_INT *value)
11658 tree val_expr, cvar;
11659 enum machine_mode mode;
11660 HOST_WIDE_INT bitsize, bitpos;
11662 int volatilep = 0, unsignedp = 0;
11664 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
11665 it does not have a value (the offset into the common area), or if it
11666 is thread local (as opposed to global) then it isn't common, and shouldn't
11667 be handled as such. */
11668 if (TREE_CODE (decl) != VAR_DECL
11669 || !TREE_PUBLIC (decl)
11670 || !TREE_STATIC (decl)
11671 || !DECL_HAS_VALUE_EXPR_P (decl)
11675 val_expr = DECL_VALUE_EXPR (decl);
11676 if (TREE_CODE (val_expr) != COMPONENT_REF)
11679 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
11680 &mode, &unsignedp, &volatilep, true);
11682 if (cvar == NULL_TREE
11683 || TREE_CODE (cvar) != VAR_DECL
11684 || DECL_ARTIFICIAL (cvar)
11685 || !TREE_PUBLIC (cvar))
11689 if (offset != NULL)
11691 if (!host_integerp (offset, 0))
11693 *value = tree_low_cst (offset, 0);
11696 *value += bitpos / BITS_PER_UNIT;
11701 /* Dereference a location expression LOC if DECL is passed by invisible
11704 static dw_loc_descr_ref
11705 loc_by_reference (dw_loc_descr_ref loc, tree decl)
11707 HOST_WIDE_INT size;
11708 enum dwarf_location_atom op;
11713 if ((TREE_CODE (decl) != PARM_DECL && TREE_CODE (decl) != RESULT_DECL)
11714 || !DECL_BY_REFERENCE (decl))
11717 size = int_size_in_bytes (TREE_TYPE (decl));
11718 if (size > DWARF2_ADDR_SIZE || size == -1)
11720 else if (size == DWARF2_ADDR_SIZE)
11723 op = DW_OP_deref_size;
11724 add_loc_descr (&loc, new_loc_descr (op, size, 0));
11728 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
11729 data attribute for a variable or a parameter. We generate the
11730 DW_AT_const_value attribute only in those cases where the given variable
11731 or parameter does not have a true "location" either in memory or in a
11732 register. This can happen (for example) when a constant is passed as an
11733 actual argument in a call to an inline function. (It's possible that
11734 these things can crop up in other ways also.) Note that one type of
11735 constant value which can be passed into an inlined function is a constant
11736 pointer. This can happen for example if an actual argument in an inlined
11737 function call evaluates to a compile-time constant address. */
11740 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
11741 enum dwarf_attribute attr)
11744 dw_loc_descr_ref descr;
11745 var_loc_list *loc_list;
11746 struct var_loc_node *node;
11747 if (TREE_CODE (decl) == ERROR_MARK)
11750 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
11751 || TREE_CODE (decl) == RESULT_DECL);
11753 /* See if we possibly have multiple locations for this variable. */
11754 loc_list = lookup_decl_loc (decl);
11756 /* If it truly has multiple locations, the first and last node will
11758 if (loc_list && loc_list->first != loc_list->last)
11760 const char *endname, *secname;
11761 dw_loc_list_ref list;
11763 enum var_init_status initialized;
11765 /* Now that we know what section we are using for a base,
11766 actually construct the list of locations.
11767 The first location information is what is passed to the
11768 function that creates the location list, and the remaining
11769 locations just get added on to that list.
11770 Note that we only know the start address for a location
11771 (IE location changes), so to build the range, we use
11772 the range [current location start, next location start].
11773 This means we have to special case the last node, and generate
11774 a range of [last location start, end of function label]. */
11776 node = loc_list->first;
11777 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11778 secname = secname_for_decl (decl);
11780 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note))
11781 initialized = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11783 initialized = VAR_INIT_STATUS_INITIALIZED;
11785 descr = loc_by_reference (loc_descriptor (varloc, initialized), decl);
11786 list = new_loc_list (descr, node->label, node->next->label, secname, 1);
11789 for (; node->next; node = node->next)
11790 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11792 /* The variable has a location between NODE->LABEL and
11793 NODE->NEXT->LABEL. */
11794 enum var_init_status initialized =
11795 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11796 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11797 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11799 add_loc_descr_to_loc_list (&list, descr,
11800 node->label, node->next->label, secname);
11803 /* If the variable has a location at the last label
11804 it keeps its location until the end of function. */
11805 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
11807 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11808 enum var_init_status initialized =
11809 NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11811 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
11812 if (!current_function_decl)
11813 endname = text_end_label;
11816 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11817 current_function_funcdef_no);
11818 endname = ggc_strdup (label_id);
11820 descr = loc_by_reference (loc_descriptor (varloc, initialized),
11822 add_loc_descr_to_loc_list (&list, descr,
11823 node->label, endname, secname);
11826 /* Finally, add the location list to the DIE, and we are done. */
11827 add_AT_loc_list (die, attr, list);
11831 /* Try to get some constant RTL for this decl, and use that as the value of
11834 rtl = rtl_for_decl_location (decl);
11835 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
11837 add_const_value_attribute (die, rtl);
11841 /* If we have tried to generate the location otherwise, and it
11842 didn't work out (we wouldn't be here if we did), and we have a one entry
11843 location list, try generating a location from that. */
11844 if (loc_list && loc_list->first)
11846 enum var_init_status status;
11847 node = loc_list->first;
11848 status = NOTE_VAR_LOCATION_STATUS (node->var_loc_note);
11849 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note), status);
11852 descr = loc_by_reference (descr, decl);
11853 add_AT_location_description (die, attr, descr);
11858 /* We couldn't get any rtl, so try directly generating the location
11859 description from the tree. */
11860 descr = loc_descriptor_from_tree (decl);
11863 descr = loc_by_reference (descr, decl);
11864 add_AT_location_description (die, attr, descr);
11867 /* None of that worked, so it must not really have a location;
11868 try adding a constant value attribute from the DECL_INITIAL. */
11869 tree_add_const_value_attribute (die, decl);
11872 /* Add VARIABLE and DIE into deferred locations list. */
11875 defer_location (tree variable, dw_die_ref die)
11877 deferred_locations entry;
11878 entry.variable = variable;
11880 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
11883 /* Helper function for tree_add_const_value_attribute. Natively encode
11884 initializer INIT into an array. Return true if successful. */
11887 native_encode_initializer (tree init, unsigned char *array, int size)
11891 if (init == NULL_TREE)
11895 switch (TREE_CODE (init))
11898 type = TREE_TYPE (init);
11899 if (TREE_CODE (type) == ARRAY_TYPE)
11901 tree enttype = TREE_TYPE (type);
11902 enum machine_mode mode = TYPE_MODE (enttype);
11904 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
11906 if (int_size_in_bytes (type) != size)
11908 if (size > TREE_STRING_LENGTH (init))
11910 memcpy (array, TREE_STRING_POINTER (init),
11911 TREE_STRING_LENGTH (init));
11912 memset (array + TREE_STRING_LENGTH (init),
11913 '\0', size - TREE_STRING_LENGTH (init));
11916 memcpy (array, TREE_STRING_POINTER (init), size);
11921 type = TREE_TYPE (init);
11922 if (int_size_in_bytes (type) != size)
11924 if (TREE_CODE (type) == ARRAY_TYPE)
11926 HOST_WIDE_INT min_index;
11927 unsigned HOST_WIDE_INT cnt;
11928 int curpos = 0, fieldsize;
11929 constructor_elt *ce;
11931 if (TYPE_DOMAIN (type) == NULL_TREE
11932 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
11935 fieldsize = int_size_in_bytes (TREE_TYPE (type));
11936 if (fieldsize <= 0)
11939 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
11940 memset (array, '\0', size);
11942 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
11945 tree val = ce->value;
11946 tree index = ce->index;
11948 if (index && TREE_CODE (index) == RANGE_EXPR)
11949 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
11952 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
11957 if (!native_encode_initializer (val, array + pos, fieldsize))
11960 curpos = pos + fieldsize;
11961 if (index && TREE_CODE (index) == RANGE_EXPR)
11963 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
11964 - tree_low_cst (TREE_OPERAND (index, 0), 0);
11968 memcpy (array + curpos, array + pos, fieldsize);
11969 curpos += fieldsize;
11972 gcc_assert (curpos <= size);
11976 else if (TREE_CODE (type) == RECORD_TYPE
11977 || TREE_CODE (type) == UNION_TYPE)
11979 tree field = NULL_TREE;
11980 unsigned HOST_WIDE_INT cnt;
11981 constructor_elt *ce;
11983 if (int_size_in_bytes (type) != size)
11986 if (TREE_CODE (type) == RECORD_TYPE)
11987 field = TYPE_FIELDS (type);
11990 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
11991 cnt++, field = field ? TREE_CHAIN (field) : 0)
11993 tree val = ce->value;
11994 int pos, fieldsize;
11996 if (ce->index != 0)
12002 if (field == NULL_TREE || DECL_BIT_FIELD (field))
12005 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
12006 && TYPE_DOMAIN (TREE_TYPE (field))
12007 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
12009 else if (DECL_SIZE_UNIT (field) == NULL_TREE
12010 || !host_integerp (DECL_SIZE_UNIT (field), 0))
12012 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
12013 pos = int_byte_position (field);
12014 gcc_assert (pos + fieldsize <= size);
12016 && !native_encode_initializer (val, array + pos, fieldsize))
12022 case VIEW_CONVERT_EXPR:
12023 case NON_LVALUE_EXPR:
12024 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
12026 return native_encode_expr (init, array, size) == size;
12030 /* If we don't have a copy of this variable in memory for some reason (such
12031 as a C++ member constant that doesn't have an out-of-line definition),
12032 we should tell the debugger about the constant value. */
12035 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
12038 tree type = TREE_TYPE (decl);
12041 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
12044 init = DECL_INITIAL (decl);
12045 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
12050 rtl = rtl_for_decl_init (init, type);
12052 add_const_value_attribute (var_die, rtl);
12053 /* If the host and target are sane, try harder. */
12054 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
12055 && initializer_constant_valid_p (init, type))
12057 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
12058 if (size > 0 && (int) size == size)
12060 unsigned char *array = GGC_CNEWVEC (unsigned char, size);
12062 if (native_encode_initializer (init, array, size))
12063 add_AT_vec (var_die, DW_AT_const_value, size, 1, array);
12068 /* Convert the CFI instructions for the current function into a
12069 location list. This is used for DW_AT_frame_base when we targeting
12070 a dwarf2 consumer that does not support the dwarf3
12071 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
12074 static dw_loc_list_ref
12075 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
12078 dw_loc_list_ref list, *list_tail;
12080 dw_cfa_location last_cfa, next_cfa;
12081 const char *start_label, *last_label, *section;
12083 fde = current_fde ();
12084 gcc_assert (fde != NULL);
12086 section = secname_for_decl (current_function_decl);
12090 next_cfa.reg = INVALID_REGNUM;
12091 next_cfa.offset = 0;
12092 next_cfa.indirect = 0;
12093 next_cfa.base_offset = 0;
12095 start_label = fde->dw_fde_begin;
12097 /* ??? Bald assumption that the CIE opcode list does not contain
12098 advance opcodes. */
12099 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
12100 lookup_cfa_1 (cfi, &next_cfa);
12102 last_cfa = next_cfa;
12103 last_label = start_label;
12105 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
12106 switch (cfi->dw_cfi_opc)
12108 case DW_CFA_set_loc:
12109 case DW_CFA_advance_loc1:
12110 case DW_CFA_advance_loc2:
12111 case DW_CFA_advance_loc4:
12112 if (!cfa_equal_p (&last_cfa, &next_cfa))
12114 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12115 start_label, last_label, section,
12118 list_tail = &(*list_tail)->dw_loc_next;
12119 last_cfa = next_cfa;
12120 start_label = last_label;
12122 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
12125 case DW_CFA_advance_loc:
12126 /* The encoding is complex enough that we should never emit this. */
12127 case DW_CFA_remember_state:
12128 case DW_CFA_restore_state:
12129 /* We don't handle these two in this function. It would be possible
12130 if it were to be required. */
12131 gcc_unreachable ();
12134 lookup_cfa_1 (cfi, &next_cfa);
12138 if (!cfa_equal_p (&last_cfa, &next_cfa))
12140 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
12141 start_label, last_label, section,
12143 list_tail = &(*list_tail)->dw_loc_next;
12144 start_label = last_label;
12146 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
12147 start_label, fde->dw_fde_end, section,
12153 /* Compute a displacement from the "steady-state frame pointer" to the
12154 frame base (often the same as the CFA), and store it in
12155 frame_pointer_fb_offset. OFFSET is added to the displacement
12156 before the latter is negated. */
12159 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
12163 #ifdef FRAME_POINTER_CFA_OFFSET
12164 reg = frame_pointer_rtx;
12165 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
12167 reg = arg_pointer_rtx;
12168 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
12171 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
12172 if (GET_CODE (elim) == PLUS)
12174 offset += INTVAL (XEXP (elim, 1));
12175 elim = XEXP (elim, 0);
12178 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12179 && (elim == hard_frame_pointer_rtx
12180 || elim == stack_pointer_rtx))
12181 || elim == (frame_pointer_needed
12182 ? hard_frame_pointer_rtx
12183 : stack_pointer_rtx));
12185 frame_pointer_fb_offset = -offset;
12188 /* Generate a DW_AT_name attribute given some string value to be included as
12189 the value of the attribute. */
12192 add_name_attribute (dw_die_ref die, const char *name_string)
12194 if (name_string != NULL && *name_string != 0)
12196 if (demangle_name_func)
12197 name_string = (*demangle_name_func) (name_string);
12199 add_AT_string (die, DW_AT_name, name_string);
12203 /* Generate a DW_AT_comp_dir attribute for DIE. */
12206 add_comp_dir_attribute (dw_die_ref die)
12208 const char *wd = get_src_pwd ();
12210 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
12213 /* Given a tree node describing an array bound (either lower or upper) output
12214 a representation for that bound. */
12217 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
12219 switch (TREE_CODE (bound))
12224 /* All fixed-bounds are represented by INTEGER_CST nodes. */
12226 if (! host_integerp (bound, 0)
12227 || (bound_attr == DW_AT_lower_bound
12228 && (((is_c_family () || is_java ()) && integer_zerop (bound))
12229 || (is_fortran () && integer_onep (bound)))))
12230 /* Use the default. */
12233 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
12237 case VIEW_CONVERT_EXPR:
12238 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
12248 dw_die_ref decl_die = lookup_decl_die (bound);
12249 dw_loc_descr_ref loc;
12251 /* ??? Can this happen, or should the variable have been bound
12252 first? Probably it can, since I imagine that we try to create
12253 the types of parameters in the order in which they exist in
12254 the list, and won't have created a forward reference to a
12255 later parameter. */
12256 if (decl_die != NULL)
12257 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12260 loc = loc_descriptor_from_tree_1 (bound, 0);
12261 add_AT_location_description (subrange_die, bound_attr, loc);
12268 /* Otherwise try to create a stack operation procedure to
12269 evaluate the value of the array bound. */
12271 dw_die_ref ctx, decl_die;
12272 dw_loc_descr_ref loc;
12274 loc = loc_descriptor_from_tree (bound);
12278 if (current_function_decl == 0)
12279 ctx = comp_unit_die;
12281 ctx = lookup_decl_die (current_function_decl);
12283 decl_die = new_die (DW_TAG_variable, ctx, bound);
12284 add_AT_flag (decl_die, DW_AT_artificial, 1);
12285 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
12286 add_AT_loc (decl_die, DW_AT_location, loc);
12288 add_AT_die_ref (subrange_die, bound_attr, decl_die);
12294 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
12295 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
12296 Note that the block of subscript information for an array type also
12297 includes information about the element type of the given array type. */
12300 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
12302 unsigned dimension_number;
12304 dw_die_ref subrange_die;
12306 for (dimension_number = 0;
12307 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
12308 type = TREE_TYPE (type), dimension_number++)
12310 tree domain = TYPE_DOMAIN (type);
12312 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
12315 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
12316 and (in GNU C only) variable bounds. Handle all three forms
12318 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
12321 /* We have an array type with specified bounds. */
12322 lower = TYPE_MIN_VALUE (domain);
12323 upper = TYPE_MAX_VALUE (domain);
12325 /* Define the index type. */
12326 if (TREE_TYPE (domain))
12328 /* ??? This is probably an Ada unnamed subrange type. Ignore the
12329 TREE_TYPE field. We can't emit debug info for this
12330 because it is an unnamed integral type. */
12331 if (TREE_CODE (domain) == INTEGER_TYPE
12332 && TYPE_NAME (domain) == NULL_TREE
12333 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
12334 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
12337 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
12341 /* ??? If upper is NULL, the array has unspecified length,
12342 but it does have a lower bound. This happens with Fortran
12344 Since the debugger is definitely going to need to know N
12345 to produce useful results, go ahead and output the lower
12346 bound solo, and hope the debugger can cope. */
12348 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
12350 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
12353 /* Otherwise we have an array type with an unspecified length. The
12354 DWARF-2 spec does not say how to handle this; let's just leave out the
12360 add_byte_size_attribute (dw_die_ref die, tree tree_node)
12364 switch (TREE_CODE (tree_node))
12369 case ENUMERAL_TYPE:
12372 case QUAL_UNION_TYPE:
12373 size = int_size_in_bytes (tree_node);
12376 /* For a data member of a struct or union, the DW_AT_byte_size is
12377 generally given as the number of bytes normally allocated for an
12378 object of the *declared* type of the member itself. This is true
12379 even for bit-fields. */
12380 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
12383 gcc_unreachable ();
12386 /* Note that `size' might be -1 when we get to this point. If it is, that
12387 indicates that the byte size of the entity in question is variable. We
12388 have no good way of expressing this fact in Dwarf at the present time,
12389 so just let the -1 pass on through. */
12390 add_AT_unsigned (die, DW_AT_byte_size, size);
12393 /* For a FIELD_DECL node which represents a bit-field, output an attribute
12394 which specifies the distance in bits from the highest order bit of the
12395 "containing object" for the bit-field to the highest order bit of the
12398 For any given bit-field, the "containing object" is a hypothetical object
12399 (of some integral or enum type) within which the given bit-field lives. The
12400 type of this hypothetical "containing object" is always the same as the
12401 declared type of the individual bit-field itself. The determination of the
12402 exact location of the "containing object" for a bit-field is rather
12403 complicated. It's handled by the `field_byte_offset' function (above).
12405 Note that it is the size (in bytes) of the hypothetical "containing object"
12406 which will be given in the DW_AT_byte_size attribute for this bit-field.
12407 (See `byte_size_attribute' above). */
12410 add_bit_offset_attribute (dw_die_ref die, tree decl)
12412 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
12413 tree type = DECL_BIT_FIELD_TYPE (decl);
12414 HOST_WIDE_INT bitpos_int;
12415 HOST_WIDE_INT highest_order_object_bit_offset;
12416 HOST_WIDE_INT highest_order_field_bit_offset;
12417 HOST_WIDE_INT unsigned bit_offset;
12419 /* Must be a field and a bit field. */
12420 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
12422 /* We can't yet handle bit-fields whose offsets are variable, so if we
12423 encounter such things, just return without generating any attribute
12424 whatsoever. Likewise for variable or too large size. */
12425 if (! host_integerp (bit_position (decl), 0)
12426 || ! host_integerp (DECL_SIZE (decl), 1))
12429 bitpos_int = int_bit_position (decl);
12431 /* Note that the bit offset is always the distance (in bits) from the
12432 highest-order bit of the "containing object" to the highest-order bit of
12433 the bit-field itself. Since the "high-order end" of any object or field
12434 is different on big-endian and little-endian machines, the computation
12435 below must take account of these differences. */
12436 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
12437 highest_order_field_bit_offset = bitpos_int;
12439 if (! BYTES_BIG_ENDIAN)
12441 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
12442 highest_order_object_bit_offset += simple_type_size_in_bits (type);
12446 = (! BYTES_BIG_ENDIAN
12447 ? highest_order_object_bit_offset - highest_order_field_bit_offset
12448 : highest_order_field_bit_offset - highest_order_object_bit_offset);
12450 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
12453 /* For a FIELD_DECL node which represents a bit field, output an attribute
12454 which specifies the length in bits of the given field. */
12457 add_bit_size_attribute (dw_die_ref die, tree decl)
12459 /* Must be a field and a bit field. */
12460 gcc_assert (TREE_CODE (decl) == FIELD_DECL
12461 && DECL_BIT_FIELD_TYPE (decl));
12463 if (host_integerp (DECL_SIZE (decl), 1))
12464 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
12467 /* If the compiled language is ANSI C, then add a 'prototyped'
12468 attribute, if arg types are given for the parameters of a function. */
12471 add_prototyped_attribute (dw_die_ref die, tree func_type)
12473 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
12474 && TYPE_ARG_TYPES (func_type) != NULL)
12475 add_AT_flag (die, DW_AT_prototyped, 1);
12478 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
12479 by looking in either the type declaration or object declaration
12483 add_abstract_origin_attribute (dw_die_ref die, tree origin)
12485 dw_die_ref origin_die = NULL;
12487 if (TREE_CODE (origin) != FUNCTION_DECL)
12489 /* We may have gotten separated from the block for the inlined
12490 function, if we're in an exception handler or some such; make
12491 sure that the abstract function has been written out.
12493 Doing this for nested functions is wrong, however; functions are
12494 distinct units, and our context might not even be inline. */
12498 fn = TYPE_STUB_DECL (fn);
12500 fn = decl_function_context (fn);
12502 dwarf2out_abstract_function (fn);
12505 if (DECL_P (origin))
12506 origin_die = lookup_decl_die (origin);
12507 else if (TYPE_P (origin))
12508 origin_die = lookup_type_die (origin);
12510 /* XXX: Functions that are never lowered don't always have correct block
12511 trees (in the case of java, they simply have no block tree, in some other
12512 languages). For these functions, there is nothing we can really do to
12513 output correct debug info for inlined functions in all cases. Rather
12514 than die, we'll just produce deficient debug info now, in that we will
12515 have variables without a proper abstract origin. In the future, when all
12516 functions are lowered, we should re-add a gcc_assert (origin_die)
12520 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
12523 /* We do not currently support the pure_virtual attribute. */
12526 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
12528 if (DECL_VINDEX (func_decl))
12530 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12532 if (host_integerp (DECL_VINDEX (func_decl), 0))
12533 add_AT_loc (die, DW_AT_vtable_elem_location,
12534 new_loc_descr (DW_OP_constu,
12535 tree_low_cst (DECL_VINDEX (func_decl), 0),
12538 /* GNU extension: Record what type this method came from originally. */
12539 if (debug_info_level > DINFO_LEVEL_TERSE)
12540 add_AT_die_ref (die, DW_AT_containing_type,
12541 lookup_type_die (DECL_CONTEXT (func_decl)));
12545 /* Add source coordinate attributes for the given decl. */
12548 add_src_coords_attributes (dw_die_ref die, tree decl)
12550 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
12552 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
12553 add_AT_unsigned (die, DW_AT_decl_line, s.line);
12556 /* Add a DW_AT_name attribute and source coordinate attribute for the
12557 given decl, but only if it actually has a name. */
12560 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
12564 decl_name = DECL_NAME (decl);
12565 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
12567 add_name_attribute (die, dwarf2_name (decl, 0));
12568 if (! DECL_ARTIFICIAL (decl))
12569 add_src_coords_attributes (die, decl);
12571 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
12572 && TREE_PUBLIC (decl)
12573 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
12574 && !DECL_ABSTRACT (decl)
12575 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
12577 add_AT_string (die, DW_AT_MIPS_linkage_name,
12578 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
12581 #ifdef VMS_DEBUGGING_INFO
12582 /* Get the function's name, as described by its RTL. This may be different
12583 from the DECL_NAME name used in the source file. */
12584 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
12586 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
12587 XEXP (DECL_RTL (decl), 0));
12588 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
12593 /* Push a new declaration scope. */
12596 push_decl_scope (tree scope)
12598 VEC_safe_push (tree, gc, decl_scope_table, scope);
12601 /* Pop a declaration scope. */
12604 pop_decl_scope (void)
12606 VEC_pop (tree, decl_scope_table);
12609 /* Return the DIE for the scope that immediately contains this type.
12610 Non-named types get global scope. Named types nested in other
12611 types get their containing scope if it's open, or global scope
12612 otherwise. All other types (i.e. function-local named types) get
12613 the current active scope. */
12616 scope_die_for (tree t, dw_die_ref context_die)
12618 dw_die_ref scope_die = NULL;
12619 tree containing_scope;
12622 /* Non-types always go in the current scope. */
12623 gcc_assert (TYPE_P (t));
12625 containing_scope = TYPE_CONTEXT (t);
12627 /* Use the containing namespace if it was passed in (for a declaration). */
12628 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
12630 if (context_die == lookup_decl_die (containing_scope))
12633 containing_scope = NULL_TREE;
12636 /* Ignore function type "scopes" from the C frontend. They mean that
12637 a tagged type is local to a parmlist of a function declarator, but
12638 that isn't useful to DWARF. */
12639 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
12640 containing_scope = NULL_TREE;
12642 if (containing_scope == NULL_TREE)
12643 scope_die = comp_unit_die;
12644 else if (TYPE_P (containing_scope))
12646 /* For types, we can just look up the appropriate DIE. But
12647 first we check to see if we're in the middle of emitting it
12648 so we know where the new DIE should go. */
12649 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
12650 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
12655 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
12656 || TREE_ASM_WRITTEN (containing_scope));
12658 /* If none of the current dies are suitable, we get file scope. */
12659 scope_die = comp_unit_die;
12662 scope_die = lookup_type_die (containing_scope);
12665 scope_die = context_die;
12670 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
12673 local_scope_p (dw_die_ref context_die)
12675 for (; context_die; context_die = context_die->die_parent)
12676 if (context_die->die_tag == DW_TAG_inlined_subroutine
12677 || context_die->die_tag == DW_TAG_subprogram)
12683 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
12684 whether or not to treat a DIE in this context as a declaration. */
12687 class_or_namespace_scope_p (dw_die_ref context_die)
12689 return (context_die
12690 && (context_die->die_tag == DW_TAG_structure_type
12691 || context_die->die_tag == DW_TAG_class_type
12692 || context_die->die_tag == DW_TAG_interface_type
12693 || context_die->die_tag == DW_TAG_union_type
12694 || context_die->die_tag == DW_TAG_namespace));
12697 /* Many forms of DIEs require a "type description" attribute. This
12698 routine locates the proper "type descriptor" die for the type given
12699 by 'type', and adds a DW_AT_type attribute below the given die. */
12702 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
12703 int decl_volatile, dw_die_ref context_die)
12705 enum tree_code code = TREE_CODE (type);
12706 dw_die_ref type_die = NULL;
12708 /* ??? If this type is an unnamed subrange type of an integral, floating-point
12709 or fixed-point type, use the inner type. This is because we have no
12710 support for unnamed types in base_type_die. This can happen if this is
12711 an Ada subrange type. Correct solution is emit a subrange type die. */
12712 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
12713 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
12714 type = TREE_TYPE (type), code = TREE_CODE (type);
12716 if (code == ERROR_MARK
12717 /* Handle a special case. For functions whose return type is void, we
12718 generate *no* type attribute. (Note that no object may have type
12719 `void', so this only applies to function return types). */
12720 || code == VOID_TYPE)
12723 type_die = modified_type_die (type,
12724 decl_const || TYPE_READONLY (type),
12725 decl_volatile || TYPE_VOLATILE (type),
12728 if (type_die != NULL)
12729 add_AT_die_ref (object_die, DW_AT_type, type_die);
12732 /* Given an object die, add the calling convention attribute for the
12733 function call type. */
12735 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
12737 enum dwarf_calling_convention value = DW_CC_normal;
12739 value = targetm.dwarf_calling_convention (TREE_TYPE (decl));
12741 /* DWARF doesn't provide a way to identify a program's source-level
12742 entry point. DW_AT_calling_convention attributes are only meant
12743 to describe functions' calling conventions. However, lacking a
12744 better way to signal the Fortran main program, we use this for the
12745 time being, following existing custom. */
12747 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
12748 value = DW_CC_program;
12750 /* Only add the attribute if the backend requests it, and
12751 is not DW_CC_normal. */
12752 if (value && (value != DW_CC_normal))
12753 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
12756 /* Given a tree pointer to a struct, class, union, or enum type node, return
12757 a pointer to the (string) tag name for the given type, or zero if the type
12758 was declared without a tag. */
12760 static const char *
12761 type_tag (const_tree type)
12763 const char *name = 0;
12765 if (TYPE_NAME (type) != 0)
12769 /* Find the IDENTIFIER_NODE for the type name. */
12770 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
12771 t = TYPE_NAME (type);
12773 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
12774 a TYPE_DECL node, regardless of whether or not a `typedef' was
12776 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12777 && ! DECL_IGNORED_P (TYPE_NAME (type)))
12779 /* We want to be extra verbose. Don't call dwarf_name if
12780 DECL_NAME isn't set. The default hook for decl_printable_name
12781 doesn't like that, and in this context it's correct to return
12782 0, instead of "<anonymous>" or the like. */
12783 if (DECL_NAME (TYPE_NAME (type)))
12784 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
12787 /* Now get the name as a string, or invent one. */
12788 if (!name && t != 0)
12789 name = IDENTIFIER_POINTER (t);
12792 return (name == 0 || *name == '\0') ? 0 : name;
12795 /* Return the type associated with a data member, make a special check
12796 for bit field types. */
12799 member_declared_type (const_tree member)
12801 return (DECL_BIT_FIELD_TYPE (member)
12802 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
12805 /* Get the decl's label, as described by its RTL. This may be different
12806 from the DECL_NAME name used in the source file. */
12809 static const char *
12810 decl_start_label (tree decl)
12813 const char *fnname;
12815 x = DECL_RTL (decl);
12816 gcc_assert (MEM_P (x));
12819 gcc_assert (GET_CODE (x) == SYMBOL_REF);
12821 fnname = XSTR (x, 0);
12826 /* These routines generate the internal representation of the DIE's for
12827 the compilation unit. Debugging information is collected by walking
12828 the declaration trees passed in from dwarf2out_decl(). */
12831 gen_array_type_die (tree type, dw_die_ref context_die)
12833 dw_die_ref scope_die = scope_die_for (type, context_die);
12834 dw_die_ref array_die;
12836 /* GNU compilers represent multidimensional array types as sequences of one
12837 dimensional array types whose element types are themselves array types.
12838 We sometimes squish that down to a single array_type DIE with multiple
12839 subscripts in the Dwarf debugging info. The draft Dwarf specification
12840 say that we are allowed to do this kind of compression in C, because
12841 there is no difference between an array of arrays and a multidimensional
12842 array. We don't do this for Ada to remain as close as possible to the
12843 actual representation, which is especially important against the language
12844 flexibilty wrt arrays of variable size. */
12846 bool collapse_nested_arrays = !is_ada ();
12849 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
12850 DW_TAG_string_type doesn't have DW_AT_type attribute). */
12851 if (TYPE_STRING_FLAG (type)
12852 && TREE_CODE (type) == ARRAY_TYPE
12854 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
12856 HOST_WIDE_INT size;
12858 array_die = new_die (DW_TAG_string_type, scope_die, type);
12859 add_name_attribute (array_die, type_tag (type));
12860 equate_type_number_to_die (type, array_die);
12861 size = int_size_in_bytes (type);
12863 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12864 else if (TYPE_DOMAIN (type) != NULL_TREE
12865 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
12866 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
12868 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
12869 dw_loc_descr_ref loc = loc_descriptor_from_tree (szdecl);
12871 size = int_size_in_bytes (TREE_TYPE (szdecl));
12872 if (loc && size > 0)
12874 add_AT_loc (array_die, DW_AT_string_length, loc);
12875 if (size != DWARF2_ADDR_SIZE)
12876 add_AT_unsigned (array_die, DW_AT_byte_size, size);
12882 /* ??? The SGI dwarf reader fails for array of array of enum types
12883 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
12884 array type comes before the outer array type. We thus call gen_type_die
12885 before we new_die and must prevent nested array types collapsing for this
12888 #ifdef MIPS_DEBUGGING_INFO
12889 gen_type_die (TREE_TYPE (type), context_die);
12890 collapse_nested_arrays = false;
12893 array_die = new_die (DW_TAG_array_type, scope_die, type);
12894 add_name_attribute (array_die, type_tag (type));
12895 equate_type_number_to_die (type, array_die);
12897 if (TREE_CODE (type) == VECTOR_TYPE)
12899 /* The frontend feeds us a representation for the vector as a struct
12900 containing an array. Pull out the array type. */
12901 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
12902 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
12905 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
12907 && TREE_CODE (type) == ARRAY_TYPE
12908 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
12909 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
12910 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
12913 /* We default the array ordering. SDB will probably do
12914 the right things even if DW_AT_ordering is not present. It's not even
12915 an issue until we start to get into multidimensional arrays anyway. If
12916 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
12917 then we'll have to put the DW_AT_ordering attribute back in. (But if
12918 and when we find out that we need to put these in, we will only do so
12919 for multidimensional arrays. */
12920 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
12923 #ifdef MIPS_DEBUGGING_INFO
12924 /* The SGI compilers handle arrays of unknown bound by setting
12925 AT_declaration and not emitting any subrange DIEs. */
12926 if (! TYPE_DOMAIN (type))
12927 add_AT_flag (array_die, DW_AT_declaration, 1);
12930 add_subscript_info (array_die, type, collapse_nested_arrays);
12932 /* Add representation of the type of the elements of this array type and
12933 emit the corresponding DIE if we haven't done it already. */
12934 element_type = TREE_TYPE (type);
12935 if (collapse_nested_arrays)
12936 while (TREE_CODE (element_type) == ARRAY_TYPE)
12938 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
12940 element_type = TREE_TYPE (element_type);
12943 #ifndef MIPS_DEBUGGING_INFO
12944 gen_type_die (element_type, context_die);
12947 add_type_attribute (array_die, element_type, 0, 0, context_die);
12949 if (get_AT (array_die, DW_AT_name))
12950 add_pubtype (type, array_die);
12953 static dw_loc_descr_ref
12954 descr_info_loc (tree val, tree base_decl)
12956 HOST_WIDE_INT size;
12957 dw_loc_descr_ref loc, loc2;
12958 enum dwarf_location_atom op;
12960 if (val == base_decl)
12961 return new_loc_descr (DW_OP_push_object_address, 0, 0);
12963 switch (TREE_CODE (val))
12966 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12968 return loc_descriptor_from_tree_1 (val, 0);
12970 if (host_integerp (val, 0))
12971 return int_loc_descriptor (tree_low_cst (val, 0));
12974 size = int_size_in_bytes (TREE_TYPE (val));
12977 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12980 if (size == DWARF2_ADDR_SIZE)
12981 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
12983 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
12985 case POINTER_PLUS_EXPR:
12987 if (host_integerp (TREE_OPERAND (val, 1), 1)
12988 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
12991 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
12994 add_loc_descr (&loc,
12995 new_loc_descr (DW_OP_plus_uconst,
12996 tree_low_cst (TREE_OPERAND (val, 1),
13003 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
13006 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
13009 add_loc_descr (&loc, loc2);
13010 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
13032 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
13033 tree val, tree base_decl)
13035 dw_loc_descr_ref loc;
13037 if (host_integerp (val, 0))
13039 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
13043 loc = descr_info_loc (val, base_decl);
13047 add_AT_loc (die, attr, loc);
13050 /* This routine generates DIE for array with hidden descriptor, details
13051 are filled into *info by a langhook. */
13054 gen_descr_array_type_die (tree type, struct array_descr_info *info,
13055 dw_die_ref context_die)
13057 dw_die_ref scope_die = scope_die_for (type, context_die);
13058 dw_die_ref array_die;
13061 array_die = new_die (DW_TAG_array_type, scope_die, type);
13062 add_name_attribute (array_die, type_tag (type));
13063 equate_type_number_to_die (type, array_die);
13065 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
13067 && info->ndimensions >= 2)
13068 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
13070 if (info->data_location)
13071 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
13073 if (info->associated)
13074 add_descr_info_field (array_die, DW_AT_associated, info->associated,
13076 if (info->allocated)
13077 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
13080 for (dim = 0; dim < info->ndimensions; dim++)
13082 dw_die_ref subrange_die
13083 = new_die (DW_TAG_subrange_type, array_die, NULL);
13085 if (info->dimen[dim].lower_bound)
13087 /* If it is the default value, omit it. */
13088 if ((is_c_family () || is_java ())
13089 && integer_zerop (info->dimen[dim].lower_bound))
13091 else if (is_fortran ()
13092 && integer_onep (info->dimen[dim].lower_bound))
13095 add_descr_info_field (subrange_die, DW_AT_lower_bound,
13096 info->dimen[dim].lower_bound,
13099 if (info->dimen[dim].upper_bound)
13100 add_descr_info_field (subrange_die, DW_AT_upper_bound,
13101 info->dimen[dim].upper_bound,
13103 if (info->dimen[dim].stride)
13104 add_descr_info_field (subrange_die, DW_AT_byte_stride,
13105 info->dimen[dim].stride,
13109 gen_type_die (info->element_type, context_die);
13110 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
13112 if (get_AT (array_die, DW_AT_name))
13113 add_pubtype (type, array_die);
13118 gen_entry_point_die (tree decl, dw_die_ref context_die)
13120 tree origin = decl_ultimate_origin (decl);
13121 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
13123 if (origin != NULL)
13124 add_abstract_origin_attribute (decl_die, origin);
13127 add_name_and_src_coords_attributes (decl_die, decl);
13128 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
13129 0, 0, context_die);
13132 if (DECL_ABSTRACT (decl))
13133 equate_decl_number_to_die (decl, decl_die);
13135 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
13139 /* Walk through the list of incomplete types again, trying once more to
13140 emit full debugging info for them. */
13143 retry_incomplete_types (void)
13147 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
13148 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
13151 /* Generate a DIE to represent an inlined instance of an enumeration type. */
13154 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
13156 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
13158 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
13159 be incomplete and such types are not marked. */
13160 add_abstract_origin_attribute (type_die, type);
13163 /* Determine what tag to use for a record type. */
13165 static enum dwarf_tag
13166 record_type_tag (tree type)
13168 if (! lang_hooks.types.classify_record)
13169 return DW_TAG_structure_type;
13171 switch (lang_hooks.types.classify_record (type))
13173 case RECORD_IS_STRUCT:
13174 return DW_TAG_structure_type;
13176 case RECORD_IS_CLASS:
13177 return DW_TAG_class_type;
13179 case RECORD_IS_INTERFACE:
13180 return DW_TAG_interface_type;
13183 gcc_unreachable ();
13187 /* Generate a DIE to represent an inlined instance of a structure type. */
13190 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
13192 dw_die_ref type_die = new_die (record_type_tag (type), context_die, type);
13194 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
13195 be incomplete and such types are not marked. */
13196 add_abstract_origin_attribute (type_die, type);
13199 /* Generate a DIE to represent an inlined instance of a union type. */
13202 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
13204 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
13206 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
13207 be incomplete and such types are not marked. */
13208 add_abstract_origin_attribute (type_die, type);
13211 /* Generate a DIE to represent an enumeration type. Note that these DIEs
13212 include all of the information about the enumeration values also. Each
13213 enumerated type name/value is listed as a child of the enumerated type
13217 gen_enumeration_type_die (tree type, dw_die_ref context_die)
13219 dw_die_ref type_die = lookup_type_die (type);
13221 if (type_die == NULL)
13223 type_die = new_die (DW_TAG_enumeration_type,
13224 scope_die_for (type, context_die), type);
13225 equate_type_number_to_die (type, type_die);
13226 add_name_attribute (type_die, type_tag (type));
13228 else if (! TYPE_SIZE (type))
13231 remove_AT (type_die, DW_AT_declaration);
13233 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
13234 given enum type is incomplete, do not generate the DW_AT_byte_size
13235 attribute or the DW_AT_element_list attribute. */
13236 if (TYPE_SIZE (type))
13240 TREE_ASM_WRITTEN (type) = 1;
13241 add_byte_size_attribute (type_die, type);
13242 if (TYPE_STUB_DECL (type) != NULL_TREE)
13243 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
13245 /* If the first reference to this type was as the return type of an
13246 inline function, then it may not have a parent. Fix this now. */
13247 if (type_die->die_parent == NULL)
13248 add_child_die (scope_die_for (type, context_die), type_die);
13250 for (link = TYPE_VALUES (type);
13251 link != NULL; link = TREE_CHAIN (link))
13253 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
13254 tree value = TREE_VALUE (link);
13256 add_name_attribute (enum_die,
13257 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
13259 if (TREE_CODE (value) == CONST_DECL)
13260 value = DECL_INITIAL (value);
13262 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
13263 /* DWARF2 does not provide a way of indicating whether or
13264 not enumeration constants are signed or unsigned. GDB
13265 always assumes the values are signed, so we output all
13266 values as if they were signed. That means that
13267 enumeration constants with very large unsigned values
13268 will appear to have negative values in the debugger. */
13269 add_AT_int (enum_die, DW_AT_const_value,
13270 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
13274 add_AT_flag (type_die, DW_AT_declaration, 1);
13276 if (get_AT (type_die, DW_AT_name))
13277 add_pubtype (type, type_die);
13282 /* Generate a DIE to represent either a real live formal parameter decl or to
13283 represent just the type of some formal parameter position in some function
13286 Note that this routine is a bit unusual because its argument may be a
13287 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
13288 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
13289 node. If it's the former then this function is being called to output a
13290 DIE to represent a formal parameter object (or some inlining thereof). If
13291 it's the latter, then this function is only being called to output a
13292 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
13293 argument type of some subprogram type. */
13296 gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
13298 tree node_or_origin = node ? node : origin;
13299 dw_die_ref parm_die
13300 = new_die (DW_TAG_formal_parameter, context_die, node);
13302 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
13304 case tcc_declaration:
13306 origin = decl_ultimate_origin (node);
13307 if (origin != NULL)
13308 add_abstract_origin_attribute (parm_die, origin);
13311 tree type = TREE_TYPE (node);
13312 add_name_and_src_coords_attributes (parm_die, node);
13313 if (DECL_BY_REFERENCE (node))
13314 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
13317 add_type_attribute (parm_die, type,
13318 TREE_READONLY (node),
13319 TREE_THIS_VOLATILE (node),
13321 if (DECL_ARTIFICIAL (node))
13322 add_AT_flag (parm_die, DW_AT_artificial, 1);
13326 equate_decl_number_to_die (node, parm_die);
13327 if (! DECL_ABSTRACT (node_or_origin))
13328 add_location_or_const_value_attribute (parm_die, node_or_origin,
13334 /* We were called with some kind of a ..._TYPE node. */
13335 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
13339 gcc_unreachable ();
13345 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
13346 at the end of an (ANSI prototyped) formal parameters list. */
13349 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
13351 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
13354 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
13355 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
13356 parameters as specified in some function type specification (except for
13357 those which appear as part of a function *definition*). */
13360 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
13363 tree formal_type = NULL;
13364 tree first_parm_type;
13367 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
13369 arg = DECL_ARGUMENTS (function_or_method_type);
13370 function_or_method_type = TREE_TYPE (function_or_method_type);
13375 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
13377 /* Make our first pass over the list of formal parameter types and output a
13378 DW_TAG_formal_parameter DIE for each one. */
13379 for (link = first_parm_type; link; )
13381 dw_die_ref parm_die;
13383 formal_type = TREE_VALUE (link);
13384 if (formal_type == void_type_node)
13387 /* Output a (nameless) DIE to represent the formal parameter itself. */
13388 parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
13389 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
13390 && link == first_parm_type)
13391 || (arg && DECL_ARTIFICIAL (arg)))
13392 add_AT_flag (parm_die, DW_AT_artificial, 1);
13394 link = TREE_CHAIN (link);
13396 arg = TREE_CHAIN (arg);
13399 /* If this function type has an ellipsis, add a
13400 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
13401 if (formal_type != void_type_node)
13402 gen_unspecified_parameters_die (function_or_method_type, context_die);
13404 /* Make our second (and final) pass over the list of formal parameter types
13405 and output DIEs to represent those types (as necessary). */
13406 for (link = TYPE_ARG_TYPES (function_or_method_type);
13407 link && TREE_VALUE (link);
13408 link = TREE_CHAIN (link))
13409 gen_type_die (TREE_VALUE (link), context_die);
13412 /* We want to generate the DIE for TYPE so that we can generate the
13413 die for MEMBER, which has been defined; we will need to refer back
13414 to the member declaration nested within TYPE. If we're trying to
13415 generate minimal debug info for TYPE, processing TYPE won't do the
13416 trick; we need to attach the member declaration by hand. */
13419 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
13421 gen_type_die (type, context_die);
13423 /* If we're trying to avoid duplicate debug info, we may not have
13424 emitted the member decl for this function. Emit it now. */
13425 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
13426 && ! lookup_decl_die (member))
13428 dw_die_ref type_die;
13429 gcc_assert (!decl_ultimate_origin (member));
13431 push_decl_scope (type);
13432 type_die = lookup_type_die (type);
13433 if (TREE_CODE (member) == FUNCTION_DECL)
13434 gen_subprogram_die (member, type_die);
13435 else if (TREE_CODE (member) == FIELD_DECL)
13437 /* Ignore the nameless fields that are used to skip bits but handle
13438 C++ anonymous unions and structs. */
13439 if (DECL_NAME (member) != NULL_TREE
13440 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
13441 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
13443 gen_type_die (member_declared_type (member), type_die);
13444 gen_field_die (member, type_die);
13448 gen_variable_die (member, NULL_TREE, type_die);
13454 /* Generate the DWARF2 info for the "abstract" instance of a function which we
13455 may later generate inlined and/or out-of-line instances of. */
13458 dwarf2out_abstract_function (tree decl)
13460 dw_die_ref old_die;
13463 int was_abstract = DECL_ABSTRACT (decl);
13465 /* Make sure we have the actual abstract inline, not a clone. */
13466 decl = DECL_ORIGIN (decl);
13468 old_die = lookup_decl_die (decl);
13469 if (old_die && get_AT (old_die, DW_AT_inline))
13470 /* We've already generated the abstract instance. */
13473 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
13474 we don't get confused by DECL_ABSTRACT. */
13475 if (debug_info_level > DINFO_LEVEL_TERSE)
13477 context = decl_class_context (decl);
13479 gen_type_die_for_member
13480 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
13483 /* Pretend we've just finished compiling this function. */
13484 save_fn = current_function_decl;
13485 current_function_decl = decl;
13486 push_cfun (DECL_STRUCT_FUNCTION (decl));
13488 set_decl_abstract_flags (decl, 1);
13489 dwarf2out_decl (decl);
13490 if (! was_abstract)
13491 set_decl_abstract_flags (decl, 0);
13493 current_function_decl = save_fn;
13497 /* Helper function of premark_used_types() which gets called through
13498 htab_traverse_resize().
13500 Marks the DIE of a given type in *SLOT as perennial, so it never gets
13501 marked as unused by prune_unused_types. */
13503 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
13508 type = (tree) *slot;
13509 die = lookup_type_die (type);
13511 die->die_perennial_p = 1;
13515 /* Mark all members of used_types_hash as perennial. */
13517 premark_used_types (void)
13519 if (cfun && cfun->used_types_hash)
13520 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
13523 /* Generate a DIE to represent a declared function (either file-scope or
13527 gen_subprogram_die (tree decl, dw_die_ref context_die)
13529 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
13530 tree origin = decl_ultimate_origin (decl);
13531 dw_die_ref subr_die;
13534 dw_die_ref old_die = lookup_decl_die (decl);
13535 int declaration = (current_function_decl != decl
13536 || class_or_namespace_scope_p (context_die));
13538 premark_used_types ();
13540 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
13541 started to generate the abstract instance of an inline, decided to output
13542 its containing class, and proceeded to emit the declaration of the inline
13543 from the member list for the class. If so, DECLARATION takes priority;
13544 we'll get back to the abstract instance when done with the class. */
13546 /* The class-scope declaration DIE must be the primary DIE. */
13547 if (origin && declaration && class_or_namespace_scope_p (context_die))
13550 gcc_assert (!old_die);
13553 /* Now that the C++ front end lazily declares artificial member fns, we
13554 might need to retrofit the declaration into its class. */
13555 if (!declaration && !origin && !old_die
13556 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
13557 && !class_or_namespace_scope_p (context_die)
13558 && debug_info_level > DINFO_LEVEL_TERSE)
13559 old_die = force_decl_die (decl);
13561 if (origin != NULL)
13563 gcc_assert (!declaration || local_scope_p (context_die));
13565 /* Fixup die_parent for the abstract instance of a nested
13566 inline function. */
13567 if (old_die && old_die->die_parent == NULL)
13568 add_child_die (context_die, old_die);
13570 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13571 add_abstract_origin_attribute (subr_die, origin);
13575 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
13576 struct dwarf_file_data * file_index = lookup_filename (s.file);
13578 if (!get_AT_flag (old_die, DW_AT_declaration)
13579 /* We can have a normal definition following an inline one in the
13580 case of redefinition of GNU C extern inlines.
13581 It seems reasonable to use AT_specification in this case. */
13582 && !get_AT (old_die, DW_AT_inline))
13584 /* Detect and ignore this case, where we are trying to output
13585 something we have already output. */
13589 /* If the definition comes from the same place as the declaration,
13590 maybe use the old DIE. We always want the DIE for this function
13591 that has the *_pc attributes to be under comp_unit_die so the
13592 debugger can find it. We also need to do this for abstract
13593 instances of inlines, since the spec requires the out-of-line copy
13594 to have the same parent. For local class methods, this doesn't
13595 apply; we just use the old DIE. */
13596 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
13597 && (DECL_ARTIFICIAL (decl)
13598 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
13599 && (get_AT_unsigned (old_die, DW_AT_decl_line)
13600 == (unsigned) s.line))))
13602 subr_die = old_die;
13604 /* Clear out the declaration attribute and the formal parameters.
13605 Do not remove all children, because it is possible that this
13606 declaration die was forced using force_decl_die(). In such
13607 cases die that forced declaration die (e.g. TAG_imported_module)
13608 is one of the children that we do not want to remove. */
13609 remove_AT (subr_die, DW_AT_declaration);
13610 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
13614 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13615 add_AT_specification (subr_die, old_die);
13616 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
13617 add_AT_file (subr_die, DW_AT_decl_file, file_index);
13618 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
13619 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
13624 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
13626 if (TREE_PUBLIC (decl))
13627 add_AT_flag (subr_die, DW_AT_external, 1);
13629 add_name_and_src_coords_attributes (subr_die, decl);
13630 if (debug_info_level > DINFO_LEVEL_TERSE)
13632 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
13633 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
13634 0, 0, context_die);
13637 add_pure_or_virtual_attribute (subr_die, decl);
13638 if (DECL_ARTIFICIAL (decl))
13639 add_AT_flag (subr_die, DW_AT_artificial, 1);
13641 if (TREE_PROTECTED (decl))
13642 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
13643 else if (TREE_PRIVATE (decl))
13644 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
13649 if (!old_die || !get_AT (old_die, DW_AT_inline))
13651 add_AT_flag (subr_die, DW_AT_declaration, 1);
13653 /* The first time we see a member function, it is in the context of
13654 the class to which it belongs. We make sure of this by emitting
13655 the class first. The next time is the definition, which is
13656 handled above. The two may come from the same source text.
13658 Note that force_decl_die() forces function declaration die. It is
13659 later reused to represent definition. */
13660 equate_decl_number_to_die (decl, subr_die);
13663 else if (DECL_ABSTRACT (decl))
13665 if (DECL_DECLARED_INLINE_P (decl))
13667 if (cgraph_function_possibly_inlined_p (decl))
13668 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
13670 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
13674 if (cgraph_function_possibly_inlined_p (decl))
13675 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
13677 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
13680 if (DECL_DECLARED_INLINE_P (decl)
13681 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
13682 add_AT_flag (subr_die, DW_AT_artificial, 1);
13684 equate_decl_number_to_die (decl, subr_die);
13686 else if (!DECL_EXTERNAL (decl))
13688 HOST_WIDE_INT cfa_fb_offset;
13690 if (!old_die || !get_AT (old_die, DW_AT_inline))
13691 equate_decl_number_to_die (decl, subr_die);
13693 if (!flag_reorder_blocks_and_partition)
13695 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
13696 current_function_funcdef_no);
13697 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
13698 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
13699 current_function_funcdef_no);
13700 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
13702 add_pubname (decl, subr_die);
13703 add_arange (decl, subr_die);
13706 { /* Do nothing for now; maybe need to duplicate die, one for
13707 hot section and one for cold section, then use the hot/cold
13708 section begin/end labels to generate the aranges... */
13710 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
13711 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
13712 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
13713 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
13715 add_pubname (decl, subr_die);
13716 add_arange (decl, subr_die);
13717 add_arange (decl, subr_die);
13721 #ifdef MIPS_DEBUGGING_INFO
13722 /* Add a reference to the FDE for this routine. */
13723 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
13726 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
13728 /* We define the "frame base" as the function's CFA. This is more
13729 convenient for several reasons: (1) It's stable across the prologue
13730 and epilogue, which makes it better than just a frame pointer,
13731 (2) With dwarf3, there exists a one-byte encoding that allows us
13732 to reference the .debug_frame data by proxy, but failing that,
13733 (3) We can at least reuse the code inspection and interpretation
13734 code that determines the CFA position at various points in the
13736 /* ??? Use some command-line or configury switch to enable the use
13737 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
13738 consumers that understand it; fall back to "pure" dwarf2 and
13739 convert the CFA data into a location list. */
13741 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
13742 if (list->dw_loc_next)
13743 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
13745 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
13748 /* Compute a displacement from the "steady-state frame pointer" to
13749 the CFA. The former is what all stack slots and argument slots
13750 will reference in the rtl; the later is what we've told the
13751 debugger about. We'll need to adjust all frame_base references
13752 by this displacement. */
13753 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
13755 if (cfun->static_chain_decl)
13756 add_AT_location_description (subr_die, DW_AT_static_link,
13757 loc_descriptor_from_tree (cfun->static_chain_decl));
13760 /* Now output descriptions of the arguments for this function. This gets
13761 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
13762 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
13763 `...' at the end of the formal parameter list. In order to find out if
13764 there was a trailing ellipsis or not, we must instead look at the type
13765 associated with the FUNCTION_DECL. This will be a node of type
13766 FUNCTION_TYPE. If the chain of type nodes hanging off of this
13767 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
13768 an ellipsis at the end. */
13770 /* In the case where we are describing a mere function declaration, all we
13771 need to do here (and all we *can* do here) is to describe the *types* of
13772 its formal parameters. */
13773 if (debug_info_level <= DINFO_LEVEL_TERSE)
13775 else if (declaration)
13776 gen_formal_types_die (decl, subr_die);
13779 /* Generate DIEs to represent all known formal parameters. */
13780 tree arg_decls = DECL_ARGUMENTS (decl);
13783 /* When generating DIEs, generate the unspecified_parameters DIE
13784 instead if we come across the arg "__builtin_va_alist" */
13785 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
13786 if (TREE_CODE (parm) == PARM_DECL)
13788 if (DECL_NAME (parm)
13789 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
13790 "__builtin_va_alist"))
13791 gen_unspecified_parameters_die (parm, subr_die);
13793 gen_decl_die (parm, NULL, subr_die);
13796 /* Decide whether we need an unspecified_parameters DIE at the end.
13797 There are 2 more cases to do this for: 1) the ansi ... declaration -
13798 this is detectable when the end of the arg list is not a
13799 void_type_node 2) an unprototyped function declaration (not a
13800 definition). This just means that we have no info about the
13801 parameters at all. */
13802 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
13803 if (fn_arg_types != NULL)
13805 /* This is the prototyped case, check for.... */
13806 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
13807 gen_unspecified_parameters_die (decl, subr_die);
13809 else if (DECL_INITIAL (decl) == NULL_TREE)
13810 gen_unspecified_parameters_die (decl, subr_die);
13813 /* Output Dwarf info for all of the stuff within the body of the function
13814 (if it has one - it may be just a declaration). */
13815 outer_scope = DECL_INITIAL (decl);
13817 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
13818 a function. This BLOCK actually represents the outermost binding contour
13819 for the function, i.e. the contour in which the function's formal
13820 parameters and labels get declared. Curiously, it appears that the front
13821 end doesn't actually put the PARM_DECL nodes for the current function onto
13822 the BLOCK_VARS list for this outer scope, but are strung off of the
13823 DECL_ARGUMENTS list for the function instead.
13825 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
13826 the LABEL_DECL nodes for the function however, and we output DWARF info
13827 for those in decls_for_scope. Just within the `outer_scope' there will be
13828 a BLOCK node representing the function's outermost pair of curly braces,
13829 and any blocks used for the base and member initializers of a C++
13830 constructor function. */
13831 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
13833 /* Emit a DW_TAG_variable DIE for a named return value. */
13834 if (DECL_NAME (DECL_RESULT (decl)))
13835 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
13837 current_function_has_inlines = 0;
13838 decls_for_scope (outer_scope, subr_die, 0);
13840 #if 0 && defined (MIPS_DEBUGGING_INFO)
13841 if (current_function_has_inlines)
13843 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
13844 if (! comp_unit_has_inlines)
13846 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
13847 comp_unit_has_inlines = 1;
13852 /* Add the calling convention attribute if requested. */
13853 add_calling_convention_attribute (subr_die, decl);
13857 /* Returns a hash value for X (which really is a die_struct). */
13860 common_block_die_table_hash (const void *x)
13862 const_dw_die_ref d = (const_dw_die_ref) x;
13863 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
13866 /* Return nonzero if decl_id and die_parent of die_struct X is the same
13867 as decl_id and die_parent of die_struct Y. */
13870 common_block_die_table_eq (const void *x, const void *y)
13872 const_dw_die_ref d = (const_dw_die_ref) x;
13873 const_dw_die_ref e = (const_dw_die_ref) y;
13874 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
13877 /* Generate a DIE to represent a declared data object.
13878 Either DECL or ORIGIN must be non-null. */
13881 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
13885 tree decl_or_origin = decl ? decl : origin;
13886 dw_die_ref var_die;
13887 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
13888 int declaration = (DECL_EXTERNAL (decl_or_origin)
13889 /* If DECL is COMDAT and has not actually been
13890 emitted, we cannot take its address; there
13891 might end up being no definition anywhere in
13892 the program. For example, consider the C++
13896 struct S { static const int i = 7; };
13901 int f() { return S<int>::i; }
13903 Here, S<int>::i is not DECL_EXTERNAL, but no
13904 definition is required, so the compiler will
13905 not emit a definition. */
13906 || (TREE_CODE (decl_or_origin) == VAR_DECL
13907 && DECL_COMDAT (decl_or_origin)
13908 && !TREE_ASM_WRITTEN (decl_or_origin))
13909 || class_or_namespace_scope_p (context_die));
13912 origin = decl_ultimate_origin (decl);
13914 com_decl = fortran_common (decl_or_origin, &off);
13916 /* Symbol in common gets emitted as a child of the common block, in the form
13917 of a data member. */
13921 dw_die_ref com_die;
13922 dw_loc_descr_ref loc;
13923 die_node com_die_arg;
13925 var_die = lookup_decl_die (decl_or_origin);
13928 if (get_AT (var_die, DW_AT_location) == NULL)
13930 loc = loc_descriptor_from_tree (com_decl);
13935 /* Optimize the common case. */
13936 if (loc->dw_loc_opc == DW_OP_addr
13937 && loc->dw_loc_next == NULL
13938 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr)
13940 loc->dw_loc_oprnd1.v.val_addr
13941 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
13943 add_loc_descr (&loc,
13944 new_loc_descr (DW_OP_plus_uconst,
13947 add_AT_loc (var_die, DW_AT_location, loc);
13948 remove_AT (var_die, DW_AT_declaration);
13954 if (common_block_die_table == NULL)
13955 common_block_die_table
13956 = htab_create_ggc (10, common_block_die_table_hash,
13957 common_block_die_table_eq, NULL);
13959 field = TREE_OPERAND (DECL_VALUE_EXPR (decl), 0);
13960 com_die_arg.decl_id = DECL_UID (com_decl);
13961 com_die_arg.die_parent = context_die;
13962 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
13963 loc = loc_descriptor_from_tree (com_decl);
13964 if (com_die == NULL)
13967 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
13970 com_die = new_die (DW_TAG_common_block, context_die, decl);
13971 add_name_and_src_coords_attributes (com_die, com_decl);
13974 add_AT_loc (com_die, DW_AT_location, loc);
13975 /* Avoid sharing the same loc descriptor between
13976 DW_TAG_common_block and DW_TAG_variable. */
13977 loc = loc_descriptor_from_tree (com_decl);
13979 else if (DECL_EXTERNAL (decl))
13980 add_AT_flag (com_die, DW_AT_declaration, 1);
13981 add_pubname_string (cnam, com_die); /* ??? needed? */
13982 com_die->decl_id = DECL_UID (com_decl);
13983 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
13984 *slot = (void *) com_die;
13986 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
13988 add_AT_loc (com_die, DW_AT_location, loc);
13989 loc = loc_descriptor_from_tree (com_decl);
13990 remove_AT (com_die, DW_AT_declaration);
13992 var_die = new_die (DW_TAG_variable, com_die, decl);
13993 add_name_and_src_coords_attributes (var_die, decl);
13994 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
13995 TREE_THIS_VOLATILE (decl), context_die);
13996 add_AT_flag (var_die, DW_AT_external, 1);
14001 /* Optimize the common case. */
14002 if (loc->dw_loc_opc == DW_OP_addr
14003 && loc->dw_loc_next == NULL
14004 && GET_CODE (loc->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
14005 loc->dw_loc_oprnd1.v.val_addr
14006 = plus_constant (loc->dw_loc_oprnd1.v.val_addr, off);
14008 add_loc_descr (&loc, new_loc_descr (DW_OP_plus_uconst,
14011 add_AT_loc (var_die, DW_AT_location, loc);
14013 else if (DECL_EXTERNAL (decl))
14014 add_AT_flag (var_die, DW_AT_declaration, 1);
14015 equate_decl_number_to_die (decl, var_die);
14019 var_die = new_die (DW_TAG_variable, context_die, decl);
14021 if (origin != NULL)
14022 add_abstract_origin_attribute (var_die, origin);
14024 /* Loop unrolling can create multiple blocks that refer to the same
14025 static variable, so we must test for the DW_AT_declaration flag.
14027 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
14028 copy decls and set the DECL_ABSTRACT flag on them instead of
14031 ??? Duplicated blocks have been rewritten to use .debug_ranges.
14033 ??? The declare_in_namespace support causes us to get two DIEs for one
14034 variable, both of which are declarations. We want to avoid considering
14035 one to be a specification, so we must test that this DIE is not a
14037 else if (old_die && TREE_STATIC (decl) && ! declaration
14038 && get_AT_flag (old_die, DW_AT_declaration) == 1)
14040 /* This is a definition of a C++ class level static. */
14041 add_AT_specification (var_die, old_die);
14042 if (DECL_NAME (decl))
14044 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
14045 struct dwarf_file_data * file_index = lookup_filename (s.file);
14047 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
14048 add_AT_file (var_die, DW_AT_decl_file, file_index);
14050 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
14051 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
14056 tree type = TREE_TYPE (decl);
14058 add_name_and_src_coords_attributes (var_die, decl);
14059 if ((TREE_CODE (decl) == PARM_DECL
14060 || TREE_CODE (decl) == RESULT_DECL)
14061 && DECL_BY_REFERENCE (decl))
14062 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
14064 add_type_attribute (var_die, type, TREE_READONLY (decl),
14065 TREE_THIS_VOLATILE (decl), context_die);
14067 if (TREE_PUBLIC (decl))
14068 add_AT_flag (var_die, DW_AT_external, 1);
14070 if (DECL_ARTIFICIAL (decl))
14071 add_AT_flag (var_die, DW_AT_artificial, 1);
14073 if (TREE_PROTECTED (decl))
14074 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
14075 else if (TREE_PRIVATE (decl))
14076 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
14080 add_AT_flag (var_die, DW_AT_declaration, 1);
14082 if (decl && (DECL_ABSTRACT (decl) || declaration))
14083 equate_decl_number_to_die (decl, var_die);
14085 if (! declaration && ! DECL_ABSTRACT (decl_or_origin))
14087 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
14088 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
14089 defer_location (decl_or_origin, var_die);
14091 add_location_or_const_value_attribute (var_die,
14094 add_pubname (decl_or_origin, var_die);
14097 tree_add_const_value_attribute (var_die, decl_or_origin);
14100 /* Generate a DIE to represent a named constant. */
14103 gen_const_die (tree decl, dw_die_ref context_die)
14105 dw_die_ref const_die;
14106 tree type = TREE_TYPE (decl);
14108 const_die = new_die (DW_TAG_constant, context_die, decl);
14109 add_name_and_src_coords_attributes (const_die, decl);
14110 add_type_attribute (const_die, type, 1, 0, context_die);
14111 if (TREE_PUBLIC (decl))
14112 add_AT_flag (const_die, DW_AT_external, 1);
14113 if (DECL_ARTIFICIAL (decl))
14114 add_AT_flag (const_die, DW_AT_artificial, 1);
14115 tree_add_const_value_attribute (const_die, decl);
14118 /* Generate a DIE to represent a label identifier. */
14121 gen_label_die (tree decl, dw_die_ref context_die)
14123 tree origin = decl_ultimate_origin (decl);
14124 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
14126 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14128 if (origin != NULL)
14129 add_abstract_origin_attribute (lbl_die, origin);
14131 add_name_and_src_coords_attributes (lbl_die, decl);
14133 if (DECL_ABSTRACT (decl))
14134 equate_decl_number_to_die (decl, lbl_die);
14137 insn = DECL_RTL_IF_SET (decl);
14139 /* Deleted labels are programmer specified labels which have been
14140 eliminated because of various optimizations. We still emit them
14141 here so that it is possible to put breakpoints on them. */
14145 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
14147 /* When optimization is enabled (via -O) some parts of the compiler
14148 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
14149 represent source-level labels which were explicitly declared by
14150 the user. This really shouldn't be happening though, so catch
14151 it if it ever does happen. */
14152 gcc_assert (!INSN_DELETED_P (insn));
14154 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
14155 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
14160 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
14161 attributes to the DIE for a block STMT, to describe where the inlined
14162 function was called from. This is similar to add_src_coords_attributes. */
14165 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
14167 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
14169 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
14170 add_AT_unsigned (die, DW_AT_call_line, s.line);
14174 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
14175 Add low_pc and high_pc attributes to the DIE for a block STMT. */
14178 add_high_low_attributes (tree stmt, dw_die_ref die)
14180 char label[MAX_ARTIFICIAL_LABEL_BYTES];
14182 if (BLOCK_FRAGMENT_CHAIN (stmt))
14186 if (inlined_function_outer_scope_p (stmt))
14188 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14189 BLOCK_NUMBER (stmt));
14190 add_AT_lbl_id (die, DW_AT_entry_pc, label);
14193 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
14195 chain = BLOCK_FRAGMENT_CHAIN (stmt);
14198 add_ranges (chain);
14199 chain = BLOCK_FRAGMENT_CHAIN (chain);
14206 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
14207 BLOCK_NUMBER (stmt));
14208 add_AT_lbl_id (die, DW_AT_low_pc, label);
14209 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
14210 BLOCK_NUMBER (stmt));
14211 add_AT_lbl_id (die, DW_AT_high_pc, label);
14215 /* Generate a DIE for a lexical block. */
14218 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
14220 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
14222 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
14223 add_high_low_attributes (stmt, stmt_die);
14225 decls_for_scope (stmt, stmt_die, depth);
14228 /* Generate a DIE for an inlined subprogram. */
14231 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
14233 tree decl = block_ultimate_origin (stmt);
14235 /* Emit info for the abstract instance first, if we haven't yet. We
14236 must emit this even if the block is abstract, otherwise when we
14237 emit the block below (or elsewhere), we may end up trying to emit
14238 a die whose origin die hasn't been emitted, and crashing. */
14239 dwarf2out_abstract_function (decl);
14241 if (! BLOCK_ABSTRACT (stmt))
14243 dw_die_ref subr_die
14244 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
14246 add_abstract_origin_attribute (subr_die, decl);
14247 if (TREE_ASM_WRITTEN (stmt))
14248 add_high_low_attributes (stmt, subr_die);
14249 add_call_src_coords_attributes (stmt, subr_die);
14251 decls_for_scope (stmt, subr_die, depth);
14252 current_function_has_inlines = 1;
14255 /* We may get here if we're the outer block of function A that was
14256 inlined into function B that was inlined into function C. When
14257 generating debugging info for C, dwarf2out_abstract_function(B)
14258 would mark all inlined blocks as abstract, including this one.
14259 So, we wouldn't (and shouldn't) expect labels to be generated
14260 for this one. Instead, just emit debugging info for
14261 declarations within the block. This is particularly important
14262 in the case of initializers of arguments passed from B to us:
14263 if they're statement expressions containing declarations, we
14264 wouldn't generate dies for their abstract variables, and then,
14265 when generating dies for the real variables, we'd die (pun
14267 gen_lexical_block_die (stmt, context_die, depth);
14270 /* Generate a DIE for a field in a record, or structure. */
14273 gen_field_die (tree decl, dw_die_ref context_die)
14275 dw_die_ref decl_die;
14277 if (TREE_TYPE (decl) == error_mark_node)
14280 decl_die = new_die (DW_TAG_member, context_die, decl);
14281 add_name_and_src_coords_attributes (decl_die, decl);
14282 add_type_attribute (decl_die, member_declared_type (decl),
14283 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
14286 if (DECL_BIT_FIELD_TYPE (decl))
14288 add_byte_size_attribute (decl_die, decl);
14289 add_bit_size_attribute (decl_die, decl);
14290 add_bit_offset_attribute (decl_die, decl);
14293 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
14294 add_data_member_location_attribute (decl_die, decl);
14296 if (DECL_ARTIFICIAL (decl))
14297 add_AT_flag (decl_die, DW_AT_artificial, 1);
14299 if (TREE_PROTECTED (decl))
14300 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
14301 else if (TREE_PRIVATE (decl))
14302 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
14304 /* Equate decl number to die, so that we can look up this decl later on. */
14305 equate_decl_number_to_die (decl, decl_die);
14309 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14310 Use modified_type_die instead.
14311 We keep this code here just in case these types of DIEs may be needed to
14312 represent certain things in other languages (e.g. Pascal) someday. */
14315 gen_pointer_type_die (tree type, dw_die_ref context_die)
14318 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
14320 equate_type_number_to_die (type, ptr_die);
14321 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14322 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14325 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14326 Use modified_type_die instead.
14327 We keep this code here just in case these types of DIEs may be needed to
14328 represent certain things in other languages (e.g. Pascal) someday. */
14331 gen_reference_type_die (tree type, dw_die_ref context_die)
14334 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
14336 equate_type_number_to_die (type, ref_die);
14337 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
14338 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
14342 /* Generate a DIE for a pointer to a member type. */
14345 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
14348 = new_die (DW_TAG_ptr_to_member_type,
14349 scope_die_for (type, context_die), type);
14351 equate_type_number_to_die (type, ptr_die);
14352 add_AT_die_ref (ptr_die, DW_AT_containing_type,
14353 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
14354 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
14357 /* Generate the DIE for the compilation unit. */
14360 gen_compile_unit_die (const char *filename)
14363 char producer[250];
14364 const char *language_string = lang_hooks.name;
14367 die = new_die (DW_TAG_compile_unit, NULL, NULL);
14371 add_name_attribute (die, filename);
14372 /* Don't add cwd for <built-in>. */
14373 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
14374 add_comp_dir_attribute (die);
14377 sprintf (producer, "%s %s", language_string, version_string);
14379 #ifdef MIPS_DEBUGGING_INFO
14380 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
14381 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
14382 not appear in the producer string, the debugger reaches the conclusion
14383 that the object file is stripped and has no debugging information.
14384 To get the MIPS/SGI debugger to believe that there is debugging
14385 information in the object file, we add a -g to the producer string. */
14386 if (debug_info_level > DINFO_LEVEL_TERSE)
14387 strcat (producer, " -g");
14390 add_AT_string (die, DW_AT_producer, producer);
14392 if (strcmp (language_string, "GNU C++") == 0)
14393 language = DW_LANG_C_plus_plus;
14394 else if (strcmp (language_string, "GNU Ada") == 0)
14395 language = DW_LANG_Ada95;
14396 else if (strcmp (language_string, "GNU F77") == 0)
14397 language = DW_LANG_Fortran77;
14398 else if (strcmp (language_string, "GNU Fortran") == 0)
14399 language = DW_LANG_Fortran95;
14400 else if (strcmp (language_string, "GNU Pascal") == 0)
14401 language = DW_LANG_Pascal83;
14402 else if (strcmp (language_string, "GNU Java") == 0)
14403 language = DW_LANG_Java;
14404 else if (strcmp (language_string, "GNU Objective-C") == 0)
14405 language = DW_LANG_ObjC;
14406 else if (strcmp (language_string, "GNU Objective-C++") == 0)
14407 language = DW_LANG_ObjC_plus_plus;
14409 language = DW_LANG_C89;
14411 add_AT_unsigned (die, DW_AT_language, language);
14415 /* Generate the DIE for a base class. */
14418 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
14420 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
14422 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
14423 add_data_member_location_attribute (die, binfo);
14425 if (BINFO_VIRTUAL_P (binfo))
14426 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
14428 if (access == access_public_node)
14429 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
14430 else if (access == access_protected_node)
14431 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
14434 /* Generate a DIE for a class member. */
14437 gen_member_die (tree type, dw_die_ref context_die)
14440 tree binfo = TYPE_BINFO (type);
14443 /* If this is not an incomplete type, output descriptions of each of its
14444 members. Note that as we output the DIEs necessary to represent the
14445 members of this record or union type, we will also be trying to output
14446 DIEs to represent the *types* of those members. However the `type'
14447 function (above) will specifically avoid generating type DIEs for member
14448 types *within* the list of member DIEs for this (containing) type except
14449 for those types (of members) which are explicitly marked as also being
14450 members of this (containing) type themselves. The g++ front- end can
14451 force any given type to be treated as a member of some other (containing)
14452 type by setting the TYPE_CONTEXT of the given (member) type to point to
14453 the TREE node representing the appropriate (containing) type. */
14455 /* First output info about the base classes. */
14458 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
14462 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
14463 gen_inheritance_die (base,
14464 (accesses ? VEC_index (tree, accesses, i)
14465 : access_public_node), context_die);
14468 /* Now output info about the data members and type members. */
14469 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
14471 /* If we thought we were generating minimal debug info for TYPE
14472 and then changed our minds, some of the member declarations
14473 may have already been defined. Don't define them again, but
14474 do put them in the right order. */
14476 child = lookup_decl_die (member);
14478 splice_child_die (context_die, child);
14480 gen_decl_die (member, NULL, context_die);
14483 /* Now output info about the function members (if any). */
14484 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
14486 /* Don't include clones in the member list. */
14487 if (DECL_ABSTRACT_ORIGIN (member))
14490 child = lookup_decl_die (member);
14492 splice_child_die (context_die, child);
14494 gen_decl_die (member, NULL, context_die);
14498 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
14499 is set, we pretend that the type was never defined, so we only get the
14500 member DIEs needed by later specification DIEs. */
14503 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
14504 enum debug_info_usage usage)
14506 dw_die_ref type_die = lookup_type_die (type);
14507 dw_die_ref scope_die = 0;
14509 int complete = (TYPE_SIZE (type)
14510 && (! TYPE_STUB_DECL (type)
14511 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
14512 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
14513 complete = complete && should_emit_struct_debug (type, usage);
14515 if (type_die && ! complete)
14518 if (TYPE_CONTEXT (type) != NULL_TREE
14519 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14520 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
14523 scope_die = scope_die_for (type, context_die);
14525 if (! type_die || (nested && scope_die == comp_unit_die))
14526 /* First occurrence of type or toplevel definition of nested class. */
14528 dw_die_ref old_die = type_die;
14530 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
14531 ? record_type_tag (type) : DW_TAG_union_type,
14533 equate_type_number_to_die (type, type_die);
14535 add_AT_specification (type_die, old_die);
14537 add_name_attribute (type_die, type_tag (type));
14540 remove_AT (type_die, DW_AT_declaration);
14542 /* If this type has been completed, then give it a byte_size attribute and
14543 then give a list of members. */
14544 if (complete && !ns_decl)
14546 /* Prevent infinite recursion in cases where the type of some member of
14547 this type is expressed in terms of this type itself. */
14548 TREE_ASM_WRITTEN (type) = 1;
14549 add_byte_size_attribute (type_die, type);
14550 if (TYPE_STUB_DECL (type) != NULL_TREE)
14551 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
14553 /* If the first reference to this type was as the return type of an
14554 inline function, then it may not have a parent. Fix this now. */
14555 if (type_die->die_parent == NULL)
14556 add_child_die (scope_die, type_die);
14558 push_decl_scope (type);
14559 gen_member_die (type, type_die);
14562 /* GNU extension: Record what type our vtable lives in. */
14563 if (TYPE_VFIELD (type))
14565 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
14567 gen_type_die (vtype, context_die);
14568 add_AT_die_ref (type_die, DW_AT_containing_type,
14569 lookup_type_die (vtype));
14574 add_AT_flag (type_die, DW_AT_declaration, 1);
14576 /* We don't need to do this for function-local types. */
14577 if (TYPE_STUB_DECL (type)
14578 && ! decl_function_context (TYPE_STUB_DECL (type)))
14579 VEC_safe_push (tree, gc, incomplete_types, type);
14582 if (get_AT (type_die, DW_AT_name))
14583 add_pubtype (type, type_die);
14586 /* Generate a DIE for a subroutine _type_. */
14589 gen_subroutine_type_die (tree type, dw_die_ref context_die)
14591 tree return_type = TREE_TYPE (type);
14592 dw_die_ref subr_die
14593 = new_die (DW_TAG_subroutine_type,
14594 scope_die_for (type, context_die), type);
14596 equate_type_number_to_die (type, subr_die);
14597 add_prototyped_attribute (subr_die, type);
14598 add_type_attribute (subr_die, return_type, 0, 0, context_die);
14599 gen_formal_types_die (type, subr_die);
14601 if (get_AT (subr_die, DW_AT_name))
14602 add_pubtype (type, subr_die);
14605 /* Generate a DIE for a type definition. */
14608 gen_typedef_die (tree decl, dw_die_ref context_die)
14610 dw_die_ref type_die;
14613 if (TREE_ASM_WRITTEN (decl))
14616 TREE_ASM_WRITTEN (decl) = 1;
14617 type_die = new_die (DW_TAG_typedef, context_die, decl);
14618 origin = decl_ultimate_origin (decl);
14619 if (origin != NULL)
14620 add_abstract_origin_attribute (type_die, origin);
14625 add_name_and_src_coords_attributes (type_die, decl);
14626 if (DECL_ORIGINAL_TYPE (decl))
14628 type = DECL_ORIGINAL_TYPE (decl);
14630 gcc_assert (type != TREE_TYPE (decl));
14631 equate_type_number_to_die (TREE_TYPE (decl), type_die);
14634 type = TREE_TYPE (decl);
14636 add_type_attribute (type_die, type, TREE_READONLY (decl),
14637 TREE_THIS_VOLATILE (decl), context_die);
14640 if (DECL_ABSTRACT (decl))
14641 equate_decl_number_to_die (decl, type_die);
14643 if (get_AT (type_die, DW_AT_name))
14644 add_pubtype (decl, type_die);
14647 /* Generate a type description DIE. */
14650 gen_type_die_with_usage (tree type, dw_die_ref context_die,
14651 enum debug_info_usage usage)
14654 struct array_descr_info info;
14656 if (type == NULL_TREE || type == error_mark_node)
14659 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
14660 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
14662 if (TREE_ASM_WRITTEN (type))
14665 /* Prevent broken recursion; we can't hand off to the same type. */
14666 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
14668 TREE_ASM_WRITTEN (type) = 1;
14669 gen_decl_die (TYPE_NAME (type), NULL, context_die);
14673 /* If this is an array type with hidden descriptor, handle it first. */
14674 if (!TREE_ASM_WRITTEN (type)
14675 && lang_hooks.types.get_array_descr_info
14676 && lang_hooks.types.get_array_descr_info (type, &info))
14678 gen_descr_array_type_die (type, &info, context_die);
14679 TREE_ASM_WRITTEN (type) = 1;
14683 /* We are going to output a DIE to represent the unqualified version
14684 of this type (i.e. without any const or volatile qualifiers) so
14685 get the main variant (i.e. the unqualified version) of this type
14686 now. (Vectors are special because the debugging info is in the
14687 cloned type itself). */
14688 if (TREE_CODE (type) != VECTOR_TYPE)
14689 type = type_main_variant (type);
14691 if (TREE_ASM_WRITTEN (type))
14694 switch (TREE_CODE (type))
14700 case REFERENCE_TYPE:
14701 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
14702 ensures that the gen_type_die recursion will terminate even if the
14703 type is recursive. Recursive types are possible in Ada. */
14704 /* ??? We could perhaps do this for all types before the switch
14706 TREE_ASM_WRITTEN (type) = 1;
14708 /* For these types, all that is required is that we output a DIE (or a
14709 set of DIEs) to represent the "basis" type. */
14710 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14711 DINFO_USAGE_IND_USE);
14715 /* This code is used for C++ pointer-to-data-member types.
14716 Output a description of the relevant class type. */
14717 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
14718 DINFO_USAGE_IND_USE);
14720 /* Output a description of the type of the object pointed to. */
14721 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14722 DINFO_USAGE_IND_USE);
14724 /* Now output a DIE to represent this pointer-to-data-member type
14726 gen_ptr_to_mbr_type_die (type, context_die);
14729 case FUNCTION_TYPE:
14730 /* Force out return type (in case it wasn't forced out already). */
14731 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14732 DINFO_USAGE_DIR_USE);
14733 gen_subroutine_type_die (type, context_die);
14737 /* Force out return type (in case it wasn't forced out already). */
14738 gen_type_die_with_usage (TREE_TYPE (type), context_die,
14739 DINFO_USAGE_DIR_USE);
14740 gen_subroutine_type_die (type, context_die);
14744 gen_array_type_die (type, context_die);
14748 gen_array_type_die (type, context_die);
14751 case ENUMERAL_TYPE:
14754 case QUAL_UNION_TYPE:
14755 /* If this is a nested type whose containing class hasn't been written
14756 out yet, writing it out will cover this one, too. This does not apply
14757 to instantiations of member class templates; they need to be added to
14758 the containing class as they are generated. FIXME: This hurts the
14759 idea of combining type decls from multiple TUs, since we can't predict
14760 what set of template instantiations we'll get. */
14761 if (TYPE_CONTEXT (type)
14762 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
14763 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
14765 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
14767 if (TREE_ASM_WRITTEN (type))
14770 /* If that failed, attach ourselves to the stub. */
14771 push_decl_scope (TYPE_CONTEXT (type));
14772 context_die = lookup_type_die (TYPE_CONTEXT (type));
14777 context_die = declare_in_namespace (type, context_die);
14781 if (TREE_CODE (type) == ENUMERAL_TYPE)
14783 /* This might have been written out by the call to
14784 declare_in_namespace. */
14785 if (!TREE_ASM_WRITTEN (type))
14786 gen_enumeration_type_die (type, context_die);
14789 gen_struct_or_union_type_die (type, context_die, usage);
14794 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
14795 it up if it is ever completed. gen_*_type_die will set it for us
14796 when appropriate. */
14802 case FIXED_POINT_TYPE:
14805 /* No DIEs needed for fundamental types. */
14809 /* No Dwarf representation currently defined. */
14813 gcc_unreachable ();
14816 TREE_ASM_WRITTEN (type) = 1;
14820 gen_type_die (tree type, dw_die_ref context_die)
14822 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
14825 /* Generate a DIE for a tagged type instantiation. */
14828 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
14830 if (type == NULL_TREE || type == error_mark_node)
14833 /* We are going to output a DIE to represent the unqualified version of
14834 this type (i.e. without any const or volatile qualifiers) so make sure
14835 that we have the main variant (i.e. the unqualified version) of this
14837 gcc_assert (type == type_main_variant (type));
14839 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
14840 an instance of an unresolved type. */
14842 switch (TREE_CODE (type))
14847 case ENUMERAL_TYPE:
14848 gen_inlined_enumeration_type_die (type, context_die);
14852 gen_inlined_structure_type_die (type, context_die);
14856 case QUAL_UNION_TYPE:
14857 gen_inlined_union_type_die (type, context_die);
14861 gcc_unreachable ();
14865 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
14866 things which are local to the given block. */
14869 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
14871 int must_output_die = 0;
14874 /* Ignore blocks that are NULL. */
14875 if (stmt == NULL_TREE)
14878 inlined_func = inlined_function_outer_scope_p (stmt);
14880 /* If the block is one fragment of a non-contiguous block, do not
14881 process the variables, since they will have been done by the
14882 origin block. Do process subblocks. */
14883 if (BLOCK_FRAGMENT_ORIGIN (stmt))
14887 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
14888 gen_block_die (sub, context_die, depth + 1);
14893 /* Determine if we need to output any Dwarf DIEs at all to represent this
14896 /* The outer scopes for inlinings *must* always be represented. We
14897 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
14898 must_output_die = 1;
14901 /* Determine if this block directly contains any "significant"
14902 local declarations which we will need to output DIEs for. */
14903 if (debug_info_level > DINFO_LEVEL_TERSE)
14904 /* We are not in terse mode so *any* local declaration counts
14905 as being a "significant" one. */
14906 must_output_die = ((BLOCK_VARS (stmt) != NULL
14907 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
14908 && (TREE_USED (stmt)
14909 || TREE_ASM_WRITTEN (stmt)
14910 || BLOCK_ABSTRACT (stmt)));
14911 else if ((TREE_USED (stmt)
14912 || TREE_ASM_WRITTEN (stmt)
14913 || BLOCK_ABSTRACT (stmt))
14914 && !dwarf2out_ignore_block (stmt))
14915 must_output_die = 1;
14918 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
14919 DIE for any block which contains no significant local declarations at
14920 all. Rather, in such cases we just call `decls_for_scope' so that any
14921 needed Dwarf info for any sub-blocks will get properly generated. Note
14922 that in terse mode, our definition of what constitutes a "significant"
14923 local declaration gets restricted to include only inlined function
14924 instances and local (nested) function definitions. */
14925 if (must_output_die)
14928 gen_inlined_subroutine_die (stmt, context_die, depth);
14930 gen_lexical_block_die (stmt, context_die, depth);
14933 decls_for_scope (stmt, context_die, depth);
14936 /* Process variable DECL (or variable with origin ORIGIN) within
14937 block STMT and add it to CONTEXT_DIE. */
14939 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
14942 tree decl_or_origin = decl ? decl : origin;
14943 tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
14945 if (ultimate_origin)
14946 origin = ultimate_origin;
14948 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
14949 die = lookup_decl_die (decl_or_origin);
14950 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
14951 && TYPE_DECL_IS_STUB (decl_or_origin))
14952 die = lookup_type_die (TREE_TYPE (decl_or_origin));
14956 if (die != NULL && die->die_parent == NULL)
14957 add_child_die (context_die, die);
14958 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
14959 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
14960 stmt, context_die);
14962 gen_decl_die (decl, origin, context_die);
14965 /* Generate all of the decls declared within a given scope and (recursively)
14966 all of its sub-blocks. */
14969 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
14975 /* Ignore NULL blocks. */
14976 if (stmt == NULL_TREE)
14979 /* Output the DIEs to represent all of the data objects and typedefs
14980 declared directly within this block but not within any nested
14981 sub-blocks. Also, nested function and tag DIEs have been
14982 generated with a parent of NULL; fix that up now. */
14983 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
14984 process_scope_var (stmt, decl, NULL_TREE, context_die);
14985 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
14986 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
14989 /* If we're at -g1, we're not interested in subblocks. */
14990 if (debug_info_level <= DINFO_LEVEL_TERSE)
14993 /* Output the DIEs to represent all sub-blocks (and the items declared
14994 therein) of this block. */
14995 for (subblocks = BLOCK_SUBBLOCKS (stmt);
14997 subblocks = BLOCK_CHAIN (subblocks))
14998 gen_block_die (subblocks, context_die, depth + 1);
15001 /* Is this a typedef we can avoid emitting? */
15004 is_redundant_typedef (const_tree decl)
15006 if (TYPE_DECL_IS_STUB (decl))
15009 if (DECL_ARTIFICIAL (decl)
15010 && DECL_CONTEXT (decl)
15011 && is_tagged_type (DECL_CONTEXT (decl))
15012 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
15013 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
15014 /* Also ignore the artificial member typedef for the class name. */
15020 /* Returns the DIE for a context. */
15022 static inline dw_die_ref
15023 get_context_die (tree context)
15027 /* Find die that represents this context. */
15028 if (TYPE_P (context))
15029 return force_type_die (context);
15031 return force_decl_die (context);
15033 return comp_unit_die;
15036 /* Returns the DIE for decl. A DIE will always be returned. */
15039 force_decl_die (tree decl)
15041 dw_die_ref decl_die;
15042 unsigned saved_external_flag;
15043 tree save_fn = NULL_TREE;
15044 decl_die = lookup_decl_die (decl);
15047 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
15049 decl_die = lookup_decl_die (decl);
15053 switch (TREE_CODE (decl))
15055 case FUNCTION_DECL:
15056 /* Clear current_function_decl, so that gen_subprogram_die thinks
15057 that this is a declaration. At this point, we just want to force
15058 declaration die. */
15059 save_fn = current_function_decl;
15060 current_function_decl = NULL_TREE;
15061 gen_subprogram_die (decl, context_die);
15062 current_function_decl = save_fn;
15066 /* Set external flag to force declaration die. Restore it after
15067 gen_decl_die() call. */
15068 saved_external_flag = DECL_EXTERNAL (decl);
15069 DECL_EXTERNAL (decl) = 1;
15070 gen_decl_die (decl, NULL, context_die);
15071 DECL_EXTERNAL (decl) = saved_external_flag;
15074 case NAMESPACE_DECL:
15075 dwarf2out_decl (decl);
15079 gcc_unreachable ();
15082 /* We should be able to find the DIE now. */
15084 decl_die = lookup_decl_die (decl);
15085 gcc_assert (decl_die);
15091 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
15092 always returned. */
15095 force_type_die (tree type)
15097 dw_die_ref type_die;
15099 type_die = lookup_type_die (type);
15102 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
15104 type_die = modified_type_die (type, TYPE_READONLY (type),
15105 TYPE_VOLATILE (type), context_die);
15106 gcc_assert (type_die);
15111 /* Force out any required namespaces to be able to output DECL,
15112 and return the new context_die for it, if it's changed. */
15115 setup_namespace_context (tree thing, dw_die_ref context_die)
15117 tree context = (DECL_P (thing)
15118 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
15119 if (context && TREE_CODE (context) == NAMESPACE_DECL)
15120 /* Force out the namespace. */
15121 context_die = force_decl_die (context);
15123 return context_die;
15126 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
15127 type) within its namespace, if appropriate.
15129 For compatibility with older debuggers, namespace DIEs only contain
15130 declarations; all definitions are emitted at CU scope. */
15133 declare_in_namespace (tree thing, dw_die_ref context_die)
15135 dw_die_ref ns_context;
15137 if (debug_info_level <= DINFO_LEVEL_TERSE)
15138 return context_die;
15140 /* If this decl is from an inlined function, then don't try to emit it in its
15141 namespace, as we will get confused. It would have already been emitted
15142 when the abstract instance of the inline function was emitted anyways. */
15143 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
15144 return context_die;
15146 ns_context = setup_namespace_context (thing, context_die);
15148 if (ns_context != context_die)
15152 if (DECL_P (thing))
15153 gen_decl_die (thing, NULL, ns_context);
15155 gen_type_die (thing, ns_context);
15157 return context_die;
15160 /* Generate a DIE for a namespace or namespace alias. */
15163 gen_namespace_die (tree decl)
15165 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
15167 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
15168 they are an alias of. */
15169 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
15171 /* Output a real namespace or module. */
15172 dw_die_ref namespace_die
15173 = new_die (is_fortran () ? DW_TAG_module : DW_TAG_namespace,
15174 context_die, decl);
15175 /* For Fortran modules defined in different CU don't add src coords. */
15176 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
15177 add_name_attribute (namespace_die, dwarf2_name (decl, 0));
15179 add_name_and_src_coords_attributes (namespace_die, decl);
15180 if (DECL_EXTERNAL (decl))
15181 add_AT_flag (namespace_die, DW_AT_declaration, 1);
15182 equate_decl_number_to_die (decl, namespace_die);
15186 /* Output a namespace alias. */
15188 /* Force out the namespace we are an alias of, if necessary. */
15189 dw_die_ref origin_die
15190 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
15192 /* Now create the namespace alias DIE. */
15193 dw_die_ref namespace_die
15194 = new_die (DW_TAG_imported_declaration, context_die, decl);
15195 add_name_and_src_coords_attributes (namespace_die, decl);
15196 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
15197 equate_decl_number_to_die (decl, namespace_die);
15201 /* Generate Dwarf debug information for a decl described by DECL. */
15204 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
15206 tree decl_or_origin = decl ? decl : origin;
15207 tree class_origin = NULL;
15209 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
15212 switch (TREE_CODE (decl_or_origin))
15218 if (!is_fortran ())
15220 /* The individual enumerators of an enum type get output when we output
15221 the Dwarf representation of the relevant enum type itself. */
15225 /* Emit its type. */
15226 gen_type_die (TREE_TYPE (decl), context_die);
15228 /* And its containing namespace. */
15229 context_die = declare_in_namespace (decl, context_die);
15231 gen_const_die (decl, context_die);
15234 case FUNCTION_DECL:
15235 /* Don't output any DIEs to represent mere function declarations,
15236 unless they are class members or explicit block externs. */
15237 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
15238 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
15239 && (current_function_decl == NULL_TREE
15240 || DECL_ARTIFICIAL (decl_or_origin)))
15245 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
15246 on local redeclarations of global functions. That seems broken. */
15247 if (current_function_decl != decl)
15248 /* This is only a declaration. */;
15251 /* If we're emitting a clone, emit info for the abstract instance. */
15252 if (origin || DECL_ORIGIN (decl) != decl)
15253 dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
15255 /* If we're emitting an out-of-line copy of an inline function,
15256 emit info for the abstract instance and set up to refer to it. */
15257 else if (cgraph_function_possibly_inlined_p (decl)
15258 && ! DECL_ABSTRACT (decl)
15259 && ! class_or_namespace_scope_p (context_die)
15260 /* dwarf2out_abstract_function won't emit a die if this is just
15261 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
15262 that case, because that works only if we have a die. */
15263 && DECL_INITIAL (decl) != NULL_TREE)
15265 dwarf2out_abstract_function (decl);
15266 set_decl_origin_self (decl);
15269 /* Otherwise we're emitting the primary DIE for this decl. */
15270 else if (debug_info_level > DINFO_LEVEL_TERSE)
15272 /* Before we describe the FUNCTION_DECL itself, make sure that we
15273 have described its return type. */
15274 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
15276 /* And its virtual context. */
15277 if (DECL_VINDEX (decl) != NULL_TREE)
15278 gen_type_die (DECL_CONTEXT (decl), context_die);
15280 /* And its containing type. */
15282 origin = decl_class_context (decl);
15283 if (origin != NULL_TREE)
15284 gen_type_die_for_member (origin, decl, context_die);
15286 /* And its containing namespace. */
15287 context_die = declare_in_namespace (decl, context_die);
15290 /* Now output a DIE to represent the function itself. */
15292 gen_subprogram_die (decl, context_die);
15296 /* If we are in terse mode, don't generate any DIEs to represent any
15297 actual typedefs. */
15298 if (debug_info_level <= DINFO_LEVEL_TERSE)
15301 /* In the special case of a TYPE_DECL node representing the declaration
15302 of some type tag, if the given TYPE_DECL is marked as having been
15303 instantiated from some other (original) TYPE_DECL node (e.g. one which
15304 was generated within the original definition of an inline function) we
15305 have to generate a special (abbreviated) DW_TAG_structure_type,
15306 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
15307 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE
15308 && is_tagged_type (TREE_TYPE (decl)))
15310 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
15314 if (is_redundant_typedef (decl))
15315 gen_type_die (TREE_TYPE (decl), context_die);
15317 /* Output a DIE to represent the typedef itself. */
15318 gen_typedef_die (decl, context_die);
15322 if (debug_info_level >= DINFO_LEVEL_NORMAL)
15323 gen_label_die (decl, context_die);
15328 /* If we are in terse mode, don't generate any DIEs to represent any
15329 variable declarations or definitions. */
15330 if (debug_info_level <= DINFO_LEVEL_TERSE)
15333 /* Output any DIEs that are needed to specify the type of this data
15335 if (TREE_CODE (decl_or_origin) == RESULT_DECL
15336 && DECL_BY_REFERENCE (decl_or_origin))
15337 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15339 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15341 /* And its containing type. */
15342 class_origin = decl_class_context (decl_or_origin);
15343 if (class_origin != NULL_TREE)
15344 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
15346 /* And its containing namespace. */
15347 context_die = declare_in_namespace (decl_or_origin, context_die);
15349 /* Now output the DIE to represent the data object itself. This gets
15350 complicated because of the possibility that the VAR_DECL really
15351 represents an inlined instance of a formal parameter for an inline
15354 origin = decl_ultimate_origin (decl);
15355 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
15356 gen_formal_parameter_die (decl, origin, context_die);
15358 gen_variable_die (decl, origin, context_die);
15362 /* Ignore the nameless fields that are used to skip bits but handle C++
15363 anonymous unions and structs. */
15364 if (DECL_NAME (decl) != NULL_TREE
15365 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
15366 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
15368 gen_type_die (member_declared_type (decl), context_die);
15369 gen_field_die (decl, context_die);
15374 if (DECL_BY_REFERENCE (decl_or_origin))
15375 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
15377 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
15378 gen_formal_parameter_die (decl, origin, context_die);
15381 case NAMESPACE_DECL:
15382 case IMPORTED_DECL:
15383 gen_namespace_die (decl);
15387 /* Probably some frontend-internal decl. Assume we don't care. */
15388 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
15393 /* Output debug information for global decl DECL. Called from toplev.c after
15394 compilation proper has finished. */
15397 dwarf2out_global_decl (tree decl)
15399 /* Output DWARF2 information for file-scope tentative data object
15400 declarations, file-scope (extern) function declarations (which
15401 had no corresponding body) and file-scope tagged type declarations
15402 and definitions which have not yet been forced out. */
15403 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
15404 dwarf2out_decl (decl);
15407 /* Output debug information for type decl DECL. Called from toplev.c
15408 and from language front ends (to record built-in types). */
15410 dwarf2out_type_decl (tree decl, int local)
15413 dwarf2out_decl (decl);
15416 /* Output debug information for imported module or decl DECL.
15417 NAME is non-NULL name in the lexical block if the decl has been renamed.
15418 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
15419 that DECL belongs to.
15420 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
15422 dwarf2out_imported_module_or_decl_1 (tree decl,
15424 tree lexical_block,
15425 dw_die_ref lexical_block_die)
15427 expanded_location xloc;
15428 dw_die_ref imported_die = NULL;
15429 dw_die_ref at_import_die;
15431 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
15433 if (is_base_type (TREE_TYPE (decl)))
15434 at_import_die = base_type_die (TREE_TYPE (decl));
15436 at_import_die = force_type_die (TREE_TYPE (decl));
15437 /* For namespace N { typedef void T; } using N::T; base_type_die
15438 returns NULL, but DW_TAG_imported_declaration requires
15439 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
15440 if (!at_import_die)
15442 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
15443 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
15444 at_import_die = lookup_type_die (TREE_TYPE (decl));
15445 gcc_assert (at_import_die);
15448 else if (TREE_CODE (decl) == IMPORTED_DECL)
15450 tree imported_ns_decl;
15451 /* IMPORTED_DECL nodes that are not imported namespace are just not
15453 gcc_assert (DECL_INITIAL (decl)
15454 && TREE_CODE (DECL_INITIAL (decl)) == NAMESPACE_DECL);
15455 imported_ns_decl = DECL_INITIAL (decl);
15456 at_import_die = lookup_decl_die (imported_ns_decl);
15457 if (!at_import_die)
15458 at_import_die = force_decl_die (imported_ns_decl);
15459 gcc_assert (at_import_die);
15463 at_import_die = lookup_decl_die (decl);
15464 if (!at_import_die)
15466 /* If we're trying to avoid duplicate debug info, we may not have
15467 emitted the member decl for this field. Emit it now. */
15468 if (TREE_CODE (decl) == FIELD_DECL)
15470 tree type = DECL_CONTEXT (decl);
15472 if (TYPE_CONTEXT (type)
15473 && TYPE_P (TYPE_CONTEXT (type))
15474 && !should_emit_struct_debug (TYPE_CONTEXT (type),
15475 DINFO_USAGE_DIR_USE))
15477 gen_type_die_for_member (type, decl,
15478 get_context_die (TYPE_CONTEXT (type)));
15480 at_import_die = force_decl_die (decl);
15484 if (TREE_CODE (decl) == NAMESPACE_DECL)
15485 imported_die = new_die (DW_TAG_imported_module,
15489 imported_die = new_die (DW_TAG_imported_declaration,
15493 xloc = expand_location (input_location);
15494 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
15495 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
15497 add_AT_string (imported_die, DW_AT_name,
15498 IDENTIFIER_POINTER (name));
15499 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
15502 /* Output debug information for imported module or decl DECL.
15503 NAME is non-NULL name in context if the decl has been renamed.
15504 CHILD is true if decl is one of the renamed decls as part of
15505 importing whole module. */
15508 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
15511 /* dw_die_ref at_import_die; */
15512 dw_die_ref scope_die;
15514 if (debug_info_level <= DINFO_LEVEL_TERSE)
15519 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
15520 We need decl DIE for reference and scope die. First, get DIE for the decl
15523 /* Get the scope die for decl context. Use comp_unit_die for global module
15524 or decl. If die is not found for non globals, force new die. */
15526 && TYPE_P (context)
15527 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
15529 scope_die = get_context_die (context);
15533 gcc_assert (scope_die->die_child);
15534 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
15535 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
15536 scope_die = scope_die->die_child;
15539 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
15540 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
15544 /* Write the debugging output for DECL. */
15547 dwarf2out_decl (tree decl)
15549 dw_die_ref context_die = comp_unit_die;
15551 switch (TREE_CODE (decl))
15556 case FUNCTION_DECL:
15557 /* What we would really like to do here is to filter out all mere
15558 file-scope declarations of file-scope functions which are never
15559 referenced later within this translation unit (and keep all of ones
15560 that *are* referenced later on) but we aren't clairvoyant, so we have
15561 no idea which functions will be referenced in the future (i.e. later
15562 on within the current translation unit). So here we just ignore all
15563 file-scope function declarations which are not also definitions. If
15564 and when the debugger needs to know something about these functions,
15565 it will have to hunt around and find the DWARF information associated
15566 with the definition of the function.
15568 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
15569 nodes represent definitions and which ones represent mere
15570 declarations. We have to check DECL_INITIAL instead. That's because
15571 the C front-end supports some weird semantics for "extern inline"
15572 function definitions. These can get inlined within the current
15573 translation unit (and thus, we need to generate Dwarf info for their
15574 abstract instances so that the Dwarf info for the concrete inlined
15575 instances can have something to refer to) but the compiler never
15576 generates any out-of-lines instances of such things (despite the fact
15577 that they *are* definitions).
15579 The important point is that the C front-end marks these "extern
15580 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
15581 them anyway. Note that the C++ front-end also plays some similar games
15582 for inline function definitions appearing within include files which
15583 also contain `#pragma interface' pragmas. */
15584 if (DECL_INITIAL (decl) == NULL_TREE)
15587 /* If we're a nested function, initially use a parent of NULL; if we're
15588 a plain function, this will be fixed up in decls_for_scope. If
15589 we're a method, it will be ignored, since we already have a DIE. */
15590 if (decl_function_context (decl)
15591 /* But if we're in terse mode, we don't care about scope. */
15592 && debug_info_level > DINFO_LEVEL_TERSE)
15593 context_die = NULL;
15597 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
15598 declaration and if the declaration was never even referenced from
15599 within this entire compilation unit. We suppress these DIEs in
15600 order to save space in the .debug section (by eliminating entries
15601 which are probably useless). Note that we must not suppress
15602 block-local extern declarations (whether used or not) because that
15603 would screw-up the debugger's name lookup mechanism and cause it to
15604 miss things which really ought to be in scope at a given point. */
15605 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
15608 /* For local statics lookup proper context die. */
15609 if (TREE_STATIC (decl) && decl_function_context (decl))
15610 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15612 /* If we are in terse mode, don't generate any DIEs to represent any
15613 variable declarations or definitions. */
15614 if (debug_info_level <= DINFO_LEVEL_TERSE)
15619 if (debug_info_level <= DINFO_LEVEL_TERSE)
15621 if (!is_fortran ())
15623 if (TREE_STATIC (decl) && decl_function_context (decl))
15624 context_die = lookup_decl_die (DECL_CONTEXT (decl));
15627 case NAMESPACE_DECL:
15628 case IMPORTED_DECL:
15629 if (debug_info_level <= DINFO_LEVEL_TERSE)
15631 if (lookup_decl_die (decl) != NULL)
15636 /* Don't emit stubs for types unless they are needed by other DIEs. */
15637 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
15640 /* Don't bother trying to generate any DIEs to represent any of the
15641 normal built-in types for the language we are compiling. */
15642 if (DECL_IS_BUILTIN (decl))
15644 /* OK, we need to generate one for `bool' so GDB knows what type
15645 comparisons have. */
15647 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
15648 && ! DECL_IGNORED_P (decl))
15649 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
15654 /* If we are in terse mode, don't generate any DIEs for types. */
15655 if (debug_info_level <= DINFO_LEVEL_TERSE)
15658 /* If we're a function-scope tag, initially use a parent of NULL;
15659 this will be fixed up in decls_for_scope. */
15660 if (decl_function_context (decl))
15661 context_die = NULL;
15669 gen_decl_die (decl, NULL, context_die);
15672 /* Output a marker (i.e. a label) for the beginning of the generated code for
15673 a lexical block. */
15676 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
15677 unsigned int blocknum)
15679 switch_to_section (current_function_section ());
15680 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
15683 /* Output a marker (i.e. a label) for the end of the generated code for a
15687 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
15689 switch_to_section (current_function_section ());
15690 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
15693 /* Returns nonzero if it is appropriate not to emit any debugging
15694 information for BLOCK, because it doesn't contain any instructions.
15696 Don't allow this for blocks with nested functions or local classes
15697 as we would end up with orphans, and in the presence of scheduling
15698 we may end up calling them anyway. */
15701 dwarf2out_ignore_block (const_tree block)
15706 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
15707 if (TREE_CODE (decl) == FUNCTION_DECL
15708 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15710 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
15712 decl = BLOCK_NONLOCALIZED_VAR (block, i);
15713 if (TREE_CODE (decl) == FUNCTION_DECL
15714 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
15721 /* Hash table routines for file_hash. */
15724 file_table_eq (const void *p1_p, const void *p2_p)
15726 const struct dwarf_file_data *const p1 =
15727 (const struct dwarf_file_data *) p1_p;
15728 const char *const p2 = (const char *) p2_p;
15729 return strcmp (p1->filename, p2) == 0;
15733 file_table_hash (const void *p_p)
15735 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
15736 return htab_hash_string (p->filename);
15739 /* Lookup FILE_NAME (in the list of filenames that we know about here in
15740 dwarf2out.c) and return its "index". The index of each (known) filename is
15741 just a unique number which is associated with only that one filename. We
15742 need such numbers for the sake of generating labels (in the .debug_sfnames
15743 section) and references to those files numbers (in the .debug_srcinfo
15744 and.debug_macinfo sections). If the filename given as an argument is not
15745 found in our current list, add it to the list and assign it the next
15746 available unique index number. In order to speed up searches, we remember
15747 the index of the filename was looked up last. This handles the majority of
15750 static struct dwarf_file_data *
15751 lookup_filename (const char *file_name)
15754 struct dwarf_file_data * created;
15756 /* Check to see if the file name that was searched on the previous
15757 call matches this file name. If so, return the index. */
15758 if (file_table_last_lookup
15759 && (file_name == file_table_last_lookup->filename
15760 || strcmp (file_table_last_lookup->filename, file_name) == 0))
15761 return file_table_last_lookup;
15763 /* Didn't match the previous lookup, search the table. */
15764 slot = htab_find_slot_with_hash (file_table, file_name,
15765 htab_hash_string (file_name), INSERT);
15767 return (struct dwarf_file_data *) *slot;
15769 created = GGC_NEW (struct dwarf_file_data);
15770 created->filename = file_name;
15771 created->emitted_number = 0;
15776 /* If the assembler will construct the file table, then translate the compiler
15777 internal file table number into the assembler file table number, and emit
15778 a .file directive if we haven't already emitted one yet. The file table
15779 numbers are different because we prune debug info for unused variables and
15780 types, which may include filenames. */
15783 maybe_emit_file (struct dwarf_file_data * fd)
15785 if (! fd->emitted_number)
15787 if (last_emitted_file)
15788 fd->emitted_number = last_emitted_file->emitted_number + 1;
15790 fd->emitted_number = 1;
15791 last_emitted_file = fd;
15793 if (DWARF2_ASM_LINE_DEBUG_INFO)
15795 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
15796 output_quoted_string (asm_out_file,
15797 remap_debug_filename (fd->filename));
15798 fputc ('\n', asm_out_file);
15802 return fd->emitted_number;
15805 /* Called by the final INSN scan whenever we see a var location. We
15806 use it to drop labels in the right places, and throw the location in
15807 our lookup table. */
15810 dwarf2out_var_location (rtx loc_note)
15812 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
15813 struct var_loc_node *newloc;
15815 static rtx last_insn;
15816 static const char *last_label;
15819 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
15821 prev_insn = PREV_INSN (loc_note);
15823 newloc = GGC_CNEW (struct var_loc_node);
15824 /* If the insn we processed last time is the previous insn
15825 and it is also a var location note, use the label we emitted
15827 if (last_insn != NULL_RTX
15828 && last_insn == prev_insn
15829 && NOTE_P (prev_insn)
15830 && NOTE_KIND (prev_insn) == NOTE_INSN_VAR_LOCATION)
15832 newloc->label = last_label;
15836 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
15837 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
15839 newloc->label = ggc_strdup (loclabel);
15841 newloc->var_loc_note = loc_note;
15842 newloc->next = NULL;
15844 if (cfun && in_cold_section_p)
15845 newloc->section_label = crtl->subsections.cold_section_label;
15847 newloc->section_label = text_section_label;
15849 last_insn = loc_note;
15850 last_label = newloc->label;
15851 decl = NOTE_VAR_LOCATION_DECL (loc_note);
15852 add_var_loc_to_decl (decl, newloc);
15855 /* We need to reset the locations at the beginning of each
15856 function. We can't do this in the end_function hook, because the
15857 declarations that use the locations won't have been output when
15858 that hook is called. Also compute have_multiple_function_sections here. */
15861 dwarf2out_begin_function (tree fun)
15863 htab_empty (decl_loc_table);
15865 if (function_section (fun) != text_section)
15866 have_multiple_function_sections = true;
15868 dwarf2out_note_section_used ();
15871 /* Output a label to mark the beginning of a source code line entry
15872 and record information relating to this source line, in
15873 'line_info_table' for later output of the .debug_line section. */
15876 dwarf2out_source_line (unsigned int line, const char *filename)
15878 if (debug_info_level >= DINFO_LEVEL_NORMAL
15881 int file_num = maybe_emit_file (lookup_filename (filename));
15883 switch_to_section (current_function_section ());
15885 /* If requested, emit something human-readable. */
15886 if (flag_debug_asm)
15887 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
15890 if (DWARF2_ASM_LINE_DEBUG_INFO)
15892 /* Emit the .loc directive understood by GNU as. */
15893 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
15895 /* Indicate that line number info exists. */
15896 line_info_table_in_use++;
15898 else if (function_section (current_function_decl) != text_section)
15900 dw_separate_line_info_ref line_info;
15901 targetm.asm_out.internal_label (asm_out_file,
15902 SEPARATE_LINE_CODE_LABEL,
15903 separate_line_info_table_in_use);
15905 /* Expand the line info table if necessary. */
15906 if (separate_line_info_table_in_use
15907 == separate_line_info_table_allocated)
15909 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15910 separate_line_info_table
15911 = GGC_RESIZEVEC (dw_separate_line_info_entry,
15912 separate_line_info_table,
15913 separate_line_info_table_allocated);
15914 memset (separate_line_info_table
15915 + separate_line_info_table_in_use,
15917 (LINE_INFO_TABLE_INCREMENT
15918 * sizeof (dw_separate_line_info_entry)));
15921 /* Add the new entry at the end of the line_info_table. */
15923 = &separate_line_info_table[separate_line_info_table_in_use++];
15924 line_info->dw_file_num = file_num;
15925 line_info->dw_line_num = line;
15926 line_info->function = current_function_funcdef_no;
15930 dw_line_info_ref line_info;
15932 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
15933 line_info_table_in_use);
15935 /* Expand the line info table if necessary. */
15936 if (line_info_table_in_use == line_info_table_allocated)
15938 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
15940 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
15941 line_info_table_allocated);
15942 memset (line_info_table + line_info_table_in_use, 0,
15943 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
15946 /* Add the new entry at the end of the line_info_table. */
15947 line_info = &line_info_table[line_info_table_in_use++];
15948 line_info->dw_file_num = file_num;
15949 line_info->dw_line_num = line;
15954 /* Record the beginning of a new source file. */
15957 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
15959 if (flag_eliminate_dwarf2_dups)
15961 /* Record the beginning of the file for break_out_includes. */
15962 dw_die_ref bincl_die;
15964 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
15965 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
15968 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15970 int file_num = maybe_emit_file (lookup_filename (filename));
15972 switch_to_section (debug_macinfo_section);
15973 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
15974 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
15977 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
15981 /* Record the end of a source file. */
15984 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
15986 if (flag_eliminate_dwarf2_dups)
15987 /* Record the end of the file for break_out_includes. */
15988 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
15990 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
15992 switch_to_section (debug_macinfo_section);
15993 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
15997 /* Called from debug_define in toplev.c. The `buffer' parameter contains
15998 the tail part of the directive line, i.e. the part which is past the
15999 initial whitespace, #, whitespace, directive-name, whitespace part. */
16002 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
16003 const char *buffer ATTRIBUTE_UNUSED)
16005 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16007 switch_to_section (debug_macinfo_section);
16008 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
16009 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
16010 dw2_asm_output_nstring (buffer, -1, "The macro");
16014 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
16015 the tail part of the directive line, i.e. the part which is past the
16016 initial whitespace, #, whitespace, directive-name, whitespace part. */
16019 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
16020 const char *buffer ATTRIBUTE_UNUSED)
16022 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16024 switch_to_section (debug_macinfo_section);
16025 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
16026 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
16027 dw2_asm_output_nstring (buffer, -1, "The macro");
16031 /* Set up for Dwarf output at the start of compilation. */
16034 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
16036 /* Allocate the file_table. */
16037 file_table = htab_create_ggc (50, file_table_hash,
16038 file_table_eq, NULL);
16040 /* Allocate the decl_die_table. */
16041 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
16042 decl_die_table_eq, NULL);
16044 /* Allocate the decl_loc_table. */
16045 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
16046 decl_loc_table_eq, NULL);
16048 /* Allocate the initial hunk of the decl_scope_table. */
16049 decl_scope_table = VEC_alloc (tree, gc, 256);
16051 /* Allocate the initial hunk of the abbrev_die_table. */
16052 abbrev_die_table = GGC_CNEWVEC (dw_die_ref, ABBREV_DIE_TABLE_INCREMENT);
16053 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
16054 /* Zero-th entry is allocated, but unused. */
16055 abbrev_die_table_in_use = 1;
16057 /* Allocate the initial hunk of the line_info_table. */
16058 line_info_table = GGC_CNEWVEC (dw_line_info_entry, LINE_INFO_TABLE_INCREMENT);
16059 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
16061 /* Zero-th entry is allocated, but unused. */
16062 line_info_table_in_use = 1;
16064 /* Allocate the pubtypes and pubnames vectors. */
16065 pubname_table = VEC_alloc (pubname_entry, gc, 32);
16066 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
16068 /* Generate the initial DIE for the .debug section. Note that the (string)
16069 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
16070 will (typically) be a relative pathname and that this pathname should be
16071 taken as being relative to the directory from which the compiler was
16072 invoked when the given (base) source file was compiled. We will fill
16073 in this value in dwarf2out_finish. */
16074 comp_unit_die = gen_compile_unit_die (NULL);
16076 incomplete_types = VEC_alloc (tree, gc, 64);
16078 used_rtx_array = VEC_alloc (rtx, gc, 32);
16080 debug_info_section = get_section (DEBUG_INFO_SECTION,
16081 SECTION_DEBUG, NULL);
16082 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
16083 SECTION_DEBUG, NULL);
16084 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
16085 SECTION_DEBUG, NULL);
16086 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
16087 SECTION_DEBUG, NULL);
16088 debug_line_section = get_section (DEBUG_LINE_SECTION,
16089 SECTION_DEBUG, NULL);
16090 debug_loc_section = get_section (DEBUG_LOC_SECTION,
16091 SECTION_DEBUG, NULL);
16092 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
16093 SECTION_DEBUG, NULL);
16094 #ifdef DEBUG_PUBTYPES_SECTION
16095 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
16096 SECTION_DEBUG, NULL);
16098 debug_str_section = get_section (DEBUG_STR_SECTION,
16099 DEBUG_STR_SECTION_FLAGS, NULL);
16100 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
16101 SECTION_DEBUG, NULL);
16102 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
16103 SECTION_DEBUG, NULL);
16105 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
16106 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
16107 DEBUG_ABBREV_SECTION_LABEL, 0);
16108 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
16109 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
16110 COLD_TEXT_SECTION_LABEL, 0);
16111 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
16113 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
16114 DEBUG_INFO_SECTION_LABEL, 0);
16115 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
16116 DEBUG_LINE_SECTION_LABEL, 0);
16117 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
16118 DEBUG_RANGES_SECTION_LABEL, 0);
16119 switch_to_section (debug_abbrev_section);
16120 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
16121 switch_to_section (debug_info_section);
16122 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
16123 switch_to_section (debug_line_section);
16124 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
16126 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16128 switch_to_section (debug_macinfo_section);
16129 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
16130 DEBUG_MACINFO_SECTION_LABEL, 0);
16131 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
16134 switch_to_section (text_section);
16135 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
16136 if (flag_reorder_blocks_and_partition)
16138 cold_text_section = unlikely_text_section ();
16139 switch_to_section (cold_text_section);
16140 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
16144 /* A helper function for dwarf2out_finish called through
16145 ht_forall. Emit one queued .debug_str string. */
16148 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
16150 struct indirect_string_node *node = (struct indirect_string_node *) *h;
16152 if (node->form == DW_FORM_strp)
16154 switch_to_section (debug_str_section);
16155 ASM_OUTPUT_LABEL (asm_out_file, node->label);
16156 assemble_string (node->str, strlen (node->str) + 1);
16162 #if ENABLE_ASSERT_CHECKING
16163 /* Verify that all marks are clear. */
16166 verify_marks_clear (dw_die_ref die)
16170 gcc_assert (! die->die_mark);
16171 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
16173 #endif /* ENABLE_ASSERT_CHECKING */
16175 /* Clear the marks for a die and its children.
16176 Be cool if the mark isn't set. */
16179 prune_unmark_dies (dw_die_ref die)
16185 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
16188 /* Given DIE that we're marking as used, find any other dies
16189 it references as attributes and mark them as used. */
16192 prune_unused_types_walk_attribs (dw_die_ref die)
16197 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16199 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
16201 /* A reference to another DIE.
16202 Make sure that it will get emitted. */
16203 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
16205 /* Set the string's refcount to 0 so that prune_unused_types_mark
16206 accounts properly for it. */
16207 if (AT_class (a) == dw_val_class_str)
16208 a->dw_attr_val.v.val_str->refcount = 0;
16213 /* Mark DIE as being used. If DOKIDS is true, then walk down
16214 to DIE's children. */
16217 prune_unused_types_mark (dw_die_ref die, int dokids)
16221 if (die->die_mark == 0)
16223 /* We haven't done this node yet. Mark it as used. */
16226 /* We also have to mark its parents as used.
16227 (But we don't want to mark our parents' kids due to this.) */
16228 if (die->die_parent)
16229 prune_unused_types_mark (die->die_parent, 0);
16231 /* Mark any referenced nodes. */
16232 prune_unused_types_walk_attribs (die);
16234 /* If this node is a specification,
16235 also mark the definition, if it exists. */
16236 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
16237 prune_unused_types_mark (die->die_definition, 1);
16240 if (dokids && die->die_mark != 2)
16242 /* We need to walk the children, but haven't done so yet.
16243 Remember that we've walked the kids. */
16246 /* If this is an array type, we need to make sure our
16247 kids get marked, even if they're types. */
16248 if (die->die_tag == DW_TAG_array_type)
16249 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
16251 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16255 /* For local classes, look if any static member functions were emitted
16256 and if so, mark them. */
16259 prune_unused_types_walk_local_classes (dw_die_ref die)
16263 if (die->die_mark == 2)
16266 switch (die->die_tag)
16268 case DW_TAG_structure_type:
16269 case DW_TAG_union_type:
16270 case DW_TAG_class_type:
16273 case DW_TAG_subprogram:
16274 if (!get_AT_flag (die, DW_AT_declaration)
16275 || die->die_definition != NULL)
16276 prune_unused_types_mark (die, 1);
16283 /* Mark children. */
16284 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
16287 /* Walk the tree DIE and mark types that we actually use. */
16290 prune_unused_types_walk (dw_die_ref die)
16294 /* Don't do anything if this node is already marked and
16295 children have been marked as well. */
16296 if (die->die_mark == 2)
16299 switch (die->die_tag)
16301 case DW_TAG_structure_type:
16302 case DW_TAG_union_type:
16303 case DW_TAG_class_type:
16304 if (die->die_perennial_p)
16307 for (c = die->die_parent; c; c = c->die_parent)
16308 if (c->die_tag == DW_TAG_subprogram)
16311 /* Finding used static member functions inside of classes
16312 is needed just for local classes, because for other classes
16313 static member function DIEs with DW_AT_specification
16314 are emitted outside of the DW_TAG_*_type. If we ever change
16315 it, we'd need to call this even for non-local classes. */
16317 prune_unused_types_walk_local_classes (die);
16319 /* It's a type node --- don't mark it. */
16322 case DW_TAG_const_type:
16323 case DW_TAG_packed_type:
16324 case DW_TAG_pointer_type:
16325 case DW_TAG_reference_type:
16326 case DW_TAG_volatile_type:
16327 case DW_TAG_typedef:
16328 case DW_TAG_array_type:
16329 case DW_TAG_interface_type:
16330 case DW_TAG_friend:
16331 case DW_TAG_variant_part:
16332 case DW_TAG_enumeration_type:
16333 case DW_TAG_subroutine_type:
16334 case DW_TAG_string_type:
16335 case DW_TAG_set_type:
16336 case DW_TAG_subrange_type:
16337 case DW_TAG_ptr_to_member_type:
16338 case DW_TAG_file_type:
16339 if (die->die_perennial_p)
16342 /* It's a type node --- don't mark it. */
16346 /* Mark everything else. */
16350 if (die->die_mark == 0)
16354 /* Now, mark any dies referenced from here. */
16355 prune_unused_types_walk_attribs (die);
16360 /* Mark children. */
16361 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
16364 /* Increment the string counts on strings referred to from DIE's
16368 prune_unused_types_update_strings (dw_die_ref die)
16373 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
16374 if (AT_class (a) == dw_val_class_str)
16376 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
16378 /* Avoid unnecessarily putting strings that are used less than
16379 twice in the hash table. */
16381 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
16384 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
16385 htab_hash_string (s->str),
16387 gcc_assert (*slot == NULL);
16393 /* Remove from the tree DIE any dies that aren't marked. */
16396 prune_unused_types_prune (dw_die_ref die)
16400 gcc_assert (die->die_mark);
16401 prune_unused_types_update_strings (die);
16403 if (! die->die_child)
16406 c = die->die_child;
16408 dw_die_ref prev = c;
16409 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
16410 if (c == die->die_child)
16412 /* No marked children between 'prev' and the end of the list. */
16414 /* No marked children at all. */
16415 die->die_child = NULL;
16418 prev->die_sib = c->die_sib;
16419 die->die_child = prev;
16424 if (c != prev->die_sib)
16426 prune_unused_types_prune (c);
16427 } while (c != die->die_child);
16431 /* Remove dies representing declarations that we never use. */
16434 prune_unused_types (void)
16437 limbo_die_node *node;
16440 #if ENABLE_ASSERT_CHECKING
16441 /* All the marks should already be clear. */
16442 verify_marks_clear (comp_unit_die);
16443 for (node = limbo_die_list; node; node = node->next)
16444 verify_marks_clear (node->die);
16445 #endif /* ENABLE_ASSERT_CHECKING */
16447 /* Set the mark on nodes that are actually used. */
16448 prune_unused_types_walk (comp_unit_die);
16449 for (node = limbo_die_list; node; node = node->next)
16450 prune_unused_types_walk (node->die);
16452 /* Also set the mark on nodes referenced from the
16453 pubname_table or arange_table. */
16454 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
16455 prune_unused_types_mark (pub->die, 1);
16456 for (i = 0; i < arange_table_in_use; i++)
16457 prune_unused_types_mark (arange_table[i], 1);
16459 /* Get rid of nodes that aren't marked; and update the string counts. */
16460 if (debug_str_hash)
16461 htab_empty (debug_str_hash);
16462 prune_unused_types_prune (comp_unit_die);
16463 for (node = limbo_die_list; node; node = node->next)
16464 prune_unused_types_prune (node->die);
16466 /* Leave the marks clear. */
16467 prune_unmark_dies (comp_unit_die);
16468 for (node = limbo_die_list; node; node = node->next)
16469 prune_unmark_dies (node->die);
16472 /* Set the parameter to true if there are any relative pathnames in
16475 file_table_relative_p (void ** slot, void *param)
16477 bool *p = (bool *) param;
16478 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
16479 if (!IS_ABSOLUTE_PATH (d->filename))
16487 /* Output stuff that dwarf requires at the end of every file,
16488 and generate the DWARF-2 debugging info. */
16491 dwarf2out_finish (const char *filename)
16493 limbo_die_node *node, *next_node;
16494 dw_die_ref die = 0;
16497 /* Add the name for the main input file now. We delayed this from
16498 dwarf2out_init to avoid complications with PCH. */
16499 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
16500 if (!IS_ABSOLUTE_PATH (filename))
16501 add_comp_dir_attribute (comp_unit_die);
16502 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
16505 htab_traverse (file_table, file_table_relative_p, &p);
16507 add_comp_dir_attribute (comp_unit_die);
16510 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
16512 add_location_or_const_value_attribute (
16513 VEC_index (deferred_locations, deferred_locations_list, i)->die,
16514 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
16518 /* Traverse the limbo die list, and add parent/child links. The only
16519 dies without parents that should be here are concrete instances of
16520 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
16521 For concrete instances, we can get the parent die from the abstract
16523 for (node = limbo_die_list; node; node = next_node)
16525 next_node = node->next;
16528 if (die->die_parent == NULL)
16530 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
16533 add_child_die (origin->die_parent, die);
16534 else if (die == comp_unit_die)
16536 else if (errorcount > 0 || sorrycount > 0)
16537 /* It's OK to be confused by errors in the input. */
16538 add_child_die (comp_unit_die, die);
16541 /* In certain situations, the lexical block containing a
16542 nested function can be optimized away, which results
16543 in the nested function die being orphaned. Likewise
16544 with the return type of that nested function. Force
16545 this to be a child of the containing function.
16547 It may happen that even the containing function got fully
16548 inlined and optimized out. In that case we are lost and
16549 assign the empty child. This should not be big issue as
16550 the function is likely unreachable too. */
16551 tree context = NULL_TREE;
16553 gcc_assert (node->created_for);
16555 if (DECL_P (node->created_for))
16556 context = DECL_CONTEXT (node->created_for);
16557 else if (TYPE_P (node->created_for))
16558 context = TYPE_CONTEXT (node->created_for);
16560 gcc_assert (context
16561 && (TREE_CODE (context) == FUNCTION_DECL
16562 || TREE_CODE (context) == NAMESPACE_DECL));
16564 origin = lookup_decl_die (context);
16566 add_child_die (origin, die);
16568 add_child_die (comp_unit_die, die);
16573 limbo_die_list = NULL;
16575 /* Walk through the list of incomplete types again, trying once more to
16576 emit full debugging info for them. */
16577 retry_incomplete_types ();
16579 if (flag_eliminate_unused_debug_types)
16580 prune_unused_types ();
16582 /* Generate separate CUs for each of the include files we've seen.
16583 They will go into limbo_die_list. */
16584 if (flag_eliminate_dwarf2_dups)
16585 break_out_includes (comp_unit_die);
16587 /* Traverse the DIE's and add add sibling attributes to those DIE's
16588 that have children. */
16589 add_sibling_attributes (comp_unit_die);
16590 for (node = limbo_die_list; node; node = node->next)
16591 add_sibling_attributes (node->die);
16593 /* Output a terminator label for the .text section. */
16594 switch_to_section (text_section);
16595 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
16596 if (flag_reorder_blocks_and_partition)
16598 switch_to_section (unlikely_text_section ());
16599 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
16602 /* We can only use the low/high_pc attributes if all of the code was
16604 if (!have_multiple_function_sections)
16606 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
16607 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
16612 unsigned fde_idx = 0;
16614 /* We need to give .debug_loc and .debug_ranges an appropriate
16615 "base address". Use zero so that these addresses become
16616 absolute. Historically, we've emitted the unexpected
16617 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
16618 Emit both to give time for other tools to adapt. */
16619 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
16620 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
16622 add_AT_range_list (comp_unit_die, DW_AT_ranges,
16623 add_ranges_by_labels (text_section_label,
16625 if (flag_reorder_blocks_and_partition)
16626 add_ranges_by_labels (cold_text_section_label,
16629 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
16631 dw_fde_ref fde = &fde_table[fde_idx];
16633 if (fde->dw_fde_switched_sections)
16635 add_ranges_by_labels (fde->dw_fde_hot_section_label,
16636 fde->dw_fde_hot_section_end_label);
16637 add_ranges_by_labels (fde->dw_fde_unlikely_section_label,
16638 fde->dw_fde_unlikely_section_end_label);
16641 add_ranges_by_labels (fde->dw_fde_begin,
16648 /* Output location list section if necessary. */
16649 if (have_location_lists)
16651 /* Output the location lists info. */
16652 switch_to_section (debug_loc_section);
16653 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
16654 DEBUG_LOC_SECTION_LABEL, 0);
16655 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
16656 output_location_lists (die);
16659 if (debug_info_level >= DINFO_LEVEL_NORMAL)
16660 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
16661 debug_line_section_label);
16663 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16664 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
16666 /* Output all of the compilation units. We put the main one last so that
16667 the offsets are available to output_pubnames. */
16668 for (node = limbo_die_list; node; node = node->next)
16669 output_comp_unit (node->die, 0);
16671 /* Output the main compilation unit if non-empty or if .debug_macinfo
16672 has been emitted. */
16673 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
16675 /* Output the abbreviation table. */
16676 switch_to_section (debug_abbrev_section);
16677 output_abbrev_section ();
16679 /* Output public names table if necessary. */
16680 if (!VEC_empty (pubname_entry, pubname_table))
16682 switch_to_section (debug_pubnames_section);
16683 output_pubnames (pubname_table);
16686 #ifdef DEBUG_PUBTYPES_SECTION
16687 /* Output public types table if necessary. */
16688 if (!VEC_empty (pubname_entry, pubtype_table))
16690 switch_to_section (debug_pubtypes_section);
16691 output_pubnames (pubtype_table);
16695 /* Output the address range information. We only put functions in the arange
16696 table, so don't write it out if we don't have any. */
16697 if (fde_table_in_use)
16699 switch_to_section (debug_aranges_section);
16703 /* Output ranges section if necessary. */
16704 if (ranges_table_in_use)
16706 switch_to_section (debug_ranges_section);
16707 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
16711 /* Output the source line correspondence table. We must do this
16712 even if there is no line information. Otherwise, on an empty
16713 translation unit, we will generate a present, but empty,
16714 .debug_info section. IRIX 6.5 `nm' will then complain when
16715 examining the file. This is done late so that any filenames
16716 used by the debug_info section are marked as 'used'. */
16717 if (! DWARF2_ASM_LINE_DEBUG_INFO)
16719 switch_to_section (debug_line_section);
16720 output_line_info ();
16723 /* Have to end the macro section. */
16724 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
16726 switch_to_section (debug_macinfo_section);
16727 dw2_asm_output_data (1, 0, "End compilation unit");
16730 /* If we emitted any DW_FORM_strp form attribute, output the string
16732 if (debug_str_hash)
16733 htab_traverse (debug_str_hash, output_indirect_string, NULL);
16737 /* This should never be used, but its address is needed for comparisons. */
16738 const struct gcc_debug_hooks dwarf2_debug_hooks;
16740 #endif /* DWARF2_DEBUGGING_INFO */
16742 #include "gt-dwarf2out.h"