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, 2010
4 Free Software Foundation, Inc.
5 Contributed by Gary Funck (gary@intrepid.com).
6 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
7 Extensively modified by Jason Merrill (jason@cygnus.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
25 /* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
31 /* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
37 /* DWARF2 Abbreviation Glossary:
39 CFA = Canonical Frame Address
40 a fixed address on the stack which identifies a call frame.
41 We define it to be the value of SP just before the call insn.
42 The CFA register and offset, which may change during the course
43 of the function, are used to calculate its value at runtime.
45 CFI = Call Frame Instruction
46 an instruction for the DWARF2 abstract machine
48 CIE = Common Information Entry
49 information describing information common to one or more FDEs
51 DIE = Debugging Information Entry
53 FDE = Frame Description Entry
54 information describing the stack call frame, in particular,
55 how to restore registers
57 DW_CFA_... = DWARF2 CFA call frame instruction
58 DW_TAG_... = DWARF2 DIE tag */
62 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
84 #include "diagnostic.h"
85 #include "tree-pretty-print.h"
88 #include "langhooks.h"
93 #include "tree-pass.h"
94 #include "tree-flow.h"
96 #ifdef DWARF2_DEBUGGING_INFO
97 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
99 static rtx last_var_location_insn;
102 #ifdef VMS_DEBUGGING_INFO
103 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
105 /* Define this macro to be a nonzero value if the directory specifications
106 which are output in the debug info should end with a separator. */
107 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
108 /* Define this macro to evaluate to a nonzero value if GCC should refrain
109 from generating indirect strings in DWARF2 debug information, for instance
110 if your target is stuck with an old version of GDB that is unable to
111 process them properly or uses VMS Debug. */
112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
114 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
115 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
118 #ifndef DWARF2_FRAME_INFO
119 # ifdef DWARF2_DEBUGGING_INFO
120 # define DWARF2_FRAME_INFO \
121 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
123 # define DWARF2_FRAME_INFO 0
127 /* Map register numbers held in the call frame info that gcc has
128 collected using DWARF_FRAME_REGNUM to those that should be output in
129 .debug_frame and .eh_frame. */
130 #ifndef DWARF2_FRAME_REG_OUT
131 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
134 /* Save the result of dwarf2out_do_frame across PCH. */
135 static GTY(()) bool saved_do_cfi_asm = 0;
137 /* Decide whether we want to emit frame unwind information for the current
141 dwarf2out_do_frame (void)
143 /* We want to emit correct CFA location expressions or lists, so we
144 have to return true if we're going to output debug info, even if
145 we're not going to output frame or unwind info. */
146 return (write_symbols == DWARF2_DEBUG
147 || write_symbols == VMS_AND_DWARF2_DEBUG
148 || DWARF2_FRAME_INFO || saved_do_cfi_asm
149 #ifdef DWARF2_UNWIND_INFO
150 || (DWARF2_UNWIND_INFO
151 && (flag_unwind_tables
152 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
157 /* Decide whether to emit frame unwind via assembler directives. */
160 dwarf2out_do_cfi_asm (void)
164 #ifdef MIPS_DEBUGGING_INFO
167 if (!flag_dwarf2_cfi_asm || !dwarf2out_do_frame ())
169 if (saved_do_cfi_asm)
171 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
174 /* Make sure the personality encoding is one the assembler can support.
175 In particular, aligned addresses can't be handled. */
176 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
177 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
179 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
180 if ((enc & 0x70) != 0 && (enc & 0x70) != DW_EH_PE_pcrel)
183 if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
185 #ifdef TARGET_UNWIND_INFO
188 if (USING_SJLJ_EXCEPTIONS || (!flag_unwind_tables && !flag_exceptions))
193 saved_do_cfi_asm = true;
197 /* The size of the target's pointer type. */
199 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
202 /* Array of RTXes referenced by the debugging information, which therefore
203 must be kept around forever. */
204 static GTY(()) VEC(rtx,gc) *used_rtx_array;
206 /* A pointer to the base of a list of incomplete types which might be
207 completed at some later time. incomplete_types_list needs to be a
208 VEC(tree,gc) because we want to tell the garbage collector about
210 static GTY(()) VEC(tree,gc) *incomplete_types;
212 /* A pointer to the base of a table of references to declaration
213 scopes. This table is a display which tracks the nesting
214 of declaration scopes at the current scope and containing
215 scopes. This table is used to find the proper place to
216 define type declaration DIE's. */
217 static GTY(()) VEC(tree,gc) *decl_scope_table;
219 /* Pointers to various DWARF2 sections. */
220 static GTY(()) section *debug_info_section;
221 static GTY(()) section *debug_abbrev_section;
222 static GTY(()) section *debug_aranges_section;
223 static GTY(()) section *debug_macinfo_section;
224 static GTY(()) section *debug_line_section;
225 static GTY(()) section *debug_loc_section;
226 static GTY(()) section *debug_pubnames_section;
227 static GTY(()) section *debug_pubtypes_section;
228 static GTY(()) section *debug_dcall_section;
229 static GTY(()) section *debug_vcall_section;
230 static GTY(()) section *debug_str_section;
231 static GTY(()) section *debug_ranges_section;
232 static GTY(()) section *debug_frame_section;
234 /* Personality decl of current unit. Used only when assembler does not support
236 static GTY(()) rtx current_unit_personality;
238 /* How to start an assembler comment. */
239 #ifndef ASM_COMMENT_START
240 #define ASM_COMMENT_START ";#"
243 typedef struct dw_cfi_struct *dw_cfi_ref;
244 typedef struct dw_fde_struct *dw_fde_ref;
245 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
247 /* Call frames are described using a sequence of Call Frame
248 Information instructions. The register number, offset
249 and address fields are provided as possible operands;
250 their use is selected by the opcode field. */
252 enum dw_cfi_oprnd_type {
254 dw_cfi_oprnd_reg_num,
260 typedef union GTY(()) dw_cfi_oprnd_struct {
261 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
262 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
263 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
264 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
268 typedef struct GTY(()) dw_cfi_struct {
269 dw_cfi_ref dw_cfi_next;
270 enum dwarf_call_frame_info dw_cfi_opc;
271 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
273 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
278 /* This is how we define the location of the CFA. We use to handle it
279 as REG + OFFSET all the time, but now it can be more complex.
280 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
281 Instead of passing around REG and OFFSET, we pass a copy
282 of this structure. */
283 typedef struct GTY(()) cfa_loc {
284 HOST_WIDE_INT offset;
285 HOST_WIDE_INT base_offset;
287 BOOL_BITFIELD indirect : 1; /* 1 if CFA is accessed via a dereference. */
288 BOOL_BITFIELD in_use : 1; /* 1 if a saved cfa is stored here. */
291 /* All call frame descriptions (FDE's) in the GCC generated DWARF
292 refer to a single Common Information Entry (CIE), defined at
293 the beginning of the .debug_frame section. This use of a single
294 CIE obviates the need to keep track of multiple CIE's
295 in the DWARF generation routines below. */
297 typedef struct GTY(()) dw_fde_struct {
299 const char *dw_fde_begin;
300 const char *dw_fde_current_label;
301 const char *dw_fde_end;
302 const char *dw_fde_vms_end_prologue;
303 const char *dw_fde_vms_begin_epilogue;
304 const char *dw_fde_hot_section_label;
305 const char *dw_fde_hot_section_end_label;
306 const char *dw_fde_unlikely_section_label;
307 const char *dw_fde_unlikely_section_end_label;
308 dw_cfi_ref dw_fde_cfi;
309 dw_cfi_ref dw_fde_switch_cfi; /* Last CFI before switching sections. */
310 HOST_WIDE_INT stack_realignment;
311 unsigned funcdef_number;
312 /* Dynamic realign argument pointer register. */
313 unsigned int drap_reg;
314 /* Virtual dynamic realign argument pointer register. */
315 unsigned int vdrap_reg;
316 /* These 3 flags are copied from rtl_data in function.h. */
317 unsigned all_throwers_are_sibcalls : 1;
318 unsigned uses_eh_lsda : 1;
319 unsigned nothrow : 1;
320 /* Whether we did stack realign in this call frame. */
321 unsigned stack_realign : 1;
322 /* Whether dynamic realign argument pointer register has been saved. */
323 unsigned drap_reg_saved: 1;
324 /* True iff dw_fde_begin label is in text_section or cold_text_section. */
325 unsigned in_std_section : 1;
326 /* True iff dw_fde_unlikely_section_label is in text_section or
327 cold_text_section. */
328 unsigned cold_in_std_section : 1;
329 /* True iff switched sections. */
330 unsigned dw_fde_switched_sections : 1;
331 /* True iff switching from cold to hot section. */
332 unsigned dw_fde_switched_cold_to_hot : 1;
336 /* Maximum size (in bytes) of an artificially generated label. */
337 #define MAX_ARTIFICIAL_LABEL_BYTES 30
339 /* The size of addresses as they appear in the Dwarf 2 data.
340 Some architectures use word addresses to refer to code locations,
341 but Dwarf 2 info always uses byte addresses. On such machines,
342 Dwarf 2 addresses need to be larger than the architecture's
344 #ifndef DWARF2_ADDR_SIZE
345 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
348 /* The size in bytes of a DWARF field indicating an offset or length
349 relative to a debug info section, specified to be 4 bytes in the
350 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
353 #ifndef DWARF_OFFSET_SIZE
354 #define DWARF_OFFSET_SIZE 4
357 /* The size in bytes of a DWARF 4 type signature. */
359 #ifndef DWARF_TYPE_SIGNATURE_SIZE
360 #define DWARF_TYPE_SIGNATURE_SIZE 8
363 /* According to the (draft) DWARF 3 specification, the initial length
364 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
365 bytes are 0xffffffff, followed by the length stored in the next 8
368 However, the SGI/MIPS ABI uses an initial length which is equal to
369 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
371 #ifndef DWARF_INITIAL_LENGTH_SIZE
372 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
375 /* Round SIZE up to the nearest BOUNDARY. */
376 #define DWARF_ROUND(SIZE,BOUNDARY) \
377 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
379 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
380 #ifndef DWARF_CIE_DATA_ALIGNMENT
381 #ifdef STACK_GROWS_DOWNWARD
382 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
384 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
388 /* CIE identifier. */
389 #if HOST_BITS_PER_WIDE_INT >= 64
390 #define DWARF_CIE_ID \
391 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
393 #define DWARF_CIE_ID DW_CIE_ID
396 /* A pointer to the base of a table that contains frame description
397 information for each routine. */
398 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
400 /* Number of elements currently allocated for fde_table. */
401 static GTY(()) unsigned fde_table_allocated;
403 /* Number of elements in fde_table currently in use. */
404 static GTY(()) unsigned fde_table_in_use;
406 /* Size (in elements) of increments by which we may expand the
408 #define FDE_TABLE_INCREMENT 256
410 /* Get the current fde_table entry we should use. */
412 static inline dw_fde_ref
415 return fde_table_in_use ? &fde_table[fde_table_in_use - 1] : NULL;
418 /* A list of call frame insns for the CIE. */
419 static GTY(()) dw_cfi_ref cie_cfi_head;
421 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
422 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
423 attribute that accelerates the lookup of the FDE associated
424 with the subprogram. This variable holds the table index of the FDE
425 associated with the current function (body) definition. */
426 static unsigned current_funcdef_fde;
429 struct GTY(()) indirect_string_node {
431 unsigned int refcount;
432 enum dwarf_form form;
436 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
438 /* True if the compilation unit has location entries that reference
440 static GTY(()) bool debug_str_hash_forced = false;
442 static GTY(()) int dw2_string_counter;
443 static GTY(()) unsigned long dwarf2out_cfi_label_num;
445 /* True if the compilation unit places functions in more than one section. */
446 static GTY(()) bool have_multiple_function_sections = false;
448 /* Whether the default text and cold text sections have been used at all. */
450 static GTY(()) bool text_section_used = false;
451 static GTY(()) bool cold_text_section_used = false;
453 /* The default cold text section. */
454 static GTY(()) section *cold_text_section;
456 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
458 /* Forward declarations for functions defined in this file. */
460 static char *stripattributes (const char *);
461 static const char *dwarf_cfi_name (unsigned);
462 static dw_cfi_ref new_cfi (void);
463 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
464 static void add_fde_cfi (const char *, dw_cfi_ref);
465 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *, dw_cfa_location *);
466 static void lookup_cfa (dw_cfa_location *);
467 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
468 #ifdef DWARF2_UNWIND_INFO
469 static void initial_return_save (rtx);
471 static HOST_WIDE_INT stack_adjust_offset (const_rtx, HOST_WIDE_INT,
473 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
474 static void output_cfi_directive (dw_cfi_ref);
475 static void output_call_frame_info (int);
476 static void dwarf2out_note_section_used (void);
477 static void flush_queued_reg_saves (void);
478 static bool clobbers_queued_reg_save (const_rtx);
479 static void dwarf2out_frame_debug_expr (rtx, const char *);
481 /* Support for complex CFA locations. */
482 static void output_cfa_loc (dw_cfi_ref);
483 static void output_cfa_loc_raw (dw_cfi_ref);
484 static void get_cfa_from_loc_descr (dw_cfa_location *,
485 struct dw_loc_descr_struct *);
486 static struct dw_loc_descr_struct *build_cfa_loc
487 (dw_cfa_location *, HOST_WIDE_INT);
488 static struct dw_loc_descr_struct *build_cfa_aligned_loc
489 (HOST_WIDE_INT, HOST_WIDE_INT);
490 static void def_cfa_1 (const char *, dw_cfa_location *);
492 /* How to start an assembler comment. */
493 #ifndef ASM_COMMENT_START
494 #define ASM_COMMENT_START ";#"
497 /* Data and reference forms for relocatable data. */
498 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
499 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
501 #ifndef DEBUG_FRAME_SECTION
502 #define DEBUG_FRAME_SECTION ".debug_frame"
505 #ifndef FUNC_BEGIN_LABEL
506 #define FUNC_BEGIN_LABEL "LFB"
509 #ifndef FUNC_END_LABEL
510 #define FUNC_END_LABEL "LFE"
513 #ifndef PROLOGUE_END_LABEL
514 #define PROLOGUE_END_LABEL "LPE"
517 #ifndef EPILOGUE_BEGIN_LABEL
518 #define EPILOGUE_BEGIN_LABEL "LEB"
521 #ifndef FRAME_BEGIN_LABEL
522 #define FRAME_BEGIN_LABEL "Lframe"
524 #define CIE_AFTER_SIZE_LABEL "LSCIE"
525 #define CIE_END_LABEL "LECIE"
526 #define FDE_LABEL "LSFDE"
527 #define FDE_AFTER_SIZE_LABEL "LASFDE"
528 #define FDE_END_LABEL "LEFDE"
529 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
530 #define LINE_NUMBER_END_LABEL "LELT"
531 #define LN_PROLOG_AS_LABEL "LASLTP"
532 #define LN_PROLOG_END_LABEL "LELTP"
533 #define DIE_LABEL_PREFIX "DW"
535 /* The DWARF 2 CFA column which tracks the return address. Normally this
536 is the column for PC, or the first column after all of the hard
538 #ifndef DWARF_FRAME_RETURN_COLUMN
540 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
542 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
546 /* The mapping from gcc register number to DWARF 2 CFA column number. By
547 default, we just provide columns for all registers. */
548 #ifndef DWARF_FRAME_REGNUM
549 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
552 /* Hook used by __throw. */
555 expand_builtin_dwarf_sp_column (void)
557 unsigned int dwarf_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
558 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum, 1));
561 /* Return a pointer to a copy of the section string name S with all
562 attributes stripped off, and an asterisk prepended (for assemble_name). */
565 stripattributes (const char *s)
567 char *stripped = XNEWVEC (char, strlen (s) + 2);
572 while (*s && *s != ',')
579 /* MEM is a memory reference for the register size table, each element of
580 which has mode MODE. Initialize column C as a return address column. */
583 init_return_column_size (enum machine_mode mode, rtx mem, unsigned int c)
585 HOST_WIDE_INT offset = c * GET_MODE_SIZE (mode);
586 HOST_WIDE_INT size = GET_MODE_SIZE (Pmode);
587 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
590 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
592 static inline HOST_WIDE_INT
593 div_data_align (HOST_WIDE_INT off)
595 HOST_WIDE_INT r = off / DWARF_CIE_DATA_ALIGNMENT;
596 gcc_assert (r * DWARF_CIE_DATA_ALIGNMENT == off);
600 /* Return true if we need a signed version of a given opcode
601 (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended). */
604 need_data_align_sf_opcode (HOST_WIDE_INT off)
606 return DWARF_CIE_DATA_ALIGNMENT < 0 ? off > 0 : off < 0;
609 /* Generate code to initialize the register size table. */
612 expand_builtin_init_dwarf_reg_sizes (tree address)
615 enum machine_mode mode = TYPE_MODE (char_type_node);
616 rtx addr = expand_normal (address);
617 rtx mem = gen_rtx_MEM (BLKmode, addr);
618 bool wrote_return_column = false;
620 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
622 int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
624 if (rnum < DWARF_FRAME_REGISTERS)
626 HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
627 enum machine_mode save_mode = reg_raw_mode[i];
630 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
631 save_mode = choose_hard_reg_mode (i, 1, true);
632 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
634 if (save_mode == VOIDmode)
636 wrote_return_column = true;
638 size = GET_MODE_SIZE (save_mode);
642 emit_move_insn (adjust_address (mem, mode, offset),
643 gen_int_mode (size, mode));
647 if (!wrote_return_column)
648 init_return_column_size (mode, mem, DWARF_FRAME_RETURN_COLUMN);
650 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
651 init_return_column_size (mode, mem, DWARF_ALT_FRAME_RETURN_COLUMN);
654 targetm.init_dwarf_reg_sizes_extra (address);
657 /* Convert a DWARF call frame info. operation to its string name */
660 dwarf_cfi_name (unsigned int cfi_opc)
664 case DW_CFA_advance_loc:
665 return "DW_CFA_advance_loc";
667 return "DW_CFA_offset";
669 return "DW_CFA_restore";
673 return "DW_CFA_set_loc";
674 case DW_CFA_advance_loc1:
675 return "DW_CFA_advance_loc1";
676 case DW_CFA_advance_loc2:
677 return "DW_CFA_advance_loc2";
678 case DW_CFA_advance_loc4:
679 return "DW_CFA_advance_loc4";
680 case DW_CFA_offset_extended:
681 return "DW_CFA_offset_extended";
682 case DW_CFA_restore_extended:
683 return "DW_CFA_restore_extended";
684 case DW_CFA_undefined:
685 return "DW_CFA_undefined";
686 case DW_CFA_same_value:
687 return "DW_CFA_same_value";
688 case DW_CFA_register:
689 return "DW_CFA_register";
690 case DW_CFA_remember_state:
691 return "DW_CFA_remember_state";
692 case DW_CFA_restore_state:
693 return "DW_CFA_restore_state";
695 return "DW_CFA_def_cfa";
696 case DW_CFA_def_cfa_register:
697 return "DW_CFA_def_cfa_register";
698 case DW_CFA_def_cfa_offset:
699 return "DW_CFA_def_cfa_offset";
702 case DW_CFA_def_cfa_expression:
703 return "DW_CFA_def_cfa_expression";
704 case DW_CFA_expression:
705 return "DW_CFA_expression";
706 case DW_CFA_offset_extended_sf:
707 return "DW_CFA_offset_extended_sf";
708 case DW_CFA_def_cfa_sf:
709 return "DW_CFA_def_cfa_sf";
710 case DW_CFA_def_cfa_offset_sf:
711 return "DW_CFA_def_cfa_offset_sf";
713 /* SGI/MIPS specific */
714 case DW_CFA_MIPS_advance_loc8:
715 return "DW_CFA_MIPS_advance_loc8";
718 case DW_CFA_GNU_window_save:
719 return "DW_CFA_GNU_window_save";
720 case DW_CFA_GNU_args_size:
721 return "DW_CFA_GNU_args_size";
722 case DW_CFA_GNU_negative_offset_extended:
723 return "DW_CFA_GNU_negative_offset_extended";
726 return "DW_CFA_<unknown>";
730 /* Return a pointer to a newly allocated Call Frame Instruction. */
732 static inline dw_cfi_ref
735 dw_cfi_ref cfi = ggc_alloc_dw_cfi_node ();
737 cfi->dw_cfi_next = NULL;
738 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
739 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
744 /* Add a Call Frame Instruction to list of instructions. */
747 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
750 dw_fde_ref fde = current_fde ();
752 /* When DRAP is used, CFA is defined with an expression. Redefine
753 CFA may lead to a different CFA value. */
754 /* ??? Of course, this heuristic fails when we're annotating epilogues,
755 because of course we'll always want to redefine the CFA back to the
756 stack pointer on the way out. Where should we move this check? */
757 if (0 && fde && fde->drap_reg != INVALID_REGNUM)
758 switch (cfi->dw_cfi_opc)
760 case DW_CFA_def_cfa_register:
761 case DW_CFA_def_cfa_offset:
762 case DW_CFA_def_cfa_offset_sf:
764 case DW_CFA_def_cfa_sf:
771 /* Find the end of the chain. */
772 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
778 /* Generate a new label for the CFI info to refer to. FORCE is true
779 if a label needs to be output even when using .cfi_* directives. */
782 dwarf2out_cfi_label (bool force)
784 static char label[20];
786 if (!force && dwarf2out_do_cfi_asm ())
788 /* In this case, we will be emitting the asm directive instead of
789 the label, so just return a placeholder to keep the rest of the
791 strcpy (label, "<do not output>");
795 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
796 ASM_OUTPUT_LABEL (asm_out_file, label);
802 /* True if remember_state should be emitted before following CFI directive. */
803 static bool emit_cfa_remember;
805 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
806 or to the CIE if LABEL is NULL. */
809 add_fde_cfi (const char *label, dw_cfi_ref cfi)
811 dw_cfi_ref *list_head;
813 if (emit_cfa_remember)
815 dw_cfi_ref cfi_remember;
817 /* Emit the state save. */
818 emit_cfa_remember = false;
819 cfi_remember = new_cfi ();
820 cfi_remember->dw_cfi_opc = DW_CFA_remember_state;
821 add_fde_cfi (label, cfi_remember);
824 list_head = &cie_cfi_head;
826 if (dwarf2out_do_cfi_asm ())
830 dw_fde_ref fde = current_fde ();
832 gcc_assert (fde != NULL);
834 /* We still have to add the cfi to the list so that lookup_cfa
835 works later on. When -g2 and above we even need to force
836 emitting of CFI labels and add to list a DW_CFA_set_loc for
837 convert_cfa_to_fb_loc_list purposes. If we're generating
838 DWARF3 output we use DW_OP_call_frame_cfa and so don't use
839 convert_cfa_to_fb_loc_list. */
840 if (dwarf_version == 2
841 && debug_info_level > DINFO_LEVEL_TERSE
842 && (write_symbols == DWARF2_DEBUG
843 || write_symbols == VMS_AND_DWARF2_DEBUG))
845 switch (cfi->dw_cfi_opc)
847 case DW_CFA_def_cfa_offset:
848 case DW_CFA_def_cfa_offset_sf:
849 case DW_CFA_def_cfa_register:
851 case DW_CFA_def_cfa_sf:
852 case DW_CFA_def_cfa_expression:
853 case DW_CFA_restore_state:
854 if (*label == 0 || strcmp (label, "<do not output>") == 0)
855 label = dwarf2out_cfi_label (true);
857 if (fde->dw_fde_current_label == NULL
858 || strcmp (label, fde->dw_fde_current_label) != 0)
862 label = xstrdup (label);
864 /* Set the location counter to the new label. */
866 /* It doesn't metter whether DW_CFA_set_loc
867 or DW_CFA_advance_loc4 is added here, those aren't
868 emitted into assembly, only looked up by
869 convert_cfa_to_fb_loc_list. */
870 xcfi->dw_cfi_opc = DW_CFA_set_loc;
871 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
872 add_cfi (&fde->dw_fde_cfi, xcfi);
873 fde->dw_fde_current_label = label;
881 output_cfi_directive (cfi);
883 list_head = &fde->dw_fde_cfi;
885 /* ??? If this is a CFI for the CIE, we don't emit. This
886 assumes that the standard CIE contents that the assembler
887 uses matches the standard CIE contents that the compiler
888 uses. This is probably a bad assumption. I'm not quite
889 sure how to address this for now. */
893 dw_fde_ref fde = current_fde ();
895 gcc_assert (fde != NULL);
898 label = dwarf2out_cfi_label (false);
900 if (fde->dw_fde_current_label == NULL
901 || strcmp (label, fde->dw_fde_current_label) != 0)
905 label = xstrdup (label);
907 /* Set the location counter to the new label. */
909 /* If we have a current label, advance from there, otherwise
910 set the location directly using set_loc. */
911 xcfi->dw_cfi_opc = fde->dw_fde_current_label
912 ? DW_CFA_advance_loc4
914 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
915 add_cfi (&fde->dw_fde_cfi, xcfi);
917 fde->dw_fde_current_label = label;
920 list_head = &fde->dw_fde_cfi;
923 add_cfi (list_head, cfi);
926 /* Subroutine of lookup_cfa. */
929 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember)
931 switch (cfi->dw_cfi_opc)
933 case DW_CFA_def_cfa_offset:
934 case DW_CFA_def_cfa_offset_sf:
935 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
937 case DW_CFA_def_cfa_register:
938 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
941 case DW_CFA_def_cfa_sf:
942 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
943 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
945 case DW_CFA_def_cfa_expression:
946 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
949 case DW_CFA_remember_state:
950 gcc_assert (!remember->in_use);
952 remember->in_use = 1;
954 case DW_CFA_restore_state:
955 gcc_assert (remember->in_use);
957 remember->in_use = 0;
965 /* Find the previous value for the CFA. */
968 lookup_cfa (dw_cfa_location *loc)
972 dw_cfa_location remember;
974 memset (loc, 0, sizeof (*loc));
975 loc->reg = INVALID_REGNUM;
978 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
979 lookup_cfa_1 (cfi, loc, &remember);
981 fde = current_fde ();
983 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
984 lookup_cfa_1 (cfi, loc, &remember);
987 /* The current rule for calculating the DWARF2 canonical frame address. */
988 static dw_cfa_location cfa;
990 /* The register used for saving registers to the stack, and its offset
992 static dw_cfa_location cfa_store;
994 /* The current save location around an epilogue. */
995 static dw_cfa_location cfa_remember;
997 /* The running total of the size of arguments pushed onto the stack. */
998 static HOST_WIDE_INT args_size;
1000 /* The last args_size we actually output. */
1001 static HOST_WIDE_INT old_args_size;
1003 /* Entry point to update the canonical frame address (CFA).
1004 LABEL is passed to add_fde_cfi. The value of CFA is now to be
1005 calculated from REG+OFFSET. */
1008 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1010 dw_cfa_location loc;
1012 loc.base_offset = 0;
1014 loc.offset = offset;
1015 def_cfa_1 (label, &loc);
1018 /* Determine if two dw_cfa_location structures define the same data. */
1021 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
1023 return (loc1->reg == loc2->reg
1024 && loc1->offset == loc2->offset
1025 && loc1->indirect == loc2->indirect
1026 && (loc1->indirect == 0
1027 || loc1->base_offset == loc2->base_offset));
1030 /* This routine does the actual work. The CFA is now calculated from
1031 the dw_cfa_location structure. */
1034 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
1037 dw_cfa_location old_cfa, loc;
1042 if (cfa_store.reg == loc.reg && loc.indirect == 0)
1043 cfa_store.offset = loc.offset;
1045 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
1046 lookup_cfa (&old_cfa);
1048 /* If nothing changed, no need to issue any call frame instructions. */
1049 if (cfa_equal_p (&loc, &old_cfa))
1054 if (loc.reg == old_cfa.reg && !loc.indirect && !old_cfa.indirect)
1056 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1057 the CFA register did not change but the offset did. The data
1058 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1059 in the assembler via the .cfi_def_cfa_offset directive. */
1061 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
1063 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
1064 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
1067 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
1068 else if (loc.offset == old_cfa.offset
1069 && old_cfa.reg != INVALID_REGNUM
1071 && !old_cfa.indirect)
1073 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1074 indicating the CFA register has changed to <register> but the
1075 offset has not changed. */
1076 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
1077 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1081 else if (loc.indirect == 0)
1083 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1084 indicating the CFA register has changed to <register> with
1085 the specified offset. The data factoring for DW_CFA_def_cfa_sf
1086 happens in output_cfi, or in the assembler via the .cfi_def_cfa
1089 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
1091 cfi->dw_cfi_opc = DW_CFA_def_cfa;
1092 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
1093 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
1097 /* Construct a DW_CFA_def_cfa_expression instruction to
1098 calculate the CFA using a full location expression since no
1099 register-offset pair is available. */
1100 struct dw_loc_descr_struct *loc_list;
1102 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
1103 loc_list = build_cfa_loc (&loc, 0);
1104 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
1107 add_fde_cfi (label, cfi);
1110 /* Add the CFI for saving a register. REG is the CFA column number.
1111 LABEL is passed to add_fde_cfi.
1112 If SREG is -1, the register is saved at OFFSET from the CFA;
1113 otherwise it is saved in SREG. */
1116 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
1118 dw_cfi_ref cfi = new_cfi ();
1119 dw_fde_ref fde = current_fde ();
1121 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1123 /* When stack is aligned, store REG using DW_CFA_expression with
1126 && fde->stack_realign
1127 && sreg == INVALID_REGNUM)
1129 cfi->dw_cfi_opc = DW_CFA_expression;
1130 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
1131 cfi->dw_cfi_oprnd2.dw_cfi_loc
1132 = build_cfa_aligned_loc (offset, fde->stack_realignment);
1134 else if (sreg == INVALID_REGNUM)
1136 if (need_data_align_sf_opcode (offset))
1137 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
1138 else if (reg & ~0x3f)
1139 cfi->dw_cfi_opc = DW_CFA_offset_extended;
1141 cfi->dw_cfi_opc = DW_CFA_offset;
1142 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
1144 else if (sreg == reg)
1145 cfi->dw_cfi_opc = DW_CFA_same_value;
1148 cfi->dw_cfi_opc = DW_CFA_register;
1149 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
1152 add_fde_cfi (label, cfi);
1155 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1156 This CFI tells the unwinder that it needs to restore the window registers
1157 from the previous frame's window save area.
1159 ??? Perhaps we should note in the CIE where windows are saved (instead of
1160 assuming 0(cfa)) and what registers are in the window. */
1163 dwarf2out_window_save (const char *label)
1165 dw_cfi_ref cfi = new_cfi ();
1167 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
1168 add_fde_cfi (label, cfi);
1171 /* Entry point for saving a register to the stack. REG is the GCC register
1172 number. LABEL and OFFSET are passed to reg_save. */
1175 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
1177 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
1180 /* Entry point for saving the return address in the stack.
1181 LABEL and OFFSET are passed to reg_save. */
1184 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
1186 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
1189 /* Entry point for saving the return address in a register.
1190 LABEL and SREG are passed to reg_save. */
1193 dwarf2out_return_reg (const char *label, unsigned int sreg)
1195 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
1198 #ifdef DWARF2_UNWIND_INFO
1199 /* Record the initial position of the return address. RTL is
1200 INCOMING_RETURN_ADDR_RTX. */
1203 initial_return_save (rtx rtl)
1205 unsigned int reg = INVALID_REGNUM;
1206 HOST_WIDE_INT offset = 0;
1208 switch (GET_CODE (rtl))
1211 /* RA is in a register. */
1212 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
1216 /* RA is on the stack. */
1217 rtl = XEXP (rtl, 0);
1218 switch (GET_CODE (rtl))
1221 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1226 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1227 offset = INTVAL (XEXP (rtl, 1));
1231 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1232 offset = -INTVAL (XEXP (rtl, 1));
1242 /* The return address is at some offset from any value we can
1243 actually load. For instance, on the SPARC it is in %i7+8. Just
1244 ignore the offset for now; it doesn't matter for unwinding frames. */
1245 gcc_assert (CONST_INT_P (XEXP (rtl, 1)));
1246 initial_return_save (XEXP (rtl, 0));
1253 if (reg != DWARF_FRAME_RETURN_COLUMN)
1254 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1258 /* Given a SET, calculate the amount of stack adjustment it
1261 static HOST_WIDE_INT
1262 stack_adjust_offset (const_rtx pattern, HOST_WIDE_INT cur_args_size,
1263 HOST_WIDE_INT cur_offset)
1265 const_rtx src = SET_SRC (pattern);
1266 const_rtx dest = SET_DEST (pattern);
1267 HOST_WIDE_INT offset = 0;
1270 if (dest == stack_pointer_rtx)
1272 code = GET_CODE (src);
1274 /* Assume (set (reg sp) (reg whatever)) sets args_size
1276 if (code == REG && src != stack_pointer_rtx)
1278 offset = -cur_args_size;
1279 #ifndef STACK_GROWS_DOWNWARD
1282 return offset - cur_offset;
1285 if (! (code == PLUS || code == MINUS)
1286 || XEXP (src, 0) != stack_pointer_rtx
1287 || !CONST_INT_P (XEXP (src, 1)))
1290 /* (set (reg sp) (plus (reg sp) (const_int))) */
1291 offset = INTVAL (XEXP (src, 1));
1297 if (MEM_P (src) && !MEM_P (dest))
1301 /* (set (mem (pre_dec (reg sp))) (foo)) */
1302 src = XEXP (dest, 0);
1303 code = GET_CODE (src);
1309 if (XEXP (src, 0) == stack_pointer_rtx)
1311 rtx val = XEXP (XEXP (src, 1), 1);
1312 /* We handle only adjustments by constant amount. */
1313 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1314 && CONST_INT_P (val));
1315 offset = -INTVAL (val);
1322 if (XEXP (src, 0) == stack_pointer_rtx)
1324 offset = GET_MODE_SIZE (GET_MODE (dest));
1331 if (XEXP (src, 0) == stack_pointer_rtx)
1333 offset = -GET_MODE_SIZE (GET_MODE (dest));
1348 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1349 indexed by INSN_UID. */
1351 static HOST_WIDE_INT *barrier_args_size;
1353 /* Helper function for compute_barrier_args_size. Handle one insn. */
1355 static HOST_WIDE_INT
1356 compute_barrier_args_size_1 (rtx insn, HOST_WIDE_INT cur_args_size,
1357 VEC (rtx, heap) **next)
1359 HOST_WIDE_INT offset = 0;
1362 if (! RTX_FRAME_RELATED_P (insn))
1364 if (prologue_epilogue_contains (insn))
1366 else if (GET_CODE (PATTERN (insn)) == SET)
1367 offset = stack_adjust_offset (PATTERN (insn), cur_args_size, 0);
1368 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1369 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1371 /* There may be stack adjustments inside compound insns. Search
1373 for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1374 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1375 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1376 cur_args_size, offset);
1381 rtx expr = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1385 expr = XEXP (expr, 0);
1386 if (GET_CODE (expr) == PARALLEL
1387 || GET_CODE (expr) == SEQUENCE)
1388 for (i = 1; i < XVECLEN (expr, 0); i++)
1390 rtx elem = XVECEXP (expr, 0, i);
1392 if (GET_CODE (elem) == SET && !RTX_FRAME_RELATED_P (elem))
1393 offset += stack_adjust_offset (elem, cur_args_size, offset);
1398 #ifndef STACK_GROWS_DOWNWARD
1402 cur_args_size += offset;
1403 if (cur_args_size < 0)
1408 rtx dest = JUMP_LABEL (insn);
1412 if (barrier_args_size [INSN_UID (dest)] < 0)
1414 barrier_args_size [INSN_UID (dest)] = cur_args_size;
1415 VEC_safe_push (rtx, heap, *next, dest);
1420 return cur_args_size;
1423 /* Walk the whole function and compute args_size on BARRIERs. */
1426 compute_barrier_args_size (void)
1428 int max_uid = get_max_uid (), i;
1430 VEC (rtx, heap) *worklist, *next, *tmp;
1432 barrier_args_size = XNEWVEC (HOST_WIDE_INT, max_uid);
1433 for (i = 0; i < max_uid; i++)
1434 barrier_args_size[i] = -1;
1436 worklist = VEC_alloc (rtx, heap, 20);
1437 next = VEC_alloc (rtx, heap, 20);
1438 insn = get_insns ();
1439 barrier_args_size[INSN_UID (insn)] = 0;
1440 VEC_quick_push (rtx, worklist, insn);
1443 while (!VEC_empty (rtx, worklist))
1445 rtx prev, body, first_insn;
1446 HOST_WIDE_INT cur_args_size;
1448 first_insn = insn = VEC_pop (rtx, worklist);
1449 cur_args_size = barrier_args_size[INSN_UID (insn)];
1450 prev = prev_nonnote_insn (insn);
1451 if (prev && BARRIER_P (prev))
1452 barrier_args_size[INSN_UID (prev)] = cur_args_size;
1454 for (; insn; insn = NEXT_INSN (insn))
1456 if (INSN_DELETED_P (insn) || NOTE_P (insn))
1458 if (BARRIER_P (insn))
1463 if (insn == first_insn)
1465 else if (barrier_args_size[INSN_UID (insn)] < 0)
1467 barrier_args_size[INSN_UID (insn)] = cur_args_size;
1472 /* The insns starting with this label have been
1473 already scanned or are in the worklist. */
1478 body = PATTERN (insn);
1479 if (GET_CODE (body) == SEQUENCE)
1481 HOST_WIDE_INT dest_args_size = cur_args_size;
1482 for (i = 1; i < XVECLEN (body, 0); i++)
1483 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0))
1484 && INSN_FROM_TARGET_P (XVECEXP (body, 0, i)))
1486 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1487 dest_args_size, &next);
1490 = compute_barrier_args_size_1 (XVECEXP (body, 0, i),
1491 cur_args_size, &next);
1493 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body, 0, 0)))
1494 compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1495 dest_args_size, &next);
1498 = compute_barrier_args_size_1 (XVECEXP (body, 0, 0),
1499 cur_args_size, &next);
1503 = compute_barrier_args_size_1 (insn, cur_args_size, &next);
1507 if (VEC_empty (rtx, next))
1510 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1514 VEC_truncate (rtx, next, 0);
1517 VEC_free (rtx, heap, worklist);
1518 VEC_free (rtx, heap, next);
1521 /* Add a CFI to update the running total of the size of arguments
1522 pushed onto the stack. */
1525 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
1529 if (size == old_args_size)
1532 old_args_size = size;
1535 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1536 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1537 add_fde_cfi (label, cfi);
1540 /* Record a stack adjustment of OFFSET bytes. */
1543 dwarf2out_stack_adjust (HOST_WIDE_INT offset, const char *label)
1545 if (cfa.reg == STACK_POINTER_REGNUM)
1546 cfa.offset += offset;
1548 if (cfa_store.reg == STACK_POINTER_REGNUM)
1549 cfa_store.offset += offset;
1551 if (ACCUMULATE_OUTGOING_ARGS)
1554 #ifndef STACK_GROWS_DOWNWARD
1558 args_size += offset;
1562 def_cfa_1 (label, &cfa);
1563 if (flag_asynchronous_unwind_tables)
1564 dwarf2out_args_size (label, args_size);
1567 /* Check INSN to see if it looks like a push or a stack adjustment, and
1568 make a note of it if it does. EH uses this information to find out
1569 how much extra space it needs to pop off the stack. */
1572 dwarf2out_notice_stack_adjust (rtx insn, bool after_p)
1574 HOST_WIDE_INT offset;
1578 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1579 with this function. Proper support would require all frame-related
1580 insns to be marked, and to be able to handle saving state around
1581 epilogues textually in the middle of the function. */
1582 if (prologue_epilogue_contains (insn))
1585 /* If INSN is an instruction from target of an annulled branch, the
1586 effects are for the target only and so current argument size
1587 shouldn't change at all. */
1589 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1590 && INSN_FROM_TARGET_P (insn))
1593 /* If only calls can throw, and we have a frame pointer,
1594 save up adjustments until we see the CALL_INSN. */
1595 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1597 if (CALL_P (insn) && !after_p)
1599 /* Extract the size of the args from the CALL rtx itself. */
1600 insn = PATTERN (insn);
1601 if (GET_CODE (insn) == PARALLEL)
1602 insn = XVECEXP (insn, 0, 0);
1603 if (GET_CODE (insn) == SET)
1604 insn = SET_SRC (insn);
1605 gcc_assert (GET_CODE (insn) == CALL);
1606 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1611 if (CALL_P (insn) && !after_p)
1613 if (!flag_asynchronous_unwind_tables)
1614 dwarf2out_args_size ("", args_size);
1617 else if (BARRIER_P (insn))
1619 /* Don't call compute_barrier_args_size () if the only
1620 BARRIER is at the end of function. */
1621 if (barrier_args_size == NULL && next_nonnote_insn (insn))
1622 compute_barrier_args_size ();
1623 if (barrier_args_size == NULL)
1627 offset = barrier_args_size[INSN_UID (insn)];
1632 offset -= args_size;
1633 #ifndef STACK_GROWS_DOWNWARD
1637 else if (GET_CODE (PATTERN (insn)) == SET)
1638 offset = stack_adjust_offset (PATTERN (insn), args_size, 0);
1639 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1640 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1642 /* There may be stack adjustments inside compound insns. Search
1644 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1645 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1646 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i),
1655 label = dwarf2out_cfi_label (false);
1656 dwarf2out_stack_adjust (offset, label);
1661 /* We delay emitting a register save until either (a) we reach the end
1662 of the prologue or (b) the register is clobbered. This clusters
1663 register saves so that there are fewer pc advances. */
1665 struct GTY(()) queued_reg_save {
1666 struct queued_reg_save *next;
1668 HOST_WIDE_INT cfa_offset;
1672 static GTY(()) struct queued_reg_save *queued_reg_saves;
1674 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1675 struct GTY(()) reg_saved_in_data {
1680 /* A list of registers saved in other registers.
1681 The list intentionally has a small maximum capacity of 4; if your
1682 port needs more than that, you might consider implementing a
1683 more efficient data structure. */
1684 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1685 static GTY(()) size_t num_regs_saved_in_regs;
1687 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1688 static const char *last_reg_save_label;
1690 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1691 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1694 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1696 struct queued_reg_save *q;
1698 /* Duplicates waste space, but it's also necessary to remove them
1699 for correctness, since the queue gets output in reverse
1701 for (q = queued_reg_saves; q != NULL; q = q->next)
1702 if (REGNO (q->reg) == REGNO (reg))
1707 q = ggc_alloc_queued_reg_save ();
1708 q->next = queued_reg_saves;
1709 queued_reg_saves = q;
1713 q->cfa_offset = offset;
1714 q->saved_reg = sreg;
1716 last_reg_save_label = label;
1719 /* Output all the entries in QUEUED_REG_SAVES. */
1722 flush_queued_reg_saves (void)
1724 struct queued_reg_save *q;
1726 for (q = queued_reg_saves; q; q = q->next)
1729 unsigned int reg, sreg;
1731 for (i = 0; i < num_regs_saved_in_regs; i++)
1732 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1734 if (q->saved_reg && i == num_regs_saved_in_regs)
1736 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1737 num_regs_saved_in_regs++;
1739 if (i != num_regs_saved_in_regs)
1741 regs_saved_in_regs[i].orig_reg = q->reg;
1742 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1745 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1747 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1749 sreg = INVALID_REGNUM;
1750 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1753 queued_reg_saves = NULL;
1754 last_reg_save_label = NULL;
1757 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1758 location for? Or, does it clobber a register which we've previously
1759 said that some other register is saved in, and for which we now
1760 have a new location for? */
1763 clobbers_queued_reg_save (const_rtx insn)
1765 struct queued_reg_save *q;
1767 for (q = queued_reg_saves; q; q = q->next)
1770 if (modified_in_p (q->reg, insn))
1772 for (i = 0; i < num_regs_saved_in_regs; i++)
1773 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1774 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1781 /* Entry point for saving the first register into the second. */
1784 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1787 unsigned int regno, sregno;
1789 for (i = 0; i < num_regs_saved_in_regs; i++)
1790 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1792 if (i == num_regs_saved_in_regs)
1794 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1795 num_regs_saved_in_regs++;
1797 regs_saved_in_regs[i].orig_reg = reg;
1798 regs_saved_in_regs[i].saved_in_reg = sreg;
1800 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1801 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1802 reg_save (label, regno, sregno, 0);
1805 /* What register, if any, is currently saved in REG? */
1808 reg_saved_in (rtx reg)
1810 unsigned int regn = REGNO (reg);
1812 struct queued_reg_save *q;
1814 for (q = queued_reg_saves; q; q = q->next)
1815 if (q->saved_reg && regn == REGNO (q->saved_reg))
1818 for (i = 0; i < num_regs_saved_in_regs; i++)
1819 if (regs_saved_in_regs[i].saved_in_reg
1820 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1821 return regs_saved_in_regs[i].orig_reg;
1827 /* A temporary register holding an integral value used in adjusting SP
1828 or setting up the store_reg. The "offset" field holds the integer
1829 value, not an offset. */
1830 static dw_cfa_location cfa_temp;
1832 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1835 dwarf2out_frame_debug_def_cfa (rtx pat, const char *label)
1837 memset (&cfa, 0, sizeof (cfa));
1839 switch (GET_CODE (pat))
1842 cfa.reg = REGNO (XEXP (pat, 0));
1843 cfa.offset = INTVAL (XEXP (pat, 1));
1847 cfa.reg = REGNO (pat);
1851 /* Recurse and define an expression. */
1855 def_cfa_1 (label, &cfa);
1858 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1861 dwarf2out_frame_debug_adjust_cfa (rtx pat, const char *label)
1865 gcc_assert (GET_CODE (pat) == SET);
1866 dest = XEXP (pat, 0);
1867 src = XEXP (pat, 1);
1869 switch (GET_CODE (src))
1872 gcc_assert (REGNO (XEXP (src, 0)) == cfa.reg);
1873 cfa.offset -= INTVAL (XEXP (src, 1));
1883 cfa.reg = REGNO (dest);
1884 gcc_assert (cfa.indirect == 0);
1886 def_cfa_1 (label, &cfa);
1889 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1892 dwarf2out_frame_debug_cfa_offset (rtx set, const char *label)
1894 HOST_WIDE_INT offset;
1895 rtx src, addr, span;
1897 src = XEXP (set, 1);
1898 addr = XEXP (set, 0);
1899 gcc_assert (MEM_P (addr));
1900 addr = XEXP (addr, 0);
1902 /* As documented, only consider extremely simple addresses. */
1903 switch (GET_CODE (addr))
1906 gcc_assert (REGNO (addr) == cfa.reg);
1907 offset = -cfa.offset;
1910 gcc_assert (REGNO (XEXP (addr, 0)) == cfa.reg);
1911 offset = INTVAL (XEXP (addr, 1)) - cfa.offset;
1917 span = targetm.dwarf_register_span (src);
1919 /* ??? We'd like to use queue_reg_save, but we need to come up with
1920 a different flushing heuristic for epilogues. */
1922 reg_save (label, DWARF_FRAME_REGNUM (REGNO (src)), INVALID_REGNUM, offset);
1925 /* We have a PARALLEL describing where the contents of SRC live.
1926 Queue register saves for each piece of the PARALLEL. */
1929 HOST_WIDE_INT span_offset = offset;
1931 gcc_assert (GET_CODE (span) == PARALLEL);
1933 limit = XVECLEN (span, 0);
1934 for (par_index = 0; par_index < limit; par_index++)
1936 rtx elem = XVECEXP (span, 0, par_index);
1938 reg_save (label, DWARF_FRAME_REGNUM (REGNO (elem)),
1939 INVALID_REGNUM, span_offset);
1940 span_offset += GET_MODE_SIZE (GET_MODE (elem));
1945 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
1948 dwarf2out_frame_debug_cfa_register (rtx set, const char *label)
1951 unsigned sregno, dregno;
1953 src = XEXP (set, 1);
1954 dest = XEXP (set, 0);
1957 sregno = DWARF_FRAME_RETURN_COLUMN;
1959 sregno = DWARF_FRAME_REGNUM (REGNO (src));
1961 dregno = DWARF_FRAME_REGNUM (REGNO (dest));
1963 /* ??? We'd like to use queue_reg_save, but we need to come up with
1964 a different flushing heuristic for epilogues. */
1965 reg_save (label, sregno, dregno, 0);
1968 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
1971 dwarf2out_frame_debug_cfa_restore (rtx reg, const char *label)
1973 dw_cfi_ref cfi = new_cfi ();
1974 unsigned int regno = DWARF_FRAME_REGNUM (REGNO (reg));
1976 cfi->dw_cfi_opc = (regno & ~0x3f ? DW_CFA_restore_extended : DW_CFA_restore);
1977 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = regno;
1979 add_fde_cfi (label, cfi);
1982 /* Record call frame debugging information for an expression EXPR,
1983 which either sets SP or FP (adjusting how we calculate the frame
1984 address) or saves a register to the stack or another register.
1985 LABEL indicates the address of EXPR.
1987 This function encodes a state machine mapping rtxes to actions on
1988 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1989 users need not read the source code.
1991 The High-Level Picture
1993 Changes in the register we use to calculate the CFA: Currently we
1994 assume that if you copy the CFA register into another register, we
1995 should take the other one as the new CFA register; this seems to
1996 work pretty well. If it's wrong for some target, it's simple
1997 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1999 Changes in the register we use for saving registers to the stack:
2000 This is usually SP, but not always. Again, we deduce that if you
2001 copy SP into another register (and SP is not the CFA register),
2002 then the new register is the one we will be using for register
2003 saves. This also seems to work.
2005 Register saves: There's not much guesswork about this one; if
2006 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
2007 register save, and the register used to calculate the destination
2008 had better be the one we think we're using for this purpose.
2009 It's also assumed that a copy from a call-saved register to another
2010 register is saving that register if RTX_FRAME_RELATED_P is set on
2011 that instruction. If the copy is from a call-saved register to
2012 the *same* register, that means that the register is now the same
2013 value as in the caller.
2015 Except: If the register being saved is the CFA register, and the
2016 offset is nonzero, we are saving the CFA, so we assume we have to
2017 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
2018 the intent is to save the value of SP from the previous frame.
2020 In addition, if a register has previously been saved to a different
2023 Invariants / Summaries of Rules
2025 cfa current rule for calculating the CFA. It usually
2026 consists of a register and an offset.
2027 cfa_store register used by prologue code to save things to the stack
2028 cfa_store.offset is the offset from the value of
2029 cfa_store.reg to the actual CFA
2030 cfa_temp register holding an integral value. cfa_temp.offset
2031 stores the value, which will be used to adjust the
2032 stack pointer. cfa_temp is also used like cfa_store,
2033 to track stores to the stack via fp or a temp reg.
2035 Rules 1- 4: Setting a register's value to cfa.reg or an expression
2036 with cfa.reg as the first operand changes the cfa.reg and its
2037 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
2040 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
2041 expression yielding a constant. This sets cfa_temp.reg
2042 and cfa_temp.offset.
2044 Rule 5: Create a new register cfa_store used to save items to the
2047 Rules 10-14: Save a register to the stack. Define offset as the
2048 difference of the original location and cfa_store's
2049 location (or cfa_temp's location if cfa_temp is used).
2051 Rules 16-20: If AND operation happens on sp in prologue, we assume
2052 stack is realigned. We will use a group of DW_OP_XXX
2053 expressions to represent the location of the stored
2054 register instead of CFA+offset.
2058 "{a,b}" indicates a choice of a xor b.
2059 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2062 (set <reg1> <reg2>:cfa.reg)
2063 effects: cfa.reg = <reg1>
2064 cfa.offset unchanged
2065 cfa_temp.reg = <reg1>
2066 cfa_temp.offset = cfa.offset
2069 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2070 {<const_int>,<reg>:cfa_temp.reg}))
2071 effects: cfa.reg = sp if fp used
2072 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2073 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2074 if cfa_store.reg==sp
2077 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2078 effects: cfa.reg = fp
2079 cfa_offset += +/- <const_int>
2082 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2083 constraints: <reg1> != fp
2085 effects: cfa.reg = <reg1>
2086 cfa_temp.reg = <reg1>
2087 cfa_temp.offset = cfa.offset
2090 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2091 constraints: <reg1> != fp
2093 effects: cfa_store.reg = <reg1>
2094 cfa_store.offset = cfa.offset - cfa_temp.offset
2097 (set <reg> <const_int>)
2098 effects: cfa_temp.reg = <reg>
2099 cfa_temp.offset = <const_int>
2102 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2103 effects: cfa_temp.reg = <reg1>
2104 cfa_temp.offset |= <const_int>
2107 (set <reg> (high <exp>))
2111 (set <reg> (lo_sum <exp> <const_int>))
2112 effects: cfa_temp.reg = <reg>
2113 cfa_temp.offset = <const_int>
2116 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2117 effects: cfa_store.offset -= <const_int>
2118 cfa.offset = cfa_store.offset if cfa.reg == sp
2120 cfa.base_offset = -cfa_store.offset
2123 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2124 effects: cfa_store.offset += -/+ mode_size(mem)
2125 cfa.offset = cfa_store.offset if cfa.reg == sp
2127 cfa.base_offset = -cfa_store.offset
2130 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2133 effects: cfa.reg = <reg1>
2134 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2137 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2138 effects: cfa.reg = <reg1>
2139 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2142 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2143 effects: cfa.reg = <reg1>
2144 cfa.base_offset = -cfa_temp.offset
2145 cfa_temp.offset -= mode_size(mem)
2148 (set <reg> {unspec, unspec_volatile})
2149 effects: target-dependent
2152 (set sp (and: sp <const_int>))
2153 constraints: cfa_store.reg == sp
2154 effects: current_fde.stack_realign = 1
2155 cfa_store.offset = 0
2156 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2159 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2160 effects: cfa_store.offset += -/+ mode_size(mem)
2163 (set (mem ({pre_inc, pre_dec} sp)) fp)
2164 constraints: fde->stack_realign == 1
2165 effects: cfa_store.offset = 0
2166 cfa.reg != HARD_FRAME_POINTER_REGNUM
2169 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2170 constraints: fde->stack_realign == 1
2172 && cfa.indirect == 0
2173 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2174 effects: Use DW_CFA_def_cfa_expression to define cfa
2175 cfa.reg == fde->drap_reg */
2178 dwarf2out_frame_debug_expr (rtx expr, const char *label)
2180 rtx src, dest, span;
2181 HOST_WIDE_INT offset;
2184 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2185 the PARALLEL independently. The first element is always processed if
2186 it is a SET. This is for backward compatibility. Other elements
2187 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2188 flag is set in them. */
2189 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
2192 int limit = XVECLEN (expr, 0);
2195 /* PARALLELs have strict read-modify-write semantics, so we
2196 ought to evaluate every rvalue before changing any lvalue.
2197 It's cumbersome to do that in general, but there's an
2198 easy approximation that is enough for all current users:
2199 handle register saves before register assignments. */
2200 if (GET_CODE (expr) == PARALLEL)
2201 for (par_index = 0; par_index < limit; par_index++)
2203 elem = XVECEXP (expr, 0, par_index);
2204 if (GET_CODE (elem) == SET
2205 && MEM_P (SET_DEST (elem))
2206 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2207 dwarf2out_frame_debug_expr (elem, label);
2210 for (par_index = 0; par_index < limit; par_index++)
2212 elem = XVECEXP (expr, 0, par_index);
2213 if (GET_CODE (elem) == SET
2214 && (!MEM_P (SET_DEST (elem)) || GET_CODE (expr) == SEQUENCE)
2215 && (RTX_FRAME_RELATED_P (elem) || par_index == 0))
2216 dwarf2out_frame_debug_expr (elem, label);
2217 else if (GET_CODE (elem) == SET
2219 && !RTX_FRAME_RELATED_P (elem))
2221 /* Stack adjustment combining might combine some post-prologue
2222 stack adjustment into a prologue stack adjustment. */
2223 HOST_WIDE_INT offset = stack_adjust_offset (elem, args_size, 0);
2226 dwarf2out_stack_adjust (offset, label);
2232 gcc_assert (GET_CODE (expr) == SET);
2234 src = SET_SRC (expr);
2235 dest = SET_DEST (expr);
2239 rtx rsi = reg_saved_in (src);
2244 fde = current_fde ();
2246 switch (GET_CODE (dest))
2249 switch (GET_CODE (src))
2251 /* Setting FP from SP. */
2253 if (cfa.reg == (unsigned) REGNO (src))
2256 /* Update the CFA rule wrt SP or FP. Make sure src is
2257 relative to the current CFA register.
2259 We used to require that dest be either SP or FP, but the
2260 ARM copies SP to a temporary register, and from there to
2261 FP. So we just rely on the backends to only set
2262 RTX_FRAME_RELATED_P on appropriate insns. */
2263 cfa.reg = REGNO (dest);
2264 cfa_temp.reg = cfa.reg;
2265 cfa_temp.offset = cfa.offset;
2269 /* Saving a register in a register. */
2270 gcc_assert (!fixed_regs [REGNO (dest)]
2271 /* For the SPARC and its register window. */
2272 || (DWARF_FRAME_REGNUM (REGNO (src))
2273 == DWARF_FRAME_RETURN_COLUMN));
2275 /* After stack is aligned, we can only save SP in FP
2276 if drap register is used. In this case, we have
2277 to restore stack pointer with the CFA value and we
2278 don't generate this DWARF information. */
2280 && fde->stack_realign
2281 && REGNO (src) == STACK_POINTER_REGNUM)
2282 gcc_assert (REGNO (dest) == HARD_FRAME_POINTER_REGNUM
2283 && fde->drap_reg != INVALID_REGNUM
2284 && cfa.reg != REGNO (src));
2286 queue_reg_save (label, src, dest, 0);
2293 if (dest == stack_pointer_rtx)
2297 switch (GET_CODE (XEXP (src, 1)))
2300 offset = INTVAL (XEXP (src, 1));
2303 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
2305 offset = cfa_temp.offset;
2311 if (XEXP (src, 0) == hard_frame_pointer_rtx)
2313 /* Restoring SP from FP in the epilogue. */
2314 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
2315 cfa.reg = STACK_POINTER_REGNUM;
2317 else if (GET_CODE (src) == LO_SUM)
2318 /* Assume we've set the source reg of the LO_SUM from sp. */
2321 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
2323 if (GET_CODE (src) != MINUS)
2325 if (cfa.reg == STACK_POINTER_REGNUM)
2326 cfa.offset += offset;
2327 if (cfa_store.reg == STACK_POINTER_REGNUM)
2328 cfa_store.offset += offset;
2330 else if (dest == hard_frame_pointer_rtx)
2333 /* Either setting the FP from an offset of the SP,
2334 or adjusting the FP */
2335 gcc_assert (frame_pointer_needed);
2337 gcc_assert (REG_P (XEXP (src, 0))
2338 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
2339 && CONST_INT_P (XEXP (src, 1)));
2340 offset = INTVAL (XEXP (src, 1));
2341 if (GET_CODE (src) != MINUS)
2343 cfa.offset += offset;
2344 cfa.reg = HARD_FRAME_POINTER_REGNUM;
2348 gcc_assert (GET_CODE (src) != MINUS);
2351 if (REG_P (XEXP (src, 0))
2352 && REGNO (XEXP (src, 0)) == cfa.reg
2353 && CONST_INT_P (XEXP (src, 1)))
2355 /* Setting a temporary CFA register that will be copied
2356 into the FP later on. */
2357 offset = - INTVAL (XEXP (src, 1));
2358 cfa.offset += offset;
2359 cfa.reg = REGNO (dest);
2360 /* Or used to save regs to the stack. */
2361 cfa_temp.reg = cfa.reg;
2362 cfa_temp.offset = cfa.offset;
2366 else if (REG_P (XEXP (src, 0))
2367 && REGNO (XEXP (src, 0)) == cfa_temp.reg
2368 && XEXP (src, 1) == stack_pointer_rtx)
2370 /* Setting a scratch register that we will use instead
2371 of SP for saving registers to the stack. */
2372 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
2373 cfa_store.reg = REGNO (dest);
2374 cfa_store.offset = cfa.offset - cfa_temp.offset;
2378 else if (GET_CODE (src) == LO_SUM
2379 && CONST_INT_P (XEXP (src, 1)))
2381 cfa_temp.reg = REGNO (dest);
2382 cfa_temp.offset = INTVAL (XEXP (src, 1));
2391 cfa_temp.reg = REGNO (dest);
2392 cfa_temp.offset = INTVAL (src);
2397 gcc_assert (REG_P (XEXP (src, 0))
2398 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
2399 && CONST_INT_P (XEXP (src, 1)));
2401 if ((unsigned) REGNO (dest) != cfa_temp.reg)
2402 cfa_temp.reg = REGNO (dest);
2403 cfa_temp.offset |= INTVAL (XEXP (src, 1));
2406 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2407 which will fill in all of the bits. */
2414 case UNSPEC_VOLATILE:
2415 gcc_assert (targetm.dwarf_handle_frame_unspec);
2416 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
2421 /* If this AND operation happens on stack pointer in prologue,
2422 we assume the stack is realigned and we extract the
2424 if (fde && XEXP (src, 0) == stack_pointer_rtx)
2426 gcc_assert (cfa_store.reg == REGNO (XEXP (src, 0)));
2427 fde->stack_realign = 1;
2428 fde->stack_realignment = INTVAL (XEXP (src, 1));
2429 cfa_store.offset = 0;
2431 if (cfa.reg != STACK_POINTER_REGNUM
2432 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2433 fde->drap_reg = cfa.reg;
2441 def_cfa_1 (label, &cfa);
2446 /* Saving a register to the stack. Make sure dest is relative to the
2448 switch (GET_CODE (XEXP (dest, 0)))
2453 /* We can't handle variable size modifications. */
2454 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
2456 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
2458 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
2459 && cfa_store.reg == STACK_POINTER_REGNUM);
2461 cfa_store.offset += offset;
2462 if (cfa.reg == STACK_POINTER_REGNUM)
2463 cfa.offset = cfa_store.offset;
2465 offset = -cfa_store.offset;
2471 offset = GET_MODE_SIZE (GET_MODE (dest));
2472 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
2475 gcc_assert ((REGNO (XEXP (XEXP (dest, 0), 0))
2476 == STACK_POINTER_REGNUM)
2477 && cfa_store.reg == STACK_POINTER_REGNUM);
2479 cfa_store.offset += offset;
2481 /* Rule 18: If stack is aligned, we will use FP as a
2482 reference to represent the address of the stored
2485 && fde->stack_realign
2486 && src == hard_frame_pointer_rtx)
2488 gcc_assert (cfa.reg != HARD_FRAME_POINTER_REGNUM);
2489 cfa_store.offset = 0;
2492 if (cfa.reg == STACK_POINTER_REGNUM)
2493 cfa.offset = cfa_store.offset;
2495 offset = -cfa_store.offset;
2499 /* With an offset. */
2506 gcc_assert (CONST_INT_P (XEXP (XEXP (dest, 0), 1))
2507 && REG_P (XEXP (XEXP (dest, 0), 0)));
2508 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
2509 if (GET_CODE (XEXP (dest, 0)) == MINUS)
2512 regno = REGNO (XEXP (XEXP (dest, 0), 0));
2514 if (cfa_store.reg == (unsigned) regno)
2515 offset -= cfa_store.offset;
2518 gcc_assert (cfa_temp.reg == (unsigned) regno);
2519 offset -= cfa_temp.offset;
2525 /* Without an offset. */
2528 int regno = REGNO (XEXP (dest, 0));
2530 if (cfa_store.reg == (unsigned) regno)
2531 offset = -cfa_store.offset;
2534 gcc_assert (cfa_temp.reg == (unsigned) regno);
2535 offset = -cfa_temp.offset;
2542 gcc_assert (cfa_temp.reg
2543 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
2544 offset = -cfa_temp.offset;
2545 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
2553 /* If the source operand of this MEM operation is not a
2554 register, basically the source is return address. Here
2555 we only care how much stack grew and we don't save it. */
2559 if (REGNO (src) != STACK_POINTER_REGNUM
2560 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
2561 && (unsigned) REGNO (src) == cfa.reg)
2563 /* We're storing the current CFA reg into the stack. */
2565 if (cfa.offset == 0)
2568 /* If stack is aligned, putting CFA reg into stack means
2569 we can no longer use reg + offset to represent CFA.
2570 Here we use DW_CFA_def_cfa_expression instead. The
2571 result of this expression equals to the original CFA
2574 && fde->stack_realign
2575 && cfa.indirect == 0
2576 && cfa.reg != HARD_FRAME_POINTER_REGNUM)
2578 dw_cfa_location cfa_exp;
2580 gcc_assert (fde->drap_reg == cfa.reg);
2582 cfa_exp.indirect = 1;
2583 cfa_exp.reg = HARD_FRAME_POINTER_REGNUM;
2584 cfa_exp.base_offset = offset;
2587 fde->drap_reg_saved = 1;
2589 def_cfa_1 (label, &cfa_exp);
2593 /* If the source register is exactly the CFA, assume
2594 we're saving SP like any other register; this happens
2596 def_cfa_1 (label, &cfa);
2597 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
2602 /* Otherwise, we'll need to look in the stack to
2603 calculate the CFA. */
2604 rtx x = XEXP (dest, 0);
2608 gcc_assert (REG_P (x));
2610 cfa.reg = REGNO (x);
2611 cfa.base_offset = offset;
2613 def_cfa_1 (label, &cfa);
2618 def_cfa_1 (label, &cfa);
2620 span = targetm.dwarf_register_span (src);
2623 queue_reg_save (label, src, NULL_RTX, offset);
2626 /* We have a PARALLEL describing where the contents of SRC
2627 live. Queue register saves for each piece of the
2631 HOST_WIDE_INT span_offset = offset;
2633 gcc_assert (GET_CODE (span) == PARALLEL);
2635 limit = XVECLEN (span, 0);
2636 for (par_index = 0; par_index < limit; par_index++)
2638 rtx elem = XVECEXP (span, 0, par_index);
2640 queue_reg_save (label, elem, NULL_RTX, span_offset);
2641 span_offset += GET_MODE_SIZE (GET_MODE (elem));
2652 /* Record call frame debugging information for INSN, which either
2653 sets SP or FP (adjusting how we calculate the frame address) or saves a
2654 register to the stack. If INSN is NULL_RTX, initialize our state.
2656 If AFTER_P is false, we're being called before the insn is emitted,
2657 otherwise after. Call instructions get invoked twice. */
2660 dwarf2out_frame_debug (rtx insn, bool after_p)
2664 bool handled_one = false;
2666 if (insn == NULL_RTX)
2670 /* Flush any queued register saves. */
2671 flush_queued_reg_saves ();
2673 /* Set up state for generating call frame debug info. */
2676 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
2678 cfa.reg = STACK_POINTER_REGNUM;
2681 cfa_temp.offset = 0;
2683 for (i = 0; i < num_regs_saved_in_regs; i++)
2685 regs_saved_in_regs[i].orig_reg = NULL_RTX;
2686 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
2688 num_regs_saved_in_regs = 0;
2690 if (barrier_args_size)
2692 XDELETEVEC (barrier_args_size);
2693 barrier_args_size = NULL;
2698 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
2699 flush_queued_reg_saves ();
2701 if (!RTX_FRAME_RELATED_P (insn))
2703 /* ??? This should be done unconditionally since stack adjustments
2704 matter if the stack pointer is not the CFA register anymore but
2705 is still used to save registers. */
2706 if (!ACCUMULATE_OUTGOING_ARGS)
2707 dwarf2out_notice_stack_adjust (insn, after_p);
2711 label = dwarf2out_cfi_label (false);
2713 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
2714 switch (REG_NOTE_KIND (note))
2716 case REG_FRAME_RELATED_EXPR:
2717 insn = XEXP (note, 0);
2720 case REG_CFA_DEF_CFA:
2721 dwarf2out_frame_debug_def_cfa (XEXP (note, 0), label);
2725 case REG_CFA_ADJUST_CFA:
2730 if (GET_CODE (n) == PARALLEL)
2731 n = XVECEXP (n, 0, 0);
2733 dwarf2out_frame_debug_adjust_cfa (n, label);
2737 case REG_CFA_OFFSET:
2740 n = single_set (insn);
2741 dwarf2out_frame_debug_cfa_offset (n, label);
2745 case REG_CFA_REGISTER:
2750 if (GET_CODE (n) == PARALLEL)
2751 n = XVECEXP (n, 0, 0);
2753 dwarf2out_frame_debug_cfa_register (n, label);
2757 case REG_CFA_RESTORE:
2762 if (GET_CODE (n) == PARALLEL)
2763 n = XVECEXP (n, 0, 0);
2766 dwarf2out_frame_debug_cfa_restore (n, label);
2770 case REG_CFA_SET_VDRAP:
2774 dw_fde_ref fde = current_fde ();
2777 gcc_assert (fde->vdrap_reg == INVALID_REGNUM);
2779 fde->vdrap_reg = REGNO (n);
2791 insn = PATTERN (insn);
2793 dwarf2out_frame_debug_expr (insn, label);
2796 /* Determine if we need to save and restore CFI information around this
2797 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2798 we do need to save/restore, then emit the save now, and insert a
2799 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2802 dwarf2out_cfi_begin_epilogue (rtx insn)
2804 bool saw_frp = false;
2807 /* Scan forward to the return insn, noticing if there are possible
2808 frame related insns. */
2809 for (i = NEXT_INSN (insn); i ; i = NEXT_INSN (i))
2814 /* Look for both regular and sibcalls to end the block. */
2815 if (returnjump_p (i))
2817 if (CALL_P (i) && SIBLING_CALL_P (i))
2820 if (GET_CODE (PATTERN (i)) == SEQUENCE)
2823 rtx seq = PATTERN (i);
2825 if (returnjump_p (XVECEXP (seq, 0, 0)))
2827 if (CALL_P (XVECEXP (seq, 0, 0))
2828 && SIBLING_CALL_P (XVECEXP (seq, 0, 0)))
2831 for (idx = 0; idx < XVECLEN (seq, 0); idx++)
2832 if (RTX_FRAME_RELATED_P (XVECEXP (seq, 0, idx)))
2836 if (RTX_FRAME_RELATED_P (i))
2840 /* If the port doesn't emit epilogue unwind info, we don't need a
2841 save/restore pair. */
2845 /* Otherwise, search forward to see if the return insn was the last
2846 basic block of the function. If so, we don't need save/restore. */
2847 gcc_assert (i != NULL);
2848 i = next_real_insn (i);
2852 /* Insert the restore before that next real insn in the stream, and before
2853 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2854 properly nested. This should be after any label or alignment. This
2855 will be pushed into the CFI stream by the function below. */
2858 rtx p = PREV_INSN (i);
2861 if (NOTE_KIND (p) == NOTE_INSN_BASIC_BLOCK)
2865 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE, i);
2867 emit_cfa_remember = true;
2869 /* And emulate the state save. */
2870 gcc_assert (!cfa_remember.in_use);
2872 cfa_remember.in_use = 1;
2875 /* A "subroutine" of dwarf2out_cfi_begin_epilogue. Emit the restore
2879 dwarf2out_frame_debug_restore_state (void)
2881 dw_cfi_ref cfi = new_cfi ();
2882 const char *label = dwarf2out_cfi_label (false);
2884 cfi->dw_cfi_opc = DW_CFA_restore_state;
2885 add_fde_cfi (label, cfi);
2887 gcc_assert (cfa_remember.in_use);
2889 cfa_remember.in_use = 0;
2894 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2895 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2896 (enum dwarf_call_frame_info cfi);
2898 static enum dw_cfi_oprnd_type
2899 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
2904 case DW_CFA_GNU_window_save:
2905 case DW_CFA_remember_state:
2906 case DW_CFA_restore_state:
2907 return dw_cfi_oprnd_unused;
2909 case DW_CFA_set_loc:
2910 case DW_CFA_advance_loc1:
2911 case DW_CFA_advance_loc2:
2912 case DW_CFA_advance_loc4:
2913 case DW_CFA_MIPS_advance_loc8:
2914 return dw_cfi_oprnd_addr;
2917 case DW_CFA_offset_extended:
2918 case DW_CFA_def_cfa:
2919 case DW_CFA_offset_extended_sf:
2920 case DW_CFA_def_cfa_sf:
2921 case DW_CFA_restore:
2922 case DW_CFA_restore_extended:
2923 case DW_CFA_undefined:
2924 case DW_CFA_same_value:
2925 case DW_CFA_def_cfa_register:
2926 case DW_CFA_register:
2927 case DW_CFA_expression:
2928 return dw_cfi_oprnd_reg_num;
2930 case DW_CFA_def_cfa_offset:
2931 case DW_CFA_GNU_args_size:
2932 case DW_CFA_def_cfa_offset_sf:
2933 return dw_cfi_oprnd_offset;
2935 case DW_CFA_def_cfa_expression:
2936 return dw_cfi_oprnd_loc;
2943 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2944 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2945 (enum dwarf_call_frame_info cfi);
2947 static enum dw_cfi_oprnd_type
2948 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
2952 case DW_CFA_def_cfa:
2953 case DW_CFA_def_cfa_sf:
2955 case DW_CFA_offset_extended_sf:
2956 case DW_CFA_offset_extended:
2957 return dw_cfi_oprnd_offset;
2959 case DW_CFA_register:
2960 return dw_cfi_oprnd_reg_num;
2962 case DW_CFA_expression:
2963 return dw_cfi_oprnd_loc;
2966 return dw_cfi_oprnd_unused;
2970 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2972 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
2973 switch to the data section instead, and write out a synthetic start label
2974 for collect2 the first time around. */
2977 switch_to_eh_frame_section (bool back)
2981 #ifdef EH_FRAME_SECTION_NAME
2982 if (eh_frame_section == 0)
2986 if (EH_TABLES_CAN_BE_READ_ONLY)
2992 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2994 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2996 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2998 flags = ((! flag_pic
2999 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
3000 && (fde_encoding & 0x70) != DW_EH_PE_aligned
3001 && (per_encoding & 0x70) != DW_EH_PE_absptr
3002 && (per_encoding & 0x70) != DW_EH_PE_aligned
3003 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
3004 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
3005 ? 0 : SECTION_WRITE);
3008 flags = SECTION_WRITE;
3009 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
3013 if (eh_frame_section)
3014 switch_to_section (eh_frame_section);
3017 /* We have no special eh_frame section. Put the information in
3018 the data section and emit special labels to guide collect2. */
3019 switch_to_section (data_section);
3023 label = get_file_function_name ("F");
3024 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3025 targetm.asm_out.globalize_label (asm_out_file,
3026 IDENTIFIER_POINTER (label));
3027 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
3032 /* Switch [BACK] to the eh or debug frame table section, depending on
3036 switch_to_frame_table_section (int for_eh, bool back)
3039 switch_to_eh_frame_section (back);
3042 if (!debug_frame_section)
3043 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
3044 SECTION_DEBUG, NULL);
3045 switch_to_section (debug_frame_section);
3049 /* Output a Call Frame Information opcode and its operand(s). */
3052 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
3057 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
3058 dw2_asm_output_data (1, (cfi->dw_cfi_opc
3059 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
3060 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
3061 ((unsigned HOST_WIDE_INT)
3062 cfi->dw_cfi_oprnd1.dw_cfi_offset));
3063 else if (cfi->dw_cfi_opc == DW_CFA_offset)
3065 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3066 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3067 "DW_CFA_offset, column %#lx", r);
3068 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3069 dw2_asm_output_data_uleb128 (off, NULL);
3071 else if (cfi->dw_cfi_opc == DW_CFA_restore)
3073 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3074 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
3075 "DW_CFA_restore, column %#lx", r);
3079 dw2_asm_output_data (1, cfi->dw_cfi_opc,
3080 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
3082 switch (cfi->dw_cfi_opc)
3084 case DW_CFA_set_loc:
3086 dw2_asm_output_encoded_addr_rtx (
3087 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3088 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
3091 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
3092 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
3093 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3096 case DW_CFA_advance_loc1:
3097 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3098 fde->dw_fde_current_label, NULL);
3099 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3102 case DW_CFA_advance_loc2:
3103 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3104 fde->dw_fde_current_label, NULL);
3105 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3108 case DW_CFA_advance_loc4:
3109 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3110 fde->dw_fde_current_label, NULL);
3111 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3114 case DW_CFA_MIPS_advance_loc8:
3115 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
3116 fde->dw_fde_current_label, NULL);
3117 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
3120 case DW_CFA_offset_extended:
3121 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3122 dw2_asm_output_data_uleb128 (r, NULL);
3123 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3124 dw2_asm_output_data_uleb128 (off, NULL);
3127 case DW_CFA_def_cfa:
3128 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3129 dw2_asm_output_data_uleb128 (r, NULL);
3130 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
3133 case DW_CFA_offset_extended_sf:
3134 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3135 dw2_asm_output_data_uleb128 (r, NULL);
3136 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3137 dw2_asm_output_data_sleb128 (off, NULL);
3140 case DW_CFA_def_cfa_sf:
3141 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3142 dw2_asm_output_data_uleb128 (r, NULL);
3143 off = div_data_align (cfi->dw_cfi_oprnd2.dw_cfi_offset);
3144 dw2_asm_output_data_sleb128 (off, NULL);
3147 case DW_CFA_restore_extended:
3148 case DW_CFA_undefined:
3149 case DW_CFA_same_value:
3150 case DW_CFA_def_cfa_register:
3151 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3152 dw2_asm_output_data_uleb128 (r, NULL);
3155 case DW_CFA_register:
3156 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
3157 dw2_asm_output_data_uleb128 (r, NULL);
3158 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
3159 dw2_asm_output_data_uleb128 (r, NULL);
3162 case DW_CFA_def_cfa_offset:
3163 case DW_CFA_GNU_args_size:
3164 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
3167 case DW_CFA_def_cfa_offset_sf:
3168 off = div_data_align (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3169 dw2_asm_output_data_sleb128 (off, NULL);
3172 case DW_CFA_GNU_window_save:
3175 case DW_CFA_def_cfa_expression:
3176 case DW_CFA_expression:
3177 output_cfa_loc (cfi);
3180 case DW_CFA_GNU_negative_offset_extended:
3181 /* Obsoleted by DW_CFA_offset_extended_sf. */
3190 /* Similar, but do it via assembler directives instead. */
3193 output_cfi_directive (dw_cfi_ref cfi)
3195 unsigned long r, r2;
3197 switch (cfi->dw_cfi_opc)
3199 case DW_CFA_advance_loc:
3200 case DW_CFA_advance_loc1:
3201 case DW_CFA_advance_loc2:
3202 case DW_CFA_advance_loc4:
3203 case DW_CFA_MIPS_advance_loc8:
3204 case DW_CFA_set_loc:
3205 /* Should only be created by add_fde_cfi in a code path not
3206 followed when emitting via directives. The assembler is
3207 going to take care of this for us. */
3211 case DW_CFA_offset_extended:
3212 case DW_CFA_offset_extended_sf:
3213 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3214 fprintf (asm_out_file, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3215 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3218 case DW_CFA_restore:
3219 case DW_CFA_restore_extended:
3220 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3221 fprintf (asm_out_file, "\t.cfi_restore %lu\n", r);
3224 case DW_CFA_undefined:
3225 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3226 fprintf (asm_out_file, "\t.cfi_undefined %lu\n", r);
3229 case DW_CFA_same_value:
3230 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3231 fprintf (asm_out_file, "\t.cfi_same_value %lu\n", r);
3234 case DW_CFA_def_cfa:
3235 case DW_CFA_def_cfa_sf:
3236 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3237 fprintf (asm_out_file, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC"\n",
3238 r, cfi->dw_cfi_oprnd2.dw_cfi_offset);
3241 case DW_CFA_def_cfa_register:
3242 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3243 fprintf (asm_out_file, "\t.cfi_def_cfa_register %lu\n", r);
3246 case DW_CFA_register:
3247 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1);
3248 r2 = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, 1);
3249 fprintf (asm_out_file, "\t.cfi_register %lu, %lu\n", r, r2);
3252 case DW_CFA_def_cfa_offset:
3253 case DW_CFA_def_cfa_offset_sf:
3254 fprintf (asm_out_file, "\t.cfi_def_cfa_offset "
3255 HOST_WIDE_INT_PRINT_DEC"\n",
3256 cfi->dw_cfi_oprnd1.dw_cfi_offset);
3259 case DW_CFA_remember_state:
3260 fprintf (asm_out_file, "\t.cfi_remember_state\n");
3262 case DW_CFA_restore_state:
3263 fprintf (asm_out_file, "\t.cfi_restore_state\n");
3266 case DW_CFA_GNU_args_size:
3267 fprintf (asm_out_file, "\t.cfi_escape %#x,", DW_CFA_GNU_args_size);
3268 dw2_asm_output_data_uleb128_raw (cfi->dw_cfi_oprnd1.dw_cfi_offset);
3270 fprintf (asm_out_file, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC,
3271 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
3272 fputc ('\n', asm_out_file);
3275 case DW_CFA_GNU_window_save:
3276 fprintf (asm_out_file, "\t.cfi_window_save\n");
3279 case DW_CFA_def_cfa_expression:
3280 case DW_CFA_expression:
3281 fprintf (asm_out_file, "\t.cfi_escape %#x,", cfi->dw_cfi_opc);
3282 output_cfa_loc_raw (cfi);
3283 fputc ('\n', asm_out_file);
3291 DEF_VEC_P (dw_cfi_ref);
3292 DEF_VEC_ALLOC_P (dw_cfi_ref, heap);
3294 /* Output CFIs to bring current FDE to the same state as after executing
3295 CFIs in CFI chain. DO_CFI_ASM is true if .cfi_* directives shall
3296 be emitted, false otherwise. If it is false, FDE and FOR_EH are the
3297 other arguments to pass to output_cfi. */
3300 output_cfis (dw_cfi_ref cfi, bool do_cfi_asm, dw_fde_ref fde, bool for_eh)
3302 struct dw_cfi_struct cfi_buf;
3304 dw_cfi_ref cfi_args_size = NULL, cfi_cfa = NULL, cfi_cfa_offset = NULL;
3305 VEC (dw_cfi_ref, heap) *regs = VEC_alloc (dw_cfi_ref, heap, 32);
3306 unsigned int len, idx;
3308 for (;; cfi = cfi->dw_cfi_next)
3309 switch (cfi ? cfi->dw_cfi_opc : DW_CFA_nop)
3311 case DW_CFA_advance_loc:
3312 case DW_CFA_advance_loc1:
3313 case DW_CFA_advance_loc2:
3314 case DW_CFA_advance_loc4:
3315 case DW_CFA_MIPS_advance_loc8:
3316 case DW_CFA_set_loc:
3317 /* All advances should be ignored. */
3319 case DW_CFA_remember_state:
3321 dw_cfi_ref args_size = cfi_args_size;
3323 /* Skip everything between .cfi_remember_state and
3324 .cfi_restore_state. */
3325 for (cfi2 = cfi->dw_cfi_next; cfi2; cfi2 = cfi2->dw_cfi_next)
3326 if (cfi2->dw_cfi_opc == DW_CFA_restore_state)
3328 else if (cfi2->dw_cfi_opc == DW_CFA_GNU_args_size)
3331 gcc_assert (cfi2->dw_cfi_opc != DW_CFA_remember_state);
3338 cfi_args_size = args_size;
3342 case DW_CFA_GNU_args_size:
3343 cfi_args_size = cfi;
3345 case DW_CFA_GNU_window_save:
3348 case DW_CFA_offset_extended:
3349 case DW_CFA_offset_extended_sf:
3350 case DW_CFA_restore:
3351 case DW_CFA_restore_extended:
3352 case DW_CFA_undefined:
3353 case DW_CFA_same_value:
3354 case DW_CFA_register:
3355 case DW_CFA_val_offset:
3356 case DW_CFA_val_offset_sf:
3357 case DW_CFA_expression:
3358 case DW_CFA_val_expression:
3359 case DW_CFA_GNU_negative_offset_extended:
3360 if (VEC_length (dw_cfi_ref, regs) <= cfi->dw_cfi_oprnd1.dw_cfi_reg_num)
3361 VEC_safe_grow_cleared (dw_cfi_ref, heap, regs,
3362 cfi->dw_cfi_oprnd1.dw_cfi_reg_num + 1);
3363 VEC_replace (dw_cfi_ref, regs, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, cfi);
3365 case DW_CFA_def_cfa:
3366 case DW_CFA_def_cfa_sf:
3367 case DW_CFA_def_cfa_expression:
3369 cfi_cfa_offset = cfi;
3371 case DW_CFA_def_cfa_register:
3374 case DW_CFA_def_cfa_offset:
3375 case DW_CFA_def_cfa_offset_sf:
3376 cfi_cfa_offset = cfi;
3379 gcc_assert (cfi == NULL);
3381 len = VEC_length (dw_cfi_ref, regs);
3382 for (idx = 0; idx < len; idx++)
3384 cfi2 = VEC_replace (dw_cfi_ref, regs, idx, NULL);
3386 && cfi2->dw_cfi_opc != DW_CFA_restore
3387 && cfi2->dw_cfi_opc != DW_CFA_restore_extended)
3390 output_cfi_directive (cfi2);
3392 output_cfi (cfi2, fde, for_eh);
3395 if (cfi_cfa && cfi_cfa_offset && cfi_cfa_offset != cfi_cfa)
3397 gcc_assert (cfi_cfa->dw_cfi_opc != DW_CFA_def_cfa_expression);
3399 switch (cfi_cfa_offset->dw_cfi_opc)
3401 case DW_CFA_def_cfa_offset:
3402 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa;
3403 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3405 case DW_CFA_def_cfa_offset_sf:
3406 cfi_buf.dw_cfi_opc = DW_CFA_def_cfa_sf;
3407 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd1;
3409 case DW_CFA_def_cfa:
3410 case DW_CFA_def_cfa_sf:
3411 cfi_buf.dw_cfi_opc = cfi_cfa_offset->dw_cfi_opc;
3412 cfi_buf.dw_cfi_oprnd2 = cfi_cfa_offset->dw_cfi_oprnd2;
3419 else if (cfi_cfa_offset)
3420 cfi_cfa = cfi_cfa_offset;
3424 output_cfi_directive (cfi_cfa);
3426 output_cfi (cfi_cfa, fde, for_eh);
3429 cfi_cfa_offset = NULL;
3431 && cfi_args_size->dw_cfi_oprnd1.dw_cfi_offset)
3434 output_cfi_directive (cfi_args_size);
3436 output_cfi (cfi_args_size, fde, for_eh);
3438 cfi_args_size = NULL;
3441 VEC_free (dw_cfi_ref, heap, regs);
3444 else if (do_cfi_asm)
3445 output_cfi_directive (cfi);
3447 output_cfi (cfi, fde, for_eh);
3454 /* Output one FDE. */
3457 output_fde (dw_fde_ref fde, bool for_eh, bool second,
3458 char *section_start_label, int fde_encoding, char *augmentation,
3459 bool any_lsda_needed, int lsda_encoding)
3461 const char *begin, *end;
3462 static unsigned int j;
3463 char l1[20], l2[20];
3466 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
3468 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
3470 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
3471 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
3472 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3473 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3474 " indicating 64-bit DWARF extension");
3475 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3477 ASM_OUTPUT_LABEL (asm_out_file, l1);
3480 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
3482 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
3483 debug_frame_section, "FDE CIE offset");
3485 if (!fde->dw_fde_switched_sections)
3487 begin = fde->dw_fde_begin;
3488 end = fde->dw_fde_end;
3492 /* For the first section, prefer dw_fde_begin over
3493 dw_fde_{hot,cold}_section_label, as the latter
3494 might be separated from the real start of the
3495 function by alignment padding. */
3497 begin = fde->dw_fde_begin;
3498 else if (fde->dw_fde_switched_cold_to_hot)
3499 begin = fde->dw_fde_hot_section_label;
3501 begin = fde->dw_fde_unlikely_section_label;
3502 if (second ^ fde->dw_fde_switched_cold_to_hot)
3503 end = fde->dw_fde_unlikely_section_end_label;
3505 end = fde->dw_fde_hot_section_end_label;
3510 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
3511 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
3512 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
3513 "FDE initial location");
3514 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
3515 end, begin, "FDE address range");
3519 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
3520 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
3523 if (augmentation[0])
3525 if (any_lsda_needed)
3527 int size = size_of_encoded_value (lsda_encoding);
3529 if (lsda_encoding == DW_EH_PE_aligned)
3531 int offset = ( 4 /* Length */
3532 + 4 /* CIE offset */
3533 + 2 * size_of_encoded_value (fde_encoding)
3534 + 1 /* Augmentation size */ );
3535 int pad = -offset & (PTR_SIZE - 1);
3538 gcc_assert (size_of_uleb128 (size) == 1);
3541 dw2_asm_output_data_uleb128 (size, "Augmentation size");
3543 if (fde->uses_eh_lsda)
3545 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
3546 fde->funcdef_number);
3547 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
3548 gen_rtx_SYMBOL_REF (Pmode, l1),
3550 "Language Specific Data Area");
3554 if (lsda_encoding == DW_EH_PE_aligned)
3555 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
3556 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
3557 "Language Specific Data Area (none)");
3561 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3564 /* Loop through the Call Frame Instructions associated with
3566 fde->dw_fde_current_label = begin;
3567 if (!fde->dw_fde_switched_sections)
3568 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3569 output_cfi (cfi, fde, for_eh);
3572 if (fde->dw_fde_switch_cfi)
3573 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
3575 output_cfi (cfi, fde, for_eh);
3576 if (cfi == fde->dw_fde_switch_cfi)
3582 dw_cfi_ref cfi_next = fde->dw_fde_cfi;
3584 if (fde->dw_fde_switch_cfi)
3586 cfi_next = fde->dw_fde_switch_cfi->dw_cfi_next;
3587 fde->dw_fde_switch_cfi->dw_cfi_next = NULL;
3588 output_cfis (fde->dw_fde_cfi, false, fde, for_eh);
3589 fde->dw_fde_switch_cfi->dw_cfi_next = cfi_next;
3591 for (cfi = cfi_next; cfi != NULL; cfi = cfi->dw_cfi_next)
3592 output_cfi (cfi, fde, for_eh);
3595 /* If we are to emit a ref/link from function bodies to their frame tables,
3596 do it now. This is typically performed to make sure that tables
3597 associated with functions are dragged with them and not discarded in
3598 garbage collecting links. We need to do this on a per function basis to
3599 cope with -ffunction-sections. */
3601 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3602 /* Switch to the function section, emit the ref to the tables, and
3603 switch *back* into the table section. */
3604 switch_to_section (function_section (fde->decl));
3605 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
3606 switch_to_frame_table_section (for_eh, true);
3609 /* Pad the FDE out to an address sized boundary. */
3610 ASM_OUTPUT_ALIGN (asm_out_file,
3611 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
3612 ASM_OUTPUT_LABEL (asm_out_file, l2);
3617 /* Return true if frame description entry FDE is needed for EH. */
3620 fde_needed_for_eh_p (dw_fde_ref fde)
3622 if (flag_asynchronous_unwind_tables)
3625 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
3628 if (fde->uses_eh_lsda)
3631 /* If exceptions are enabled, we have collected nothrow info. */
3632 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
3638 /* Output the call frame information used to record information
3639 that relates to calculating the frame pointer, and records the
3640 location of saved registers. */
3643 output_call_frame_info (int for_eh)
3648 char l1[20], l2[20], section_start_label[20];
3649 bool any_lsda_needed = false;
3650 char augmentation[6];
3651 int augmentation_size;
3652 int fde_encoding = DW_EH_PE_absptr;
3653 int per_encoding = DW_EH_PE_absptr;
3654 int lsda_encoding = DW_EH_PE_absptr;
3656 rtx personality = NULL;
3659 /* Don't emit a CIE if there won't be any FDEs. */
3660 if (fde_table_in_use == 0)
3663 /* Nothing to do if the assembler's doing it all. */
3664 if (dwarf2out_do_cfi_asm ())
3667 /* If we don't have any functions we'll want to unwind out of, don't emit
3668 any EH unwind information. If we make FDEs linkonce, we may have to
3669 emit an empty label for an FDE that wouldn't otherwise be emitted. We
3670 want to avoid having an FDE kept around when the function it refers to
3671 is discarded. Example where this matters: a primary function template
3672 in C++ requires EH information, an explicit specialization doesn't. */
3675 bool any_eh_needed = false;
3677 for (i = 0; i < fde_table_in_use; i++)
3678 if (fde_table[i].uses_eh_lsda)
3679 any_eh_needed = any_lsda_needed = true;
3680 else if (fde_needed_for_eh_p (&fde_table[i]))
3681 any_eh_needed = true;
3682 else if (TARGET_USES_WEAK_UNWIND_INFO)
3683 targetm.asm_out.emit_unwind_label (asm_out_file, fde_table[i].decl,
3690 /* We're going to be generating comments, so turn on app. */
3694 /* Switch to the proper frame section, first time. */
3695 switch_to_frame_table_section (for_eh, false);
3697 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
3698 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
3700 /* Output the CIE. */
3701 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
3702 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
3703 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
3704 dw2_asm_output_data (4, 0xffffffff,
3705 "Initial length escape value indicating 64-bit DWARF extension");
3706 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
3707 "Length of Common Information Entry");
3708 ASM_OUTPUT_LABEL (asm_out_file, l1);
3710 /* Now that the CIE pointer is PC-relative for EH,
3711 use 0 to identify the CIE. */
3712 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
3713 (for_eh ? 0 : DWARF_CIE_ID),
3714 "CIE Identifier Tag");
3716 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3717 use CIE version 1, unless that would produce incorrect results
3718 due to overflowing the return register column. */
3719 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
3721 if (return_reg >= 256 || dwarf_version > 2)
3723 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
3725 augmentation[0] = 0;
3726 augmentation_size = 0;
3728 personality = current_unit_personality;
3734 z Indicates that a uleb128 is present to size the
3735 augmentation section.
3736 L Indicates the encoding (and thus presence) of
3737 an LSDA pointer in the FDE augmentation.
3738 R Indicates a non-default pointer encoding for
3740 P Indicates the presence of an encoding + language
3741 personality routine in the CIE augmentation. */
3743 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3744 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3745 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3747 p = augmentation + 1;
3751 augmentation_size += 1 + size_of_encoded_value (per_encoding);
3752 assemble_external_libcall (personality);
3754 if (any_lsda_needed)
3757 augmentation_size += 1;
3759 if (fde_encoding != DW_EH_PE_absptr)
3762 augmentation_size += 1;
3764 if (p > augmentation + 1)
3766 augmentation[0] = 'z';
3770 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3771 if (personality && per_encoding == DW_EH_PE_aligned)
3773 int offset = ( 4 /* Length */
3775 + 1 /* CIE version */
3776 + strlen (augmentation) + 1 /* Augmentation */
3777 + size_of_uleb128 (1) /* Code alignment */
3778 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
3780 + 1 /* Augmentation size */
3781 + 1 /* Personality encoding */ );
3782 int pad = -offset & (PTR_SIZE - 1);
3784 augmentation_size += pad;
3786 /* Augmentations should be small, so there's scarce need to
3787 iterate for a solution. Die if we exceed one uleb128 byte. */
3788 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
3792 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
3793 if (dw_cie_version >= 4)
3795 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
3796 dw2_asm_output_data (1, 0, "CIE Segment Size");
3798 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3799 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
3800 "CIE Data Alignment Factor");
3802 if (dw_cie_version == 1)
3803 dw2_asm_output_data (1, return_reg, "CIE RA Column");
3805 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
3807 if (augmentation[0])
3809 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
3812 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
3813 eh_data_format_name (per_encoding));
3814 dw2_asm_output_encoded_addr_rtx (per_encoding,
3819 if (any_lsda_needed)
3820 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
3821 eh_data_format_name (lsda_encoding));
3823 if (fde_encoding != DW_EH_PE_absptr)
3824 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
3825 eh_data_format_name (fde_encoding));
3828 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
3829 output_cfi (cfi, NULL, for_eh);
3831 /* Pad the CIE out to an address sized boundary. */
3832 ASM_OUTPUT_ALIGN (asm_out_file,
3833 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
3834 ASM_OUTPUT_LABEL (asm_out_file, l2);
3836 /* Loop through all of the FDE's. */
3837 for (i = 0; i < fde_table_in_use; i++)
3840 fde = &fde_table[i];
3842 /* Don't emit EH unwind info for leaf functions that don't need it. */
3843 if (for_eh && !fde_needed_for_eh_p (fde))
3846 for (k = 0; k < (fde->dw_fde_switched_sections ? 2 : 1); k++)
3847 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
3848 augmentation, any_lsda_needed, lsda_encoding);
3851 if (for_eh && targetm.terminate_dw2_eh_frame_info)
3852 dw2_asm_output_data (4, 0, "End of Table");
3853 #ifdef MIPS_DEBUGGING_INFO
3854 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3855 get a value of 0. Putting .align 0 after the label fixes it. */
3856 ASM_OUTPUT_ALIGN (asm_out_file, 0);
3859 /* Turn off app to make assembly quicker. */
3864 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
3867 dwarf2out_do_cfi_startproc (bool second)
3871 rtx personality = get_personality_function (current_function_decl);
3873 fprintf (asm_out_file, "\t.cfi_startproc\n");
3877 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3880 /* ??? The GAS support isn't entirely consistent. We have to
3881 handle indirect support ourselves, but PC-relative is done
3882 in the assembler. Further, the assembler can't handle any
3883 of the weirder relocation types. */
3884 if (enc & DW_EH_PE_indirect)
3885 ref = dw2_force_const_mem (ref, true);
3887 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
3888 output_addr_const (asm_out_file, ref);
3889 fputc ('\n', asm_out_file);
3892 if (crtl->uses_eh_lsda)
3896 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3897 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
3898 current_function_funcdef_no);
3899 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
3900 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
3902 if (enc & DW_EH_PE_indirect)
3903 ref = dw2_force_const_mem (ref, true);
3905 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
3906 output_addr_const (asm_out_file, ref);
3907 fputc ('\n', asm_out_file);
3911 /* Output a marker (i.e. a label) for the beginning of a function, before
3915 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
3916 const char *file ATTRIBUTE_UNUSED)
3918 char label[MAX_ARTIFICIAL_LABEL_BYTES];
3923 current_function_func_begin_label = NULL;
3925 #ifdef TARGET_UNWIND_INFO
3926 /* ??? current_function_func_begin_label is also used by except.c
3927 for call-site information. We must emit this label if it might
3929 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
3930 && ! dwarf2out_do_frame ())
3933 if (! dwarf2out_do_frame ())
3937 fnsec = function_section (current_function_decl);
3938 switch_to_section (fnsec);
3939 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
3940 current_function_funcdef_no);
3941 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
3942 current_function_funcdef_no);
3943 dup_label = xstrdup (label);
3944 current_function_func_begin_label = dup_label;
3946 #ifdef TARGET_UNWIND_INFO
3947 /* We can elide the fde allocation if we're not emitting debug info. */
3948 if (! dwarf2out_do_frame ())
3952 /* Expand the fde table if necessary. */
3953 if (fde_table_in_use == fde_table_allocated)
3955 fde_table_allocated += FDE_TABLE_INCREMENT;
3956 fde_table = GGC_RESIZEVEC (dw_fde_node, fde_table, fde_table_allocated);
3957 memset (fde_table + fde_table_in_use, 0,
3958 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
3961 /* Record the FDE associated with this function. */
3962 current_funcdef_fde = fde_table_in_use;
3964 /* Add the new FDE at the end of the fde_table. */
3965 fde = &fde_table[fde_table_in_use++];
3966 fde->decl = current_function_decl;
3967 fde->dw_fde_begin = dup_label;
3968 fde->dw_fde_current_label = dup_label;
3969 fde->dw_fde_hot_section_label = NULL;
3970 fde->dw_fde_hot_section_end_label = NULL;
3971 fde->dw_fde_unlikely_section_label = NULL;
3972 fde->dw_fde_unlikely_section_end_label = NULL;
3973 fde->dw_fde_switched_sections = 0;
3974 fde->dw_fde_switched_cold_to_hot = 0;
3975 fde->dw_fde_end = NULL;
3976 fde->dw_fde_vms_end_prologue = NULL;
3977 fde->dw_fde_vms_begin_epilogue = NULL;
3978 fde->dw_fde_cfi = NULL;
3979 fde->dw_fde_switch_cfi = NULL;
3980 fde->funcdef_number = current_function_funcdef_no;
3981 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
3982 fde->uses_eh_lsda = crtl->uses_eh_lsda;
3983 fde->nothrow = crtl->nothrow;
3984 fde->drap_reg = INVALID_REGNUM;
3985 fde->vdrap_reg = INVALID_REGNUM;
3986 if (flag_reorder_blocks_and_partition)
3988 section *unlikelysec;
3989 if (first_function_block_is_cold)
3990 fde->in_std_section = 1;
3993 = (fnsec == text_section
3994 || (cold_text_section && fnsec == cold_text_section));
3995 unlikelysec = unlikely_text_section ();
3996 fde->cold_in_std_section
3997 = (unlikelysec == text_section
3998 || (cold_text_section && unlikelysec == cold_text_section));
4003 = (fnsec == text_section
4004 || (cold_text_section && fnsec == cold_text_section));
4005 fde->cold_in_std_section = 0;
4008 args_size = old_args_size = 0;
4010 /* We only want to output line number information for the genuine dwarf2
4011 prologue case, not the eh frame case. */
4012 #ifdef DWARF2_DEBUGGING_INFO
4014 dwarf2out_source_line (line, file, 0, true);
4017 if (dwarf2out_do_cfi_asm ())
4018 dwarf2out_do_cfi_startproc (false);
4021 rtx personality = get_personality_function (current_function_decl);
4022 if (!current_unit_personality)
4023 current_unit_personality = personality;
4025 /* We cannot keep a current personality per function as without CFI
4026 asm, at the point where we emit the CFI data, there is no current
4027 function anymore. */
4028 if (personality && current_unit_personality != personality)
4029 sorry ("multiple EH personalities are supported only with assemblers "
4030 "supporting .cfi_personality directive");
4034 /* Output a marker (i.e. a label) for the end of the generated code
4035 for a function prologue. This gets called *after* the prologue code has
4039 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
4040 const char *file ATTRIBUTE_UNUSED)
4043 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4045 /* Output a label to mark the endpoint of the code generated for this
4047 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
4048 current_function_funcdef_no);
4049 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
4050 current_function_funcdef_no);
4051 fde = &fde_table[fde_table_in_use - 1];
4052 fde->dw_fde_vms_end_prologue = xstrdup (label);
4055 /* Output a marker (i.e. a label) for the beginning of the generated code
4056 for a function epilogue. This gets called *before* the prologue code has
4060 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4061 const char *file ATTRIBUTE_UNUSED)
4064 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4066 fde = &fde_table[fde_table_in_use - 1];
4067 if (fde->dw_fde_vms_begin_epilogue)
4070 /* Output a label to mark the endpoint of the code generated for this
4072 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
4073 current_function_funcdef_no);
4074 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
4075 current_function_funcdef_no);
4076 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
4079 /* Output a marker (i.e. a label) for the absolute end of the generated code
4080 for a function definition. This gets called *after* the epilogue code has
4084 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
4085 const char *file ATTRIBUTE_UNUSED)
4088 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4090 #ifdef DWARF2_DEBUGGING_INFO
4091 last_var_location_insn = NULL_RTX;
4094 if (dwarf2out_do_cfi_asm ())
4095 fprintf (asm_out_file, "\t.cfi_endproc\n");
4097 /* Output a label to mark the endpoint of the code generated for this
4099 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
4100 current_function_funcdef_no);
4101 ASM_OUTPUT_LABEL (asm_out_file, label);
4102 fde = current_fde ();
4103 gcc_assert (fde != NULL);
4104 fde->dw_fde_end = xstrdup (label);
4108 dwarf2out_frame_init (void)
4110 /* Allocate the initial hunk of the fde_table. */
4111 fde_table = ggc_alloc_cleared_vec_dw_fde_node (FDE_TABLE_INCREMENT);
4112 fde_table_allocated = FDE_TABLE_INCREMENT;
4113 fde_table_in_use = 0;
4115 /* Generate the CFA instructions common to all FDE's. Do it now for the
4116 sake of lookup_cfa. */
4118 /* On entry, the Canonical Frame Address is at SP. */
4119 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
4121 #ifdef DWARF2_UNWIND_INFO
4122 if (DWARF2_UNWIND_INFO || DWARF2_FRAME_INFO)
4123 initial_return_save (INCOMING_RETURN_ADDR_RTX);
4128 dwarf2out_frame_finish (void)
4130 /* Output call frame information. */
4131 if (DWARF2_FRAME_INFO)
4132 output_call_frame_info (0);
4134 #ifndef TARGET_UNWIND_INFO
4135 /* Output another copy for the unwinder. */
4136 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
4137 output_call_frame_info (1);
4141 /* Note that the current function section is being used for code. */
4144 dwarf2out_note_section_used (void)
4146 section *sec = current_function_section ();
4147 if (sec == text_section)
4148 text_section_used = true;
4149 else if (sec == cold_text_section)
4150 cold_text_section_used = true;
4154 dwarf2out_switch_text_section (void)
4156 dw_fde_ref fde = current_fde ();
4158 gcc_assert (cfun && fde && !fde->dw_fde_switched_sections);
4160 fde->dw_fde_switched_sections = 1;
4161 fde->dw_fde_switched_cold_to_hot = !in_cold_section_p;
4163 fde->dw_fde_hot_section_label = crtl->subsections.hot_section_label;
4164 fde->dw_fde_hot_section_end_label = crtl->subsections.hot_section_end_label;
4165 fde->dw_fde_unlikely_section_label = crtl->subsections.cold_section_label;
4166 fde->dw_fde_unlikely_section_end_label = crtl->subsections.cold_section_end_label;
4167 have_multiple_function_sections = true;
4169 /* Reset the current label on switching text sections, so that we
4170 don't attempt to advance_loc4 between labels in different sections. */
4171 fde->dw_fde_current_label = NULL;
4173 /* There is no need to mark used sections when not debugging. */
4174 if (cold_text_section != NULL)
4175 dwarf2out_note_section_used ();
4177 if (dwarf2out_do_cfi_asm ())
4178 fprintf (asm_out_file, "\t.cfi_endproc\n");
4180 /* Now do the real section switch. */
4181 switch_to_section (current_function_section ());
4183 if (dwarf2out_do_cfi_asm ())
4185 dwarf2out_do_cfi_startproc (true);
4186 /* As this is a different FDE, insert all current CFI instructions
4188 output_cfis (fde->dw_fde_cfi, true, fde, true);
4192 dw_cfi_ref cfi = fde->dw_fde_cfi;
4194 cfi = fde->dw_fde_cfi;
4196 while (cfi->dw_cfi_next != NULL)
4197 cfi = cfi->dw_cfi_next;
4198 fde->dw_fde_switch_cfi = cfi;
4203 /* And now, the subset of the debugging information support code necessary
4204 for emitting location expressions. */
4206 /* Data about a single source file. */
4207 struct GTY(()) dwarf_file_data {
4208 const char * filename;
4212 typedef struct dw_val_struct *dw_val_ref;
4213 typedef struct die_struct *dw_die_ref;
4214 typedef const struct die_struct *const_dw_die_ref;
4215 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
4216 typedef struct dw_loc_list_struct *dw_loc_list_ref;
4218 typedef struct GTY(()) deferred_locations_struct
4222 } deferred_locations;
4224 DEF_VEC_O(deferred_locations);
4225 DEF_VEC_ALLOC_O(deferred_locations,gc);
4227 static GTY(()) VEC(deferred_locations, gc) *deferred_locations_list;
4229 DEF_VEC_P(dw_die_ref);
4230 DEF_VEC_ALLOC_P(dw_die_ref,heap);
4232 /* Each DIE may have a series of attribute/value pairs. Values
4233 can take on several forms. The forms that are used in this
4234 implementation are listed below. */
4239 dw_val_class_offset,
4241 dw_val_class_loc_list,
4242 dw_val_class_range_list,
4244 dw_val_class_unsigned_const,
4245 dw_val_class_const_double,
4248 dw_val_class_die_ref,
4249 dw_val_class_fde_ref,
4250 dw_val_class_lbl_id,
4251 dw_val_class_lineptr,
4253 dw_val_class_macptr,
4256 dw_val_class_vms_delta
4259 /* Describe a floating point constant value, or a vector constant value. */
4261 typedef struct GTY(()) dw_vec_struct {
4262 unsigned char * GTY((length ("%h.length"))) array;
4268 /* The dw_val_node describes an attribute's value, as it is
4269 represented internally. */
4271 typedef struct GTY(()) dw_val_struct {
4272 enum dw_val_class val_class;
4273 union dw_val_struct_union
4275 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
4276 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
4277 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
4278 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
4279 HOST_WIDE_INT GTY ((default)) val_int;
4280 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
4281 double_int GTY ((tag ("dw_val_class_const_double"))) val_double;
4282 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
4283 struct dw_val_die_union
4287 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
4288 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
4289 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
4290 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
4291 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
4292 struct dwarf_file_data * GTY ((tag ("dw_val_class_file"))) val_file;
4293 unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8[8];
4294 struct dw_val_vms_delta_union
4298 } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta;
4300 GTY ((desc ("%1.val_class"))) v;
4304 /* Locations in memory are described using a sequence of stack machine
4307 typedef struct GTY(()) dw_loc_descr_struct {
4308 dw_loc_descr_ref dw_loc_next;
4309 ENUM_BITFIELD (dwarf_location_atom) dw_loc_opc : 8;
4310 /* Used to distinguish DW_OP_addr with a direct symbol relocation
4311 from DW_OP_addr with a dtp-relative symbol relocation. */
4312 unsigned int dtprel : 1;
4314 dw_val_node dw_loc_oprnd1;
4315 dw_val_node dw_loc_oprnd2;
4319 /* Location lists are ranges + location descriptions for that range,
4320 so you can track variables that are in different places over
4321 their entire life. */
4322 typedef struct GTY(()) dw_loc_list_struct {
4323 dw_loc_list_ref dw_loc_next;
4324 const char *begin; /* Label for begin address of range */
4325 const char *end; /* Label for end address of range */
4326 char *ll_symbol; /* Label for beginning of location list.
4327 Only on head of list */
4328 const char *section; /* Section this loclist is relative to */
4329 dw_loc_descr_ref expr;
4332 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
4334 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4336 /* Convert a DWARF stack opcode into its string name. */
4339 dwarf_stack_op_name (unsigned int op)
4344 return "DW_OP_addr";
4346 return "DW_OP_deref";
4348 return "DW_OP_const1u";
4350 return "DW_OP_const1s";
4352 return "DW_OP_const2u";
4354 return "DW_OP_const2s";
4356 return "DW_OP_const4u";
4358 return "DW_OP_const4s";
4360 return "DW_OP_const8u";
4362 return "DW_OP_const8s";
4364 return "DW_OP_constu";
4366 return "DW_OP_consts";
4370 return "DW_OP_drop";
4372 return "DW_OP_over";
4374 return "DW_OP_pick";
4376 return "DW_OP_swap";
4380 return "DW_OP_xderef";
4388 return "DW_OP_minus";
4400 return "DW_OP_plus";
4401 case DW_OP_plus_uconst:
4402 return "DW_OP_plus_uconst";
4408 return "DW_OP_shra";
4426 return "DW_OP_skip";
4428 return "DW_OP_lit0";
4430 return "DW_OP_lit1";
4432 return "DW_OP_lit2";
4434 return "DW_OP_lit3";
4436 return "DW_OP_lit4";
4438 return "DW_OP_lit5";
4440 return "DW_OP_lit6";
4442 return "DW_OP_lit7";
4444 return "DW_OP_lit8";
4446 return "DW_OP_lit9";
4448 return "DW_OP_lit10";
4450 return "DW_OP_lit11";
4452 return "DW_OP_lit12";
4454 return "DW_OP_lit13";
4456 return "DW_OP_lit14";
4458 return "DW_OP_lit15";
4460 return "DW_OP_lit16";
4462 return "DW_OP_lit17";
4464 return "DW_OP_lit18";
4466 return "DW_OP_lit19";
4468 return "DW_OP_lit20";
4470 return "DW_OP_lit21";
4472 return "DW_OP_lit22";
4474 return "DW_OP_lit23";
4476 return "DW_OP_lit24";
4478 return "DW_OP_lit25";
4480 return "DW_OP_lit26";
4482 return "DW_OP_lit27";
4484 return "DW_OP_lit28";
4486 return "DW_OP_lit29";
4488 return "DW_OP_lit30";
4490 return "DW_OP_lit31";
4492 return "DW_OP_reg0";
4494 return "DW_OP_reg1";
4496 return "DW_OP_reg2";
4498 return "DW_OP_reg3";
4500 return "DW_OP_reg4";
4502 return "DW_OP_reg5";
4504 return "DW_OP_reg6";
4506 return "DW_OP_reg7";
4508 return "DW_OP_reg8";
4510 return "DW_OP_reg9";
4512 return "DW_OP_reg10";
4514 return "DW_OP_reg11";
4516 return "DW_OP_reg12";
4518 return "DW_OP_reg13";
4520 return "DW_OP_reg14";
4522 return "DW_OP_reg15";
4524 return "DW_OP_reg16";
4526 return "DW_OP_reg17";
4528 return "DW_OP_reg18";
4530 return "DW_OP_reg19";
4532 return "DW_OP_reg20";
4534 return "DW_OP_reg21";
4536 return "DW_OP_reg22";
4538 return "DW_OP_reg23";
4540 return "DW_OP_reg24";
4542 return "DW_OP_reg25";
4544 return "DW_OP_reg26";
4546 return "DW_OP_reg27";
4548 return "DW_OP_reg28";
4550 return "DW_OP_reg29";
4552 return "DW_OP_reg30";
4554 return "DW_OP_reg31";
4556 return "DW_OP_breg0";
4558 return "DW_OP_breg1";
4560 return "DW_OP_breg2";
4562 return "DW_OP_breg3";
4564 return "DW_OP_breg4";
4566 return "DW_OP_breg5";
4568 return "DW_OP_breg6";
4570 return "DW_OP_breg7";
4572 return "DW_OP_breg8";
4574 return "DW_OP_breg9";
4576 return "DW_OP_breg10";
4578 return "DW_OP_breg11";
4580 return "DW_OP_breg12";
4582 return "DW_OP_breg13";
4584 return "DW_OP_breg14";
4586 return "DW_OP_breg15";
4588 return "DW_OP_breg16";
4590 return "DW_OP_breg17";
4592 return "DW_OP_breg18";
4594 return "DW_OP_breg19";
4596 return "DW_OP_breg20";
4598 return "DW_OP_breg21";
4600 return "DW_OP_breg22";
4602 return "DW_OP_breg23";
4604 return "DW_OP_breg24";
4606 return "DW_OP_breg25";
4608 return "DW_OP_breg26";
4610 return "DW_OP_breg27";
4612 return "DW_OP_breg28";
4614 return "DW_OP_breg29";
4616 return "DW_OP_breg30";
4618 return "DW_OP_breg31";
4620 return "DW_OP_regx";
4622 return "DW_OP_fbreg";
4624 return "DW_OP_bregx";
4626 return "DW_OP_piece";
4627 case DW_OP_deref_size:
4628 return "DW_OP_deref_size";
4629 case DW_OP_xderef_size:
4630 return "DW_OP_xderef_size";
4634 case DW_OP_push_object_address:
4635 return "DW_OP_push_object_address";
4637 return "DW_OP_call2";
4639 return "DW_OP_call4";
4640 case DW_OP_call_ref:
4641 return "DW_OP_call_ref";
4642 case DW_OP_implicit_value:
4643 return "DW_OP_implicit_value";
4644 case DW_OP_stack_value:
4645 return "DW_OP_stack_value";
4646 case DW_OP_form_tls_address:
4647 return "DW_OP_form_tls_address";
4648 case DW_OP_call_frame_cfa:
4649 return "DW_OP_call_frame_cfa";
4650 case DW_OP_bit_piece:
4651 return "DW_OP_bit_piece";
4653 case DW_OP_GNU_push_tls_address:
4654 return "DW_OP_GNU_push_tls_address";
4655 case DW_OP_GNU_uninit:
4656 return "DW_OP_GNU_uninit";
4657 case DW_OP_GNU_encoded_addr:
4658 return "DW_OP_GNU_encoded_addr";
4661 return "OP_<unknown>";
4665 /* Return a pointer to a newly allocated location description. Location
4666 descriptions are simple expression terms that can be strung
4667 together to form more complicated location (address) descriptions. */
4669 static inline dw_loc_descr_ref
4670 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
4671 unsigned HOST_WIDE_INT oprnd2)
4673 dw_loc_descr_ref descr = ggc_alloc_cleared_dw_loc_descr_node ();
4675 descr->dw_loc_opc = op;
4676 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4677 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4678 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4679 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4684 /* Return a pointer to a newly allocated location description for
4687 static inline dw_loc_descr_ref
4688 new_reg_loc_descr (unsigned int reg, unsigned HOST_WIDE_INT offset)
4691 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
4694 return new_loc_descr (DW_OP_bregx, reg, offset);
4697 /* Add a location description term to a location description expression. */
4700 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
4702 dw_loc_descr_ref *d;
4704 /* Find the end of the chain. */
4705 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4711 /* Add a constant OFFSET to a location expression. */
4714 loc_descr_plus_const (dw_loc_descr_ref *list_head, HOST_WIDE_INT offset)
4716 dw_loc_descr_ref loc;
4719 gcc_assert (*list_head != NULL);
4724 /* Find the end of the chain. */
4725 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
4729 if (loc->dw_loc_opc == DW_OP_fbreg
4730 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
4731 p = &loc->dw_loc_oprnd1.v.val_int;
4732 else if (loc->dw_loc_opc == DW_OP_bregx)
4733 p = &loc->dw_loc_oprnd2.v.val_int;
4735 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4736 offset. Don't optimize if an signed integer overflow would happen. */
4738 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
4739 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
4742 else if (offset > 0)
4743 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
4747 loc->dw_loc_next = int_loc_descriptor (-offset);
4748 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
4752 #ifdef DWARF2_DEBUGGING_INFO
4753 /* Add a constant OFFSET to a location list. */
4756 loc_list_plus_const (dw_loc_list_ref list_head, HOST_WIDE_INT offset)
4759 for (d = list_head; d != NULL; d = d->dw_loc_next)
4760 loc_descr_plus_const (&d->expr, offset);
4764 /* Return the size of a location descriptor. */
4766 static unsigned long
4767 size_of_loc_descr (dw_loc_descr_ref loc)
4769 unsigned long size = 1;
4771 switch (loc->dw_loc_opc)
4774 size += DWARF2_ADDR_SIZE;
4793 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4796 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4801 case DW_OP_plus_uconst:
4802 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4840 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4843 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4846 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4849 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4850 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4853 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4855 case DW_OP_bit_piece:
4856 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4857 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
4859 case DW_OP_deref_size:
4860 case DW_OP_xderef_size:
4869 case DW_OP_call_ref:
4870 size += DWARF2_ADDR_SIZE;
4872 case DW_OP_implicit_value:
4873 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
4874 + loc->dw_loc_oprnd1.v.val_unsigned;
4883 /* Return the size of a series of location descriptors. */
4885 static unsigned long
4886 size_of_locs (dw_loc_descr_ref loc)
4891 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4892 field, to avoid writing to a PCH file. */
4893 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4895 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
4897 size += size_of_loc_descr (l);
4902 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
4904 l->dw_loc_addr = size;
4905 size += size_of_loc_descr (l);
4911 #ifdef DWARF2_DEBUGGING_INFO
4912 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4915 /* Output location description stack opcode's operands (if any). */
4918 output_loc_operands (dw_loc_descr_ref loc)
4920 dw_val_ref val1 = &loc->dw_loc_oprnd1;
4921 dw_val_ref val2 = &loc->dw_loc_oprnd2;
4923 switch (loc->dw_loc_opc)
4925 #ifdef DWARF2_DEBUGGING_INFO
4928 dw2_asm_output_data (2, val1->v.val_int, NULL);
4933 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
4934 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
4936 fputc ('\n', asm_out_file);
4941 dw2_asm_output_data (4, val1->v.val_int, NULL);
4946 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
4947 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
4949 fputc ('\n', asm_out_file);
4954 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
4955 dw2_asm_output_data (8, val1->v.val_int, NULL);
4962 gcc_assert (val1->val_class == dw_val_class_loc);
4963 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
4965 dw2_asm_output_data (2, offset, NULL);
4968 case DW_OP_implicit_value:
4969 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
4970 switch (val2->val_class)
4972 case dw_val_class_const:
4973 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
4975 case dw_val_class_vec:
4977 unsigned int elt_size = val2->v.val_vec.elt_size;
4978 unsigned int len = val2->v.val_vec.length;
4982 if (elt_size > sizeof (HOST_WIDE_INT))
4987 for (i = 0, p = val2->v.val_vec.array;
4990 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
4991 "fp or vector constant word %u", i);
4994 case dw_val_class_const_double:
4996 unsigned HOST_WIDE_INT first, second;
4998 if (WORDS_BIG_ENDIAN)
5000 first = val2->v.val_double.high;
5001 second = val2->v.val_double.low;
5005 first = val2->v.val_double.low;
5006 second = val2->v.val_double.high;
5008 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
5010 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
5014 case dw_val_class_addr:
5015 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
5016 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
5031 case DW_OP_implicit_value:
5032 /* We currently don't make any attempt to make sure these are
5033 aligned properly like we do for the main unwind info, so
5034 don't support emitting things larger than a byte if we're
5035 only doing unwinding. */
5040 dw2_asm_output_data (1, val1->v.val_int, NULL);
5043 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5046 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5049 dw2_asm_output_data (1, val1->v.val_int, NULL);
5051 case DW_OP_plus_uconst:
5052 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5086 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5089 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5092 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
5095 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5096 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
5099 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5101 case DW_OP_bit_piece:
5102 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
5103 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
5105 case DW_OP_deref_size:
5106 case DW_OP_xderef_size:
5107 dw2_asm_output_data (1, val1->v.val_int, NULL);
5113 if (targetm.asm_out.output_dwarf_dtprel)
5115 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
5118 fputc ('\n', asm_out_file);
5125 #ifdef DWARF2_DEBUGGING_INFO
5126 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
5134 /* Other codes have no operands. */
5139 /* Output a sequence of location operations. */
5142 output_loc_sequence (dw_loc_descr_ref loc)
5144 for (; loc != NULL; loc = loc->dw_loc_next)
5146 /* Output the opcode. */
5147 dw2_asm_output_data (1, loc->dw_loc_opc,
5148 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
5150 /* Output the operand(s) (if any). */
5151 output_loc_operands (loc);
5155 /* Output location description stack opcode's operands (if any).
5156 The output is single bytes on a line, suitable for .cfi_escape. */
5159 output_loc_operands_raw (dw_loc_descr_ref loc)
5161 dw_val_ref val1 = &loc->dw_loc_oprnd1;
5162 dw_val_ref val2 = &loc->dw_loc_oprnd2;
5164 switch (loc->dw_loc_opc)
5167 case DW_OP_implicit_value:
5168 /* We cannot output addresses in .cfi_escape, only bytes. */
5174 case DW_OP_deref_size:
5175 case DW_OP_xderef_size:
5176 fputc (',', asm_out_file);
5177 dw2_asm_output_data_raw (1, val1->v.val_int);
5182 fputc (',', asm_out_file);
5183 dw2_asm_output_data_raw (2, val1->v.val_int);
5188 fputc (',', asm_out_file);
5189 dw2_asm_output_data_raw (4, val1->v.val_int);
5194 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
5195 fputc (',', asm_out_file);
5196 dw2_asm_output_data_raw (8, val1->v.val_int);
5204 gcc_assert (val1->val_class == dw_val_class_loc);
5205 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
5207 fputc (',', asm_out_file);
5208 dw2_asm_output_data_raw (2, offset);
5213 case DW_OP_plus_uconst:
5216 fputc (',', asm_out_file);
5217 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5220 case DW_OP_bit_piece:
5221 fputc (',', asm_out_file);
5222 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5223 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
5260 fputc (',', asm_out_file);
5261 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
5265 fputc (',', asm_out_file);
5266 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
5267 fputc (',', asm_out_file);
5268 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
5272 /* Other codes have no operands. */
5278 output_loc_sequence_raw (dw_loc_descr_ref loc)
5282 /* Output the opcode. */
5283 fprintf (asm_out_file, "%#x", loc->dw_loc_opc);
5284 output_loc_operands_raw (loc);
5286 if (!loc->dw_loc_next)
5288 loc = loc->dw_loc_next;
5290 fputc (',', asm_out_file);
5294 /* This routine will generate the correct assembly data for a location
5295 description based on a cfi entry with a complex address. */
5298 output_cfa_loc (dw_cfi_ref cfi)
5300 dw_loc_descr_ref loc;
5303 if (cfi->dw_cfi_opc == DW_CFA_expression)
5305 dw2_asm_output_data (1, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, NULL);
5306 loc = cfi->dw_cfi_oprnd2.dw_cfi_loc;
5309 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5311 /* Output the size of the block. */
5312 size = size_of_locs (loc);
5313 dw2_asm_output_data_uleb128 (size, NULL);
5315 /* Now output the operations themselves. */
5316 output_loc_sequence (loc);
5319 /* Similar, but used for .cfi_escape. */
5322 output_cfa_loc_raw (dw_cfi_ref cfi)
5324 dw_loc_descr_ref loc;
5327 if (cfi->dw_cfi_opc == DW_CFA_expression)
5329 fprintf (asm_out_file, "%#x,", cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
5330 loc = cfi->dw_cfi_oprnd2.dw_cfi_loc;
5333 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
5335 /* Output the size of the block. */
5336 size = size_of_locs (loc);
5337 dw2_asm_output_data_uleb128_raw (size);
5338 fputc (',', asm_out_file);
5340 /* Now output the operations themselves. */
5341 output_loc_sequence_raw (loc);
5344 /* This function builds a dwarf location descriptor sequence from a
5345 dw_cfa_location, adding the given OFFSET to the result of the
5348 static struct dw_loc_descr_struct *
5349 build_cfa_loc (dw_cfa_location *cfa, HOST_WIDE_INT offset)
5351 struct dw_loc_descr_struct *head, *tmp;
5353 offset += cfa->offset;
5357 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
5358 head->dw_loc_oprnd1.val_class = dw_val_class_const;
5359 tmp = new_loc_descr (DW_OP_deref, 0, 0);
5360 add_loc_descr (&head, tmp);
5363 tmp = new_loc_descr (DW_OP_plus_uconst, offset, 0);
5364 add_loc_descr (&head, tmp);
5368 head = new_reg_loc_descr (cfa->reg, offset);
5373 /* This function builds a dwarf location descriptor sequence for
5374 the address at OFFSET from the CFA when stack is aligned to
5377 static struct dw_loc_descr_struct *
5378 build_cfa_aligned_loc (HOST_WIDE_INT offset, HOST_WIDE_INT alignment)
5380 struct dw_loc_descr_struct *head;
5381 unsigned int dwarf_fp
5382 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
5384 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
5385 if (cfa.reg == HARD_FRAME_POINTER_REGNUM && cfa.indirect == 0)
5387 head = new_reg_loc_descr (dwarf_fp, 0);
5388 add_loc_descr (&head, int_loc_descriptor (alignment));
5389 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
5390 loc_descr_plus_const (&head, offset);
5393 head = new_reg_loc_descr (dwarf_fp, offset);
5397 /* This function fills in aa dw_cfa_location structure from a dwarf location
5398 descriptor sequence. */
5401 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
5403 struct dw_loc_descr_struct *ptr;
5405 cfa->base_offset = 0;
5409 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
5411 enum dwarf_location_atom op = ptr->dw_loc_opc;
5447 cfa->reg = op - DW_OP_reg0;
5450 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5484 cfa->reg = op - DW_OP_breg0;
5485 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
5488 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
5489 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
5494 case DW_OP_plus_uconst:
5495 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
5498 internal_error ("DW_LOC_OP %s not implemented",
5499 dwarf_stack_op_name (ptr->dw_loc_opc));
5503 #endif /* .debug_frame support */
5505 /* And now, the support for symbolic debugging information. */
5506 #ifdef DWARF2_DEBUGGING_INFO
5508 /* .debug_str support. */
5509 static int output_indirect_string (void **, void *);
5511 static void dwarf2out_init (const char *);
5512 static void dwarf2out_finish (const char *);
5513 static void dwarf2out_assembly_start (void);
5514 static void dwarf2out_define (unsigned int, const char *);
5515 static void dwarf2out_undef (unsigned int, const char *);
5516 static void dwarf2out_start_source_file (unsigned, const char *);
5517 static void dwarf2out_end_source_file (unsigned);
5518 static void dwarf2out_function_decl (tree);
5519 static void dwarf2out_begin_block (unsigned, unsigned);
5520 static void dwarf2out_end_block (unsigned, unsigned);
5521 static bool dwarf2out_ignore_block (const_tree);
5522 static void dwarf2out_global_decl (tree);
5523 static void dwarf2out_type_decl (tree, int);
5524 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool);
5525 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
5527 static void dwarf2out_abstract_function (tree);
5528 static void dwarf2out_var_location (rtx);
5529 static void dwarf2out_direct_call (tree);
5530 static void dwarf2out_virtual_call_token (tree, int);
5531 static void dwarf2out_copy_call_info (rtx, rtx);
5532 static void dwarf2out_virtual_call (int);
5533 static void dwarf2out_begin_function (tree);
5534 static void dwarf2out_set_name (tree, tree);
5536 /* The debug hooks structure. */
5538 const struct gcc_debug_hooks dwarf2_debug_hooks =
5542 dwarf2out_assembly_start,
5545 dwarf2out_start_source_file,
5546 dwarf2out_end_source_file,
5547 dwarf2out_begin_block,
5548 dwarf2out_end_block,
5549 dwarf2out_ignore_block,
5550 dwarf2out_source_line,
5551 dwarf2out_begin_prologue,
5552 #if VMS_DEBUGGING_INFO
5553 dwarf2out_vms_end_prologue,
5554 dwarf2out_vms_begin_epilogue,
5556 debug_nothing_int_charstar,
5557 debug_nothing_int_charstar,
5559 dwarf2out_end_epilogue,
5560 dwarf2out_begin_function,
5561 debug_nothing_int, /* end_function */
5562 dwarf2out_function_decl, /* function_decl */
5563 dwarf2out_global_decl,
5564 dwarf2out_type_decl, /* type_decl */
5565 dwarf2out_imported_module_or_decl,
5566 debug_nothing_tree, /* deferred_inline_function */
5567 /* The DWARF 2 backend tries to reduce debugging bloat by not
5568 emitting the abstract description of inline functions until
5569 something tries to reference them. */
5570 dwarf2out_abstract_function, /* outlining_inline_function */
5571 debug_nothing_rtx, /* label */
5572 debug_nothing_int, /* handle_pch */
5573 dwarf2out_var_location,
5574 dwarf2out_switch_text_section,
5575 dwarf2out_direct_call,
5576 dwarf2out_virtual_call_token,
5577 dwarf2out_copy_call_info,
5578 dwarf2out_virtual_call,
5580 1 /* start_end_main_source_file */
5584 /* NOTE: In the comments in this file, many references are made to
5585 "Debugging Information Entries". This term is abbreviated as `DIE'
5586 throughout the remainder of this file. */
5588 /* An internal representation of the DWARF output is built, and then
5589 walked to generate the DWARF debugging info. The walk of the internal
5590 representation is done after the entire program has been compiled.
5591 The types below are used to describe the internal representation. */
5593 /* Various DIE's use offsets relative to the beginning of the
5594 .debug_info section to refer to each other. */
5596 typedef long int dw_offset;
5598 /* Define typedefs here to avoid circular dependencies. */
5600 typedef struct dw_attr_struct *dw_attr_ref;
5601 typedef struct dw_line_info_struct *dw_line_info_ref;
5602 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
5603 typedef struct pubname_struct *pubname_ref;
5604 typedef struct dw_ranges_struct *dw_ranges_ref;
5605 typedef struct dw_ranges_by_label_struct *dw_ranges_by_label_ref;
5606 typedef struct comdat_type_struct *comdat_type_node_ref;
5608 /* Each entry in the line_info_table maintains the file and
5609 line number associated with the label generated for that
5610 entry. The label gives the PC value associated with
5611 the line number entry. */
5613 typedef struct GTY(()) dw_line_info_struct {
5614 unsigned long dw_file_num;
5615 unsigned long dw_line_num;
5619 /* Line information for functions in separate sections; each one gets its
5621 typedef struct GTY(()) dw_separate_line_info_struct {
5622 unsigned long dw_file_num;
5623 unsigned long dw_line_num;
5624 unsigned long function;
5626 dw_separate_line_info_entry;
5628 /* Each DIE attribute has a field specifying the attribute kind,
5629 a link to the next attribute in the chain, and an attribute value.
5630 Attributes are typically linked below the DIE they modify. */
5632 typedef struct GTY(()) dw_attr_struct {
5633 enum dwarf_attribute dw_attr;
5634 dw_val_node dw_attr_val;
5638 DEF_VEC_O(dw_attr_node);
5639 DEF_VEC_ALLOC_O(dw_attr_node,gc);
5641 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
5642 The children of each node form a circular list linked by
5643 die_sib. die_child points to the node *before* the "first" child node. */
5645 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct {
5646 enum dwarf_tag die_tag;
5647 union die_symbol_or_type_node
5649 char * GTY ((tag ("0"))) die_symbol;
5650 comdat_type_node_ref GTY ((tag ("1"))) die_type_node;
5652 GTY ((desc ("dwarf_version >= 4"))) die_id;
5653 VEC(dw_attr_node,gc) * die_attr;
5654 dw_die_ref die_parent;
5655 dw_die_ref die_child;
5657 dw_die_ref die_definition; /* ref from a specification to its definition */
5658 dw_offset die_offset;
5659 unsigned long die_abbrev;
5661 /* Die is used and must not be pruned as unused. */
5662 int die_perennial_p;
5663 unsigned int decl_id;
5667 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
5668 #define FOR_EACH_CHILD(die, c, expr) do { \
5669 c = die->die_child; \
5673 } while (c != die->die_child); \
5676 /* The pubname structure */
5678 typedef struct GTY(()) pubname_struct {
5684 DEF_VEC_O(pubname_entry);
5685 DEF_VEC_ALLOC_O(pubname_entry, gc);
5687 struct GTY(()) dw_ranges_struct {
5688 /* If this is positive, it's a block number, otherwise it's a
5689 bitwise-negated index into dw_ranges_by_label. */
5693 struct GTY(()) dw_ranges_by_label_struct {
5698 /* The comdat type node structure. */
5699 typedef struct GTY(()) comdat_type_struct
5701 dw_die_ref root_die;
5702 dw_die_ref type_die;
5703 char signature[DWARF_TYPE_SIGNATURE_SIZE];
5704 struct comdat_type_struct *next;
5708 /* The limbo die list structure. */
5709 typedef struct GTY(()) limbo_die_struct {
5712 struct limbo_die_struct *next;
5716 typedef struct GTY(()) skeleton_chain_struct
5720 struct skeleton_chain_struct *parent;
5722 skeleton_chain_node;
5724 /* How to start an assembler comment. */
5725 #ifndef ASM_COMMENT_START
5726 #define ASM_COMMENT_START ";#"
5729 /* Define a macro which returns nonzero for a TYPE_DECL which was
5730 implicitly generated for a tagged type.
5732 Note that unlike the gcc front end (which generates a NULL named
5733 TYPE_DECL node for each complete tagged type, each array type, and
5734 each function type node created) the g++ front end generates a
5735 _named_ TYPE_DECL node for each tagged type node created.
5736 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
5737 generate a DW_TAG_typedef DIE for them. */
5739 #define TYPE_DECL_IS_STUB(decl) \
5740 (DECL_NAME (decl) == NULL_TREE \
5741 || (DECL_ARTIFICIAL (decl) \
5742 && is_tagged_type (TREE_TYPE (decl)) \
5743 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
5744 /* This is necessary for stub decls that \
5745 appear in nested inline functions. */ \
5746 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
5747 && (decl_ultimate_origin (decl) \
5748 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
5750 /* Information concerning the compilation unit's programming
5751 language, and compiler version. */
5753 /* Fixed size portion of the DWARF compilation unit header. */
5754 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
5755 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
5757 /* Fixed size portion of the DWARF comdat type unit header. */
5758 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
5759 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
5760 + DWARF_OFFSET_SIZE)
5762 /* Fixed size portion of public names info. */
5763 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
5765 /* Fixed size portion of the address range info. */
5766 #define DWARF_ARANGES_HEADER_SIZE \
5767 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5768 DWARF2_ADDR_SIZE * 2) \
5769 - DWARF_INITIAL_LENGTH_SIZE)
5771 /* Size of padding portion in the address range info. It must be
5772 aligned to twice the pointer size. */
5773 #define DWARF_ARANGES_PAD_SIZE \
5774 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5775 DWARF2_ADDR_SIZE * 2) \
5776 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
5778 /* Use assembler line directives if available. */
5779 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
5780 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
5781 #define DWARF2_ASM_LINE_DEBUG_INFO 1
5783 #define DWARF2_ASM_LINE_DEBUG_INFO 0
5787 /* Minimum line offset in a special line info. opcode.
5788 This value was chosen to give a reasonable range of values. */
5789 #define DWARF_LINE_BASE -10
5791 /* First special line opcode - leave room for the standard opcodes. */
5792 #define DWARF_LINE_OPCODE_BASE 10
5794 /* Range of line offsets in a special line info. opcode. */
5795 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
5797 /* Flag that indicates the initial value of the is_stmt_start flag.
5798 In the present implementation, we do not mark any lines as
5799 the beginning of a source statement, because that information
5800 is not made available by the GCC front-end. */
5801 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
5803 /* Maximum number of operations per instruction bundle. */
5804 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
5805 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
5808 #ifdef DWARF2_DEBUGGING_INFO
5809 /* This location is used by calc_die_sizes() to keep track
5810 the offset of each DIE within the .debug_info section. */
5811 static unsigned long next_die_offset;
5814 /* Record the root of the DIE's built for the current compilation unit. */
5815 static GTY(()) dw_die_ref comp_unit_die;
5817 /* A list of type DIEs that have been separated into comdat sections. */
5818 static GTY(()) comdat_type_node *comdat_type_list;
5820 /* A list of DIEs with a NULL parent waiting to be relocated. */
5821 static GTY(()) limbo_die_node *limbo_die_list;
5823 /* A list of DIEs for which we may have to generate
5824 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
5825 static GTY(()) limbo_die_node *deferred_asm_name;
5827 /* Filenames referenced by this compilation unit. */
5828 static GTY((param_is (struct dwarf_file_data))) htab_t file_table;
5830 /* A hash table of references to DIE's that describe declarations.
5831 The key is a DECL_UID() which is a unique number identifying each decl. */
5832 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
5834 /* A hash table of references to DIE's that describe COMMON blocks.
5835 The key is DECL_UID() ^ die_parent. */
5836 static GTY ((param_is (struct die_struct))) htab_t common_block_die_table;
5838 typedef struct GTY(()) die_arg_entry_struct {
5843 DEF_VEC_O(die_arg_entry);
5844 DEF_VEC_ALLOC_O(die_arg_entry,gc);
5846 /* Node of the variable location list. */
5847 struct GTY ((chain_next ("%h.next"))) var_loc_node {
5848 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
5849 EXPR_LIST chain. For small bitsizes, bitsize is encoded
5850 in mode of the EXPR_LIST node and first EXPR_LIST operand
5851 is either NOTE_INSN_VAR_LOCATION for a piece with a known
5852 location or NULL for padding. For larger bitsizes,
5853 mode is 0 and first operand is a CONCAT with bitsize
5854 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
5855 NULL as second operand. */
5857 const char * GTY (()) label;
5858 struct var_loc_node * GTY (()) next;
5861 /* Variable location list. */
5862 struct GTY (()) var_loc_list_def {
5863 struct var_loc_node * GTY (()) first;
5865 /* Pointer to the last but one or last element of the
5866 chained list. If the list is empty, both first and
5867 last are NULL, if the list contains just one node
5868 or the last node certainly is not redundant, it points
5869 to the last node, otherwise points to the last but one.
5870 Do not mark it for GC because it is marked through the chain. */
5871 struct var_loc_node * GTY ((skip ("%h"))) last;
5873 /* DECL_UID of the variable decl. */
5874 unsigned int decl_id;
5876 typedef struct var_loc_list_def var_loc_list;
5879 /* Table of decl location linked lists. */
5880 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
5882 /* A pointer to the base of a list of references to DIE's that
5883 are uniquely identified by their tag, presence/absence of
5884 children DIE's, and list of attribute/value pairs. */
5885 static GTY((length ("abbrev_die_table_allocated")))
5886 dw_die_ref *abbrev_die_table;
5888 /* Number of elements currently allocated for abbrev_die_table. */
5889 static GTY(()) unsigned abbrev_die_table_allocated;
5891 /* Number of elements in type_die_table currently in use. */
5892 static GTY(()) unsigned abbrev_die_table_in_use;
5894 /* Size (in elements) of increments by which we may expand the
5895 abbrev_die_table. */
5896 #define ABBREV_DIE_TABLE_INCREMENT 256
5898 /* A pointer to the base of a table that contains line information
5899 for each source code line in .text in the compilation unit. */
5900 static GTY((length ("line_info_table_allocated")))
5901 dw_line_info_ref line_info_table;
5903 /* Number of elements currently allocated for line_info_table. */
5904 static GTY(()) unsigned line_info_table_allocated;
5906 /* Number of elements in line_info_table currently in use. */
5907 static GTY(()) unsigned line_info_table_in_use;
5909 /* A pointer to the base of a table that contains line information
5910 for each source code line outside of .text in the compilation unit. */
5911 static GTY ((length ("separate_line_info_table_allocated")))
5912 dw_separate_line_info_ref separate_line_info_table;
5914 /* Number of elements currently allocated for separate_line_info_table. */
5915 static GTY(()) unsigned separate_line_info_table_allocated;
5917 /* Number of elements in separate_line_info_table currently in use. */
5918 static GTY(()) unsigned separate_line_info_table_in_use;
5920 /* Size (in elements) of increments by which we may expand the
5922 #define LINE_INFO_TABLE_INCREMENT 1024
5924 /* A pointer to the base of a table that contains a list of publicly
5925 accessible names. */
5926 static GTY (()) VEC (pubname_entry, gc) * pubname_table;
5928 /* A pointer to the base of a table that contains a list of publicly
5929 accessible types. */
5930 static GTY (()) VEC (pubname_entry, gc) * pubtype_table;
5932 /* Array of dies for which we should generate .debug_arange info. */
5933 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
5935 /* Number of elements currently allocated for arange_table. */
5936 static GTY(()) unsigned arange_table_allocated;
5938 /* Number of elements in arange_table currently in use. */
5939 static GTY(()) unsigned arange_table_in_use;
5941 /* Size (in elements) of increments by which we may expand the
5943 #define ARANGE_TABLE_INCREMENT 64
5945 /* Array of dies for which we should generate .debug_ranges info. */
5946 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
5948 /* Number of elements currently allocated for ranges_table. */
5949 static GTY(()) unsigned ranges_table_allocated;
5951 /* Number of elements in ranges_table currently in use. */
5952 static GTY(()) unsigned ranges_table_in_use;
5954 /* Array of pairs of labels referenced in ranges_table. */
5955 static GTY ((length ("ranges_by_label_allocated")))
5956 dw_ranges_by_label_ref ranges_by_label;
5958 /* Number of elements currently allocated for ranges_by_label. */
5959 static GTY(()) unsigned ranges_by_label_allocated;
5961 /* Number of elements in ranges_by_label currently in use. */
5962 static GTY(()) unsigned ranges_by_label_in_use;
5964 /* Size (in elements) of increments by which we may expand the
5966 #define RANGES_TABLE_INCREMENT 64
5968 /* Whether we have location lists that need outputting */
5969 static GTY(()) bool have_location_lists;
5971 /* Unique label counter. */
5972 static GTY(()) unsigned int loclabel_num;
5974 /* Unique label counter for point-of-call tables. */
5975 static GTY(()) unsigned int poc_label_num;
5977 /* The direct call table structure. */
5979 typedef struct GTY(()) dcall_struct {
5980 unsigned int poc_label_num;
5982 dw_die_ref targ_die;
5986 DEF_VEC_O(dcall_entry);
5987 DEF_VEC_ALLOC_O(dcall_entry, gc);
5989 /* The virtual call table structure. */
5991 typedef struct GTY(()) vcall_struct {
5992 unsigned int poc_label_num;
5993 unsigned int vtable_slot;
5997 DEF_VEC_O(vcall_entry);
5998 DEF_VEC_ALLOC_O(vcall_entry, gc);
6000 /* Pointers to the direct and virtual call tables. */
6001 static GTY (()) VEC (dcall_entry, gc) * dcall_table = NULL;
6002 static GTY (()) VEC (vcall_entry, gc) * vcall_table = NULL;
6004 /* A hash table to map INSN_UIDs to vtable slot indexes. */
6006 struct GTY (()) vcall_insn {
6008 unsigned int vtable_slot;
6011 static GTY ((param_is (struct vcall_insn))) htab_t vcall_insn_table;
6013 #ifdef DWARF2_DEBUGGING_INFO
6014 /* Record whether the function being analyzed contains inlined functions. */
6015 static int current_function_has_inlines;
6017 #if 0 && defined (MIPS_DEBUGGING_INFO)
6018 static int comp_unit_has_inlines;
6021 /* The last file entry emitted by maybe_emit_file(). */
6022 static GTY(()) struct dwarf_file_data * last_emitted_file;
6024 /* Number of internal labels generated by gen_internal_sym(). */
6025 static GTY(()) int label_num;
6027 /* Cached result of previous call to lookup_filename. */
6028 static GTY(()) struct dwarf_file_data * file_table_last_lookup;
6030 static GTY(()) VEC(die_arg_entry,gc) *tmpl_value_parm_die_table;
6032 #ifdef DWARF2_DEBUGGING_INFO
6034 /* Offset from the "steady-state frame pointer" to the frame base,
6035 within the current function. */
6036 static HOST_WIDE_INT frame_pointer_fb_offset;
6038 /* Forward declarations for functions defined in this file. */
6040 static int is_pseudo_reg (const_rtx);
6041 static tree type_main_variant (tree);
6042 static int is_tagged_type (const_tree);
6043 static const char *dwarf_tag_name (unsigned);
6044 static const char *dwarf_attr_name (unsigned);
6045 static const char *dwarf_form_name (unsigned);
6046 static tree decl_ultimate_origin (const_tree);
6047 static tree decl_class_context (tree);
6048 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
6049 static inline enum dw_val_class AT_class (dw_attr_ref);
6050 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
6051 static inline unsigned AT_flag (dw_attr_ref);
6052 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
6053 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
6054 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
6055 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
6056 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
6057 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
6058 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
6059 unsigned int, unsigned char *);
6060 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
6061 static hashval_t debug_str_do_hash (const void *);
6062 static int debug_str_eq (const void *, const void *);
6063 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
6064 static inline const char *AT_string (dw_attr_ref);
6065 static enum dwarf_form AT_string_form (dw_attr_ref);
6066 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
6067 static void add_AT_specification (dw_die_ref, dw_die_ref);
6068 static inline dw_die_ref AT_ref (dw_attr_ref);
6069 static inline int AT_ref_external (dw_attr_ref);
6070 static inline void set_AT_ref_external (dw_attr_ref, int);
6071 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
6072 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
6073 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
6074 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
6076 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
6077 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
6078 static inline rtx AT_addr (dw_attr_ref);
6079 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
6080 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
6081 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
6082 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
6083 unsigned HOST_WIDE_INT);
6084 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
6086 static inline const char *AT_lbl (dw_attr_ref);
6087 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
6088 static const char *get_AT_low_pc (dw_die_ref);
6089 static const char *get_AT_hi_pc (dw_die_ref);
6090 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
6091 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
6092 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
6093 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
6094 static bool is_cxx (void);
6095 static bool is_fortran (void);
6096 static bool is_ada (void);
6097 static void remove_AT (dw_die_ref, enum dwarf_attribute);
6098 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
6099 static void add_child_die (dw_die_ref, dw_die_ref);
6100 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
6101 static dw_die_ref lookup_type_die (tree);
6102 static void equate_type_number_to_die (tree, dw_die_ref);
6103 static hashval_t decl_die_table_hash (const void *);
6104 static int decl_die_table_eq (const void *, const void *);
6105 static dw_die_ref lookup_decl_die (tree);
6106 static hashval_t common_block_die_table_hash (const void *);
6107 static int common_block_die_table_eq (const void *, const void *);
6108 static hashval_t decl_loc_table_hash (const void *);
6109 static int decl_loc_table_eq (const void *, const void *);
6110 static var_loc_list *lookup_decl_loc (const_tree);
6111 static void equate_decl_number_to_die (tree, dw_die_ref);
6112 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *);
6113 static void print_spaces (FILE *);
6114 static void print_die (dw_die_ref, FILE *);
6115 static void print_dwarf_line_table (FILE *);
6116 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
6117 static dw_die_ref pop_compile_unit (dw_die_ref);
6118 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
6119 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
6120 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
6121 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
6122 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
6123 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
6124 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_ref,
6125 struct md5_ctx *, int *);
6126 struct checksum_attributes;
6127 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
6128 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
6129 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
6130 static void generate_type_signature (dw_die_ref, comdat_type_node *);
6131 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
6132 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
6133 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
6134 static int same_die_p (dw_die_ref, dw_die_ref, int *);
6135 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
6136 static void compute_section_prefix (dw_die_ref);
6137 static int is_type_die (dw_die_ref);
6138 static int is_comdat_die (dw_die_ref);
6139 static int is_symbol_die (dw_die_ref);
6140 static void assign_symbol_names (dw_die_ref);
6141 static void break_out_includes (dw_die_ref);
6142 static int is_declaration_die (dw_die_ref);
6143 static int should_move_die_to_comdat (dw_die_ref);
6144 static dw_die_ref clone_as_declaration (dw_die_ref);
6145 static dw_die_ref clone_die (dw_die_ref);
6146 static dw_die_ref clone_tree (dw_die_ref);
6147 static void copy_declaration_context (dw_die_ref, dw_die_ref);
6148 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
6149 static void generate_skeleton_bottom_up (skeleton_chain_node *);
6150 static dw_die_ref generate_skeleton (dw_die_ref);
6151 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
6153 static void break_out_comdat_types (dw_die_ref);
6154 static dw_die_ref copy_ancestor_tree (dw_die_ref, dw_die_ref, htab_t);
6155 static void copy_decls_walk (dw_die_ref, dw_die_ref, htab_t);
6156 static void copy_decls_for_unworthy_types (dw_die_ref);
6158 static hashval_t htab_cu_hash (const void *);
6159 static int htab_cu_eq (const void *, const void *);
6160 static void htab_cu_del (void *);
6161 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
6162 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
6163 static void add_sibling_attributes (dw_die_ref);
6164 static void build_abbrev_table (dw_die_ref);
6165 static void output_location_lists (dw_die_ref);
6166 static int constant_size (unsigned HOST_WIDE_INT);
6167 static unsigned long size_of_die (dw_die_ref);
6168 static void calc_die_sizes (dw_die_ref);
6169 static void mark_dies (dw_die_ref);
6170 static void unmark_dies (dw_die_ref);
6171 static void unmark_all_dies (dw_die_ref);
6172 static unsigned long size_of_pubnames (VEC (pubname_entry,gc) *);
6173 static unsigned long size_of_aranges (void);
6174 static enum dwarf_form value_format (dw_attr_ref);
6175 static void output_value_format (dw_attr_ref);
6176 static void output_abbrev_section (void);
6177 static void output_die_symbol (dw_die_ref);
6178 static void output_die (dw_die_ref);
6179 static void output_compilation_unit_header (void);
6180 static void output_comp_unit (dw_die_ref, int);
6181 static void output_comdat_type_unit (comdat_type_node *);
6182 static const char *dwarf2_name (tree, int);
6183 static void add_pubname (tree, dw_die_ref);
6184 static void add_pubname_string (const char *, dw_die_ref);
6185 static void add_pubtype (tree, dw_die_ref);
6186 static void output_pubnames (VEC (pubname_entry,gc) *);
6187 static void add_arange (tree, dw_die_ref);
6188 static void output_aranges (void);
6189 static unsigned int add_ranges_num (int);
6190 static unsigned int add_ranges (const_tree);
6191 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
6193 static void output_ranges (void);
6194 static void output_line_info (void);
6195 static void output_file_names (void);
6196 static dw_die_ref base_type_die (tree);
6197 static int is_base_type (tree);
6198 static dw_die_ref subrange_type_die (tree, tree, tree, dw_die_ref);
6199 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
6200 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
6201 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
6202 static int type_is_enum (const_tree);
6203 static unsigned int dbx_reg_number (const_rtx);
6204 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
6205 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
6206 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
6207 enum var_init_status);
6208 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
6209 enum var_init_status);
6210 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT,
6211 enum var_init_status);
6212 static int is_based_loc (const_rtx);
6213 static int resolve_one_addr (rtx *, void *);
6214 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode,
6215 enum var_init_status);
6216 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
6217 enum var_init_status);
6218 static dw_loc_descr_ref loc_descriptor (rtx, enum machine_mode mode,
6219 enum var_init_status);
6220 static dw_loc_list_ref loc_list_from_tree (tree, int);
6221 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int);
6222 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
6223 static tree field_type (const_tree);
6224 static unsigned int simple_type_align_in_bits (const_tree);
6225 static unsigned int simple_decl_align_in_bits (const_tree);
6226 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
6227 static HOST_WIDE_INT field_byte_offset (const_tree);
6228 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
6230 static void add_data_member_location_attribute (dw_die_ref, tree);
6231 static bool add_const_value_attribute (dw_die_ref, rtx);
6232 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
6233 static void insert_double (double_int, unsigned char *);
6234 static void insert_float (const_rtx, unsigned char *);
6235 static rtx rtl_for_decl_location (tree);
6236 static bool add_location_or_const_value_attribute (dw_die_ref, tree,
6237 enum dwarf_attribute);
6238 static bool tree_add_const_value_attribute (dw_die_ref, tree);
6239 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
6240 static void add_name_attribute (dw_die_ref, const char *);
6241 static void add_comp_dir_attribute (dw_die_ref);
6242 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
6243 static void add_subscript_info (dw_die_ref, tree, bool);
6244 static void add_byte_size_attribute (dw_die_ref, tree);
6245 static void add_bit_offset_attribute (dw_die_ref, tree);
6246 static void add_bit_size_attribute (dw_die_ref, tree);
6247 static void add_prototyped_attribute (dw_die_ref, tree);
6248 static dw_die_ref add_abstract_origin_attribute (dw_die_ref, tree);
6249 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
6250 static void add_src_coords_attributes (dw_die_ref, tree);
6251 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
6252 static void push_decl_scope (tree);
6253 static void pop_decl_scope (void);
6254 static dw_die_ref scope_die_for (tree, dw_die_ref);
6255 static inline int local_scope_p (dw_die_ref);
6256 static inline int class_scope_p (dw_die_ref);
6257 static inline int class_or_namespace_scope_p (dw_die_ref);
6258 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
6259 static void add_calling_convention_attribute (dw_die_ref, tree);
6260 static const char *type_tag (const_tree);
6261 static tree member_declared_type (const_tree);
6263 static const char *decl_start_label (tree);
6265 static void gen_array_type_die (tree, dw_die_ref);
6266 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
6268 static void gen_entry_point_die (tree, dw_die_ref);
6270 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
6271 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
6272 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
6273 static void gen_unspecified_parameters_die (tree, dw_die_ref);
6274 static void gen_formal_types_die (tree, dw_die_ref);
6275 static void gen_subprogram_die (tree, dw_die_ref);
6276 static void gen_variable_die (tree, tree, dw_die_ref);
6277 static void gen_const_die (tree, dw_die_ref);
6278 static void gen_label_die (tree, dw_die_ref);
6279 static void gen_lexical_block_die (tree, dw_die_ref, int);
6280 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
6281 static void gen_field_die (tree, dw_die_ref);
6282 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
6283 static dw_die_ref gen_compile_unit_die (const char *);
6284 static void gen_inheritance_die (tree, tree, dw_die_ref);
6285 static void gen_member_die (tree, dw_die_ref);
6286 static void gen_struct_or_union_type_die (tree, dw_die_ref,
6287 enum debug_info_usage);
6288 static void gen_subroutine_type_die (tree, dw_die_ref);
6289 static void gen_typedef_die (tree, dw_die_ref);
6290 static void gen_type_die (tree, dw_die_ref);
6291 static void gen_block_die (tree, dw_die_ref, int);
6292 static void decls_for_scope (tree, dw_die_ref, int);
6293 static int is_redundant_typedef (const_tree);
6294 static bool is_naming_typedef_decl (const_tree);
6295 static inline dw_die_ref get_context_die (tree);
6296 static void gen_namespace_die (tree, dw_die_ref);
6297 static void gen_decl_die (tree, tree, dw_die_ref);
6298 static dw_die_ref force_decl_die (tree);
6299 static dw_die_ref force_type_die (tree);
6300 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
6301 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
6302 static struct dwarf_file_data * lookup_filename (const char *);
6303 static void retry_incomplete_types (void);
6304 static void gen_type_die_for_member (tree, tree, dw_die_ref);
6305 static void gen_generic_params_dies (tree);
6306 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
6307 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
6308 static void splice_child_die (dw_die_ref, dw_die_ref);
6309 static int file_info_cmp (const void *, const void *);
6310 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
6311 const char *, const char *);
6312 static void output_loc_list (dw_loc_list_ref);
6313 static char *gen_internal_sym (const char *);
6315 static void prune_unmark_dies (dw_die_ref);
6316 static void prune_unused_types_mark (dw_die_ref, int);
6317 static void prune_unused_types_walk (dw_die_ref);
6318 static void prune_unused_types_walk_attribs (dw_die_ref);
6319 static void prune_unused_types_prune (dw_die_ref);
6320 static void prune_unused_types (void);
6321 static int maybe_emit_file (struct dwarf_file_data *fd);
6322 static inline const char *AT_vms_delta1 (dw_attr_ref);
6323 static inline const char *AT_vms_delta2 (dw_attr_ref);
6324 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
6325 const char *, const char *);
6326 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
6327 static void gen_remaining_tmpl_value_param_die_attribute (void);
6329 /* Section names used to hold DWARF debugging information. */
6330 #ifndef DEBUG_INFO_SECTION
6331 #define DEBUG_INFO_SECTION ".debug_info"
6333 #ifndef DEBUG_ABBREV_SECTION
6334 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
6336 #ifndef DEBUG_ARANGES_SECTION
6337 #define DEBUG_ARANGES_SECTION ".debug_aranges"
6339 #ifndef DEBUG_MACINFO_SECTION
6340 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
6342 #ifndef DEBUG_LINE_SECTION
6343 #define DEBUG_LINE_SECTION ".debug_line"
6345 #ifndef DEBUG_LOC_SECTION
6346 #define DEBUG_LOC_SECTION ".debug_loc"
6348 #ifndef DEBUG_PUBNAMES_SECTION
6349 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
6351 #ifndef DEBUG_PUBTYPES_SECTION
6352 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
6354 #ifndef DEBUG_DCALL_SECTION
6355 #define DEBUG_DCALL_SECTION ".debug_dcall"
6357 #ifndef DEBUG_VCALL_SECTION
6358 #define DEBUG_VCALL_SECTION ".debug_vcall"
6360 #ifndef DEBUG_STR_SECTION
6361 #define DEBUG_STR_SECTION ".debug_str"
6363 #ifndef DEBUG_RANGES_SECTION
6364 #define DEBUG_RANGES_SECTION ".debug_ranges"
6367 /* Standard ELF section names for compiled code and data. */
6368 #ifndef TEXT_SECTION_NAME
6369 #define TEXT_SECTION_NAME ".text"
6372 /* Section flags for .debug_str section. */
6373 #define DEBUG_STR_SECTION_FLAGS \
6374 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
6375 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
6378 /* Labels we insert at beginning sections we can reference instead of
6379 the section names themselves. */
6381 #ifndef TEXT_SECTION_LABEL
6382 #define TEXT_SECTION_LABEL "Ltext"
6384 #ifndef COLD_TEXT_SECTION_LABEL
6385 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
6387 #ifndef DEBUG_LINE_SECTION_LABEL
6388 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
6390 #ifndef DEBUG_INFO_SECTION_LABEL
6391 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
6393 #ifndef DEBUG_ABBREV_SECTION_LABEL
6394 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
6396 #ifndef DEBUG_LOC_SECTION_LABEL
6397 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
6399 #ifndef DEBUG_RANGES_SECTION_LABEL
6400 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
6402 #ifndef DEBUG_MACINFO_SECTION_LABEL
6403 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
6407 /* Definitions of defaults for formats and names of various special
6408 (artificial) labels which may be generated within this file (when the -g
6409 options is used and DWARF2_DEBUGGING_INFO is in effect.
6410 If necessary, these may be overridden from within the tm.h file, but
6411 typically, overriding these defaults is unnecessary. */
6413 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6414 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6415 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6416 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
6417 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6418 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6419 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6420 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6421 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
6422 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
6424 #ifndef TEXT_END_LABEL
6425 #define TEXT_END_LABEL "Letext"
6427 #ifndef COLD_END_LABEL
6428 #define COLD_END_LABEL "Letext_cold"
6430 #ifndef BLOCK_BEGIN_LABEL
6431 #define BLOCK_BEGIN_LABEL "LBB"
6433 #ifndef BLOCK_END_LABEL
6434 #define BLOCK_END_LABEL "LBE"
6436 #ifndef LINE_CODE_LABEL
6437 #define LINE_CODE_LABEL "LM"
6439 #ifndef SEPARATE_LINE_CODE_LABEL
6440 #define SEPARATE_LINE_CODE_LABEL "LSM"
6444 /* We allow a language front-end to designate a function that is to be
6445 called to "demangle" any name before it is put into a DIE. */
6447 static const char *(*demangle_name_func) (const char *);
6450 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
6452 demangle_name_func = func;
6455 /* Test if rtl node points to a pseudo register. */
6458 is_pseudo_reg (const_rtx rtl)
6460 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
6461 || (GET_CODE (rtl) == SUBREG
6462 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
6465 /* Return a reference to a type, with its const and volatile qualifiers
6469 type_main_variant (tree type)
6471 type = TYPE_MAIN_VARIANT (type);
6473 /* ??? There really should be only one main variant among any group of
6474 variants of a given type (and all of the MAIN_VARIANT values for all
6475 members of the group should point to that one type) but sometimes the C
6476 front-end messes this up for array types, so we work around that bug
6478 if (TREE_CODE (type) == ARRAY_TYPE)
6479 while (type != TYPE_MAIN_VARIANT (type))
6480 type = TYPE_MAIN_VARIANT (type);
6485 /* Return nonzero if the given type node represents a tagged type. */
6488 is_tagged_type (const_tree type)
6490 enum tree_code code = TREE_CODE (type);
6492 return (code == RECORD_TYPE || code == UNION_TYPE
6493 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
6496 /* Convert a DIE tag into its string name. */
6499 dwarf_tag_name (unsigned int tag)
6503 case DW_TAG_padding:
6504 return "DW_TAG_padding";
6505 case DW_TAG_array_type:
6506 return "DW_TAG_array_type";
6507 case DW_TAG_class_type:
6508 return "DW_TAG_class_type";
6509 case DW_TAG_entry_point:
6510 return "DW_TAG_entry_point";
6511 case DW_TAG_enumeration_type:
6512 return "DW_TAG_enumeration_type";
6513 case DW_TAG_formal_parameter:
6514 return "DW_TAG_formal_parameter";
6515 case DW_TAG_imported_declaration:
6516 return "DW_TAG_imported_declaration";
6518 return "DW_TAG_label";
6519 case DW_TAG_lexical_block:
6520 return "DW_TAG_lexical_block";
6522 return "DW_TAG_member";
6523 case DW_TAG_pointer_type:
6524 return "DW_TAG_pointer_type";
6525 case DW_TAG_reference_type:
6526 return "DW_TAG_reference_type";
6527 case DW_TAG_compile_unit:
6528 return "DW_TAG_compile_unit";
6529 case DW_TAG_string_type:
6530 return "DW_TAG_string_type";
6531 case DW_TAG_structure_type:
6532 return "DW_TAG_structure_type";
6533 case DW_TAG_subroutine_type:
6534 return "DW_TAG_subroutine_type";
6535 case DW_TAG_typedef:
6536 return "DW_TAG_typedef";
6537 case DW_TAG_union_type:
6538 return "DW_TAG_union_type";
6539 case DW_TAG_unspecified_parameters:
6540 return "DW_TAG_unspecified_parameters";
6541 case DW_TAG_variant:
6542 return "DW_TAG_variant";
6543 case DW_TAG_common_block:
6544 return "DW_TAG_common_block";
6545 case DW_TAG_common_inclusion:
6546 return "DW_TAG_common_inclusion";
6547 case DW_TAG_inheritance:
6548 return "DW_TAG_inheritance";
6549 case DW_TAG_inlined_subroutine:
6550 return "DW_TAG_inlined_subroutine";
6552 return "DW_TAG_module";
6553 case DW_TAG_ptr_to_member_type:
6554 return "DW_TAG_ptr_to_member_type";
6555 case DW_TAG_set_type:
6556 return "DW_TAG_set_type";
6557 case DW_TAG_subrange_type:
6558 return "DW_TAG_subrange_type";
6559 case DW_TAG_with_stmt:
6560 return "DW_TAG_with_stmt";
6561 case DW_TAG_access_declaration:
6562 return "DW_TAG_access_declaration";
6563 case DW_TAG_base_type:
6564 return "DW_TAG_base_type";
6565 case DW_TAG_catch_block:
6566 return "DW_TAG_catch_block";
6567 case DW_TAG_const_type:
6568 return "DW_TAG_const_type";
6569 case DW_TAG_constant:
6570 return "DW_TAG_constant";
6571 case DW_TAG_enumerator:
6572 return "DW_TAG_enumerator";
6573 case DW_TAG_file_type:
6574 return "DW_TAG_file_type";
6576 return "DW_TAG_friend";
6577 case DW_TAG_namelist:
6578 return "DW_TAG_namelist";
6579 case DW_TAG_namelist_item:
6580 return "DW_TAG_namelist_item";
6581 case DW_TAG_packed_type:
6582 return "DW_TAG_packed_type";
6583 case DW_TAG_subprogram:
6584 return "DW_TAG_subprogram";
6585 case DW_TAG_template_type_param:
6586 return "DW_TAG_template_type_param";
6587 case DW_TAG_template_value_param:
6588 return "DW_TAG_template_value_param";
6589 case DW_TAG_thrown_type:
6590 return "DW_TAG_thrown_type";
6591 case DW_TAG_try_block:
6592 return "DW_TAG_try_block";
6593 case DW_TAG_variant_part:
6594 return "DW_TAG_variant_part";
6595 case DW_TAG_variable:
6596 return "DW_TAG_variable";
6597 case DW_TAG_volatile_type:
6598 return "DW_TAG_volatile_type";
6599 case DW_TAG_dwarf_procedure:
6600 return "DW_TAG_dwarf_procedure";
6601 case DW_TAG_restrict_type:
6602 return "DW_TAG_restrict_type";
6603 case DW_TAG_interface_type:
6604 return "DW_TAG_interface_type";
6605 case DW_TAG_namespace:
6606 return "DW_TAG_namespace";
6607 case DW_TAG_imported_module:
6608 return "DW_TAG_imported_module";
6609 case DW_TAG_unspecified_type:
6610 return "DW_TAG_unspecified_type";
6611 case DW_TAG_partial_unit:
6612 return "DW_TAG_partial_unit";
6613 case DW_TAG_imported_unit:
6614 return "DW_TAG_imported_unit";
6615 case DW_TAG_condition:
6616 return "DW_TAG_condition";
6617 case DW_TAG_shared_type:
6618 return "DW_TAG_shared_type";
6619 case DW_TAG_type_unit:
6620 return "DW_TAG_type_unit";
6621 case DW_TAG_rvalue_reference_type:
6622 return "DW_TAG_rvalue_reference_type";
6623 case DW_TAG_template_alias:
6624 return "DW_TAG_template_alias";
6625 case DW_TAG_GNU_template_parameter_pack:
6626 return "DW_TAG_GNU_template_parameter_pack";
6627 case DW_TAG_GNU_formal_parameter_pack:
6628 return "DW_TAG_GNU_formal_parameter_pack";
6629 case DW_TAG_MIPS_loop:
6630 return "DW_TAG_MIPS_loop";
6631 case DW_TAG_format_label:
6632 return "DW_TAG_format_label";
6633 case DW_TAG_function_template:
6634 return "DW_TAG_function_template";
6635 case DW_TAG_class_template:
6636 return "DW_TAG_class_template";
6637 case DW_TAG_GNU_BINCL:
6638 return "DW_TAG_GNU_BINCL";
6639 case DW_TAG_GNU_EINCL:
6640 return "DW_TAG_GNU_EINCL";
6641 case DW_TAG_GNU_template_template_param:
6642 return "DW_TAG_GNU_template_template_param";
6644 return "DW_TAG_<unknown>";
6648 /* Convert a DWARF attribute code into its string name. */
6651 dwarf_attr_name (unsigned int attr)
6656 return "DW_AT_sibling";
6657 case DW_AT_location:
6658 return "DW_AT_location";
6660 return "DW_AT_name";
6661 case DW_AT_ordering:
6662 return "DW_AT_ordering";
6663 case DW_AT_subscr_data:
6664 return "DW_AT_subscr_data";
6665 case DW_AT_byte_size:
6666 return "DW_AT_byte_size";
6667 case DW_AT_bit_offset:
6668 return "DW_AT_bit_offset";
6669 case DW_AT_bit_size:
6670 return "DW_AT_bit_size";
6671 case DW_AT_element_list:
6672 return "DW_AT_element_list";
6673 case DW_AT_stmt_list:
6674 return "DW_AT_stmt_list";
6676 return "DW_AT_low_pc";
6678 return "DW_AT_high_pc";
6679 case DW_AT_language:
6680 return "DW_AT_language";
6682 return "DW_AT_member";
6684 return "DW_AT_discr";
6685 case DW_AT_discr_value:
6686 return "DW_AT_discr_value";
6687 case DW_AT_visibility:
6688 return "DW_AT_visibility";
6690 return "DW_AT_import";
6691 case DW_AT_string_length:
6692 return "DW_AT_string_length";
6693 case DW_AT_common_reference:
6694 return "DW_AT_common_reference";
6695 case DW_AT_comp_dir:
6696 return "DW_AT_comp_dir";
6697 case DW_AT_const_value:
6698 return "DW_AT_const_value";
6699 case DW_AT_containing_type:
6700 return "DW_AT_containing_type";
6701 case DW_AT_default_value:
6702 return "DW_AT_default_value";
6704 return "DW_AT_inline";
6705 case DW_AT_is_optional:
6706 return "DW_AT_is_optional";
6707 case DW_AT_lower_bound:
6708 return "DW_AT_lower_bound";
6709 case DW_AT_producer:
6710 return "DW_AT_producer";
6711 case DW_AT_prototyped:
6712 return "DW_AT_prototyped";
6713 case DW_AT_return_addr:
6714 return "DW_AT_return_addr";
6715 case DW_AT_start_scope:
6716 return "DW_AT_start_scope";
6717 case DW_AT_bit_stride:
6718 return "DW_AT_bit_stride";
6719 case DW_AT_upper_bound:
6720 return "DW_AT_upper_bound";
6721 case DW_AT_abstract_origin:
6722 return "DW_AT_abstract_origin";
6723 case DW_AT_accessibility:
6724 return "DW_AT_accessibility";
6725 case DW_AT_address_class:
6726 return "DW_AT_address_class";
6727 case DW_AT_artificial:
6728 return "DW_AT_artificial";
6729 case DW_AT_base_types:
6730 return "DW_AT_base_types";
6731 case DW_AT_calling_convention:
6732 return "DW_AT_calling_convention";
6734 return "DW_AT_count";
6735 case DW_AT_data_member_location:
6736 return "DW_AT_data_member_location";
6737 case DW_AT_decl_column:
6738 return "DW_AT_decl_column";
6739 case DW_AT_decl_file:
6740 return "DW_AT_decl_file";
6741 case DW_AT_decl_line:
6742 return "DW_AT_decl_line";
6743 case DW_AT_declaration:
6744 return "DW_AT_declaration";
6745 case DW_AT_discr_list:
6746 return "DW_AT_discr_list";
6747 case DW_AT_encoding:
6748 return "DW_AT_encoding";
6749 case DW_AT_external:
6750 return "DW_AT_external";
6751 case DW_AT_explicit:
6752 return "DW_AT_explicit";
6753 case DW_AT_frame_base:
6754 return "DW_AT_frame_base";
6756 return "DW_AT_friend";
6757 case DW_AT_identifier_case:
6758 return "DW_AT_identifier_case";
6759 case DW_AT_macro_info:
6760 return "DW_AT_macro_info";
6761 case DW_AT_namelist_items:
6762 return "DW_AT_namelist_items";
6763 case DW_AT_priority:
6764 return "DW_AT_priority";
6766 return "DW_AT_segment";
6767 case DW_AT_specification:
6768 return "DW_AT_specification";
6769 case DW_AT_static_link:
6770 return "DW_AT_static_link";
6772 return "DW_AT_type";
6773 case DW_AT_use_location:
6774 return "DW_AT_use_location";
6775 case DW_AT_variable_parameter:
6776 return "DW_AT_variable_parameter";
6777 case DW_AT_virtuality:
6778 return "DW_AT_virtuality";
6779 case DW_AT_vtable_elem_location:
6780 return "DW_AT_vtable_elem_location";
6782 case DW_AT_allocated:
6783 return "DW_AT_allocated";
6784 case DW_AT_associated:
6785 return "DW_AT_associated";
6786 case DW_AT_data_location:
6787 return "DW_AT_data_location";
6788 case DW_AT_byte_stride:
6789 return "DW_AT_byte_stride";
6790 case DW_AT_entry_pc:
6791 return "DW_AT_entry_pc";
6792 case DW_AT_use_UTF8:
6793 return "DW_AT_use_UTF8";
6794 case DW_AT_extension:
6795 return "DW_AT_extension";
6797 return "DW_AT_ranges";
6798 case DW_AT_trampoline:
6799 return "DW_AT_trampoline";
6800 case DW_AT_call_column:
6801 return "DW_AT_call_column";
6802 case DW_AT_call_file:
6803 return "DW_AT_call_file";
6804 case DW_AT_call_line:
6805 return "DW_AT_call_line";
6807 case DW_AT_signature:
6808 return "DW_AT_signature";
6809 case DW_AT_main_subprogram:
6810 return "DW_AT_main_subprogram";
6811 case DW_AT_data_bit_offset:
6812 return "DW_AT_data_bit_offset";
6813 case DW_AT_const_expr:
6814 return "DW_AT_const_expr";
6815 case DW_AT_enum_class:
6816 return "DW_AT_enum_class";
6817 case DW_AT_linkage_name:
6818 return "DW_AT_linkage_name";
6820 case DW_AT_MIPS_fde:
6821 return "DW_AT_MIPS_fde";
6822 case DW_AT_MIPS_loop_begin:
6823 return "DW_AT_MIPS_loop_begin";
6824 case DW_AT_MIPS_tail_loop_begin:
6825 return "DW_AT_MIPS_tail_loop_begin";
6826 case DW_AT_MIPS_epilog_begin:
6827 return "DW_AT_MIPS_epilog_begin";
6828 #if VMS_DEBUGGING_INFO
6829 case DW_AT_HP_prologue:
6830 return "DW_AT_HP_prologue";
6832 case DW_AT_MIPS_loop_unroll_factor:
6833 return "DW_AT_MIPS_loop_unroll_factor";
6835 case DW_AT_MIPS_software_pipeline_depth:
6836 return "DW_AT_MIPS_software_pipeline_depth";
6837 case DW_AT_MIPS_linkage_name:
6838 return "DW_AT_MIPS_linkage_name";
6839 #if VMS_DEBUGGING_INFO
6840 case DW_AT_HP_epilogue:
6841 return "DW_AT_HP_epilogue";
6843 case DW_AT_MIPS_stride:
6844 return "DW_AT_MIPS_stride";
6846 case DW_AT_MIPS_abstract_name:
6847 return "DW_AT_MIPS_abstract_name";
6848 case DW_AT_MIPS_clone_origin:
6849 return "DW_AT_MIPS_clone_origin";
6850 case DW_AT_MIPS_has_inlines:
6851 return "DW_AT_MIPS_has_inlines";
6853 case DW_AT_sf_names:
6854 return "DW_AT_sf_names";
6855 case DW_AT_src_info:
6856 return "DW_AT_src_info";
6857 case DW_AT_mac_info:
6858 return "DW_AT_mac_info";
6859 case DW_AT_src_coords:
6860 return "DW_AT_src_coords";
6861 case DW_AT_body_begin:
6862 return "DW_AT_body_begin";
6863 case DW_AT_body_end:
6864 return "DW_AT_body_end";
6865 case DW_AT_GNU_vector:
6866 return "DW_AT_GNU_vector";
6867 case DW_AT_GNU_guarded_by:
6868 return "DW_AT_GNU_guarded_by";
6869 case DW_AT_GNU_pt_guarded_by:
6870 return "DW_AT_GNU_pt_guarded_by";
6871 case DW_AT_GNU_guarded:
6872 return "DW_AT_GNU_guarded";
6873 case DW_AT_GNU_pt_guarded:
6874 return "DW_AT_GNU_pt_guarded";
6875 case DW_AT_GNU_locks_excluded:
6876 return "DW_AT_GNU_locks_excluded";
6877 case DW_AT_GNU_exclusive_locks_required:
6878 return "DW_AT_GNU_exclusive_locks_required";
6879 case DW_AT_GNU_shared_locks_required:
6880 return "DW_AT_GNU_shared_locks_required";
6881 case DW_AT_GNU_odr_signature:
6882 return "DW_AT_GNU_odr_signature";
6883 case DW_AT_GNU_template_name:
6884 return "DW_AT_GNU_template_name";
6886 case DW_AT_VMS_rtnbeg_pd_address:
6887 return "DW_AT_VMS_rtnbeg_pd_address";
6890 return "DW_AT_<unknown>";
6894 /* Convert a DWARF value form code into its string name. */
6897 dwarf_form_name (unsigned int form)
6902 return "DW_FORM_addr";
6903 case DW_FORM_block2:
6904 return "DW_FORM_block2";
6905 case DW_FORM_block4:
6906 return "DW_FORM_block4";
6908 return "DW_FORM_data2";
6910 return "DW_FORM_data4";
6912 return "DW_FORM_data8";
6913 case DW_FORM_string:
6914 return "DW_FORM_string";
6916 return "DW_FORM_block";
6917 case DW_FORM_block1:
6918 return "DW_FORM_block1";
6920 return "DW_FORM_data1";
6922 return "DW_FORM_flag";
6924 return "DW_FORM_sdata";
6926 return "DW_FORM_strp";
6928 return "DW_FORM_udata";
6929 case DW_FORM_ref_addr:
6930 return "DW_FORM_ref_addr";
6932 return "DW_FORM_ref1";
6934 return "DW_FORM_ref2";
6936 return "DW_FORM_ref4";
6938 return "DW_FORM_ref8";
6939 case DW_FORM_ref_udata:
6940 return "DW_FORM_ref_udata";
6941 case DW_FORM_indirect:
6942 return "DW_FORM_indirect";
6943 case DW_FORM_sec_offset:
6944 return "DW_FORM_sec_offset";
6945 case DW_FORM_exprloc:
6946 return "DW_FORM_exprloc";
6947 case DW_FORM_flag_present:
6948 return "DW_FORM_flag_present";
6949 case DW_FORM_ref_sig8:
6950 return "DW_FORM_ref_sig8";
6952 return "DW_FORM_<unknown>";
6956 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
6957 instance of an inlined instance of a decl which is local to an inline
6958 function, so we have to trace all of the way back through the origin chain
6959 to find out what sort of node actually served as the original seed for the
6963 decl_ultimate_origin (const_tree decl)
6965 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
6968 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
6969 nodes in the function to point to themselves; ignore that if
6970 we're trying to output the abstract instance of this function. */
6971 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
6974 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
6975 most distant ancestor, this should never happen. */
6976 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
6978 return DECL_ABSTRACT_ORIGIN (decl);
6981 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
6982 of a virtual function may refer to a base class, so we check the 'this'
6986 decl_class_context (tree decl)
6988 tree context = NULL_TREE;
6990 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
6991 context = DECL_CONTEXT (decl);
6993 context = TYPE_MAIN_VARIANT
6994 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
6996 if (context && !TYPE_P (context))
6997 context = NULL_TREE;
7002 /* Add an attribute/value pair to a DIE. */
7005 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
7007 /* Maybe this should be an assert? */
7011 if (die->die_attr == NULL)
7012 die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
7013 VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
7016 static inline enum dw_val_class
7017 AT_class (dw_attr_ref a)
7019 return a->dw_attr_val.val_class;
7022 /* Add a flag value attribute to a DIE. */
7025 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
7029 attr.dw_attr = attr_kind;
7030 attr.dw_attr_val.val_class = dw_val_class_flag;
7031 attr.dw_attr_val.v.val_flag = flag;
7032 add_dwarf_attr (die, &attr);
7035 static inline unsigned
7036 AT_flag (dw_attr_ref a)
7038 gcc_assert (a && AT_class (a) == dw_val_class_flag);
7039 return a->dw_attr_val.v.val_flag;
7042 /* Add a signed integer attribute value to a DIE. */
7045 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
7049 attr.dw_attr = attr_kind;
7050 attr.dw_attr_val.val_class = dw_val_class_const;
7051 attr.dw_attr_val.v.val_int = int_val;
7052 add_dwarf_attr (die, &attr);
7055 static inline HOST_WIDE_INT
7056 AT_int (dw_attr_ref a)
7058 gcc_assert (a && AT_class (a) == dw_val_class_const);
7059 return a->dw_attr_val.v.val_int;
7062 /* Add an unsigned integer attribute value to a DIE. */
7065 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
7066 unsigned HOST_WIDE_INT unsigned_val)
7070 attr.dw_attr = attr_kind;
7071 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
7072 attr.dw_attr_val.v.val_unsigned = unsigned_val;
7073 add_dwarf_attr (die, &attr);
7076 static inline unsigned HOST_WIDE_INT
7077 AT_unsigned (dw_attr_ref a)
7079 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
7080 return a->dw_attr_val.v.val_unsigned;
7083 /* Add an unsigned double integer attribute value to a DIE. */
7086 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
7087 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
7091 attr.dw_attr = attr_kind;
7092 attr.dw_attr_val.val_class = dw_val_class_const_double;
7093 attr.dw_attr_val.v.val_double.high = high;
7094 attr.dw_attr_val.v.val_double.low = low;
7095 add_dwarf_attr (die, &attr);
7098 /* Add a floating point attribute value to a DIE and return it. */
7101 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
7102 unsigned int length, unsigned int elt_size, unsigned char *array)
7106 attr.dw_attr = attr_kind;
7107 attr.dw_attr_val.val_class = dw_val_class_vec;
7108 attr.dw_attr_val.v.val_vec.length = length;
7109 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
7110 attr.dw_attr_val.v.val_vec.array = array;
7111 add_dwarf_attr (die, &attr);
7114 /* Add an 8-byte data attribute value to a DIE. */
7117 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
7118 unsigned char data8[8])
7122 attr.dw_attr = attr_kind;
7123 attr.dw_attr_val.val_class = dw_val_class_data8;
7124 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
7125 add_dwarf_attr (die, &attr);
7128 /* Hash and equality functions for debug_str_hash. */
7131 debug_str_do_hash (const void *x)
7133 return htab_hash_string (((const struct indirect_string_node *)x)->str);
7137 debug_str_eq (const void *x1, const void *x2)
7139 return strcmp ((((const struct indirect_string_node *)x1)->str),
7140 (const char *)x2) == 0;
7143 /* Add STR to the indirect string hash table. */
7145 static struct indirect_string_node *
7146 find_AT_string (const char *str)
7148 struct indirect_string_node *node;
7151 if (! debug_str_hash)
7152 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
7153 debug_str_eq, NULL);
7155 slot = htab_find_slot_with_hash (debug_str_hash, str,
7156 htab_hash_string (str), INSERT);
7159 node = ggc_alloc_cleared_indirect_string_node ();
7160 node->str = ggc_strdup (str);
7164 node = (struct indirect_string_node *) *slot;
7170 /* Add a string attribute value to a DIE. */
7173 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
7176 struct indirect_string_node *node;
7178 node = find_AT_string (str);
7180 attr.dw_attr = attr_kind;
7181 attr.dw_attr_val.val_class = dw_val_class_str;
7182 attr.dw_attr_val.v.val_str = node;
7183 add_dwarf_attr (die, &attr);
7186 /* Create a label for an indirect string node, ensuring it is going to
7187 be output, unless its reference count goes down to zero. */
7190 gen_label_for_indirect_string (struct indirect_string_node *node)
7197 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
7198 ++dw2_string_counter;
7199 node->label = xstrdup (label);
7202 /* Create a SYMBOL_REF rtx whose value is the initial address of a
7203 debug string STR. */
7206 get_debug_string_label (const char *str)
7208 struct indirect_string_node *node = find_AT_string (str);
7210 debug_str_hash_forced = true;
7212 gen_label_for_indirect_string (node);
7214 return gen_rtx_SYMBOL_REF (Pmode, node->label);
7217 static inline const char *
7218 AT_string (dw_attr_ref a)
7220 gcc_assert (a && AT_class (a) == dw_val_class_str);
7221 return a->dw_attr_val.v.val_str->str;
7224 /* Find out whether a string should be output inline in DIE
7225 or out-of-line in .debug_str section. */
7227 static enum dwarf_form
7228 AT_string_form (dw_attr_ref a)
7230 struct indirect_string_node *node;
7233 gcc_assert (a && AT_class (a) == dw_val_class_str);
7235 node = a->dw_attr_val.v.val_str;
7239 len = strlen (node->str) + 1;
7241 /* If the string is shorter or equal to the size of the reference, it is
7242 always better to put it inline. */
7243 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
7244 return node->form = DW_FORM_string;
7246 /* If we cannot expect the linker to merge strings in .debug_str
7247 section, only put it into .debug_str if it is worth even in this
7249 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
7250 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
7251 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
7252 return node->form = DW_FORM_string;
7254 gen_label_for_indirect_string (node);
7256 return node->form = DW_FORM_strp;
7259 /* Add a DIE reference attribute value to a DIE. */
7262 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
7266 attr.dw_attr = attr_kind;
7267 attr.dw_attr_val.val_class = dw_val_class_die_ref;
7268 attr.dw_attr_val.v.val_die_ref.die = targ_die;
7269 attr.dw_attr_val.v.val_die_ref.external = 0;
7270 add_dwarf_attr (die, &attr);
7273 /* Add an AT_specification attribute to a DIE, and also make the back
7274 pointer from the specification to the definition. */
7277 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
7279 add_AT_die_ref (die, DW_AT_specification, targ_die);
7280 gcc_assert (!targ_die->die_definition);
7281 targ_die->die_definition = die;
7284 static inline dw_die_ref
7285 AT_ref (dw_attr_ref a)
7287 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7288 return a->dw_attr_val.v.val_die_ref.die;
7292 AT_ref_external (dw_attr_ref a)
7294 if (a && AT_class (a) == dw_val_class_die_ref)
7295 return a->dw_attr_val.v.val_die_ref.external;
7301 set_AT_ref_external (dw_attr_ref a, int i)
7303 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
7304 a->dw_attr_val.v.val_die_ref.external = i;
7307 /* Add an FDE reference attribute value to a DIE. */
7310 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
7314 attr.dw_attr = attr_kind;
7315 attr.dw_attr_val.val_class = dw_val_class_fde_ref;
7316 attr.dw_attr_val.v.val_fde_index = targ_fde;
7317 add_dwarf_attr (die, &attr);
7320 /* Add a location description attribute value to a DIE. */
7323 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
7327 attr.dw_attr = attr_kind;
7328 attr.dw_attr_val.val_class = dw_val_class_loc;
7329 attr.dw_attr_val.v.val_loc = loc;
7330 add_dwarf_attr (die, &attr);
7333 static inline dw_loc_descr_ref
7334 AT_loc (dw_attr_ref a)
7336 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7337 return a->dw_attr_val.v.val_loc;
7341 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
7345 attr.dw_attr = attr_kind;
7346 attr.dw_attr_val.val_class = dw_val_class_loc_list;
7347 attr.dw_attr_val.v.val_loc_list = loc_list;
7348 add_dwarf_attr (die, &attr);
7349 have_location_lists = true;
7352 static inline dw_loc_list_ref
7353 AT_loc_list (dw_attr_ref a)
7355 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7356 return a->dw_attr_val.v.val_loc_list;
7359 static inline dw_loc_list_ref *
7360 AT_loc_list_ptr (dw_attr_ref a)
7362 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
7363 return &a->dw_attr_val.v.val_loc_list;
7366 /* Add an address constant attribute value to a DIE. */
7369 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
7373 attr.dw_attr = attr_kind;
7374 attr.dw_attr_val.val_class = dw_val_class_addr;
7375 attr.dw_attr_val.v.val_addr = addr;
7376 add_dwarf_attr (die, &attr);
7379 /* Get the RTX from to an address DIE attribute. */
7382 AT_addr (dw_attr_ref a)
7384 gcc_assert (a && AT_class (a) == dw_val_class_addr);
7385 return a->dw_attr_val.v.val_addr;
7388 /* Add a file attribute value to a DIE. */
7391 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
7392 struct dwarf_file_data *fd)
7396 attr.dw_attr = attr_kind;
7397 attr.dw_attr_val.val_class = dw_val_class_file;
7398 attr.dw_attr_val.v.val_file = fd;
7399 add_dwarf_attr (die, &attr);
7402 /* Get the dwarf_file_data from a file DIE attribute. */
7404 static inline struct dwarf_file_data *
7405 AT_file (dw_attr_ref a)
7407 gcc_assert (a && AT_class (a) == dw_val_class_file);
7408 return a->dw_attr_val.v.val_file;
7411 /* Add a vms delta attribute value to a DIE. */
7414 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
7415 const char *lbl1, const char *lbl2)
7419 attr.dw_attr = attr_kind;
7420 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
7421 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
7422 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
7423 add_dwarf_attr (die, &attr);
7426 /* Add a label identifier attribute value to a DIE. */
7429 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
7433 attr.dw_attr = attr_kind;
7434 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
7435 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
7436 add_dwarf_attr (die, &attr);
7439 /* Add a section offset attribute value to a DIE, an offset into the
7440 debug_line section. */
7443 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7448 attr.dw_attr = attr_kind;
7449 attr.dw_attr_val.val_class = dw_val_class_lineptr;
7450 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7451 add_dwarf_attr (die, &attr);
7454 /* Add a section offset attribute value to a DIE, an offset into the
7455 debug_macinfo section. */
7458 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
7463 attr.dw_attr = attr_kind;
7464 attr.dw_attr_val.val_class = dw_val_class_macptr;
7465 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
7466 add_dwarf_attr (die, &attr);
7469 /* Add an offset attribute value to a DIE. */
7472 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
7473 unsigned HOST_WIDE_INT offset)
7477 attr.dw_attr = attr_kind;
7478 attr.dw_attr_val.val_class = dw_val_class_offset;
7479 attr.dw_attr_val.v.val_offset = offset;
7480 add_dwarf_attr (die, &attr);
7483 /* Add an range_list attribute value to a DIE. */
7486 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
7487 long unsigned int offset)
7491 attr.dw_attr = attr_kind;
7492 attr.dw_attr_val.val_class = dw_val_class_range_list;
7493 attr.dw_attr_val.v.val_offset = offset;
7494 add_dwarf_attr (die, &attr);
7497 /* Return the start label of a delta attribute. */
7499 static inline const char *
7500 AT_vms_delta1 (dw_attr_ref a)
7502 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
7503 return a->dw_attr_val.v.val_vms_delta.lbl1;
7506 /* Return the end label of a delta attribute. */
7508 static inline const char *
7509 AT_vms_delta2 (dw_attr_ref a)
7511 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
7512 return a->dw_attr_val.v.val_vms_delta.lbl2;
7515 static inline const char *
7516 AT_lbl (dw_attr_ref a)
7518 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
7519 || AT_class (a) == dw_val_class_lineptr
7520 || AT_class (a) == dw_val_class_macptr));
7521 return a->dw_attr_val.v.val_lbl_id;
7524 /* Get the attribute of type attr_kind. */
7527 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7531 dw_die_ref spec = NULL;
7536 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7537 if (a->dw_attr == attr_kind)
7539 else if (a->dw_attr == DW_AT_specification
7540 || a->dw_attr == DW_AT_abstract_origin)
7544 return get_AT (spec, attr_kind);
7549 /* Return the "low pc" attribute value, typically associated with a subprogram
7550 DIE. Return null if the "low pc" attribute is either not present, or if it
7551 cannot be represented as an assembler label identifier. */
7553 static inline const char *
7554 get_AT_low_pc (dw_die_ref die)
7556 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
7558 return a ? AT_lbl (a) : NULL;
7561 /* Return the "high pc" attribute value, typically associated with a subprogram
7562 DIE. Return null if the "high pc" attribute is either not present, or if it
7563 cannot be represented as an assembler label identifier. */
7565 static inline const char *
7566 get_AT_hi_pc (dw_die_ref die)
7568 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
7570 return a ? AT_lbl (a) : NULL;
7573 /* Return the value of the string attribute designated by ATTR_KIND, or
7574 NULL if it is not present. */
7576 static inline const char *
7577 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
7579 dw_attr_ref a = get_AT (die, attr_kind);
7581 return a ? AT_string (a) : NULL;
7584 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
7585 if it is not present. */
7588 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
7590 dw_attr_ref a = get_AT (die, attr_kind);
7592 return a ? AT_flag (a) : 0;
7595 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
7596 if it is not present. */
7598 static inline unsigned
7599 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
7601 dw_attr_ref a = get_AT (die, attr_kind);
7603 return a ? AT_unsigned (a) : 0;
7606 static inline dw_die_ref
7607 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
7609 dw_attr_ref a = get_AT (die, attr_kind);
7611 return a ? AT_ref (a) : NULL;
7614 static inline struct dwarf_file_data *
7615 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
7617 dw_attr_ref a = get_AT (die, attr_kind);
7619 return a ? AT_file (a) : NULL;
7622 /* Return TRUE if the language is C++. */
7627 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7629 return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
7632 /* Return TRUE if the language is Fortran. */
7637 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7639 return (lang == DW_LANG_Fortran77
7640 || lang == DW_LANG_Fortran90
7641 || lang == DW_LANG_Fortran95);
7644 /* Return TRUE if the language is Ada. */
7649 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
7651 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
7654 /* Remove the specified attribute if present. */
7657 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
7665 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
7666 if (a->dw_attr == attr_kind)
7668 if (AT_class (a) == dw_val_class_str)
7669 if (a->dw_attr_val.v.val_str->refcount)
7670 a->dw_attr_val.v.val_str->refcount--;
7672 /* VEC_ordered_remove should help reduce the number of abbrevs
7674 VEC_ordered_remove (dw_attr_node, die->die_attr, ix);
7679 /* Remove CHILD from its parent. PREV must have the property that
7680 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
7683 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
7685 gcc_assert (child->die_parent == prev->die_parent);
7686 gcc_assert (prev->die_sib == child);
7689 gcc_assert (child->die_parent->die_child == child);
7693 prev->die_sib = child->die_sib;
7694 if (child->die_parent->die_child == child)
7695 child->die_parent->die_child = prev;
7698 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
7699 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
7702 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
7704 dw_die_ref parent = old_child->die_parent;
7706 gcc_assert (parent == prev->die_parent);
7707 gcc_assert (prev->die_sib == old_child);
7709 new_child->die_parent = parent;
7710 if (prev == old_child)
7712 gcc_assert (parent->die_child == old_child);
7713 new_child->die_sib = new_child;
7717 prev->die_sib = new_child;
7718 new_child->die_sib = old_child->die_sib;
7720 if (old_child->die_parent->die_child == old_child)
7721 old_child->die_parent->die_child = new_child;
7724 /* Move all children from OLD_PARENT to NEW_PARENT. */
7727 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
7730 new_parent->die_child = old_parent->die_child;
7731 old_parent->die_child = NULL;
7732 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
7735 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
7739 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
7745 dw_die_ref prev = c;
7747 while (c->die_tag == tag)
7749 remove_child_with_prev (c, prev);
7750 /* Might have removed every child. */
7751 if (c == c->die_sib)
7755 } while (c != die->die_child);
7758 /* Add a CHILD_DIE as the last child of DIE. */
7761 add_child_die (dw_die_ref die, dw_die_ref child_die)
7763 /* FIXME this should probably be an assert. */
7764 if (! die || ! child_die)
7766 gcc_assert (die != child_die);
7768 child_die->die_parent = die;
7771 child_die->die_sib = die->die_child->die_sib;
7772 die->die_child->die_sib = child_die;
7775 child_die->die_sib = child_die;
7776 die->die_child = child_die;
7779 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
7780 is the specification, to the end of PARENT's list of children.
7781 This is done by removing and re-adding it. */
7784 splice_child_die (dw_die_ref parent, dw_die_ref child)
7788 /* We want the declaration DIE from inside the class, not the
7789 specification DIE at toplevel. */
7790 if (child->die_parent != parent)
7792 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
7798 gcc_assert (child->die_parent == parent
7799 || (child->die_parent
7800 == get_AT_ref (parent, DW_AT_specification)));
7802 for (p = child->die_parent->die_child; ; p = p->die_sib)
7803 if (p->die_sib == child)
7805 remove_child_with_prev (child, p);
7809 add_child_die (parent, child);
7812 /* Return a pointer to a newly created DIE node. */
7814 static inline dw_die_ref
7815 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
7817 dw_die_ref die = ggc_alloc_cleared_die_node ();
7819 die->die_tag = tag_value;
7821 if (parent_die != NULL)
7822 add_child_die (parent_die, die);
7825 limbo_die_node *limbo_node;
7827 limbo_node = ggc_alloc_cleared_limbo_die_node ();
7828 limbo_node->die = die;
7829 limbo_node->created_for = t;
7830 limbo_node->next = limbo_die_list;
7831 limbo_die_list = limbo_node;
7837 /* Return the DIE associated with the given type specifier. */
7839 static inline dw_die_ref
7840 lookup_type_die (tree type)
7842 return TYPE_SYMTAB_DIE (type);
7845 /* Equate a DIE to a given type specifier. */
7848 equate_type_number_to_die (tree type, dw_die_ref type_die)
7850 TYPE_SYMTAB_DIE (type) = type_die;
7853 /* Returns a hash value for X (which really is a die_struct). */
7856 decl_die_table_hash (const void *x)
7858 return (hashval_t) ((const_dw_die_ref) x)->decl_id;
7861 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
7864 decl_die_table_eq (const void *x, const void *y)
7866 return (((const_dw_die_ref) x)->decl_id == DECL_UID ((const_tree) y));
7869 /* Return the DIE associated with a given declaration. */
7871 static inline dw_die_ref
7872 lookup_decl_die (tree decl)
7874 return (dw_die_ref) htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
7877 /* Returns a hash value for X (which really is a var_loc_list). */
7880 decl_loc_table_hash (const void *x)
7882 return (hashval_t) ((const var_loc_list *) x)->decl_id;
7885 /* Return nonzero if decl_id of var_loc_list X is the same as
7889 decl_loc_table_eq (const void *x, const void *y)
7891 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const_tree) y));
7894 /* Return the var_loc list associated with a given declaration. */
7896 static inline var_loc_list *
7897 lookup_decl_loc (const_tree decl)
7899 if (!decl_loc_table)
7901 return (var_loc_list *)
7902 htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
7905 /* Equate a DIE to a particular declaration. */
7908 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
7910 unsigned int decl_id = DECL_UID (decl);
7913 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
7915 decl_die->decl_id = decl_id;
7918 /* Return how many bits covers PIECE EXPR_LIST. */
7921 decl_piece_bitsize (rtx piece)
7923 int ret = (int) GET_MODE (piece);
7926 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
7927 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
7928 return INTVAL (XEXP (XEXP (piece, 0), 0));
7931 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
7934 decl_piece_varloc_ptr (rtx piece)
7936 if ((int) GET_MODE (piece))
7937 return &XEXP (piece, 0);
7939 return &XEXP (XEXP (piece, 0), 1);
7942 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
7943 Next is the chain of following piece nodes. */
7946 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
7948 if (bitsize <= (int) MAX_MACHINE_MODE)
7949 return alloc_EXPR_LIST (bitsize, loc_note, next);
7951 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
7956 /* Return rtx that should be stored into loc field for
7957 LOC_NOTE and BITPOS/BITSIZE. */
7960 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
7961 HOST_WIDE_INT bitsize)
7965 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
7967 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
7972 /* This function either modifies location piece list *DEST in
7973 place (if SRC and INNER is NULL), or copies location piece list
7974 *SRC to *DEST while modifying it. Location BITPOS is modified
7975 to contain LOC_NOTE, any pieces overlapping it are removed resp.
7976 not copied and if needed some padding around it is added.
7977 When modifying in place, DEST should point to EXPR_LIST where
7978 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
7979 to the start of the whole list and INNER points to the EXPR_LIST
7980 where earlier pieces cover PIECE_BITPOS bits. */
7983 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
7984 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
7985 HOST_WIDE_INT bitsize, rtx loc_note)
7988 bool copy = inner != NULL;
7992 /* First copy all nodes preceeding the current bitpos. */
7993 while (src != inner)
7995 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
7996 decl_piece_bitsize (*src), NULL_RTX);
7997 dest = &XEXP (*dest, 1);
7998 src = &XEXP (*src, 1);
8001 /* Add padding if needed. */
8002 if (bitpos != piece_bitpos)
8004 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
8005 copy ? NULL_RTX : *dest);
8006 dest = &XEXP (*dest, 1);
8008 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
8011 /* A piece with correct bitpos and bitsize already exist,
8012 just update the location for it and return. */
8013 *decl_piece_varloc_ptr (*dest) = loc_note;
8016 /* Add the piece that changed. */
8017 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
8018 dest = &XEXP (*dest, 1);
8019 /* Skip over pieces that overlap it. */
8020 diff = bitpos - piece_bitpos + bitsize;
8023 while (diff > 0 && *src)
8026 diff -= decl_piece_bitsize (piece);
8028 src = &XEXP (piece, 1);
8031 *src = XEXP (piece, 1);
8032 free_EXPR_LIST_node (piece);
8035 /* Add padding if needed. */
8036 if (diff < 0 && *src)
8040 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
8041 dest = &XEXP (*dest, 1);
8045 /* Finally copy all nodes following it. */
8048 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
8049 decl_piece_bitsize (*src), NULL_RTX);
8050 dest = &XEXP (*dest, 1);
8051 src = &XEXP (*src, 1);
8055 /* Add a variable location node to the linked list for DECL. */
8057 static struct var_loc_node *
8058 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label)
8060 unsigned int decl_id;
8063 struct var_loc_node *loc = NULL;
8064 HOST_WIDE_INT bitsize = -1, bitpos = -1;
8066 if (DECL_DEBUG_EXPR_IS_FROM (decl))
8068 tree realdecl = DECL_DEBUG_EXPR (decl);
8069 if (realdecl && handled_component_p (realdecl))
8071 HOST_WIDE_INT maxsize;
8074 = get_ref_base_and_extent (realdecl, &bitpos, &bitsize, &maxsize);
8075 if (!DECL_P (innerdecl)
8076 || DECL_IGNORED_P (innerdecl)
8077 || TREE_STATIC (innerdecl)
8079 || bitpos + bitsize > 256
8080 || bitsize != maxsize)
8086 decl_id = DECL_UID (decl);
8087 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
8090 temp = ggc_alloc_cleared_var_loc_list ();
8091 temp->decl_id = decl_id;
8095 temp = (var_loc_list *) *slot;
8099 struct var_loc_node *last = temp->last, *unused = NULL;
8100 rtx *piece_loc = NULL, last_loc_note;
8101 int piece_bitpos = 0;
8105 gcc_assert (last->next == NULL);
8107 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
8109 piece_loc = &last->loc;
8112 int cur_bitsize = decl_piece_bitsize (*piece_loc);
8113 if (piece_bitpos + cur_bitsize > bitpos)
8115 piece_bitpos += cur_bitsize;
8116 piece_loc = &XEXP (*piece_loc, 1);
8120 /* TEMP->LAST here is either pointer to the last but one or
8121 last element in the chained list, LAST is pointer to the
8123 if (label && strcmp (last->label, label) == 0)
8125 /* For SRA optimized variables if there weren't any real
8126 insns since last note, just modify the last node. */
8127 if (piece_loc != NULL)
8129 adjust_piece_list (piece_loc, NULL, NULL,
8130 bitpos, piece_bitpos, bitsize, loc_note);
8133 /* If the last note doesn't cover any instructions, remove it. */
8134 if (temp->last != last)
8136 temp->last->next = NULL;
8139 gcc_assert (strcmp (last->label, label) != 0);
8143 gcc_assert (temp->first == temp->last);
8144 memset (temp->last, '\0', sizeof (*temp->last));
8145 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
8149 if (bitsize == -1 && NOTE_P (last->loc))
8150 last_loc_note = last->loc;
8151 else if (piece_loc != NULL
8152 && *piece_loc != NULL_RTX
8153 && piece_bitpos == bitpos
8154 && decl_piece_bitsize (*piece_loc) == bitsize)
8155 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
8157 last_loc_note = NULL_RTX;
8158 /* If the current location is the same as the end of the list,
8159 and either both or neither of the locations is uninitialized,
8160 we have nothing to do. */
8161 if (last_loc_note == NULL_RTX
8162 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
8163 NOTE_VAR_LOCATION_LOC (loc_note)))
8164 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
8165 != NOTE_VAR_LOCATION_STATUS (loc_note))
8166 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
8167 == VAR_INIT_STATUS_UNINITIALIZED)
8168 || (NOTE_VAR_LOCATION_STATUS (loc_note)
8169 == VAR_INIT_STATUS_UNINITIALIZED))))
8171 /* Add LOC to the end of list and update LAST. If the last
8172 element of the list has been removed above, reuse its
8173 memory for the new node, otherwise allocate a new one. */
8177 memset (loc, '\0', sizeof (*loc));
8180 loc = ggc_alloc_cleared_var_loc_node ();
8181 if (bitsize == -1 || piece_loc == NULL)
8182 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
8184 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
8185 bitpos, piece_bitpos, bitsize, loc_note);
8187 /* Ensure TEMP->LAST will point either to the new last but one
8188 element of the chain, or to the last element in it. */
8189 if (last != temp->last)
8197 loc = ggc_alloc_cleared_var_loc_node ();
8200 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
8205 /* Keep track of the number of spaces used to indent the
8206 output of the debugging routines that print the structure of
8207 the DIE internal representation. */
8208 static int print_indent;
8210 /* Indent the line the number of spaces given by print_indent. */
8213 print_spaces (FILE *outfile)
8215 fprintf (outfile, "%*s", print_indent, "");
8218 /* Print a type signature in hex. */
8221 print_signature (FILE *outfile, char *sig)
8225 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
8226 fprintf (outfile, "%02x", sig[i] & 0xff);
8229 /* Print the information associated with a given DIE, and its children.
8230 This routine is a debugging aid only. */
8233 print_die (dw_die_ref die, FILE *outfile)
8239 print_spaces (outfile);
8240 fprintf (outfile, "DIE %4ld: %s\n",
8241 die->die_offset, dwarf_tag_name (die->die_tag));
8242 print_spaces (outfile);
8243 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
8244 fprintf (outfile, " offset: %ld\n", die->die_offset);
8245 if (dwarf_version >= 4 && die->die_id.die_type_node)
8247 print_spaces (outfile);
8248 fprintf (outfile, " signature: ");
8249 print_signature (outfile, die->die_id.die_type_node->signature);
8250 fprintf (outfile, "\n");
8253 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8255 print_spaces (outfile);
8256 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
8258 switch (AT_class (a))
8260 case dw_val_class_addr:
8261 fprintf (outfile, "address");
8263 case dw_val_class_offset:
8264 fprintf (outfile, "offset");
8266 case dw_val_class_loc:
8267 fprintf (outfile, "location descriptor");
8269 case dw_val_class_loc_list:
8270 fprintf (outfile, "location list -> label:%s",
8271 AT_loc_list (a)->ll_symbol);
8273 case dw_val_class_range_list:
8274 fprintf (outfile, "range list");
8276 case dw_val_class_const:
8277 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
8279 case dw_val_class_unsigned_const:
8280 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
8282 case dw_val_class_const_double:
8283 fprintf (outfile, "constant ("HOST_WIDE_INT_PRINT_DEC","\
8284 HOST_WIDE_INT_PRINT_UNSIGNED")",
8285 a->dw_attr_val.v.val_double.high,
8286 a->dw_attr_val.v.val_double.low);
8288 case dw_val_class_vec:
8289 fprintf (outfile, "floating-point or vector constant");
8291 case dw_val_class_flag:
8292 fprintf (outfile, "%u", AT_flag (a));
8294 case dw_val_class_die_ref:
8295 if (AT_ref (a) != NULL)
8297 if (dwarf_version >= 4 && AT_ref (a)->die_id.die_type_node)
8299 fprintf (outfile, "die -> signature: ");
8300 print_signature (outfile,
8301 AT_ref (a)->die_id.die_type_node->signature);
8303 else if (dwarf_version < 4 && AT_ref (a)->die_id.die_symbol)
8304 fprintf (outfile, "die -> label: %s",
8305 AT_ref (a)->die_id.die_symbol);
8307 fprintf (outfile, "die -> %ld", AT_ref (a)->die_offset);
8310 fprintf (outfile, "die -> <null>");
8312 case dw_val_class_vms_delta:
8313 fprintf (outfile, "delta: @slotcount(%s-%s)",
8314 AT_vms_delta2 (a), AT_vms_delta1 (a));
8316 case dw_val_class_lbl_id:
8317 case dw_val_class_lineptr:
8318 case dw_val_class_macptr:
8319 fprintf (outfile, "label: %s", AT_lbl (a));
8321 case dw_val_class_str:
8322 if (AT_string (a) != NULL)
8323 fprintf (outfile, "\"%s\"", AT_string (a));
8325 fprintf (outfile, "<null>");
8327 case dw_val_class_file:
8328 fprintf (outfile, "\"%s\" (%d)", AT_file (a)->filename,
8329 AT_file (a)->emitted_number);
8331 case dw_val_class_data8:
8335 for (i = 0; i < 8; i++)
8336 fprintf (outfile, "%02x", a->dw_attr_val.v.val_data8[i]);
8343 fprintf (outfile, "\n");
8346 if (die->die_child != NULL)
8349 FOR_EACH_CHILD (die, c, print_die (c, outfile));
8352 if (print_indent == 0)
8353 fprintf (outfile, "\n");
8356 /* Print the contents of the source code line number correspondence table.
8357 This routine is a debugging aid only. */
8360 print_dwarf_line_table (FILE *outfile)
8363 dw_line_info_ref line_info;
8365 fprintf (outfile, "\n\nDWARF source line information\n");
8366 for (i = 1; i < line_info_table_in_use; i++)
8368 line_info = &line_info_table[i];
8369 fprintf (outfile, "%5d: %4ld %6ld\n", i,
8370 line_info->dw_file_num,
8371 line_info->dw_line_num);
8374 fprintf (outfile, "\n\n");
8377 /* Print the information collected for a given DIE. */
8380 debug_dwarf_die (dw_die_ref die)
8382 print_die (die, stderr);
8385 /* Print all DWARF information collected for the compilation unit.
8386 This routine is a debugging aid only. */
8392 print_die (comp_unit_die, stderr);
8393 if (! DWARF2_ASM_LINE_DEBUG_INFO)
8394 print_dwarf_line_table (stderr);
8397 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
8398 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
8399 DIE that marks the start of the DIEs for this include file. */
8402 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
8404 const char *filename = get_AT_string (bincl_die, DW_AT_name);
8405 dw_die_ref new_unit = gen_compile_unit_die (filename);
8407 new_unit->die_sib = old_unit;
8411 /* Close an include-file CU and reopen the enclosing one. */
8414 pop_compile_unit (dw_die_ref old_unit)
8416 dw_die_ref new_unit = old_unit->die_sib;
8418 old_unit->die_sib = NULL;
8422 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8423 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
8425 /* Calculate the checksum of a location expression. */
8428 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
8432 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
8434 CHECKSUM (loc->dw_loc_oprnd1);
8435 CHECKSUM (loc->dw_loc_oprnd2);
8438 /* Calculate the checksum of an attribute. */
8441 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
8443 dw_loc_descr_ref loc;
8446 CHECKSUM (at->dw_attr);
8448 /* We don't care that this was compiled with a different compiler
8449 snapshot; if the output is the same, that's what matters. */
8450 if (at->dw_attr == DW_AT_producer)
8453 switch (AT_class (at))
8455 case dw_val_class_const:
8456 CHECKSUM (at->dw_attr_val.v.val_int);
8458 case dw_val_class_unsigned_const:
8459 CHECKSUM (at->dw_attr_val.v.val_unsigned);
8461 case dw_val_class_const_double:
8462 CHECKSUM (at->dw_attr_val.v.val_double);
8464 case dw_val_class_vec:
8465 CHECKSUM (at->dw_attr_val.v.val_vec);
8467 case dw_val_class_flag:
8468 CHECKSUM (at->dw_attr_val.v.val_flag);
8470 case dw_val_class_str:
8471 CHECKSUM_STRING (AT_string (at));
8474 case dw_val_class_addr:
8476 gcc_assert (GET_CODE (r) == SYMBOL_REF);
8477 CHECKSUM_STRING (XSTR (r, 0));
8480 case dw_val_class_offset:
8481 CHECKSUM (at->dw_attr_val.v.val_offset);
8484 case dw_val_class_loc:
8485 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
8486 loc_checksum (loc, ctx);
8489 case dw_val_class_die_ref:
8490 die_checksum (AT_ref (at), ctx, mark);
8493 case dw_val_class_fde_ref:
8494 case dw_val_class_vms_delta:
8495 case dw_val_class_lbl_id:
8496 case dw_val_class_lineptr:
8497 case dw_val_class_macptr:
8500 case dw_val_class_file:
8501 CHECKSUM_STRING (AT_file (at)->filename);
8504 case dw_val_class_data8:
8505 CHECKSUM (at->dw_attr_val.v.val_data8);
8513 /* Calculate the checksum of a DIE. */
8516 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
8522 /* To avoid infinite recursion. */
8525 CHECKSUM (die->die_mark);
8528 die->die_mark = ++(*mark);
8530 CHECKSUM (die->die_tag);
8532 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8533 attr_checksum (a, ctx, mark);
8535 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
8539 #undef CHECKSUM_STRING
8541 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
8542 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8543 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
8544 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
8545 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
8546 #define CHECKSUM_ATTR(FOO) \
8547 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
8549 /* Calculate the checksum of a number in signed LEB128 format. */
8552 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
8559 byte = (value & 0x7f);
8561 more = !((value == 0 && (byte & 0x40) == 0)
8562 || (value == -1 && (byte & 0x40) != 0));
8571 /* Calculate the checksum of a number in unsigned LEB128 format. */
8574 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
8578 unsigned char byte = (value & 0x7f);
8581 /* More bytes to follow. */
8589 /* Checksum the context of the DIE. This adds the names of any
8590 surrounding namespaces or structures to the checksum. */
8593 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
8597 int tag = die->die_tag;
8599 if (tag != DW_TAG_namespace
8600 && tag != DW_TAG_structure_type
8601 && tag != DW_TAG_class_type)
8604 name = get_AT_string (die, DW_AT_name);
8606 spec = get_AT_ref (die, DW_AT_specification);
8610 if (die->die_parent != NULL)
8611 checksum_die_context (die->die_parent, ctx);
8613 CHECKSUM_ULEB128 ('C');
8614 CHECKSUM_ULEB128 (tag);
8616 CHECKSUM_STRING (name);
8619 /* Calculate the checksum of a location expression. */
8622 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
8624 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
8625 were emitted as a DW_FORM_sdata instead of a location expression. */
8626 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
8628 CHECKSUM_ULEB128 (DW_FORM_sdata);
8629 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
8633 /* Otherwise, just checksum the raw location expression. */
8636 CHECKSUM_ULEB128 (loc->dw_loc_opc);
8637 CHECKSUM (loc->dw_loc_oprnd1);
8638 CHECKSUM (loc->dw_loc_oprnd2);
8639 loc = loc->dw_loc_next;
8643 /* Calculate the checksum of an attribute. */
8646 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_ref at,
8647 struct md5_ctx *ctx, int *mark)
8649 dw_loc_descr_ref loc;
8652 if (AT_class (at) == dw_val_class_die_ref)
8654 dw_die_ref target_die = AT_ref (at);
8656 /* For pointer and reference types, we checksum only the (qualified)
8657 name of the target type (if there is a name). For friend entries,
8658 we checksum only the (qualified) name of the target type or function.
8659 This allows the checksum to remain the same whether the target type
8660 is complete or not. */
8661 if ((at->dw_attr == DW_AT_type
8662 && (tag == DW_TAG_pointer_type
8663 || tag == DW_TAG_reference_type
8664 || tag == DW_TAG_rvalue_reference_type
8665 || tag == DW_TAG_ptr_to_member_type))
8666 || (at->dw_attr == DW_AT_friend
8667 && tag == DW_TAG_friend))
8669 dw_attr_ref name_attr = get_AT (target_die, DW_AT_name);
8671 if (name_attr != NULL)
8673 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
8677 CHECKSUM_ULEB128 ('N');
8678 CHECKSUM_ULEB128 (at->dw_attr);
8679 if (decl->die_parent != NULL)
8680 checksum_die_context (decl->die_parent, ctx);
8681 CHECKSUM_ULEB128 ('E');
8682 CHECKSUM_STRING (AT_string (name_attr));
8687 /* For all other references to another DIE, we check to see if the
8688 target DIE has already been visited. If it has, we emit a
8689 backward reference; if not, we descend recursively. */
8690 if (target_die->die_mark > 0)
8692 CHECKSUM_ULEB128 ('R');
8693 CHECKSUM_ULEB128 (at->dw_attr);
8694 CHECKSUM_ULEB128 (target_die->die_mark);
8698 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
8702 target_die->die_mark = ++(*mark);
8703 CHECKSUM_ULEB128 ('T');
8704 CHECKSUM_ULEB128 (at->dw_attr);
8705 if (decl->die_parent != NULL)
8706 checksum_die_context (decl->die_parent, ctx);
8707 die_checksum_ordered (target_die, ctx, mark);
8712 CHECKSUM_ULEB128 ('A');
8713 CHECKSUM_ULEB128 (at->dw_attr);
8715 switch (AT_class (at))
8717 case dw_val_class_const:
8718 CHECKSUM_ULEB128 (DW_FORM_sdata);
8719 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
8722 case dw_val_class_unsigned_const:
8723 CHECKSUM_ULEB128 (DW_FORM_sdata);
8724 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
8727 case dw_val_class_const_double:
8728 CHECKSUM_ULEB128 (DW_FORM_block);
8729 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
8730 CHECKSUM (at->dw_attr_val.v.val_double);
8733 case dw_val_class_vec:
8734 CHECKSUM_ULEB128 (DW_FORM_block);
8735 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_vec));
8736 CHECKSUM (at->dw_attr_val.v.val_vec);
8739 case dw_val_class_flag:
8740 CHECKSUM_ULEB128 (DW_FORM_flag);
8741 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
8744 case dw_val_class_str:
8745 CHECKSUM_ULEB128 (DW_FORM_string);
8746 CHECKSUM_STRING (AT_string (at));
8749 case dw_val_class_addr:
8751 gcc_assert (GET_CODE (r) == SYMBOL_REF);
8752 CHECKSUM_ULEB128 (DW_FORM_string);
8753 CHECKSUM_STRING (XSTR (r, 0));
8756 case dw_val_class_offset:
8757 CHECKSUM_ULEB128 (DW_FORM_sdata);
8758 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
8761 case dw_val_class_loc:
8762 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
8763 loc_checksum_ordered (loc, ctx);
8766 case dw_val_class_fde_ref:
8767 case dw_val_class_lbl_id:
8768 case dw_val_class_lineptr:
8769 case dw_val_class_macptr:
8772 case dw_val_class_file:
8773 CHECKSUM_ULEB128 (DW_FORM_string);
8774 CHECKSUM_STRING (AT_file (at)->filename);
8777 case dw_val_class_data8:
8778 CHECKSUM (at->dw_attr_val.v.val_data8);
8786 struct checksum_attributes
8788 dw_attr_ref at_name;
8789 dw_attr_ref at_type;
8790 dw_attr_ref at_friend;
8791 dw_attr_ref at_accessibility;
8792 dw_attr_ref at_address_class;
8793 dw_attr_ref at_allocated;
8794 dw_attr_ref at_artificial;
8795 dw_attr_ref at_associated;
8796 dw_attr_ref at_binary_scale;
8797 dw_attr_ref at_bit_offset;
8798 dw_attr_ref at_bit_size;
8799 dw_attr_ref at_bit_stride;
8800 dw_attr_ref at_byte_size;
8801 dw_attr_ref at_byte_stride;
8802 dw_attr_ref at_const_value;
8803 dw_attr_ref at_containing_type;
8804 dw_attr_ref at_count;
8805 dw_attr_ref at_data_location;
8806 dw_attr_ref at_data_member_location;
8807 dw_attr_ref at_decimal_scale;
8808 dw_attr_ref at_decimal_sign;
8809 dw_attr_ref at_default_value;
8810 dw_attr_ref at_digit_count;
8811 dw_attr_ref at_discr;
8812 dw_attr_ref at_discr_list;
8813 dw_attr_ref at_discr_value;
8814 dw_attr_ref at_encoding;
8815 dw_attr_ref at_endianity;
8816 dw_attr_ref at_explicit;
8817 dw_attr_ref at_is_optional;
8818 dw_attr_ref at_location;
8819 dw_attr_ref at_lower_bound;
8820 dw_attr_ref at_mutable;
8821 dw_attr_ref at_ordering;
8822 dw_attr_ref at_picture_string;
8823 dw_attr_ref at_prototyped;
8824 dw_attr_ref at_small;
8825 dw_attr_ref at_segment;
8826 dw_attr_ref at_string_length;
8827 dw_attr_ref at_threads_scaled;
8828 dw_attr_ref at_upper_bound;
8829 dw_attr_ref at_use_location;
8830 dw_attr_ref at_use_UTF8;
8831 dw_attr_ref at_variable_parameter;
8832 dw_attr_ref at_virtuality;
8833 dw_attr_ref at_visibility;
8834 dw_attr_ref at_vtable_elem_location;
8837 /* Collect the attributes that we will want to use for the checksum. */
8840 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
8845 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
8856 attrs->at_friend = a;
8858 case DW_AT_accessibility:
8859 attrs->at_accessibility = a;
8861 case DW_AT_address_class:
8862 attrs->at_address_class = a;
8864 case DW_AT_allocated:
8865 attrs->at_allocated = a;
8867 case DW_AT_artificial:
8868 attrs->at_artificial = a;
8870 case DW_AT_associated:
8871 attrs->at_associated = a;
8873 case DW_AT_binary_scale:
8874 attrs->at_binary_scale = a;
8876 case DW_AT_bit_offset:
8877 attrs->at_bit_offset = a;
8879 case DW_AT_bit_size:
8880 attrs->at_bit_size = a;
8882 case DW_AT_bit_stride:
8883 attrs->at_bit_stride = a;
8885 case DW_AT_byte_size:
8886 attrs->at_byte_size = a;
8888 case DW_AT_byte_stride:
8889 attrs->at_byte_stride = a;
8891 case DW_AT_const_value:
8892 attrs->at_const_value = a;
8894 case DW_AT_containing_type:
8895 attrs->at_containing_type = a;
8898 attrs->at_count = a;
8900 case DW_AT_data_location:
8901 attrs->at_data_location = a;
8903 case DW_AT_data_member_location:
8904 attrs->at_data_member_location = a;
8906 case DW_AT_decimal_scale:
8907 attrs->at_decimal_scale = a;
8909 case DW_AT_decimal_sign:
8910 attrs->at_decimal_sign = a;
8912 case DW_AT_default_value:
8913 attrs->at_default_value = a;
8915 case DW_AT_digit_count:
8916 attrs->at_digit_count = a;
8919 attrs->at_discr = a;
8921 case DW_AT_discr_list:
8922 attrs->at_discr_list = a;
8924 case DW_AT_discr_value:
8925 attrs->at_discr_value = a;
8927 case DW_AT_encoding:
8928 attrs->at_encoding = a;
8930 case DW_AT_endianity:
8931 attrs->at_endianity = a;
8933 case DW_AT_explicit:
8934 attrs->at_explicit = a;
8936 case DW_AT_is_optional:
8937 attrs->at_is_optional = a;
8939 case DW_AT_location:
8940 attrs->at_location = a;
8942 case DW_AT_lower_bound:
8943 attrs->at_lower_bound = a;
8946 attrs->at_mutable = a;
8948 case DW_AT_ordering:
8949 attrs->at_ordering = a;
8951 case DW_AT_picture_string:
8952 attrs->at_picture_string = a;
8954 case DW_AT_prototyped:
8955 attrs->at_prototyped = a;
8958 attrs->at_small = a;
8961 attrs->at_segment = a;
8963 case DW_AT_string_length:
8964 attrs->at_string_length = a;
8966 case DW_AT_threads_scaled:
8967 attrs->at_threads_scaled = a;
8969 case DW_AT_upper_bound:
8970 attrs->at_upper_bound = a;
8972 case DW_AT_use_location:
8973 attrs->at_use_location = a;
8975 case DW_AT_use_UTF8:
8976 attrs->at_use_UTF8 = a;
8978 case DW_AT_variable_parameter:
8979 attrs->at_variable_parameter = a;
8981 case DW_AT_virtuality:
8982 attrs->at_virtuality = a;
8984 case DW_AT_visibility:
8985 attrs->at_visibility = a;
8987 case DW_AT_vtable_elem_location:
8988 attrs->at_vtable_elem_location = a;
8996 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
8999 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
9003 struct checksum_attributes attrs;
9005 CHECKSUM_ULEB128 ('D');
9006 CHECKSUM_ULEB128 (die->die_tag);
9008 memset (&attrs, 0, sizeof (attrs));
9010 decl = get_AT_ref (die, DW_AT_specification);
9012 collect_checksum_attributes (&attrs, decl);
9013 collect_checksum_attributes (&attrs, die);
9015 CHECKSUM_ATTR (attrs.at_name);
9016 CHECKSUM_ATTR (attrs.at_accessibility);
9017 CHECKSUM_ATTR (attrs.at_address_class);
9018 CHECKSUM_ATTR (attrs.at_allocated);
9019 CHECKSUM_ATTR (attrs.at_artificial);
9020 CHECKSUM_ATTR (attrs.at_associated);
9021 CHECKSUM_ATTR (attrs.at_binary_scale);
9022 CHECKSUM_ATTR (attrs.at_bit_offset);
9023 CHECKSUM_ATTR (attrs.at_bit_size);
9024 CHECKSUM_ATTR (attrs.at_bit_stride);
9025 CHECKSUM_ATTR (attrs.at_byte_size);
9026 CHECKSUM_ATTR (attrs.at_byte_stride);
9027 CHECKSUM_ATTR (attrs.at_const_value);
9028 CHECKSUM_ATTR (attrs.at_containing_type);
9029 CHECKSUM_ATTR (attrs.at_count);
9030 CHECKSUM_ATTR (attrs.at_data_location);
9031 CHECKSUM_ATTR (attrs.at_data_member_location);
9032 CHECKSUM_ATTR (attrs.at_decimal_scale);
9033 CHECKSUM_ATTR (attrs.at_decimal_sign);
9034 CHECKSUM_ATTR (attrs.at_default_value);
9035 CHECKSUM_ATTR (attrs.at_digit_count);
9036 CHECKSUM_ATTR (attrs.at_discr);
9037 CHECKSUM_ATTR (attrs.at_discr_list);
9038 CHECKSUM_ATTR (attrs.at_discr_value);
9039 CHECKSUM_ATTR (attrs.at_encoding);
9040 CHECKSUM_ATTR (attrs.at_endianity);
9041 CHECKSUM_ATTR (attrs.at_explicit);
9042 CHECKSUM_ATTR (attrs.at_is_optional);
9043 CHECKSUM_ATTR (attrs.at_location);
9044 CHECKSUM_ATTR (attrs.at_lower_bound);
9045 CHECKSUM_ATTR (attrs.at_mutable);
9046 CHECKSUM_ATTR (attrs.at_ordering);
9047 CHECKSUM_ATTR (attrs.at_picture_string);
9048 CHECKSUM_ATTR (attrs.at_prototyped);
9049 CHECKSUM_ATTR (attrs.at_small);
9050 CHECKSUM_ATTR (attrs.at_segment);
9051 CHECKSUM_ATTR (attrs.at_string_length);
9052 CHECKSUM_ATTR (attrs.at_threads_scaled);
9053 CHECKSUM_ATTR (attrs.at_upper_bound);
9054 CHECKSUM_ATTR (attrs.at_use_location);
9055 CHECKSUM_ATTR (attrs.at_use_UTF8);
9056 CHECKSUM_ATTR (attrs.at_variable_parameter);
9057 CHECKSUM_ATTR (attrs.at_virtuality);
9058 CHECKSUM_ATTR (attrs.at_visibility);
9059 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
9060 CHECKSUM_ATTR (attrs.at_type);
9061 CHECKSUM_ATTR (attrs.at_friend);
9063 /* Checksum the child DIEs, except for nested types and member functions. */
9066 dw_attr_ref name_attr;
9069 name_attr = get_AT (c, DW_AT_name);
9070 if ((is_type_die (c) || c->die_tag == DW_TAG_subprogram)
9071 && name_attr != NULL)
9073 CHECKSUM_ULEB128 ('S');
9074 CHECKSUM_ULEB128 (c->die_tag);
9075 CHECKSUM_STRING (AT_string (name_attr));
9079 /* Mark this DIE so it gets processed when unmarking. */
9080 if (c->die_mark == 0)
9082 die_checksum_ordered (c, ctx, mark);
9084 } while (c != die->die_child);
9086 CHECKSUM_ULEB128 (0);
9090 #undef CHECKSUM_STRING
9091 #undef CHECKSUM_ATTR
9092 #undef CHECKSUM_LEB128
9093 #undef CHECKSUM_ULEB128
9095 /* Generate the type signature for DIE. This is computed by generating an
9096 MD5 checksum over the DIE's tag, its relevant attributes, and its
9097 children. Attributes that are references to other DIEs are processed
9098 by recursion, using the MARK field to prevent infinite recursion.
9099 If the DIE is nested inside a namespace or another type, we also
9100 need to include that context in the signature. The lower 64 bits
9101 of the resulting MD5 checksum comprise the signature. */
9104 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
9108 unsigned char checksum[16];
9112 name = get_AT_string (die, DW_AT_name);
9113 decl = get_AT_ref (die, DW_AT_specification);
9115 /* First, compute a signature for just the type name (and its surrounding
9116 context, if any. This is stored in the type unit DIE for link-time
9117 ODR (one-definition rule) checking. */
9119 if (is_cxx() && name != NULL)
9121 md5_init_ctx (&ctx);
9123 /* Checksum the names of surrounding namespaces and structures. */
9124 if (decl != NULL && decl->die_parent != NULL)
9125 checksum_die_context (decl->die_parent, &ctx);
9127 md5_process_bytes (&die->die_tag, sizeof (die->die_tag), &ctx);
9128 md5_process_bytes (name, strlen (name) + 1, &ctx);
9129 md5_finish_ctx (&ctx, checksum);
9131 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
9134 /* Next, compute the complete type signature. */
9136 md5_init_ctx (&ctx);
9138 die->die_mark = mark;
9140 /* Checksum the names of surrounding namespaces and structures. */
9141 if (decl != NULL && decl->die_parent != NULL)
9142 checksum_die_context (decl->die_parent, &ctx);
9144 /* Checksum the DIE and its children. */
9145 die_checksum_ordered (die, &ctx, &mark);
9146 unmark_all_dies (die);
9147 md5_finish_ctx (&ctx, checksum);
9149 /* Store the signature in the type node and link the type DIE and the
9150 type node together. */
9151 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
9152 DWARF_TYPE_SIGNATURE_SIZE);
9153 die->die_id.die_type_node = type_node;
9154 type_node->type_die = die;
9156 /* If the DIE is a specification, link its declaration to the type node
9159 decl->die_id.die_type_node = type_node;
9162 /* Do the location expressions look same? */
9164 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
9166 return loc1->dw_loc_opc == loc2->dw_loc_opc
9167 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
9168 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
9171 /* Do the values look the same? */
9173 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
9175 dw_loc_descr_ref loc1, loc2;
9178 if (v1->val_class != v2->val_class)
9181 switch (v1->val_class)
9183 case dw_val_class_const:
9184 return v1->v.val_int == v2->v.val_int;
9185 case dw_val_class_unsigned_const:
9186 return v1->v.val_unsigned == v2->v.val_unsigned;
9187 case dw_val_class_const_double:
9188 return v1->v.val_double.high == v2->v.val_double.high
9189 && v1->v.val_double.low == v2->v.val_double.low;
9190 case dw_val_class_vec:
9191 if (v1->v.val_vec.length != v2->v.val_vec.length
9192 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
9194 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
9195 v1->v.val_vec.length * v1->v.val_vec.elt_size))
9198 case dw_val_class_flag:
9199 return v1->v.val_flag == v2->v.val_flag;
9200 case dw_val_class_str:
9201 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
9203 case dw_val_class_addr:
9204 r1 = v1->v.val_addr;
9205 r2 = v2->v.val_addr;
9206 if (GET_CODE (r1) != GET_CODE (r2))
9208 return !rtx_equal_p (r1, r2);
9210 case dw_val_class_offset:
9211 return v1->v.val_offset == v2->v.val_offset;
9213 case dw_val_class_loc:
9214 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
9216 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
9217 if (!same_loc_p (loc1, loc2, mark))
9219 return !loc1 && !loc2;
9221 case dw_val_class_die_ref:
9222 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
9224 case dw_val_class_fde_ref:
9225 case dw_val_class_vms_delta:
9226 case dw_val_class_lbl_id:
9227 case dw_val_class_lineptr:
9228 case dw_val_class_macptr:
9231 case dw_val_class_file:
9232 return v1->v.val_file == v2->v.val_file;
9234 case dw_val_class_data8:
9235 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
9242 /* Do the attributes look the same? */
9245 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
9247 if (at1->dw_attr != at2->dw_attr)
9250 /* We don't care that this was compiled with a different compiler
9251 snapshot; if the output is the same, that's what matters. */
9252 if (at1->dw_attr == DW_AT_producer)
9255 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
9258 /* Do the dies look the same? */
9261 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
9267 /* To avoid infinite recursion. */
9269 return die1->die_mark == die2->die_mark;
9270 die1->die_mark = die2->die_mark = ++(*mark);
9272 if (die1->die_tag != die2->die_tag)
9275 if (VEC_length (dw_attr_node, die1->die_attr)
9276 != VEC_length (dw_attr_node, die2->die_attr))
9279 for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
9280 if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
9283 c1 = die1->die_child;
9284 c2 = die2->die_child;
9293 if (!same_die_p (c1, c2, mark))
9297 if (c1 == die1->die_child)
9299 if (c2 == die2->die_child)
9309 /* Do the dies look the same? Wrapper around same_die_p. */
9312 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
9315 int ret = same_die_p (die1, die2, &mark);
9317 unmark_all_dies (die1);
9318 unmark_all_dies (die2);
9323 /* The prefix to attach to symbols on DIEs in the current comdat debug
9325 static char *comdat_symbol_id;
9327 /* The index of the current symbol within the current comdat CU. */
9328 static unsigned int comdat_symbol_number;
9330 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
9331 children, and set comdat_symbol_id accordingly. */
9334 compute_section_prefix (dw_die_ref unit_die)
9336 const char *die_name = get_AT_string (unit_die, DW_AT_name);
9337 const char *base = die_name ? lbasename (die_name) : "anonymous";
9338 char *name = XALLOCAVEC (char, strlen (base) + 64);
9341 unsigned char checksum[16];
9344 /* Compute the checksum of the DIE, then append part of it as hex digits to
9345 the name filename of the unit. */
9347 md5_init_ctx (&ctx);
9349 die_checksum (unit_die, &ctx, &mark);
9350 unmark_all_dies (unit_die);
9351 md5_finish_ctx (&ctx, checksum);
9353 sprintf (name, "%s.", base);
9354 clean_symbol_name (name);
9356 p = name + strlen (name);
9357 for (i = 0; i < 4; i++)
9359 sprintf (p, "%.2x", checksum[i]);
9363 comdat_symbol_id = unit_die->die_id.die_symbol = xstrdup (name);
9364 comdat_symbol_number = 0;
9367 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
9370 is_type_die (dw_die_ref die)
9372 switch (die->die_tag)
9374 case DW_TAG_array_type:
9375 case DW_TAG_class_type:
9376 case DW_TAG_interface_type:
9377 case DW_TAG_enumeration_type:
9378 case DW_TAG_pointer_type:
9379 case DW_TAG_reference_type:
9380 case DW_TAG_rvalue_reference_type:
9381 case DW_TAG_string_type:
9382 case DW_TAG_structure_type:
9383 case DW_TAG_subroutine_type:
9384 case DW_TAG_union_type:
9385 case DW_TAG_ptr_to_member_type:
9386 case DW_TAG_set_type:
9387 case DW_TAG_subrange_type:
9388 case DW_TAG_base_type:
9389 case DW_TAG_const_type:
9390 case DW_TAG_file_type:
9391 case DW_TAG_packed_type:
9392 case DW_TAG_volatile_type:
9393 case DW_TAG_typedef:
9400 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
9401 Basically, we want to choose the bits that are likely to be shared between
9402 compilations (types) and leave out the bits that are specific to individual
9403 compilations (functions). */
9406 is_comdat_die (dw_die_ref c)
9408 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
9409 we do for stabs. The advantage is a greater likelihood of sharing between
9410 objects that don't include headers in the same order (and therefore would
9411 put the base types in a different comdat). jason 8/28/00 */
9413 if (c->die_tag == DW_TAG_base_type)
9416 if (c->die_tag == DW_TAG_pointer_type
9417 || c->die_tag == DW_TAG_reference_type
9418 || c->die_tag == DW_TAG_rvalue_reference_type
9419 || c->die_tag == DW_TAG_const_type
9420 || c->die_tag == DW_TAG_volatile_type)
9422 dw_die_ref t = get_AT_ref (c, DW_AT_type);
9424 return t ? is_comdat_die (t) : 0;
9427 return is_type_die (c);
9430 /* Returns 1 iff C is the sort of DIE that might be referred to from another
9431 compilation unit. */
9434 is_symbol_die (dw_die_ref c)
9436 return (is_type_die (c)
9437 || is_declaration_die (c)
9438 || c->die_tag == DW_TAG_namespace
9439 || c->die_tag == DW_TAG_module);
9443 gen_internal_sym (const char *prefix)
9447 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
9448 return xstrdup (buf);
9451 /* Assign symbols to all worthy DIEs under DIE. */
9454 assign_symbol_names (dw_die_ref die)
9458 if (is_symbol_die (die))
9460 if (comdat_symbol_id)
9462 char *p = XALLOCAVEC (char, strlen (comdat_symbol_id) + 64);
9464 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
9465 comdat_symbol_id, comdat_symbol_number++);
9466 die->die_id.die_symbol = xstrdup (p);
9469 die->die_id.die_symbol = gen_internal_sym ("LDIE");
9472 FOR_EACH_CHILD (die, c, assign_symbol_names (c));
9475 struct cu_hash_table_entry
9478 unsigned min_comdat_num, max_comdat_num;
9479 struct cu_hash_table_entry *next;
9482 /* Routines to manipulate hash table of CUs. */
9484 htab_cu_hash (const void *of)
9486 const struct cu_hash_table_entry *const entry =
9487 (const struct cu_hash_table_entry *) of;
9489 return htab_hash_string (entry->cu->die_id.die_symbol);
9493 htab_cu_eq (const void *of1, const void *of2)
9495 const struct cu_hash_table_entry *const entry1 =
9496 (const struct cu_hash_table_entry *) of1;
9497 const struct die_struct *const entry2 = (const struct die_struct *) of2;
9499 return !strcmp (entry1->cu->die_id.die_symbol, entry2->die_id.die_symbol);
9503 htab_cu_del (void *what)
9505 struct cu_hash_table_entry *next,
9506 *entry = (struct cu_hash_table_entry *) what;
9516 /* Check whether we have already seen this CU and set up SYM_NUM
9519 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
9521 struct cu_hash_table_entry dummy;
9522 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
9524 dummy.max_comdat_num = 0;
9526 slot = (struct cu_hash_table_entry **)
9527 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
9531 for (; entry; last = entry, entry = entry->next)
9533 if (same_die_p_wrap (cu, entry->cu))
9539 *sym_num = entry->min_comdat_num;
9543 entry = XCNEW (struct cu_hash_table_entry);
9545 entry->min_comdat_num = *sym_num = last->max_comdat_num;
9546 entry->next = *slot;
9552 /* Record SYM_NUM to record of CU in HTABLE. */
9554 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
9556 struct cu_hash_table_entry **slot, *entry;
9558 slot = (struct cu_hash_table_entry **)
9559 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_id.die_symbol),
9563 entry->max_comdat_num = sym_num;
9566 /* Traverse the DIE (which is always comp_unit_die), and set up
9567 additional compilation units for each of the include files we see
9568 bracketed by BINCL/EINCL. */
9571 break_out_includes (dw_die_ref die)
9574 dw_die_ref unit = NULL;
9575 limbo_die_node *node, **pnode;
9576 htab_t cu_hash_table;
9580 dw_die_ref prev = c;
9582 while (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
9583 || (unit && is_comdat_die (c)))
9585 dw_die_ref next = c->die_sib;
9587 /* This DIE is for a secondary CU; remove it from the main one. */
9588 remove_child_with_prev (c, prev);
9590 if (c->die_tag == DW_TAG_GNU_BINCL)
9591 unit = push_new_compile_unit (unit, c);
9592 else if (c->die_tag == DW_TAG_GNU_EINCL)
9593 unit = pop_compile_unit (unit);
9595 add_child_die (unit, c);
9597 if (c == die->die_child)
9600 } while (c != die->die_child);
9603 /* We can only use this in debugging, since the frontend doesn't check
9604 to make sure that we leave every include file we enter. */
9608 assign_symbol_names (die);
9609 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
9610 for (node = limbo_die_list, pnode = &limbo_die_list;
9616 compute_section_prefix (node->die);
9617 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
9618 &comdat_symbol_number);
9619 assign_symbol_names (node->die);
9621 *pnode = node->next;
9624 pnode = &node->next;
9625 record_comdat_symbol_number (node->die, cu_hash_table,
9626 comdat_symbol_number);
9629 htab_delete (cu_hash_table);
9632 /* Return non-zero if this DIE is a declaration. */
9635 is_declaration_die (dw_die_ref die)
9640 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9641 if (a->dw_attr == DW_AT_declaration)
9647 /* Return non-zero if this DIE is nested inside a subprogram. */
9650 is_nested_in_subprogram (dw_die_ref die)
9652 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
9656 return local_scope_p (decl);
9659 /* Return non-zero if this is a type DIE that should be moved to a
9660 COMDAT .debug_types section. */
9663 should_move_die_to_comdat (dw_die_ref die)
9665 switch (die->die_tag)
9667 case DW_TAG_class_type:
9668 case DW_TAG_structure_type:
9669 case DW_TAG_enumeration_type:
9670 case DW_TAG_union_type:
9671 /* Don't move declarations, inlined instances, or types nested in a
9673 if (is_declaration_die (die)
9674 || get_AT (die, DW_AT_abstract_origin)
9675 || is_nested_in_subprogram (die))
9678 case DW_TAG_array_type:
9679 case DW_TAG_interface_type:
9680 case DW_TAG_pointer_type:
9681 case DW_TAG_reference_type:
9682 case DW_TAG_rvalue_reference_type:
9683 case DW_TAG_string_type:
9684 case DW_TAG_subroutine_type:
9685 case DW_TAG_ptr_to_member_type:
9686 case DW_TAG_set_type:
9687 case DW_TAG_subrange_type:
9688 case DW_TAG_base_type:
9689 case DW_TAG_const_type:
9690 case DW_TAG_file_type:
9691 case DW_TAG_packed_type:
9692 case DW_TAG_volatile_type:
9693 case DW_TAG_typedef:
9699 /* Make a clone of DIE. */
9702 clone_die (dw_die_ref die)
9708 clone = ggc_alloc_cleared_die_node ();
9709 clone->die_tag = die->die_tag;
9711 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9712 add_dwarf_attr (clone, a);
9717 /* Make a clone of the tree rooted at DIE. */
9720 clone_tree (dw_die_ref die)
9723 dw_die_ref clone = clone_die (die);
9725 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree(c)));
9730 /* Make a clone of DIE as a declaration. */
9733 clone_as_declaration (dw_die_ref die)
9740 /* If the DIE is already a declaration, just clone it. */
9741 if (is_declaration_die (die))
9742 return clone_die (die);
9744 /* If the DIE is a specification, just clone its declaration DIE. */
9745 decl = get_AT_ref (die, DW_AT_specification);
9747 return clone_die (decl);
9749 clone = ggc_alloc_cleared_die_node ();
9750 clone->die_tag = die->die_tag;
9752 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
9754 /* We don't want to copy over all attributes.
9755 For example we don't want DW_AT_byte_size because otherwise we will no
9756 longer have a declaration and GDB will treat it as a definition. */
9760 case DW_AT_artificial:
9761 case DW_AT_containing_type:
9762 case DW_AT_external:
9765 case DW_AT_virtuality:
9766 case DW_AT_linkage_name:
9767 case DW_AT_MIPS_linkage_name:
9768 add_dwarf_attr (clone, a);
9770 case DW_AT_byte_size:
9776 if (die->die_id.die_type_node)
9777 add_AT_die_ref (clone, DW_AT_signature, die);
9779 add_AT_flag (clone, DW_AT_declaration, 1);
9783 /* Copy the declaration context to the new compile unit DIE. This includes
9784 any surrounding namespace or type declarations. If the DIE has an
9785 AT_specification attribute, it also includes attributes and children
9786 attached to the specification. */
9789 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
9792 dw_die_ref new_decl;
9794 decl = get_AT_ref (die, DW_AT_specification);
9803 /* Copy the type node pointer from the new DIE to the original
9804 declaration DIE so we can forward references later. */
9805 decl->die_id.die_type_node = die->die_id.die_type_node;
9807 remove_AT (die, DW_AT_specification);
9809 for (ix = 0; VEC_iterate (dw_attr_node, decl->die_attr, ix, a); ix++)
9811 if (a->dw_attr != DW_AT_name
9812 && a->dw_attr != DW_AT_declaration
9813 && a->dw_attr != DW_AT_external)
9814 add_dwarf_attr (die, a);
9817 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree(c)));
9820 if (decl->die_parent != NULL
9821 && decl->die_parent->die_tag != DW_TAG_compile_unit
9822 && decl->die_parent->die_tag != DW_TAG_type_unit)
9824 new_decl = copy_ancestor_tree (unit, decl, NULL);
9825 if (new_decl != NULL)
9827 remove_AT (new_decl, DW_AT_signature);
9828 add_AT_specification (die, new_decl);
9833 /* Generate the skeleton ancestor tree for the given NODE, then clone
9834 the DIE and add the clone into the tree. */
9837 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
9839 if (node->new_die != NULL)
9842 node->new_die = clone_as_declaration (node->old_die);
9844 if (node->parent != NULL)
9846 generate_skeleton_ancestor_tree (node->parent);
9847 add_child_die (node->parent->new_die, node->new_die);
9851 /* Generate a skeleton tree of DIEs containing any declarations that are
9852 found in the original tree. We traverse the tree looking for declaration
9853 DIEs, and construct the skeleton from the bottom up whenever we find one. */
9856 generate_skeleton_bottom_up (skeleton_chain_node *parent)
9858 skeleton_chain_node node;
9861 dw_die_ref prev = NULL;
9862 dw_die_ref next = NULL;
9864 node.parent = parent;
9866 first = c = parent->old_die->die_child;
9870 if (prev == NULL || prev->die_sib == c)
9873 next = (c == first ? NULL : c->die_sib);
9875 node.new_die = NULL;
9876 if (is_declaration_die (c))
9878 /* Clone the existing DIE, move the original to the skeleton
9879 tree (which is in the main CU), and put the clone, with
9880 all the original's children, where the original came from. */
9881 dw_die_ref clone = clone_die (c);
9882 move_all_children (c, clone);
9884 replace_child (c, clone, prev);
9885 generate_skeleton_ancestor_tree (parent);
9886 add_child_die (parent->new_die, c);
9890 generate_skeleton_bottom_up (&node);
9891 } while (next != NULL);
9894 /* Wrapper function for generate_skeleton_bottom_up. */
9897 generate_skeleton (dw_die_ref die)
9899 skeleton_chain_node node;
9902 node.new_die = NULL;
9905 /* If this type definition is nested inside another type,
9906 always leave at least a declaration in its place. */
9907 if (die->die_parent != NULL && is_type_die (die->die_parent))
9908 node.new_die = clone_as_declaration (die);
9910 generate_skeleton_bottom_up (&node);
9911 return node.new_die;
9914 /* Remove the DIE from its parent, possibly replacing it with a cloned
9915 declaration. The original DIE will be moved to a new compile unit
9916 so that existing references to it follow it to the new location. If
9917 any of the original DIE's descendants is a declaration, we need to
9918 replace the original DIE with a skeleton tree and move the
9919 declarations back into the skeleton tree. */
9922 remove_child_or_replace_with_skeleton (dw_die_ref child, dw_die_ref prev)
9924 dw_die_ref skeleton;
9926 skeleton = generate_skeleton (child);
9927 if (skeleton == NULL)
9928 remove_child_with_prev (child, prev);
9931 skeleton->die_id.die_type_node = child->die_id.die_type_node;
9932 replace_child (child, skeleton, prev);
9938 /* Traverse the DIE and set up additional .debug_types sections for each
9939 type worthy of being placed in a COMDAT section. */
9942 break_out_comdat_types (dw_die_ref die)
9946 dw_die_ref prev = NULL;
9947 dw_die_ref next = NULL;
9948 dw_die_ref unit = NULL;
9950 first = c = die->die_child;
9954 if (prev == NULL || prev->die_sib == c)
9957 next = (c == first ? NULL : c->die_sib);
9958 if (should_move_die_to_comdat (c))
9960 dw_die_ref replacement;
9961 comdat_type_node_ref type_node;
9963 /* Create a new type unit DIE as the root for the new tree, and
9964 add it to the list of comdat types. */
9965 unit = new_die (DW_TAG_type_unit, NULL, NULL);
9966 add_AT_unsigned (unit, DW_AT_language,
9967 get_AT_unsigned (comp_unit_die, DW_AT_language));
9968 type_node = ggc_alloc_cleared_comdat_type_node ();
9969 type_node->root_die = unit;
9970 type_node->next = comdat_type_list;
9971 comdat_type_list = type_node;
9973 /* Generate the type signature. */
9974 generate_type_signature (c, type_node);
9976 /* Copy the declaration context, attributes, and children of the
9977 declaration into the new compile unit DIE. */
9978 copy_declaration_context (unit, c);
9980 /* Remove this DIE from the main CU. */
9981 replacement = remove_child_or_replace_with_skeleton (c, prev);
9983 /* Break out nested types into their own type units. */
9984 break_out_comdat_types (c);
9986 /* Add the DIE to the new compunit. */
9987 add_child_die (unit, c);
9989 if (replacement != NULL)
9992 else if (c->die_tag == DW_TAG_namespace
9993 || c->die_tag == DW_TAG_class_type
9994 || c->die_tag == DW_TAG_structure_type
9995 || c->die_tag == DW_TAG_union_type)
9997 /* Look for nested types that can be broken out. */
9998 break_out_comdat_types (c);
10000 } while (next != NULL);
10003 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
10005 struct decl_table_entry
10011 /* Routines to manipulate hash table of copied declarations. */
10014 htab_decl_hash (const void *of)
10016 const struct decl_table_entry *const entry =
10017 (const struct decl_table_entry *) of;
10019 return htab_hash_pointer (entry->orig);
10023 htab_decl_eq (const void *of1, const void *of2)
10025 const struct decl_table_entry *const entry1 =
10026 (const struct decl_table_entry *) of1;
10027 const struct die_struct *const entry2 = (const struct die_struct *) of2;
10029 return entry1->orig == entry2;
10033 htab_decl_del (void *what)
10035 struct decl_table_entry *entry = (struct decl_table_entry *) what;
10040 /* Copy DIE and its ancestors, up to, but not including, the compile unit
10041 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
10042 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
10043 to check if the ancestor has already been copied into UNIT. */
10046 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
10048 dw_die_ref parent = die->die_parent;
10049 dw_die_ref new_parent = unit;
10051 void **slot = NULL;
10052 struct decl_table_entry *entry = NULL;
10056 /* Check if the entry has already been copied to UNIT. */
10057 slot = htab_find_slot_with_hash (decl_table, die,
10058 htab_hash_pointer (die), INSERT);
10059 if (*slot != HTAB_EMPTY_ENTRY)
10061 entry = (struct decl_table_entry *) *slot;
10062 return entry->copy;
10065 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
10066 entry = XCNEW (struct decl_table_entry);
10068 entry->copy = NULL;
10072 if (parent != NULL)
10074 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
10077 if (parent->die_tag != DW_TAG_compile_unit
10078 && parent->die_tag != DW_TAG_type_unit)
10079 new_parent = copy_ancestor_tree (unit, parent, decl_table);
10082 copy = clone_as_declaration (die);
10083 add_child_die (new_parent, copy);
10085 if (decl_table != NULL)
10087 /* Record the pointer to the copy. */
10088 entry->copy = copy;
10094 /* Walk the DIE and its children, looking for references to incomplete
10095 or trivial types that are unmarked (i.e., that are not in the current
10099 copy_decls_walk (dw_die_ref unit, dw_die_ref die, htab_t decl_table)
10105 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10107 if (AT_class (a) == dw_val_class_die_ref)
10109 dw_die_ref targ = AT_ref (a);
10110 comdat_type_node_ref type_node = targ->die_id.die_type_node;
10112 struct decl_table_entry *entry;
10114 if (targ->die_mark != 0 || type_node != NULL)
10117 slot = htab_find_slot_with_hash (decl_table, targ,
10118 htab_hash_pointer (targ), INSERT);
10120 if (*slot != HTAB_EMPTY_ENTRY)
10122 /* TARG has already been copied, so we just need to
10123 modify the reference to point to the copy. */
10124 entry = (struct decl_table_entry *) *slot;
10125 a->dw_attr_val.v.val_die_ref.die = entry->copy;
10129 dw_die_ref parent = unit;
10130 dw_die_ref copy = clone_tree (targ);
10132 /* Make sure the cloned tree is marked as part of the
10136 /* Record in DECL_TABLE that TARG has been copied.
10137 Need to do this now, before the recursive call,
10138 because DECL_TABLE may be expanded and SLOT
10139 would no longer be a valid pointer. */
10140 entry = XCNEW (struct decl_table_entry);
10141 entry->orig = targ;
10142 entry->copy = copy;
10145 /* If TARG has surrounding context, copy its ancestor tree
10146 into the new type unit. */
10147 if (targ->die_parent != NULL
10148 && targ->die_parent->die_tag != DW_TAG_compile_unit
10149 && targ->die_parent->die_tag != DW_TAG_type_unit)
10150 parent = copy_ancestor_tree (unit, targ->die_parent,
10153 add_child_die (parent, copy);
10154 a->dw_attr_val.v.val_die_ref.die = copy;
10156 /* Make sure the newly-copied DIE is walked. If it was
10157 installed in a previously-added context, it won't
10158 get visited otherwise. */
10159 if (parent != unit)
10161 /* Find the highest point of the newly-added tree,
10162 mark each node along the way, and walk from there. */
10163 parent->die_mark = 1;
10164 while (parent->die_parent
10165 && parent->die_parent->die_mark == 0)
10167 parent = parent->die_parent;
10168 parent->die_mark = 1;
10170 copy_decls_walk (unit, parent, decl_table);
10176 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
10179 /* Copy declarations for "unworthy" types into the new comdat section.
10180 Incomplete types, modified types, and certain other types aren't broken
10181 out into comdat sections of their own, so they don't have a signature,
10182 and we need to copy the declaration into the same section so that we
10183 don't have an external reference. */
10186 copy_decls_for_unworthy_types (dw_die_ref unit)
10191 decl_table = htab_create (10, htab_decl_hash, htab_decl_eq, htab_decl_del);
10192 copy_decls_walk (unit, unit, decl_table);
10193 htab_delete (decl_table);
10194 unmark_dies (unit);
10197 /* Traverse the DIE and add a sibling attribute if it may have the
10198 effect of speeding up access to siblings. To save some space,
10199 avoid generating sibling attributes for DIE's without children. */
10202 add_sibling_attributes (dw_die_ref die)
10206 if (! die->die_child)
10209 if (die->die_parent && die != die->die_parent->die_child)
10210 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
10212 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
10215 /* Output all location lists for the DIE and its children. */
10218 output_location_lists (dw_die_ref die)
10224 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10225 if (AT_class (a) == dw_val_class_loc_list)
10226 output_loc_list (AT_loc_list (a));
10228 FOR_EACH_CHILD (die, c, output_location_lists (c));
10231 /* The format of each DIE (and its attribute value pairs) is encoded in an
10232 abbreviation table. This routine builds the abbreviation table and assigns
10233 a unique abbreviation id for each abbreviation entry. The children of each
10234 die are visited recursively. */
10237 build_abbrev_table (dw_die_ref die)
10239 unsigned long abbrev_id;
10240 unsigned int n_alloc;
10245 /* Scan the DIE references, and mark as external any that refer to
10246 DIEs from other CUs (i.e. those which are not marked). */
10247 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10248 if (AT_class (a) == dw_val_class_die_ref
10249 && AT_ref (a)->die_mark == 0)
10251 gcc_assert (dwarf_version >= 4 || AT_ref (a)->die_id.die_symbol);
10252 set_AT_ref_external (a, 1);
10255 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
10257 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
10258 dw_attr_ref die_a, abbrev_a;
10262 if (abbrev->die_tag != die->die_tag)
10264 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
10267 if (VEC_length (dw_attr_node, abbrev->die_attr)
10268 != VEC_length (dw_attr_node, die->die_attr))
10271 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
10273 abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
10274 if ((abbrev_a->dw_attr != die_a->dw_attr)
10275 || (value_format (abbrev_a) != value_format (die_a)))
10285 if (abbrev_id >= abbrev_die_table_in_use)
10287 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
10289 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
10290 abbrev_die_table = GGC_RESIZEVEC (dw_die_ref, abbrev_die_table,
10293 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
10294 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
10295 abbrev_die_table_allocated = n_alloc;
10298 ++abbrev_die_table_in_use;
10299 abbrev_die_table[abbrev_id] = die;
10302 die->die_abbrev = abbrev_id;
10303 FOR_EACH_CHILD (die, c, build_abbrev_table (c));
10306 /* Return the power-of-two number of bytes necessary to represent VALUE. */
10309 constant_size (unsigned HOST_WIDE_INT value)
10316 log = floor_log2 (value);
10319 log = 1 << (floor_log2 (log) + 1);
10324 /* Return the size of a DIE as it is represented in the
10325 .debug_info section. */
10327 static unsigned long
10328 size_of_die (dw_die_ref die)
10330 unsigned long size = 0;
10334 size += size_of_uleb128 (die->die_abbrev);
10335 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10337 switch (AT_class (a))
10339 case dw_val_class_addr:
10340 size += DWARF2_ADDR_SIZE;
10342 case dw_val_class_offset:
10343 size += DWARF_OFFSET_SIZE;
10345 case dw_val_class_loc:
10347 unsigned long lsize = size_of_locs (AT_loc (a));
10349 /* Block length. */
10350 if (dwarf_version >= 4)
10351 size += size_of_uleb128 (lsize);
10353 size += constant_size (lsize);
10357 case dw_val_class_loc_list:
10358 size += DWARF_OFFSET_SIZE;
10360 case dw_val_class_range_list:
10361 size += DWARF_OFFSET_SIZE;
10363 case dw_val_class_const:
10364 size += size_of_sleb128 (AT_int (a));
10366 case dw_val_class_unsigned_const:
10367 size += constant_size (AT_unsigned (a));
10369 case dw_val_class_const_double:
10370 size += 2 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
10371 if (HOST_BITS_PER_WIDE_INT >= 64)
10372 size++; /* block */
10374 case dw_val_class_vec:
10375 size += constant_size (a->dw_attr_val.v.val_vec.length
10376 * a->dw_attr_val.v.val_vec.elt_size)
10377 + a->dw_attr_val.v.val_vec.length
10378 * a->dw_attr_val.v.val_vec.elt_size; /* block */
10380 case dw_val_class_flag:
10381 if (dwarf_version >= 4)
10382 /* Currently all add_AT_flag calls pass in 1 as last argument,
10383 so DW_FORM_flag_present can be used. If that ever changes,
10384 we'll need to use DW_FORM_flag and have some optimization
10385 in build_abbrev_table that will change those to
10386 DW_FORM_flag_present if it is set to 1 in all DIEs using
10387 the same abbrev entry. */
10388 gcc_assert (a->dw_attr_val.v.val_flag == 1);
10392 case dw_val_class_die_ref:
10393 if (AT_ref_external (a))
10395 /* In DWARF4, we use DW_FORM_sig8; for earlier versions
10396 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
10397 is sized by target address length, whereas in DWARF3
10398 it's always sized as an offset. */
10399 if (dwarf_version >= 4)
10400 size += DWARF_TYPE_SIGNATURE_SIZE;
10401 else if (dwarf_version == 2)
10402 size += DWARF2_ADDR_SIZE;
10404 size += DWARF_OFFSET_SIZE;
10407 size += DWARF_OFFSET_SIZE;
10409 case dw_val_class_fde_ref:
10410 size += DWARF_OFFSET_SIZE;
10412 case dw_val_class_lbl_id:
10413 size += DWARF2_ADDR_SIZE;
10415 case dw_val_class_lineptr:
10416 case dw_val_class_macptr:
10417 size += DWARF_OFFSET_SIZE;
10419 case dw_val_class_str:
10420 if (AT_string_form (a) == DW_FORM_strp)
10421 size += DWARF_OFFSET_SIZE;
10423 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
10425 case dw_val_class_file:
10426 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
10428 case dw_val_class_data8:
10431 case dw_val_class_vms_delta:
10432 size += DWARF_OFFSET_SIZE;
10435 gcc_unreachable ();
10442 /* Size the debugging information associated with a given DIE. Visits the
10443 DIE's children recursively. Updates the global variable next_die_offset, on
10444 each time through. Uses the current value of next_die_offset to update the
10445 die_offset field in each DIE. */
10448 calc_die_sizes (dw_die_ref die)
10452 die->die_offset = next_die_offset;
10453 next_die_offset += size_of_die (die);
10455 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
10457 if (die->die_child != NULL)
10458 /* Count the null byte used to terminate sibling lists. */
10459 next_die_offset += 1;
10462 /* Set the marks for a die and its children. We do this so
10463 that we know whether or not a reference needs to use FORM_ref_addr; only
10464 DIEs in the same CU will be marked. We used to clear out the offset
10465 and use that as the flag, but ran into ordering problems. */
10468 mark_dies (dw_die_ref die)
10472 gcc_assert (!die->die_mark);
10475 FOR_EACH_CHILD (die, c, mark_dies (c));
10478 /* Clear the marks for a die and its children. */
10481 unmark_dies (dw_die_ref die)
10485 if (dwarf_version < 4)
10486 gcc_assert (die->die_mark);
10489 FOR_EACH_CHILD (die, c, unmark_dies (c));
10492 /* Clear the marks for a die, its children and referred dies. */
10495 unmark_all_dies (dw_die_ref die)
10501 if (!die->die_mark)
10505 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
10507 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10508 if (AT_class (a) == dw_val_class_die_ref)
10509 unmark_all_dies (AT_ref (a));
10512 /* Return the size of the .debug_pubnames or .debug_pubtypes table
10513 generated for the compilation unit. */
10515 static unsigned long
10516 size_of_pubnames (VEC (pubname_entry, gc) * names)
10518 unsigned long size;
10522 size = DWARF_PUBNAMES_HEADER_SIZE;
10523 for (i = 0; VEC_iterate (pubname_entry, names, i, p); i++)
10524 if (names != pubtype_table
10525 || p->die->die_offset != 0
10526 || !flag_eliminate_unused_debug_types)
10527 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1;
10529 size += DWARF_OFFSET_SIZE;
10533 /* Return the size of the information in the .debug_aranges section. */
10535 static unsigned long
10536 size_of_aranges (void)
10538 unsigned long size;
10540 size = DWARF_ARANGES_HEADER_SIZE;
10542 /* Count the address/length pair for this compilation unit. */
10543 if (text_section_used)
10544 size += 2 * DWARF2_ADDR_SIZE;
10545 if (cold_text_section_used)
10546 size += 2 * DWARF2_ADDR_SIZE;
10547 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
10549 /* Count the two zero words used to terminated the address range table. */
10550 size += 2 * DWARF2_ADDR_SIZE;
10554 /* Select the encoding of an attribute value. */
10556 static enum dwarf_form
10557 value_format (dw_attr_ref a)
10559 switch (a->dw_attr_val.val_class)
10561 case dw_val_class_addr:
10562 /* Only very few attributes allow DW_FORM_addr. */
10563 switch (a->dw_attr)
10566 case DW_AT_high_pc:
10567 case DW_AT_entry_pc:
10568 case DW_AT_trampoline:
10569 return DW_FORM_addr;
10573 switch (DWARF2_ADDR_SIZE)
10576 return DW_FORM_data1;
10578 return DW_FORM_data2;
10580 return DW_FORM_data4;
10582 return DW_FORM_data8;
10584 gcc_unreachable ();
10586 case dw_val_class_range_list:
10587 case dw_val_class_loc_list:
10588 if (dwarf_version >= 4)
10589 return DW_FORM_sec_offset;
10591 case dw_val_class_vms_delta:
10592 case dw_val_class_offset:
10593 switch (DWARF_OFFSET_SIZE)
10596 return DW_FORM_data4;
10598 return DW_FORM_data8;
10600 gcc_unreachable ();
10602 case dw_val_class_loc:
10603 if (dwarf_version >= 4)
10604 return DW_FORM_exprloc;
10605 switch (constant_size (size_of_locs (AT_loc (a))))
10608 return DW_FORM_block1;
10610 return DW_FORM_block2;
10612 gcc_unreachable ();
10614 case dw_val_class_const:
10615 return DW_FORM_sdata;
10616 case dw_val_class_unsigned_const:
10617 switch (constant_size (AT_unsigned (a)))
10620 return DW_FORM_data1;
10622 return DW_FORM_data2;
10624 return DW_FORM_data4;
10626 return DW_FORM_data8;
10628 gcc_unreachable ();
10630 case dw_val_class_const_double:
10631 switch (HOST_BITS_PER_WIDE_INT)
10634 return DW_FORM_data2;
10636 return DW_FORM_data4;
10638 return DW_FORM_data8;
10641 return DW_FORM_block1;
10643 case dw_val_class_vec:
10644 switch (constant_size (a->dw_attr_val.v.val_vec.length
10645 * a->dw_attr_val.v.val_vec.elt_size))
10648 return DW_FORM_block1;
10650 return DW_FORM_block2;
10652 return DW_FORM_block4;
10654 gcc_unreachable ();
10656 case dw_val_class_flag:
10657 if (dwarf_version >= 4)
10659 /* Currently all add_AT_flag calls pass in 1 as last argument,
10660 so DW_FORM_flag_present can be used. If that ever changes,
10661 we'll need to use DW_FORM_flag and have some optimization
10662 in build_abbrev_table that will change those to
10663 DW_FORM_flag_present if it is set to 1 in all DIEs using
10664 the same abbrev entry. */
10665 gcc_assert (a->dw_attr_val.v.val_flag == 1);
10666 return DW_FORM_flag_present;
10668 return DW_FORM_flag;
10669 case dw_val_class_die_ref:
10670 if (AT_ref_external (a))
10671 return dwarf_version >= 4 ? DW_FORM_sig8 : DW_FORM_ref_addr;
10673 return DW_FORM_ref;
10674 case dw_val_class_fde_ref:
10675 return DW_FORM_data;
10676 case dw_val_class_lbl_id:
10677 return DW_FORM_addr;
10678 case dw_val_class_lineptr:
10679 case dw_val_class_macptr:
10680 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
10681 case dw_val_class_str:
10682 return AT_string_form (a);
10683 case dw_val_class_file:
10684 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
10687 return DW_FORM_data1;
10689 return DW_FORM_data2;
10691 return DW_FORM_data4;
10693 gcc_unreachable ();
10696 case dw_val_class_data8:
10697 return DW_FORM_data8;
10700 gcc_unreachable ();
10704 /* Output the encoding of an attribute value. */
10707 output_value_format (dw_attr_ref a)
10709 enum dwarf_form form = value_format (a);
10711 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
10714 /* Output the .debug_abbrev section which defines the DIE abbreviation
10718 output_abbrev_section (void)
10720 unsigned long abbrev_id;
10722 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
10724 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
10726 dw_attr_ref a_attr;
10728 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
10729 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
10730 dwarf_tag_name (abbrev->die_tag));
10732 if (abbrev->die_child != NULL)
10733 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
10735 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
10737 for (ix = 0; VEC_iterate (dw_attr_node, abbrev->die_attr, ix, a_attr);
10740 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
10741 dwarf_attr_name (a_attr->dw_attr));
10742 output_value_format (a_attr);
10745 dw2_asm_output_data (1, 0, NULL);
10746 dw2_asm_output_data (1, 0, NULL);
10749 /* Terminate the table. */
10750 dw2_asm_output_data (1, 0, NULL);
10753 /* Output a symbol we can use to refer to this DIE from another CU. */
10756 output_die_symbol (dw_die_ref die)
10758 char *sym = die->die_id.die_symbol;
10763 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
10764 /* We make these global, not weak; if the target doesn't support
10765 .linkonce, it doesn't support combining the sections, so debugging
10767 targetm.asm_out.globalize_label (asm_out_file, sym);
10769 ASM_OUTPUT_LABEL (asm_out_file, sym);
10772 /* Return a new location list, given the begin and end range, and the
10775 static inline dw_loc_list_ref
10776 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
10777 const char *section)
10779 dw_loc_list_ref retlist = ggc_alloc_cleared_dw_loc_list_node ();
10781 retlist->begin = begin;
10782 retlist->end = end;
10783 retlist->expr = expr;
10784 retlist->section = section;
10789 /* Generate a new internal symbol for this location list node, if it
10790 hasn't got one yet. */
10793 gen_llsym (dw_loc_list_ref list)
10795 gcc_assert (!list->ll_symbol);
10796 list->ll_symbol = gen_internal_sym ("LLST");
10799 /* Output the location list given to us. */
10802 output_loc_list (dw_loc_list_ref list_head)
10804 dw_loc_list_ref curr = list_head;
10806 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
10808 /* Walk the location list, and output each range + expression. */
10809 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
10811 unsigned long size;
10812 /* Don't output an entry that starts and ends at the same address. */
10813 if (strcmp (curr->begin, curr->end) == 0)
10815 if (!have_multiple_function_sections)
10817 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
10818 "Location list begin address (%s)",
10819 list_head->ll_symbol);
10820 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
10821 "Location list end address (%s)",
10822 list_head->ll_symbol);
10826 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
10827 "Location list begin address (%s)",
10828 list_head->ll_symbol);
10829 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
10830 "Location list end address (%s)",
10831 list_head->ll_symbol);
10833 size = size_of_locs (curr->expr);
10835 /* Output the block length for this list of location operations. */
10836 gcc_assert (size <= 0xffff);
10837 dw2_asm_output_data (2, size, "%s", "Location expression size");
10839 output_loc_sequence (curr->expr);
10842 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10843 "Location list terminator begin (%s)",
10844 list_head->ll_symbol);
10845 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10846 "Location list terminator end (%s)",
10847 list_head->ll_symbol);
10850 /* Output a type signature. */
10853 output_signature (const char *sig, const char *name)
10857 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
10858 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
10861 /* Output the DIE and its attributes. Called recursively to generate
10862 the definitions of each child DIE. */
10865 output_die (dw_die_ref die)
10869 unsigned long size;
10872 /* If someone in another CU might refer to us, set up a symbol for
10873 them to point to. */
10874 if (dwarf_version < 4 && die->die_id.die_symbol)
10875 output_die_symbol (die);
10877 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
10878 (unsigned long)die->die_offset,
10879 dwarf_tag_name (die->die_tag));
10881 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
10883 const char *name = dwarf_attr_name (a->dw_attr);
10885 switch (AT_class (a))
10887 case dw_val_class_addr:
10888 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
10891 case dw_val_class_offset:
10892 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
10896 case dw_val_class_range_list:
10898 char *p = strchr (ranges_section_label, '\0');
10900 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
10901 a->dw_attr_val.v.val_offset);
10902 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
10903 debug_ranges_section, "%s", name);
10908 case dw_val_class_loc:
10909 size = size_of_locs (AT_loc (a));
10911 /* Output the block length for this list of location operations. */
10912 if (dwarf_version >= 4)
10913 dw2_asm_output_data_uleb128 (size, "%s", name);
10915 dw2_asm_output_data (constant_size (size), size, "%s", name);
10917 output_loc_sequence (AT_loc (a));
10920 case dw_val_class_const:
10921 /* ??? It would be slightly more efficient to use a scheme like is
10922 used for unsigned constants below, but gdb 4.x does not sign
10923 extend. Gdb 5.x does sign extend. */
10924 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
10927 case dw_val_class_unsigned_const:
10928 dw2_asm_output_data (constant_size (AT_unsigned (a)),
10929 AT_unsigned (a), "%s", name);
10932 case dw_val_class_const_double:
10934 unsigned HOST_WIDE_INT first, second;
10936 if (HOST_BITS_PER_WIDE_INT >= 64)
10937 dw2_asm_output_data (1,
10938 2 * HOST_BITS_PER_WIDE_INT
10939 / HOST_BITS_PER_CHAR,
10942 if (WORDS_BIG_ENDIAN)
10944 first = a->dw_attr_val.v.val_double.high;
10945 second = a->dw_attr_val.v.val_double.low;
10949 first = a->dw_attr_val.v.val_double.low;
10950 second = a->dw_attr_val.v.val_double.high;
10953 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
10955 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
10960 case dw_val_class_vec:
10962 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
10963 unsigned int len = a->dw_attr_val.v.val_vec.length;
10967 dw2_asm_output_data (constant_size (len * elt_size),
10968 len * elt_size, "%s", name);
10969 if (elt_size > sizeof (HOST_WIDE_INT))
10974 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
10976 i++, p += elt_size)
10977 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
10978 "fp or vector constant word %u", i);
10982 case dw_val_class_flag:
10983 if (dwarf_version >= 4)
10985 /* Currently all add_AT_flag calls pass in 1 as last argument,
10986 so DW_FORM_flag_present can be used. If that ever changes,
10987 we'll need to use DW_FORM_flag and have some optimization
10988 in build_abbrev_table that will change those to
10989 DW_FORM_flag_present if it is set to 1 in all DIEs using
10990 the same abbrev entry. */
10991 gcc_assert (AT_flag (a) == 1);
10992 if (flag_debug_asm)
10993 fprintf (asm_out_file, "\t\t\t%s %s\n",
10994 ASM_COMMENT_START, name);
10997 dw2_asm_output_data (1, AT_flag (a), "%s", name);
11000 case dw_val_class_loc_list:
11002 char *sym = AT_loc_list (a)->ll_symbol;
11005 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
11010 case dw_val_class_die_ref:
11011 if (AT_ref_external (a))
11013 if (dwarf_version >= 4)
11015 comdat_type_node_ref type_node =
11016 AT_ref (a)->die_id.die_type_node;
11018 gcc_assert (type_node);
11019 output_signature (type_node->signature, name);
11023 char *sym = AT_ref (a)->die_id.die_symbol;
11027 /* In DWARF2, DW_FORM_ref_addr is sized by target address
11028 length, whereas in DWARF3 it's always sized as an
11030 if (dwarf_version == 2)
11031 size = DWARF2_ADDR_SIZE;
11033 size = DWARF_OFFSET_SIZE;
11034 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
11040 gcc_assert (AT_ref (a)->die_offset);
11041 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
11046 case dw_val_class_fde_ref:
11050 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
11051 a->dw_attr_val.v.val_fde_index * 2);
11052 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
11057 case dw_val_class_vms_delta:
11058 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
11059 AT_vms_delta2 (a), AT_vms_delta1 (a),
11063 case dw_val_class_lbl_id:
11064 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
11067 case dw_val_class_lineptr:
11068 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
11069 debug_line_section, "%s", name);
11072 case dw_val_class_macptr:
11073 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
11074 debug_macinfo_section, "%s", name);
11077 case dw_val_class_str:
11078 if (AT_string_form (a) == DW_FORM_strp)
11079 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
11080 a->dw_attr_val.v.val_str->label,
11082 "%s: \"%s\"", name, AT_string (a));
11084 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
11087 case dw_val_class_file:
11089 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
11091 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
11092 a->dw_attr_val.v.val_file->filename);
11096 case dw_val_class_data8:
11100 for (i = 0; i < 8; i++)
11101 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
11102 i == 0 ? "%s" : NULL, name);
11107 gcc_unreachable ();
11111 FOR_EACH_CHILD (die, c, output_die (c));
11113 /* Add null byte to terminate sibling list. */
11114 if (die->die_child != NULL)
11115 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
11116 (unsigned long) die->die_offset);
11119 /* Output the compilation unit that appears at the beginning of the
11120 .debug_info section, and precedes the DIE descriptions. */
11123 output_compilation_unit_header (void)
11125 int ver = dwarf_version;
11127 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11128 dw2_asm_output_data (4, 0xffffffff,
11129 "Initial length escape value indicating 64-bit DWARF extension");
11130 dw2_asm_output_data (DWARF_OFFSET_SIZE,
11131 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
11132 "Length of Compilation Unit Info");
11133 dw2_asm_output_data (2, ver, "DWARF version number");
11134 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
11135 debug_abbrev_section,
11136 "Offset Into Abbrev. Section");
11137 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11140 /* Output the compilation unit DIE and its children. */
11143 output_comp_unit (dw_die_ref die, int output_if_empty)
11145 const char *secname;
11146 char *oldsym, *tmp;
11148 /* Unless we are outputting main CU, we may throw away empty ones. */
11149 if (!output_if_empty && die->die_child == NULL)
11152 /* Even if there are no children of this DIE, we must output the information
11153 about the compilation unit. Otherwise, on an empty translation unit, we
11154 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11155 will then complain when examining the file. First mark all the DIEs in
11156 this CU so we know which get local refs. */
11159 build_abbrev_table (die);
11161 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11162 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
11163 calc_die_sizes (die);
11165 oldsym = die->die_id.die_symbol;
11168 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
11170 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
11172 die->die_id.die_symbol = NULL;
11173 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11176 switch_to_section (debug_info_section);
11178 /* Output debugging information. */
11179 output_compilation_unit_header ();
11182 /* Leave the marks on the main CU, so we can check them in
11183 output_pubnames. */
11187 die->die_id.die_symbol = oldsym;
11191 /* Output a comdat type unit DIE and its children. */
11194 output_comdat_type_unit (comdat_type_node *node)
11196 const char *secname;
11199 #if defined (OBJECT_FORMAT_ELF)
11203 /* First mark all the DIEs in this CU so we know which get local refs. */
11204 mark_dies (node->root_die);
11206 build_abbrev_table (node->root_die);
11208 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11209 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
11210 calc_die_sizes (node->root_die);
11212 #if defined (OBJECT_FORMAT_ELF)
11213 secname = ".debug_types";
11214 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11215 sprintf (tmp, "wt.");
11216 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11217 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
11218 comdat_key = get_identifier (tmp);
11219 targetm.asm_out.named_section (secname,
11220 SECTION_DEBUG | SECTION_LINKONCE,
11223 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11224 sprintf (tmp, ".gnu.linkonce.wt.");
11225 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11226 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
11228 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11231 /* Output debugging information. */
11232 output_compilation_unit_header ();
11233 output_signature (node->signature, "Type Signature");
11234 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
11235 "Offset to Type DIE");
11236 output_die (node->root_die);
11238 unmark_dies (node->root_die);
11241 /* Return the DWARF2/3 pubname associated with a decl. */
11243 static const char *
11244 dwarf2_name (tree decl, int scope)
11246 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
11249 /* Add a new entry to .debug_pubnames if appropriate. */
11252 add_pubname_string (const char *str, dw_die_ref die)
11254 if (targetm.want_debug_pub_sections)
11259 e.name = xstrdup (str);
11260 VEC_safe_push (pubname_entry, gc, pubname_table, &e);
11265 add_pubname (tree decl, dw_die_ref die)
11267 if (targetm.want_debug_pub_sections && TREE_PUBLIC (decl))
11269 const char *name = dwarf2_name (decl, 1);
11271 add_pubname_string (name, die);
11275 /* Add a new entry to .debug_pubtypes if appropriate. */
11278 add_pubtype (tree decl, dw_die_ref die)
11282 if (!targetm.want_debug_pub_sections)
11286 if ((TREE_PUBLIC (decl)
11287 || die->die_parent == comp_unit_die)
11288 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
11293 if (TYPE_NAME (decl))
11295 if (TREE_CODE (TYPE_NAME (decl)) == IDENTIFIER_NODE)
11296 e.name = IDENTIFIER_POINTER (TYPE_NAME (decl));
11297 else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
11298 && DECL_NAME (TYPE_NAME (decl)))
11299 e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
11301 e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
11306 e.name = dwarf2_name (decl, 1);
11308 e.name = xstrdup (e.name);
11311 /* If we don't have a name for the type, there's no point in adding
11312 it to the table. */
11313 if (e.name && e.name[0] != '\0')
11314 VEC_safe_push (pubname_entry, gc, pubtype_table, &e);
11318 /* Output the public names table used to speed up access to externally
11319 visible names; or the public types table used to find type definitions. */
11322 output_pubnames (VEC (pubname_entry, gc) * names)
11325 unsigned long pubnames_length = size_of_pubnames (names);
11328 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11329 dw2_asm_output_data (4, 0xffffffff,
11330 "Initial length escape value indicating 64-bit DWARF extension");
11331 if (names == pubname_table)
11332 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
11333 "Length of Public Names Info");
11335 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
11336 "Length of Public Type Names Info");
11337 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
11338 dw2_asm_output_data (2, 2, "DWARF Version");
11339 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11340 debug_info_section,
11341 "Offset of Compilation Unit Info");
11342 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
11343 "Compilation Unit Length");
11345 for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
11347 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11348 if (names == pubname_table)
11349 gcc_assert (pub->die->die_mark);
11351 if (names != pubtype_table
11352 || pub->die->die_offset != 0
11353 || !flag_eliminate_unused_debug_types)
11355 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
11358 dw2_asm_output_nstring (pub->name, -1, "external name");
11362 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
11365 /* Add a new entry to .debug_aranges if appropriate. */
11368 add_arange (tree decl, dw_die_ref die)
11370 if (! DECL_SECTION_NAME (decl))
11373 if (arange_table_in_use == arange_table_allocated)
11375 arange_table_allocated += ARANGE_TABLE_INCREMENT;
11376 arange_table = GGC_RESIZEVEC (dw_die_ref, arange_table,
11377 arange_table_allocated);
11378 memset (arange_table + arange_table_in_use, 0,
11379 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
11382 arange_table[arange_table_in_use++] = die;
11385 /* Output the information that goes into the .debug_aranges table.
11386 Namely, define the beginning and ending address range of the
11387 text section generated for this compilation unit. */
11390 output_aranges (void)
11393 unsigned long aranges_length = size_of_aranges ();
11395 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11396 dw2_asm_output_data (4, 0xffffffff,
11397 "Initial length escape value indicating 64-bit DWARF extension");
11398 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
11399 "Length of Address Ranges Info");
11400 /* Version number for aranges is still 2, even in DWARF3. */
11401 dw2_asm_output_data (2, 2, "DWARF Version");
11402 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11403 debug_info_section,
11404 "Offset of Compilation Unit Info");
11405 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
11406 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11408 /* We need to align to twice the pointer size here. */
11409 if (DWARF_ARANGES_PAD_SIZE)
11411 /* Pad using a 2 byte words so that padding is correct for any
11413 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11414 2 * DWARF2_ADDR_SIZE);
11415 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
11416 dw2_asm_output_data (2, 0, NULL);
11419 /* It is necessary not to output these entries if the sections were
11420 not used; if the sections were not used, the length will be 0 and
11421 the address may end up as 0 if the section is discarded by ld
11422 --gc-sections, leaving an invalid (0, 0) entry that can be
11423 confused with the terminator. */
11424 if (text_section_used)
11426 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
11427 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
11428 text_section_label, "Length");
11430 if (cold_text_section_used)
11432 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
11434 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
11435 cold_text_section_label, "Length");
11438 for (i = 0; i < arange_table_in_use; i++)
11440 dw_die_ref die = arange_table[i];
11442 /* We shouldn't see aranges for DIEs outside of the main CU. */
11443 gcc_assert (die->die_mark);
11445 if (die->die_tag == DW_TAG_subprogram)
11447 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
11449 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
11450 get_AT_low_pc (die), "Length");
11454 /* A static variable; extract the symbol from DW_AT_location.
11455 Note that this code isn't currently hit, as we only emit
11456 aranges for functions (jason 9/23/99). */
11457 dw_attr_ref a = get_AT (die, DW_AT_location);
11458 dw_loc_descr_ref loc;
11460 gcc_assert (a && AT_class (a) == dw_val_class_loc);
11463 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
11465 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
11466 loc->dw_loc_oprnd1.v.val_addr, "Address");
11467 dw2_asm_output_data (DWARF2_ADDR_SIZE,
11468 get_AT_unsigned (die, DW_AT_byte_size),
11473 /* Output the terminator words. */
11474 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11475 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11478 /* Add a new entry to .debug_ranges. Return the offset at which it
11481 static unsigned int
11482 add_ranges_num (int num)
11484 unsigned int in_use = ranges_table_in_use;
11486 if (in_use == ranges_table_allocated)
11488 ranges_table_allocated += RANGES_TABLE_INCREMENT;
11489 ranges_table = GGC_RESIZEVEC (struct dw_ranges_struct, ranges_table,
11490 ranges_table_allocated);
11491 memset (ranges_table + ranges_table_in_use, 0,
11492 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
11495 ranges_table[in_use].num = num;
11496 ranges_table_in_use = in_use + 1;
11498 return in_use * 2 * DWARF2_ADDR_SIZE;
11501 /* Add a new entry to .debug_ranges corresponding to a block, or a
11502 range terminator if BLOCK is NULL. */
11504 static unsigned int
11505 add_ranges (const_tree block)
11507 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0);
11510 /* Add a new entry to .debug_ranges corresponding to a pair of
11514 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
11517 unsigned int in_use = ranges_by_label_in_use;
11518 unsigned int offset;
11520 if (in_use == ranges_by_label_allocated)
11522 ranges_by_label_allocated += RANGES_TABLE_INCREMENT;
11523 ranges_by_label = GGC_RESIZEVEC (struct dw_ranges_by_label_struct,
11525 ranges_by_label_allocated);
11526 memset (ranges_by_label + ranges_by_label_in_use, 0,
11527 RANGES_TABLE_INCREMENT
11528 * sizeof (struct dw_ranges_by_label_struct));
11531 ranges_by_label[in_use].begin = begin;
11532 ranges_by_label[in_use].end = end;
11533 ranges_by_label_in_use = in_use + 1;
11535 offset = add_ranges_num (-(int)in_use - 1);
11538 add_AT_range_list (die, DW_AT_ranges, offset);
11544 output_ranges (void)
11547 static const char *const start_fmt = "Offset %#x";
11548 const char *fmt = start_fmt;
11550 for (i = 0; i < ranges_table_in_use; i++)
11552 int block_num = ranges_table[i].num;
11556 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
11557 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
11559 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
11560 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
11562 /* If all code is in the text section, then the compilation
11563 unit base address defaults to DW_AT_low_pc, which is the
11564 base of the text section. */
11565 if (!have_multiple_function_sections)
11567 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
11568 text_section_label,
11569 fmt, i * 2 * DWARF2_ADDR_SIZE);
11570 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
11571 text_section_label, NULL);
11574 /* Otherwise, the compilation unit base address is zero,
11575 which allows us to use absolute addresses, and not worry
11576 about whether the target supports cross-section
11580 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11581 fmt, i * 2 * DWARF2_ADDR_SIZE);
11582 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
11588 /* Negative block_num stands for an index into ranges_by_label. */
11589 else if (block_num < 0)
11591 int lab_idx = - block_num - 1;
11593 if (!have_multiple_function_sections)
11595 gcc_unreachable ();
11597 /* If we ever use add_ranges_by_labels () for a single
11598 function section, all we have to do is to take out
11599 the #if 0 above. */
11600 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11601 ranges_by_label[lab_idx].begin,
11602 text_section_label,
11603 fmt, i * 2 * DWARF2_ADDR_SIZE);
11604 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11605 ranges_by_label[lab_idx].end,
11606 text_section_label, NULL);
11611 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11612 ranges_by_label[lab_idx].begin,
11613 fmt, i * 2 * DWARF2_ADDR_SIZE);
11614 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11615 ranges_by_label[lab_idx].end,
11621 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11622 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11628 /* Data structure containing information about input files. */
11631 const char *path; /* Complete file name. */
11632 const char *fname; /* File name part. */
11633 int length; /* Length of entire string. */
11634 struct dwarf_file_data * file_idx; /* Index in input file table. */
11635 int dir_idx; /* Index in directory table. */
11638 /* Data structure containing information about directories with source
11642 const char *path; /* Path including directory name. */
11643 int length; /* Path length. */
11644 int prefix; /* Index of directory entry which is a prefix. */
11645 int count; /* Number of files in this directory. */
11646 int dir_idx; /* Index of directory used as base. */
11649 /* Callback function for file_info comparison. We sort by looking at
11650 the directories in the path. */
11653 file_info_cmp (const void *p1, const void *p2)
11655 const struct file_info *const s1 = (const struct file_info *) p1;
11656 const struct file_info *const s2 = (const struct file_info *) p2;
11657 const unsigned char *cp1;
11658 const unsigned char *cp2;
11660 /* Take care of file names without directories. We need to make sure that
11661 we return consistent values to qsort since some will get confused if
11662 we return the same value when identical operands are passed in opposite
11663 orders. So if neither has a directory, return 0 and otherwise return
11664 1 or -1 depending on which one has the directory. */
11665 if ((s1->path == s1->fname || s2->path == s2->fname))
11666 return (s2->path == s2->fname) - (s1->path == s1->fname);
11668 cp1 = (const unsigned char *) s1->path;
11669 cp2 = (const unsigned char *) s2->path;
11675 /* Reached the end of the first path? If so, handle like above. */
11676 if ((cp1 == (const unsigned char *) s1->fname)
11677 || (cp2 == (const unsigned char *) s2->fname))
11678 return ((cp2 == (const unsigned char *) s2->fname)
11679 - (cp1 == (const unsigned char *) s1->fname));
11681 /* Character of current path component the same? */
11682 else if (*cp1 != *cp2)
11683 return *cp1 - *cp2;
11687 struct file_name_acquire_data
11689 struct file_info *files;
11694 /* Traversal function for the hash table. */
11697 file_name_acquire (void ** slot, void *data)
11699 struct file_name_acquire_data *fnad = (struct file_name_acquire_data *) data;
11700 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
11701 struct file_info *fi;
11704 gcc_assert (fnad->max_files >= d->emitted_number);
11706 if (! d->emitted_number)
11709 gcc_assert (fnad->max_files != fnad->used_files);
11711 fi = fnad->files + fnad->used_files++;
11713 /* Skip all leading "./". */
11715 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
11718 /* Create a new array entry. */
11720 fi->length = strlen (f);
11723 /* Search for the file name part. */
11724 f = strrchr (f, DIR_SEPARATOR);
11725 #if defined (DIR_SEPARATOR_2)
11727 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
11731 if (f == NULL || f < g)
11737 fi->fname = f == NULL ? fi->path : f + 1;
11741 /* Output the directory table and the file name table. We try to minimize
11742 the total amount of memory needed. A heuristic is used to avoid large
11743 slowdowns with many input files. */
11746 output_file_names (void)
11748 struct file_name_acquire_data fnad;
11750 struct file_info *files;
11751 struct dir_info *dirs;
11759 if (!last_emitted_file)
11761 dw2_asm_output_data (1, 0, "End directory table");
11762 dw2_asm_output_data (1, 0, "End file name table");
11766 numfiles = last_emitted_file->emitted_number;
11768 /* Allocate the various arrays we need. */
11769 files = XALLOCAVEC (struct file_info, numfiles);
11770 dirs = XALLOCAVEC (struct dir_info, numfiles);
11772 fnad.files = files;
11773 fnad.used_files = 0;
11774 fnad.max_files = numfiles;
11775 htab_traverse (file_table, file_name_acquire, &fnad);
11776 gcc_assert (fnad.used_files == fnad.max_files);
11778 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
11780 /* Find all the different directories used. */
11781 dirs[0].path = files[0].path;
11782 dirs[0].length = files[0].fname - files[0].path;
11783 dirs[0].prefix = -1;
11785 dirs[0].dir_idx = 0;
11786 files[0].dir_idx = 0;
11789 for (i = 1; i < numfiles; i++)
11790 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
11791 && memcmp (dirs[ndirs - 1].path, files[i].path,
11792 dirs[ndirs - 1].length) == 0)
11794 /* Same directory as last entry. */
11795 files[i].dir_idx = ndirs - 1;
11796 ++dirs[ndirs - 1].count;
11802 /* This is a new directory. */
11803 dirs[ndirs].path = files[i].path;
11804 dirs[ndirs].length = files[i].fname - files[i].path;
11805 dirs[ndirs].count = 1;
11806 dirs[ndirs].dir_idx = ndirs;
11807 files[i].dir_idx = ndirs;
11809 /* Search for a prefix. */
11810 dirs[ndirs].prefix = -1;
11811 for (j = 0; j < ndirs; j++)
11812 if (dirs[j].length < dirs[ndirs].length
11813 && dirs[j].length > 1
11814 && (dirs[ndirs].prefix == -1
11815 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
11816 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
11817 dirs[ndirs].prefix = j;
11822 /* Now to the actual work. We have to find a subset of the directories which
11823 allow expressing the file name using references to the directory table
11824 with the least amount of characters. We do not do an exhaustive search
11825 where we would have to check out every combination of every single
11826 possible prefix. Instead we use a heuristic which provides nearly optimal
11827 results in most cases and never is much off. */
11828 saved = XALLOCAVEC (int, ndirs);
11829 savehere = XALLOCAVEC (int, ndirs);
11831 memset (saved, '\0', ndirs * sizeof (saved[0]));
11832 for (i = 0; i < ndirs; i++)
11837 /* We can always save some space for the current directory. But this
11838 does not mean it will be enough to justify adding the directory. */
11839 savehere[i] = dirs[i].length;
11840 total = (savehere[i] - saved[i]) * dirs[i].count;
11842 for (j = i + 1; j < ndirs; j++)
11845 if (saved[j] < dirs[i].length)
11847 /* Determine whether the dirs[i] path is a prefix of the
11851 k = dirs[j].prefix;
11852 while (k != -1 && k != (int) i)
11853 k = dirs[k].prefix;
11857 /* Yes it is. We can possibly save some memory by
11858 writing the filenames in dirs[j] relative to
11860 savehere[j] = dirs[i].length;
11861 total += (savehere[j] - saved[j]) * dirs[j].count;
11866 /* Check whether we can save enough to justify adding the dirs[i]
11868 if (total > dirs[i].length + 1)
11870 /* It's worthwhile adding. */
11871 for (j = i; j < ndirs; j++)
11872 if (savehere[j] > 0)
11874 /* Remember how much we saved for this directory so far. */
11875 saved[j] = savehere[j];
11877 /* Remember the prefix directory. */
11878 dirs[j].dir_idx = i;
11883 /* Emit the directory name table. */
11884 idx_offset = dirs[0].length > 0 ? 1 : 0;
11885 for (i = 1 - idx_offset; i < ndirs; i++)
11886 dw2_asm_output_nstring (dirs[i].path,
11888 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
11889 "Directory Entry: %#x", i + idx_offset);
11891 dw2_asm_output_data (1, 0, "End directory table");
11893 /* We have to emit them in the order of emitted_number since that's
11894 used in the debug info generation. To do this efficiently we
11895 generate a back-mapping of the indices first. */
11896 backmap = XALLOCAVEC (int, numfiles);
11897 for (i = 0; i < numfiles; i++)
11898 backmap[files[i].file_idx->emitted_number - 1] = i;
11900 /* Now write all the file names. */
11901 for (i = 0; i < numfiles; i++)
11903 int file_idx = backmap[i];
11904 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
11906 #ifdef VMS_DEBUGGING_INFO
11907 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
11909 /* Setting these fields can lead to debugger miscomparisons,
11910 but VMS Debug requires them to be set correctly. */
11915 int maxfilelen = strlen (files[file_idx].path)
11916 + dirs[dir_idx].length
11917 + MAX_VMS_VERSION_LEN + 1;
11918 char *filebuf = XALLOCAVEC (char, maxfilelen);
11920 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
11921 snprintf (filebuf, maxfilelen, "%s;%d",
11922 files[file_idx].path + dirs[dir_idx].length, ver);
11924 dw2_asm_output_nstring
11925 (filebuf, -1, "File Entry: %#x", (unsigned) i + 1);
11927 /* Include directory index. */
11928 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
11930 /* Modification time. */
11931 dw2_asm_output_data_uleb128
11932 ((vms_file_stats_name (files[file_idx].path, &cdt, 0, 0, 0) == 0)
11936 /* File length in bytes. */
11937 dw2_asm_output_data_uleb128
11938 ((vms_file_stats_name (files[file_idx].path, 0, &siz, 0, 0) == 0)
11942 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
11943 "File Entry: %#x", (unsigned) i + 1);
11945 /* Include directory index. */
11946 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
11948 /* Modification time. */
11949 dw2_asm_output_data_uleb128 (0, NULL);
11951 /* File length in bytes. */
11952 dw2_asm_output_data_uleb128 (0, NULL);
11956 dw2_asm_output_data (1, 0, "End file name table");
11960 /* Output the source line number correspondence information. This
11961 information goes into the .debug_line section. */
11964 output_line_info (void)
11966 char l1[20], l2[20], p1[20], p2[20];
11967 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
11968 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
11970 unsigned n_op_args;
11971 unsigned long lt_index;
11972 unsigned long current_line;
11975 unsigned long current_file;
11976 unsigned long function;
11977 int ver = dwarf_version;
11979 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
11980 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
11981 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
11982 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
11984 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11985 dw2_asm_output_data (4, 0xffffffff,
11986 "Initial length escape value indicating 64-bit DWARF extension");
11987 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
11988 "Length of Source Line Info");
11989 ASM_OUTPUT_LABEL (asm_out_file, l1);
11991 dw2_asm_output_data (2, ver, "DWARF Version");
11992 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
11993 ASM_OUTPUT_LABEL (asm_out_file, p1);
11995 /* Define the architecture-dependent minimum instruction length (in
11996 bytes). In this implementation of DWARF, this field is used for
11997 information purposes only. Since GCC generates assembly language,
11998 we have no a priori knowledge of how many instruction bytes are
11999 generated for each source line, and therefore can use only the
12000 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
12001 commands. Accordingly, we fix this as `1', which is "correct
12002 enough" for all architectures, and don't let the target override. */
12003 dw2_asm_output_data (1, 1,
12004 "Minimum Instruction Length");
12007 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
12008 "Maximum Operations Per Instruction");
12009 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
12010 "Default is_stmt_start flag");
12011 dw2_asm_output_data (1, DWARF_LINE_BASE,
12012 "Line Base Value (Special Opcodes)");
12013 dw2_asm_output_data (1, DWARF_LINE_RANGE,
12014 "Line Range Value (Special Opcodes)");
12015 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
12016 "Special Opcode Base");
12018 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
12022 case DW_LNS_advance_pc:
12023 case DW_LNS_advance_line:
12024 case DW_LNS_set_file:
12025 case DW_LNS_set_column:
12026 case DW_LNS_fixed_advance_pc:
12034 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
12038 /* Write out the information about the files we use. */
12039 output_file_names ();
12040 ASM_OUTPUT_LABEL (asm_out_file, p2);
12042 /* We used to set the address register to the first location in the text
12043 section here, but that didn't accomplish anything since we already
12044 have a line note for the opening brace of the first function. */
12046 /* Generate the line number to PC correspondence table, encoded as
12047 a series of state machine operations. */
12051 if (cfun && in_cold_section_p)
12052 strcpy (prev_line_label, crtl->subsections.cold_section_label);
12054 strcpy (prev_line_label, text_section_label);
12055 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
12057 dw_line_info_ref line_info = &line_info_table[lt_index];
12060 /* Disable this optimization for now; GDB wants to see two line notes
12061 at the beginning of a function so it can find the end of the
12064 /* Don't emit anything for redundant notes. Just updating the
12065 address doesn't accomplish anything, because we already assume
12066 that anything after the last address is this line. */
12067 if (line_info->dw_line_num == current_line
12068 && line_info->dw_file_num == current_file)
12072 /* Emit debug info for the address of the current line.
12074 Unfortunately, we have little choice here currently, and must always
12075 use the most general form. GCC does not know the address delta
12076 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
12077 attributes which will give an upper bound on the address range. We
12078 could perhaps use length attributes to determine when it is safe to
12079 use DW_LNS_fixed_advance_pc. */
12081 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
12084 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
12085 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12086 "DW_LNS_fixed_advance_pc");
12087 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
12091 /* This can handle any delta. This takes
12092 4+DWARF2_ADDR_SIZE bytes. */
12093 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12094 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12095 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12096 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12099 strcpy (prev_line_label, line_label);
12101 /* Emit debug info for the source file of the current line, if
12102 different from the previous line. */
12103 if (line_info->dw_file_num != current_file)
12105 current_file = line_info->dw_file_num;
12106 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
12107 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
12110 /* Emit debug info for the current line number, choosing the encoding
12111 that uses the least amount of space. */
12112 if (line_info->dw_line_num != current_line)
12114 line_offset = line_info->dw_line_num - current_line;
12115 line_delta = line_offset - DWARF_LINE_BASE;
12116 current_line = line_info->dw_line_num;
12117 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
12118 /* This can handle deltas from -10 to 234, using the current
12119 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
12121 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
12122 "line %lu", current_line);
12125 /* This can handle any delta. This takes at least 4 bytes,
12126 depending on the value being encoded. */
12127 dw2_asm_output_data (1, DW_LNS_advance_line,
12128 "advance to line %lu", current_line);
12129 dw2_asm_output_data_sleb128 (line_offset, NULL);
12130 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12134 /* We still need to start a new row, so output a copy insn. */
12135 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12138 /* Emit debug info for the address of the end of the function. */
12141 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12142 "DW_LNS_fixed_advance_pc");
12143 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
12147 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12148 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12149 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12150 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
12153 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
12154 dw2_asm_output_data_uleb128 (1, NULL);
12155 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
12160 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
12162 dw_separate_line_info_ref line_info
12163 = &separate_line_info_table[lt_index];
12166 /* Don't emit anything for redundant notes. */
12167 if (line_info->dw_line_num == current_line
12168 && line_info->dw_file_num == current_file
12169 && line_info->function == function)
12173 /* Emit debug info for the address of the current line. If this is
12174 a new function, or the first line of a function, then we need
12175 to handle it differently. */
12176 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
12178 if (function != line_info->function)
12180 function = line_info->function;
12182 /* Set the address register to the first line in the function. */
12183 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12184 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12185 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12186 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12190 /* ??? See the DW_LNS_advance_pc comment above. */
12193 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12194 "DW_LNS_fixed_advance_pc");
12195 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
12199 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12200 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12201 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12202 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12206 strcpy (prev_line_label, line_label);
12208 /* Emit debug info for the source file of the current line, if
12209 different from the previous line. */
12210 if (line_info->dw_file_num != current_file)
12212 current_file = line_info->dw_file_num;
12213 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
12214 dw2_asm_output_data_uleb128 (current_file, "%lu", current_file);
12217 /* Emit debug info for the current line number, choosing the encoding
12218 that uses the least amount of space. */
12219 if (line_info->dw_line_num != current_line)
12221 line_offset = line_info->dw_line_num - current_line;
12222 line_delta = line_offset - DWARF_LINE_BASE;
12223 current_line = line_info->dw_line_num;
12224 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
12225 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
12226 "line %lu", current_line);
12229 dw2_asm_output_data (1, DW_LNS_advance_line,
12230 "advance to line %lu", current_line);
12231 dw2_asm_output_data_sleb128 (line_offset, NULL);
12232 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12236 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
12244 /* If we're done with a function, end its sequence. */
12245 if (lt_index == separate_line_info_table_in_use
12246 || separate_line_info_table[lt_index].function != function)
12251 /* Emit debug info for the address of the end of the function. */
12252 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
12255 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
12256 "DW_LNS_fixed_advance_pc");
12257 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
12261 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12262 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12263 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12264 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12267 /* Output the marker for the end of this sequence. */
12268 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
12269 dw2_asm_output_data_uleb128 (1, NULL);
12270 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
12274 /* Output the marker for the end of the line number info. */
12275 ASM_OUTPUT_LABEL (asm_out_file, l2);
12278 /* Return the size of the .debug_dcall table for the compilation unit. */
12280 static unsigned long
12281 size_of_dcall_table (void)
12283 unsigned long size;
12286 tree last_poc_decl = NULL;
12288 /* Header: version + debug info section pointer + pointer size. */
12289 size = 2 + DWARF_OFFSET_SIZE + 1;
12291 /* Each entry: code label + DIE offset. */
12292 for (i = 0; VEC_iterate (dcall_entry, dcall_table, i, p); i++)
12294 gcc_assert (p->targ_die != NULL);
12295 /* Insert a "from" entry when the point-of-call DIE offset changes. */
12296 if (p->poc_decl != last_poc_decl)
12298 dw_die_ref poc_die = lookup_decl_die (p->poc_decl);
12299 gcc_assert (poc_die);
12300 last_poc_decl = p->poc_decl;
12302 size += (DWARF_OFFSET_SIZE
12303 + size_of_uleb128 (poc_die->die_offset));
12305 size += DWARF_OFFSET_SIZE + size_of_uleb128 (p->targ_die->die_offset);
12311 /* Output the direct call table used to disambiguate PC values when
12312 identical function have been merged. */
12315 output_dcall_table (void)
12318 unsigned long dcall_length = size_of_dcall_table ();
12320 char poc_label[MAX_ARTIFICIAL_LABEL_BYTES];
12321 tree last_poc_decl = NULL;
12323 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
12324 dw2_asm_output_data (4, 0xffffffff,
12325 "Initial length escape value indicating 64-bit DWARF extension");
12326 dw2_asm_output_data (DWARF_OFFSET_SIZE, dcall_length,
12327 "Length of Direct Call Table");
12328 dw2_asm_output_data (2, 4, "Version number");
12329 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
12330 debug_info_section,
12331 "Offset of Compilation Unit Info");
12332 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
12334 for (i = 0; VEC_iterate (dcall_entry, dcall_table, i, p); i++)
12336 /* Insert a "from" entry when the point-of-call DIE offset changes. */
12337 if (p->poc_decl != last_poc_decl)
12339 dw_die_ref poc_die = lookup_decl_die (p->poc_decl);
12340 last_poc_decl = p->poc_decl;
12343 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, "New caller");
12344 dw2_asm_output_data_uleb128 (poc_die->die_offset,
12345 "Caller DIE offset");
12348 ASM_GENERATE_INTERNAL_LABEL (poc_label, "LPOC", p->poc_label_num);
12349 dw2_asm_output_addr (DWARF_OFFSET_SIZE, poc_label, "Point of call");
12350 dw2_asm_output_data_uleb128 (p->targ_die->die_offset,
12351 "Callee DIE offset");
12355 /* Return the size of the .debug_vcall table for the compilation unit. */
12357 static unsigned long
12358 size_of_vcall_table (void)
12360 unsigned long size;
12364 /* Header: version + pointer size. */
12367 /* Each entry: code label + vtable slot index. */
12368 for (i = 0; VEC_iterate (vcall_entry, vcall_table, i, p); i++)
12369 size += DWARF_OFFSET_SIZE + size_of_uleb128 (p->vtable_slot);
12374 /* Output the virtual call table used to disambiguate PC values when
12375 identical function have been merged. */
12378 output_vcall_table (void)
12381 unsigned long vcall_length = size_of_vcall_table ();
12383 char poc_label[MAX_ARTIFICIAL_LABEL_BYTES];
12385 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
12386 dw2_asm_output_data (4, 0xffffffff,
12387 "Initial length escape value indicating 64-bit DWARF extension");
12388 dw2_asm_output_data (DWARF_OFFSET_SIZE, vcall_length,
12389 "Length of Virtual Call Table");
12390 dw2_asm_output_data (2, 4, "Version number");
12391 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
12393 for (i = 0; VEC_iterate (vcall_entry, vcall_table, i, p); i++)
12395 ASM_GENERATE_INTERNAL_LABEL (poc_label, "LPOC", p->poc_label_num);
12396 dw2_asm_output_addr (DWARF_OFFSET_SIZE, poc_label, "Point of call");
12397 dw2_asm_output_data_uleb128 (p->vtable_slot, "Vtable slot");
12401 /* Given a pointer to a tree node for some base type, return a pointer to
12402 a DIE that describes the given type.
12404 This routine must only be called for GCC type nodes that correspond to
12405 Dwarf base (fundamental) types. */
12408 base_type_die (tree type)
12410 dw_die_ref base_type_result;
12411 enum dwarf_type encoding;
12413 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
12416 /* If this is a subtype that should not be emitted as a subrange type,
12417 use the base type. See subrange_type_for_debug_p. */
12418 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
12419 type = TREE_TYPE (type);
12421 switch (TREE_CODE (type))
12424 if ((dwarf_version >= 4 || !dwarf_strict)
12425 && TYPE_NAME (type)
12426 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12427 && DECL_IS_BUILTIN (TYPE_NAME (type))
12428 && DECL_NAME (TYPE_NAME (type)))
12430 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
12431 if (strcmp (name, "char16_t") == 0
12432 || strcmp (name, "char32_t") == 0)
12434 encoding = DW_ATE_UTF;
12438 if (TYPE_STRING_FLAG (type))
12440 if (TYPE_UNSIGNED (type))
12441 encoding = DW_ATE_unsigned_char;
12443 encoding = DW_ATE_signed_char;
12445 else if (TYPE_UNSIGNED (type))
12446 encoding = DW_ATE_unsigned;
12448 encoding = DW_ATE_signed;
12452 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
12454 if (dwarf_version >= 3 || !dwarf_strict)
12455 encoding = DW_ATE_decimal_float;
12457 encoding = DW_ATE_lo_user;
12460 encoding = DW_ATE_float;
12463 case FIXED_POINT_TYPE:
12464 if (!(dwarf_version >= 3 || !dwarf_strict))
12465 encoding = DW_ATE_lo_user;
12466 else if (TYPE_UNSIGNED (type))
12467 encoding = DW_ATE_unsigned_fixed;
12469 encoding = DW_ATE_signed_fixed;
12472 /* Dwarf2 doesn't know anything about complex ints, so use
12473 a user defined type for it. */
12475 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
12476 encoding = DW_ATE_complex_float;
12478 encoding = DW_ATE_lo_user;
12482 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12483 encoding = DW_ATE_boolean;
12487 /* No other TREE_CODEs are Dwarf fundamental types. */
12488 gcc_unreachable ();
12491 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
12493 add_AT_unsigned (base_type_result, DW_AT_byte_size,
12494 int_size_in_bytes (type));
12495 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
12497 return base_type_result;
12500 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12501 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12504 is_base_type (tree type)
12506 switch (TREE_CODE (type))
12512 case FIXED_POINT_TYPE:
12520 case QUAL_UNION_TYPE:
12521 case ENUMERAL_TYPE:
12522 case FUNCTION_TYPE:
12525 case REFERENCE_TYPE:
12532 gcc_unreachable ();
12538 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12539 node, return the size in bits for the type if it is a constant, or else
12540 return the alignment for the type if the type's size is not constant, or
12541 else return BITS_PER_WORD if the type actually turns out to be an
12542 ERROR_MARK node. */
12544 static inline unsigned HOST_WIDE_INT
12545 simple_type_size_in_bits (const_tree type)
12547 if (TREE_CODE (type) == ERROR_MARK)
12548 return BITS_PER_WORD;
12549 else if (TYPE_SIZE (type) == NULL_TREE)
12551 else if (host_integerp (TYPE_SIZE (type), 1))
12552 return tree_low_cst (TYPE_SIZE (type), 1);
12554 return TYPE_ALIGN (type);
12557 /* Similarly, but return a double_int instead of UHWI. */
12559 static inline double_int
12560 double_int_type_size_in_bits (const_tree type)
12562 if (TREE_CODE (type) == ERROR_MARK)
12563 return uhwi_to_double_int (BITS_PER_WORD);
12564 else if (TYPE_SIZE (type) == NULL_TREE)
12565 return double_int_zero;
12566 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
12567 return tree_to_double_int (TYPE_SIZE (type));
12569 return uhwi_to_double_int (TYPE_ALIGN (type));
12572 /* Given a pointer to a tree node for a subrange type, return a pointer
12573 to a DIE that describes the given type. */
12576 subrange_type_die (tree type, tree low, tree high, dw_die_ref context_die)
12578 dw_die_ref subrange_die;
12579 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
12581 if (context_die == NULL)
12582 context_die = comp_unit_die;
12584 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
12586 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
12588 /* The size of the subrange type and its base type do not match,
12589 so we need to generate a size attribute for the subrange type. */
12590 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
12594 add_bound_info (subrange_die, DW_AT_lower_bound, low);
12596 add_bound_info (subrange_die, DW_AT_upper_bound, high);
12598 return subrange_die;
12601 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
12602 entry that chains various modifiers in front of the given type. */
12605 modified_type_die (tree type, int is_const_type, int is_volatile_type,
12606 dw_die_ref context_die)
12608 enum tree_code code = TREE_CODE (type);
12609 dw_die_ref mod_type_die;
12610 dw_die_ref sub_die = NULL;
12611 tree item_type = NULL;
12612 tree qualified_type;
12613 tree name, low, high;
12615 if (code == ERROR_MARK)
12618 /* See if we already have the appropriately qualified variant of
12621 = get_qualified_type (type,
12622 ((is_const_type ? TYPE_QUAL_CONST : 0)
12623 | (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
12625 if (qualified_type == sizetype
12626 && TYPE_NAME (qualified_type)
12627 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
12629 #ifdef ENABLE_CHECKING
12630 gcc_assert (TREE_CODE (TREE_TYPE (TYPE_NAME (qualified_type)))
12632 && TYPE_PRECISION (TREE_TYPE (TYPE_NAME (qualified_type)))
12633 == TYPE_PRECISION (qualified_type)
12634 && TYPE_UNSIGNED (TREE_TYPE (TYPE_NAME (qualified_type)))
12635 == TYPE_UNSIGNED (qualified_type));
12637 qualified_type = TREE_TYPE (TYPE_NAME (qualified_type));
12640 /* If we do, then we can just use its DIE, if it exists. */
12641 if (qualified_type)
12643 mod_type_die = lookup_type_die (qualified_type);
12645 return mod_type_die;
12648 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
12650 /* Handle C typedef types. */
12651 if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name)
12652 && !DECL_ARTIFICIAL (name))
12654 tree dtype = TREE_TYPE (name);
12656 if (qualified_type == dtype)
12658 /* For a named type, use the typedef. */
12659 gen_type_die (qualified_type, context_die);
12660 return lookup_type_die (qualified_type);
12662 else if (is_const_type < TYPE_READONLY (dtype)
12663 || is_volatile_type < TYPE_VOLATILE (dtype)
12664 || (is_const_type <= TYPE_READONLY (dtype)
12665 && is_volatile_type <= TYPE_VOLATILE (dtype)
12666 && DECL_ORIGINAL_TYPE (name) != type))
12667 /* cv-unqualified version of named type. Just use the unnamed
12668 type to which it refers. */
12669 return modified_type_die (DECL_ORIGINAL_TYPE (name),
12670 is_const_type, is_volatile_type,
12672 /* Else cv-qualified version of named type; fall through. */
12677 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
12678 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
12680 else if (is_volatile_type)
12682 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
12683 sub_die = modified_type_die (type, 0, 0, context_die);
12685 else if (code == POINTER_TYPE)
12687 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
12688 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
12689 simple_type_size_in_bits (type) / BITS_PER_UNIT);
12690 item_type = TREE_TYPE (type);
12691 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
12692 add_AT_unsigned (mod_type_die, DW_AT_address_class,
12693 TYPE_ADDR_SPACE (item_type));
12695 else if (code == REFERENCE_TYPE)
12697 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
12698 mod_type_die = new_die (DW_TAG_rvalue_reference_type, comp_unit_die,
12701 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
12702 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
12703 simple_type_size_in_bits (type) / BITS_PER_UNIT);
12704 item_type = TREE_TYPE (type);
12705 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type)))
12706 add_AT_unsigned (mod_type_die, DW_AT_address_class,
12707 TYPE_ADDR_SPACE (item_type));
12709 else if (code == INTEGER_TYPE
12710 && TREE_TYPE (type) != NULL_TREE
12711 && subrange_type_for_debug_p (type, &low, &high))
12713 mod_type_die = subrange_type_die (type, low, high, context_die);
12714 item_type = TREE_TYPE (type);
12716 else if (is_base_type (type))
12717 mod_type_die = base_type_die (type);
12720 gen_type_die (type, context_die);
12722 /* We have to get the type_main_variant here (and pass that to the
12723 `lookup_type_die' routine) because the ..._TYPE node we have
12724 might simply be a *copy* of some original type node (where the
12725 copy was created to help us keep track of typedef names) and
12726 that copy might have a different TYPE_UID from the original
12728 if (TREE_CODE (type) != VECTOR_TYPE)
12729 return lookup_type_die (type_main_variant (type));
12731 /* Vectors have the debugging information in the type,
12732 not the main variant. */
12733 return lookup_type_die (type);
12736 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
12737 don't output a DW_TAG_typedef, since there isn't one in the
12738 user's program; just attach a DW_AT_name to the type.
12739 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
12740 if the base type already has the same name. */
12742 && ((TREE_CODE (name) != TYPE_DECL
12743 && (qualified_type == TYPE_MAIN_VARIANT (type)
12744 || (!is_const_type && !is_volatile_type)))
12745 || (TREE_CODE (name) == TYPE_DECL
12746 && TREE_TYPE (name) == qualified_type
12747 && DECL_NAME (name))))
12749 if (TREE_CODE (name) == TYPE_DECL)
12750 /* Could just call add_name_and_src_coords_attributes here,
12751 but since this is a builtin type it doesn't have any
12752 useful source coordinates anyway. */
12753 name = DECL_NAME (name);
12754 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
12756 /* This probably indicates a bug. */
12757 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
12758 add_name_attribute (mod_type_die, "__unknown__");
12760 if (qualified_type)
12761 equate_type_number_to_die (qualified_type, mod_type_die);
12764 /* We must do this after the equate_type_number_to_die call, in case
12765 this is a recursive type. This ensures that the modified_type_die
12766 recursion will terminate even if the type is recursive. Recursive
12767 types are possible in Ada. */
12768 sub_die = modified_type_die (item_type,
12769 TYPE_READONLY (item_type),
12770 TYPE_VOLATILE (item_type),
12773 if (sub_die != NULL)
12774 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
12776 return mod_type_die;
12779 /* Generate DIEs for the generic parameters of T.
12780 T must be either a generic type or a generic function.
12781 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
12784 gen_generic_params_dies (tree t)
12788 dw_die_ref die = NULL;
12790 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
12794 die = lookup_type_die (t);
12795 else if (DECL_P (t))
12796 die = lookup_decl_die (t);
12800 parms = lang_hooks.get_innermost_generic_parms (t);
12802 /* T has no generic parameter. It means T is neither a generic type
12803 or function. End of story. */
12806 parms_num = TREE_VEC_LENGTH (parms);
12807 args = lang_hooks.get_innermost_generic_args (t);
12808 for (i = 0; i < parms_num; i++)
12810 tree parm, arg, arg_pack_elems;
12812 parm = TREE_VEC_ELT (parms, i);
12813 arg = TREE_VEC_ELT (args, i);
12814 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
12815 gcc_assert (parm && TREE_VALUE (parm) && arg);
12817 if (parm && TREE_VALUE (parm) && arg)
12819 /* If PARM represents a template parameter pack,
12820 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
12821 by DW_TAG_template_*_parameter DIEs for the argument
12822 pack elements of ARG. Note that ARG would then be
12823 an argument pack. */
12824 if (arg_pack_elems)
12825 template_parameter_pack_die (TREE_VALUE (parm),
12829 generic_parameter_die (TREE_VALUE (parm), arg,
12830 true /* Emit DW_AT_name */, die);
12835 /* Create and return a DIE for PARM which should be
12836 the representation of a generic type parameter.
12837 For instance, in the C++ front end, PARM would be a template parameter.
12838 ARG is the argument to PARM.
12839 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
12841 PARENT_DIE is the parent DIE which the new created DIE should be added to,
12842 as a child node. */
12845 generic_parameter_die (tree parm, tree arg,
12847 dw_die_ref parent_die)
12849 dw_die_ref tmpl_die = NULL;
12850 const char *name = NULL;
12852 if (!parm || !DECL_NAME (parm) || !arg)
12855 /* We support non-type generic parameters and arguments,
12856 type generic parameters and arguments, as well as
12857 generic generic parameters (a.k.a. template template parameters in C++)
12859 if (TREE_CODE (parm) == PARM_DECL)
12860 /* PARM is a nontype generic parameter */
12861 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
12862 else if (TREE_CODE (parm) == TYPE_DECL)
12863 /* PARM is a type generic parameter. */
12864 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
12865 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
12866 /* PARM is a generic generic parameter.
12867 Its DIE is a GNU extension. It shall have a
12868 DW_AT_name attribute to represent the name of the template template
12869 parameter, and a DW_AT_GNU_template_name attribute to represent the
12870 name of the template template argument. */
12871 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
12874 gcc_unreachable ();
12880 /* If PARM is a generic parameter pack, it means we are
12881 emitting debug info for a template argument pack element.
12882 In other terms, ARG is a template argument pack element.
12883 In that case, we don't emit any DW_AT_name attribute for
12887 name = IDENTIFIER_POINTER (DECL_NAME (parm));
12889 add_AT_string (tmpl_die, DW_AT_name, name);
12892 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
12894 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
12895 TMPL_DIE should have a child DW_AT_type attribute that is set
12896 to the type of the argument to PARM, which is ARG.
12897 If PARM is a type generic parameter, TMPL_DIE should have a
12898 child DW_AT_type that is set to ARG. */
12899 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
12900 add_type_attribute (tmpl_die, tmpl_type, 0,
12901 TREE_THIS_VOLATILE (tmpl_type),
12906 /* So TMPL_DIE is a DIE representing a
12907 a generic generic template parameter, a.k.a template template
12908 parameter in C++ and arg is a template. */
12910 /* The DW_AT_GNU_template_name attribute of the DIE must be set
12911 to the name of the argument. */
12912 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
12914 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
12917 if (TREE_CODE (parm) == PARM_DECL)
12918 /* So PARM is a non-type generic parameter.
12919 DWARF3 5.6.8 says we must set a DW_AT_const_value child
12920 attribute of TMPL_DIE which value represents the value
12922 We must be careful here:
12923 The value of ARG might reference some function decls.
12924 We might currently be emitting debug info for a generic
12925 type and types are emitted before function decls, we don't
12926 know if the function decls referenced by ARG will actually be
12927 emitted after cgraph computations.
12928 So must defer the generation of the DW_AT_const_value to
12929 after cgraph is ready. */
12930 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
12936 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
12937 PARM_PACK must be a template parameter pack. The returned DIE
12938 will be child DIE of PARENT_DIE. */
12941 template_parameter_pack_die (tree parm_pack,
12942 tree parm_pack_args,
12943 dw_die_ref parent_die)
12948 gcc_assert (parent_die && parm_pack);
12950 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
12951 add_name_and_src_coords_attributes (die, parm_pack);
12952 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
12953 generic_parameter_die (parm_pack,
12954 TREE_VEC_ELT (parm_pack_args, j),
12955 false /* Don't emit DW_AT_name */,
12960 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
12961 an enumerated type. */
12964 type_is_enum (const_tree type)
12966 return TREE_CODE (type) == ENUMERAL_TYPE;
12969 /* Return the DBX register number described by a given RTL node. */
12971 static unsigned int
12972 dbx_reg_number (const_rtx rtl)
12974 unsigned regno = REGNO (rtl);
12976 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
12978 #ifdef LEAF_REG_REMAP
12979 if (current_function_uses_only_leaf_regs)
12981 int leaf_reg = LEAF_REG_REMAP (regno);
12982 if (leaf_reg != -1)
12983 regno = (unsigned) leaf_reg;
12987 return DBX_REGISTER_NUMBER (regno);
12990 /* Optionally add a DW_OP_piece term to a location description expression.
12991 DW_OP_piece is only added if the location description expression already
12992 doesn't end with DW_OP_piece. */
12995 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
12997 dw_loc_descr_ref loc;
12999 if (*list_head != NULL)
13001 /* Find the end of the chain. */
13002 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
13005 if (loc->dw_loc_opc != DW_OP_piece)
13006 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
13010 /* Return a location descriptor that designates a machine register or
13011 zero if there is none. */
13013 static dw_loc_descr_ref
13014 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
13018 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
13021 /* We only use "frame base" when we're sure we're talking about the
13022 post-prologue local stack frame. We do this by *not* running
13023 register elimination until this point, and recognizing the special
13024 argument pointer and soft frame pointer rtx's.
13025 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13026 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
13027 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
13029 dw_loc_descr_ref result = NULL;
13031 if (dwarf_version >= 4 || !dwarf_strict)
13033 result = mem_loc_descriptor (rtl, VOIDmode, initialized);
13035 add_loc_descr (&result,
13036 new_loc_descr (DW_OP_stack_value, 0, 0));
13041 regs = targetm.dwarf_register_span (rtl);
13043 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
13044 return multiple_reg_loc_descriptor (rtl, regs, initialized);
13046 return one_reg_loc_descriptor (dbx_reg_number (rtl), initialized);
13049 /* Return a location descriptor that designates a machine register for
13050 a given hard register number. */
13052 static dw_loc_descr_ref
13053 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
13055 dw_loc_descr_ref reg_loc_descr;
13059 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
13061 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
13063 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13064 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13066 return reg_loc_descr;
13069 /* Given an RTL of a register, return a location descriptor that
13070 designates a value that spans more than one register. */
13072 static dw_loc_descr_ref
13073 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
13074 enum var_init_status initialized)
13076 int nregs, size, i;
13078 dw_loc_descr_ref loc_result = NULL;
13081 #ifdef LEAF_REG_REMAP
13082 if (current_function_uses_only_leaf_regs)
13084 int leaf_reg = LEAF_REG_REMAP (reg);
13085 if (leaf_reg != -1)
13086 reg = (unsigned) leaf_reg;
13089 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
13090 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
13092 /* Simple, contiguous registers. */
13093 if (regs == NULL_RTX)
13095 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
13100 dw_loc_descr_ref t;
13102 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
13103 VAR_INIT_STATUS_INITIALIZED);
13104 add_loc_descr (&loc_result, t);
13105 add_loc_descr_op_piece (&loc_result, size);
13111 /* Now onto stupid register sets in non contiguous locations. */
13113 gcc_assert (GET_CODE (regs) == PARALLEL);
13115 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
13118 for (i = 0; i < XVECLEN (regs, 0); ++i)
13120 dw_loc_descr_ref t;
13122 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)),
13123 VAR_INIT_STATUS_INITIALIZED);
13124 add_loc_descr (&loc_result, t);
13125 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
13126 add_loc_descr_op_piece (&loc_result, size);
13129 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13130 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13134 #endif /* DWARF2_DEBUGGING_INFO */
13136 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
13138 /* Return a location descriptor that designates a constant. */
13140 static dw_loc_descr_ref
13141 int_loc_descriptor (HOST_WIDE_INT i)
13143 enum dwarf_location_atom op;
13145 /* Pick the smallest representation of a constant, rather than just
13146 defaulting to the LEB encoding. */
13150 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
13151 else if (i <= 0xff)
13152 op = DW_OP_const1u;
13153 else if (i <= 0xffff)
13154 op = DW_OP_const2u;
13155 else if (HOST_BITS_PER_WIDE_INT == 32
13156 || i <= 0xffffffff)
13157 op = DW_OP_const4u;
13164 op = DW_OP_const1s;
13165 else if (i >= -0x8000)
13166 op = DW_OP_const2s;
13167 else if (HOST_BITS_PER_WIDE_INT == 32
13168 || i >= -0x80000000)
13169 op = DW_OP_const4s;
13174 return new_loc_descr (op, i, 0);
13178 #ifdef DWARF2_DEBUGGING_INFO
13179 /* Return loc description representing "address" of integer value.
13180 This can appear only as toplevel expression. */
13182 static dw_loc_descr_ref
13183 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
13186 dw_loc_descr_ref loc_result = NULL;
13188 if (!(dwarf_version >= 4 || !dwarf_strict))
13195 else if (i <= 0xff)
13197 else if (i <= 0xffff)
13199 else if (HOST_BITS_PER_WIDE_INT == 32
13200 || i <= 0xffffffff)
13203 litsize = 1 + size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
13209 else if (i >= -0x8000)
13211 else if (HOST_BITS_PER_WIDE_INT == 32
13212 || i >= -0x80000000)
13215 litsize = 1 + size_of_sleb128 (i);
13217 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
13218 is more compact. For DW_OP_stack_value we need:
13219 litsize + 1 (DW_OP_stack_value)
13220 and for DW_OP_implicit_value:
13221 1 (DW_OP_implicit_value) + 1 (length) + size. */
13222 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
13224 loc_result = int_loc_descriptor (i);
13225 add_loc_descr (&loc_result,
13226 new_loc_descr (DW_OP_stack_value, 0, 0));
13230 loc_result = new_loc_descr (DW_OP_implicit_value,
13232 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
13233 loc_result->dw_loc_oprnd2.v.val_int = i;
13237 /* Return a location descriptor that designates a base+offset location. */
13239 static dw_loc_descr_ref
13240 based_loc_descr (rtx reg, HOST_WIDE_INT offset,
13241 enum var_init_status initialized)
13243 unsigned int regno;
13244 dw_loc_descr_ref result;
13245 dw_fde_ref fde = current_fde ();
13247 /* We only use "frame base" when we're sure we're talking about the
13248 post-prologue local stack frame. We do this by *not* running
13249 register elimination until this point, and recognizing the special
13250 argument pointer and soft frame pointer rtx's. */
13251 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
13253 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
13257 if (GET_CODE (elim) == PLUS)
13259 offset += INTVAL (XEXP (elim, 1));
13260 elim = XEXP (elim, 0);
13262 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
13263 && (elim == hard_frame_pointer_rtx
13264 || elim == stack_pointer_rtx))
13265 || elim == (frame_pointer_needed
13266 ? hard_frame_pointer_rtx
13267 : stack_pointer_rtx));
13269 /* If drap register is used to align stack, use frame
13270 pointer + offset to access stack variables. If stack
13271 is aligned without drap, use stack pointer + offset to
13272 access stack variables. */
13273 if (crtl->stack_realign_tried
13274 && reg == frame_pointer_rtx)
13277 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
13278 ? HARD_FRAME_POINTER_REGNUM
13279 : STACK_POINTER_REGNUM);
13280 return new_reg_loc_descr (base_reg, offset);
13283 offset += frame_pointer_fb_offset;
13284 return new_loc_descr (DW_OP_fbreg, offset, 0);
13289 && (fde->drap_reg == REGNO (reg)
13290 || fde->vdrap_reg == REGNO (reg)))
13292 /* Use cfa+offset to represent the location of arguments passed
13293 on the stack when drap is used to align stack.
13294 Only do this when not optimizing, for optimized code var-tracking
13295 is supposed to track where the arguments live and the register
13296 used as vdrap or drap in some spot might be used for something
13297 else in other part of the routine. */
13298 return new_loc_descr (DW_OP_fbreg, offset, 0);
13301 regno = dbx_reg_number (reg);
13303 result = new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + regno),
13306 result = new_loc_descr (DW_OP_bregx, regno, offset);
13308 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13309 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13314 /* Return true if this RTL expression describes a base+offset calculation. */
13317 is_based_loc (const_rtx rtl)
13319 return (GET_CODE (rtl) == PLUS
13320 && ((REG_P (XEXP (rtl, 0))
13321 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
13322 && CONST_INT_P (XEXP (rtl, 1)))));
13325 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
13328 static dw_loc_descr_ref
13329 tls_mem_loc_descriptor (rtx mem)
13332 dw_loc_descr_ref loc_result;
13334 if (MEM_EXPR (mem) == NULL_TREE || MEM_OFFSET (mem) == NULL_RTX)
13337 base = get_base_address (MEM_EXPR (mem));
13339 || TREE_CODE (base) != VAR_DECL
13340 || !DECL_THREAD_LOCAL_P (base))
13343 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1);
13344 if (loc_result == NULL)
13347 if (INTVAL (MEM_OFFSET (mem)))
13348 loc_descr_plus_const (&loc_result, INTVAL (MEM_OFFSET (mem)));
13353 /* Output debug info about reason why we failed to expand expression as dwarf
13357 expansion_failed (tree expr, rtx rtl, char const *reason)
13359 if (dump_file && (dump_flags & TDF_DETAILS))
13361 fprintf (dump_file, "Failed to expand as dwarf: ");
13363 print_generic_expr (dump_file, expr, dump_flags);
13366 fprintf (dump_file, "\n");
13367 print_rtl (dump_file, rtl);
13369 fprintf (dump_file, "\nReason: %s\n", reason);
13373 /* Helper function for const_ok_for_output, called either directly
13374 or via for_each_rtx. */
13377 const_ok_for_output_1 (rtx *rtlp, void *data ATTRIBUTE_UNUSED)
13381 if (GET_CODE (rtl) == UNSPEC)
13383 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
13384 we can't express it in the debug info. */
13385 #ifdef ENABLE_CHECKING
13386 inform (current_function_decl
13387 ? DECL_SOURCE_LOCATION (current_function_decl)
13388 : UNKNOWN_LOCATION,
13389 "non-delegitimized UNSPEC %d found in variable location",
13392 expansion_failed (NULL_TREE, rtl,
13393 "UNSPEC hasn't been delegitimized.\n");
13397 if (GET_CODE (rtl) != SYMBOL_REF)
13400 if (CONSTANT_POOL_ADDRESS_P (rtl))
13403 get_pool_constant_mark (rtl, &marked);
13404 /* If all references to this pool constant were optimized away,
13405 it was not output and thus we can't represent it. */
13408 expansion_failed (NULL_TREE, rtl,
13409 "Constant was removed from constant pool.\n");
13414 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
13417 /* Avoid references to external symbols in debug info, on several targets
13418 the linker might even refuse to link when linking a shared library,
13419 and in many other cases the relocations for .debug_info/.debug_loc are
13420 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
13421 to be defined within the same shared library or executable are fine. */
13422 if (SYMBOL_REF_EXTERNAL_P (rtl))
13424 tree decl = SYMBOL_REF_DECL (rtl);
13426 if (decl == NULL || !targetm.binds_local_p (decl))
13428 expansion_failed (NULL_TREE, rtl,
13429 "Symbol not defined in current TU.\n");
13437 /* Return true if constant RTL can be emitted in DW_OP_addr or
13438 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
13439 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
13442 const_ok_for_output (rtx rtl)
13444 if (GET_CODE (rtl) == SYMBOL_REF)
13445 return const_ok_for_output_1 (&rtl, NULL) == 0;
13447 if (GET_CODE (rtl) == CONST)
13448 return for_each_rtx (&XEXP (rtl, 0), const_ok_for_output_1, NULL) == 0;
13453 /* The following routine converts the RTL for a variable or parameter
13454 (resident in memory) into an equivalent Dwarf representation of a
13455 mechanism for getting the address of that same variable onto the top of a
13456 hypothetical "address evaluation" stack.
13458 When creating memory location descriptors, we are effectively transforming
13459 the RTL for a memory-resident object into its Dwarf postfix expression
13460 equivalent. This routine recursively descends an RTL tree, turning
13461 it into Dwarf postfix code as it goes.
13463 MODE is the mode of the memory reference, needed to handle some
13464 autoincrement addressing modes.
13466 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
13467 location list for RTL.
13469 Return 0 if we can't represent the location. */
13471 static dw_loc_descr_ref
13472 mem_loc_descriptor (rtx rtl, enum machine_mode mode,
13473 enum var_init_status initialized)
13475 dw_loc_descr_ref mem_loc_result = NULL;
13476 enum dwarf_location_atom op;
13477 dw_loc_descr_ref op0, op1;
13479 /* Note that for a dynamically sized array, the location we will generate a
13480 description of here will be the lowest numbered location which is
13481 actually within the array. That's *not* necessarily the same as the
13482 zeroth element of the array. */
13484 rtl = targetm.delegitimize_address (rtl);
13486 switch (GET_CODE (rtl))
13491 return mem_loc_descriptor (XEXP (rtl, 0), mode, initialized);
13494 /* The case of a subreg may arise when we have a local (register)
13495 variable or a formal (register) parameter which doesn't quite fill
13496 up an entire register. For now, just assume that it is
13497 legitimate to make the Dwarf info refer to the whole register which
13498 contains the given subreg. */
13499 if (!subreg_lowpart_p (rtl))
13501 rtl = SUBREG_REG (rtl);
13502 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
13504 if (GET_MODE_CLASS (GET_MODE (rtl)) != MODE_INT)
13506 mem_loc_result = mem_loc_descriptor (rtl, mode, initialized);
13510 /* Whenever a register number forms a part of the description of the
13511 method for calculating the (dynamic) address of a memory resident
13512 object, DWARF rules require the register number be referred to as
13513 a "base register". This distinction is not based in any way upon
13514 what category of register the hardware believes the given register
13515 belongs to. This is strictly DWARF terminology we're dealing with
13516 here. Note that in cases where the location of a memory-resident
13517 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
13518 OP_CONST (0)) the actual DWARF location descriptor that we generate
13519 may just be OP_BASEREG (basereg). This may look deceptively like
13520 the object in question was allocated to a register (rather than in
13521 memory) so DWARF consumers need to be aware of the subtle
13522 distinction between OP_REG and OP_BASEREG. */
13523 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
13524 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
13525 else if (stack_realign_drap
13527 && crtl->args.internal_arg_pointer == rtl
13528 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
13530 /* If RTL is internal_arg_pointer, which has been optimized
13531 out, use DRAP instead. */
13532 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
13533 VAR_INIT_STATUS_INITIALIZED);
13539 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13540 VAR_INIT_STATUS_INITIALIZED);
13545 int shift = DWARF2_ADDR_SIZE
13546 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
13547 shift *= BITS_PER_UNIT;
13548 if (GET_CODE (rtl) == SIGN_EXTEND)
13552 mem_loc_result = op0;
13553 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
13554 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
13555 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
13556 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13561 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
13562 VAR_INIT_STATUS_INITIALIZED);
13563 if (mem_loc_result == NULL)
13564 mem_loc_result = tls_mem_loc_descriptor (rtl);
13565 if (mem_loc_result != 0)
13567 if (GET_MODE_SIZE (GET_MODE (rtl)) > DWARF2_ADDR_SIZE)
13569 expansion_failed (NULL_TREE, rtl, "DWARF address size mismatch");
13572 else if (GET_MODE_SIZE (GET_MODE (rtl)) == DWARF2_ADDR_SIZE)
13573 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
13575 add_loc_descr (&mem_loc_result,
13576 new_loc_descr (DW_OP_deref_size,
13577 GET_MODE_SIZE (GET_MODE (rtl)), 0));
13581 rtx new_rtl = avoid_constant_pool_reference (rtl);
13582 if (new_rtl != rtl)
13583 return mem_loc_descriptor (new_rtl, mode, initialized);
13588 rtl = XEXP (rtl, 1);
13590 /* ... fall through ... */
13593 /* Some ports can transform a symbol ref into a label ref, because
13594 the symbol ref is too far away and has to be dumped into a constant
13598 if (GET_CODE (rtl) == SYMBOL_REF
13599 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
13601 dw_loc_descr_ref temp;
13603 /* If this is not defined, we have no way to emit the data. */
13604 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
13607 /* We used to emit DW_OP_addr here, but that's wrong, since
13608 DW_OP_addr should be relocated by the debug info consumer,
13609 while DW_OP_GNU_push_tls_address operand should not. */
13610 temp = new_loc_descr (DWARF2_ADDR_SIZE == 4
13611 ? DW_OP_const4u : DW_OP_const8u, 0, 0);
13612 temp->dw_loc_oprnd1.val_class = dw_val_class_addr;
13613 temp->dw_loc_oprnd1.v.val_addr = rtl;
13614 temp->dtprel = true;
13616 mem_loc_result = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
13617 add_loc_descr (&mem_loc_result, temp);
13622 if (!const_ok_for_output (rtl))
13626 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
13627 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
13628 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
13629 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
13635 expansion_failed (NULL_TREE, rtl,
13636 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
13640 /* Extract the PLUS expression nested inside and fall into
13641 PLUS code below. */
13642 rtl = XEXP (rtl, 1);
13647 /* Turn these into a PLUS expression and fall into the PLUS code
13649 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
13650 GEN_INT (GET_CODE (rtl) == PRE_INC
13651 ? GET_MODE_UNIT_SIZE (mode)
13652 : -GET_MODE_UNIT_SIZE (mode)));
13654 /* ... fall through ... */
13658 if (is_based_loc (rtl))
13659 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
13660 INTVAL (XEXP (rtl, 1)),
13661 VAR_INIT_STATUS_INITIALIZED);
13664 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode,
13665 VAR_INIT_STATUS_INITIALIZED);
13666 if (mem_loc_result == 0)
13669 if (CONST_INT_P (XEXP (rtl, 1)))
13670 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
13673 dw_loc_descr_ref mem_loc_result2
13674 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13675 VAR_INIT_STATUS_INITIALIZED);
13676 if (mem_loc_result2 == 0)
13678 add_loc_descr (&mem_loc_result, mem_loc_result2);
13679 add_loc_descr (&mem_loc_result,
13680 new_loc_descr (DW_OP_plus, 0, 0));
13685 /* If a pseudo-reg is optimized away, it is possible for it to
13686 be replaced with a MEM containing a multiply or shift. */
13728 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13729 VAR_INIT_STATUS_INITIALIZED);
13730 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13731 VAR_INIT_STATUS_INITIALIZED);
13733 if (op0 == 0 || op1 == 0)
13736 mem_loc_result = op0;
13737 add_loc_descr (&mem_loc_result, op1);
13738 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13742 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13743 VAR_INIT_STATUS_INITIALIZED);
13744 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13745 VAR_INIT_STATUS_INITIALIZED);
13747 if (op0 == 0 || op1 == 0)
13750 mem_loc_result = op0;
13751 add_loc_descr (&mem_loc_result, op1);
13752 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13753 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
13754 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
13755 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13756 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
13772 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13773 VAR_INIT_STATUS_INITIALIZED);
13778 mem_loc_result = op0;
13779 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13783 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
13811 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
13812 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 1))) > DWARF2_ADDR_SIZE)
13816 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
13818 if (op_mode == VOIDmode)
13819 op_mode = GET_MODE (XEXP (rtl, 1));
13820 if (op_mode != VOIDmode && GET_MODE_CLASS (op_mode) != MODE_INT)
13823 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13824 VAR_INIT_STATUS_INITIALIZED);
13825 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13826 VAR_INIT_STATUS_INITIALIZED);
13828 if (op0 == 0 || op1 == 0)
13831 if (op_mode != VOIDmode
13832 && GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
13834 int shift = DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode);
13835 shift *= BITS_PER_UNIT;
13836 /* For eq/ne, if the operands are known to be zero-extended,
13837 there is no need to do the fancy shifting up. */
13838 if (op == DW_OP_eq || op == DW_OP_ne)
13840 dw_loc_descr_ref last0, last1;
13842 last0->dw_loc_next != NULL;
13843 last0 = last0->dw_loc_next)
13846 last1->dw_loc_next != NULL;
13847 last1 = last1->dw_loc_next)
13849 /* deref_size zero extends, and for constants we can check
13850 whether they are zero extended or not. */
13851 if (((last0->dw_loc_opc == DW_OP_deref_size
13852 && last0->dw_loc_oprnd1.v.val_int
13853 <= GET_MODE_SIZE (op_mode))
13854 || (CONST_INT_P (XEXP (rtl, 0))
13855 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
13856 == (INTVAL (XEXP (rtl, 0))
13857 & GET_MODE_MASK (op_mode))))
13858 && ((last1->dw_loc_opc == DW_OP_deref_size
13859 && last1->dw_loc_oprnd1.v.val_int
13860 <= GET_MODE_SIZE (op_mode))
13861 || (CONST_INT_P (XEXP (rtl, 1))
13862 && (unsigned HOST_WIDE_INT)
13863 INTVAL (XEXP (rtl, 1))
13864 == (INTVAL (XEXP (rtl, 1))
13865 & GET_MODE_MASK (op_mode)))))
13868 add_loc_descr (&op0, int_loc_descriptor (shift));
13869 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
13870 if (CONST_INT_P (XEXP (rtl, 1)))
13871 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) << shift);
13874 add_loc_descr (&op1, int_loc_descriptor (shift));
13875 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
13881 mem_loc_result = op0;
13882 add_loc_descr (&mem_loc_result, op1);
13883 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
13884 if (STORE_FLAG_VALUE != 1)
13886 add_loc_descr (&mem_loc_result,
13887 int_loc_descriptor (STORE_FLAG_VALUE));
13888 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
13909 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
13910 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 1))) > DWARF2_ADDR_SIZE)
13914 enum machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
13916 if (op_mode == VOIDmode)
13917 op_mode = GET_MODE (XEXP (rtl, 1));
13918 if (op_mode != VOIDmode && GET_MODE_CLASS (op_mode) != MODE_INT)
13921 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13922 VAR_INIT_STATUS_INITIALIZED);
13923 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13924 VAR_INIT_STATUS_INITIALIZED);
13926 if (op0 == 0 || op1 == 0)
13929 if (op_mode != VOIDmode
13930 && GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
13932 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
13933 dw_loc_descr_ref last0, last1;
13935 last0->dw_loc_next != NULL;
13936 last0 = last0->dw_loc_next)
13939 last1->dw_loc_next != NULL;
13940 last1 = last1->dw_loc_next)
13942 if (CONST_INT_P (XEXP (rtl, 0)))
13943 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
13944 /* deref_size zero extends, so no need to mask it again. */
13945 else if (last0->dw_loc_opc != DW_OP_deref_size
13946 || last0->dw_loc_oprnd1.v.val_int
13947 > GET_MODE_SIZE (op_mode))
13949 add_loc_descr (&op0, int_loc_descriptor (mask));
13950 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
13952 if (CONST_INT_P (XEXP (rtl, 1)))
13953 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
13954 /* deref_size zero extends, so no need to mask it again. */
13955 else if (last1->dw_loc_opc != DW_OP_deref_size
13956 || last1->dw_loc_oprnd1.v.val_int
13957 > GET_MODE_SIZE (op_mode))
13959 add_loc_descr (&op1, int_loc_descriptor (mask));
13960 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
13965 HOST_WIDE_INT bias = 1;
13966 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
13967 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
13968 if (CONST_INT_P (XEXP (rtl, 1)))
13969 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
13970 + INTVAL (XEXP (rtl, 1)));
13972 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
13982 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl, 0))) != MODE_INT
13983 || GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) > DWARF2_ADDR_SIZE
13984 || GET_MODE (XEXP (rtl, 0)) != GET_MODE (XEXP (rtl, 1)))
13987 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
13988 VAR_INIT_STATUS_INITIALIZED);
13989 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode,
13990 VAR_INIT_STATUS_INITIALIZED);
13992 if (op0 == 0 || op1 == 0)
13995 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
13996 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
13997 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
13998 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
14000 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
14002 HOST_WIDE_INT mask = GET_MODE_MASK (GET_MODE (XEXP (rtl, 0)));
14003 add_loc_descr (&op0, int_loc_descriptor (mask));
14004 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14005 add_loc_descr (&op1, int_loc_descriptor (mask));
14006 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
14010 HOST_WIDE_INT bias = 1;
14011 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
14012 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14013 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14016 else if (GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0))) < DWARF2_ADDR_SIZE)
14018 int shift = DWARF2_ADDR_SIZE
14019 - GET_MODE_SIZE (GET_MODE (XEXP (rtl, 0)));
14020 shift *= BITS_PER_UNIT;
14021 add_loc_descr (&op0, int_loc_descriptor (shift));
14022 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
14023 add_loc_descr (&op1, int_loc_descriptor (shift));
14024 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
14027 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
14031 mem_loc_result = op0;
14032 add_loc_descr (&mem_loc_result, op1);
14033 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14035 dw_loc_descr_ref bra_node, drop_node;
14037 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14038 add_loc_descr (&mem_loc_result, bra_node);
14039 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
14040 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
14041 add_loc_descr (&mem_loc_result, drop_node);
14042 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14043 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
14049 if (CONST_INT_P (XEXP (rtl, 1))
14050 && CONST_INT_P (XEXP (rtl, 2))
14051 && ((unsigned) INTVAL (XEXP (rtl, 1))
14052 + (unsigned) INTVAL (XEXP (rtl, 2))
14053 <= GET_MODE_BITSIZE (GET_MODE (rtl)))
14054 && GET_MODE_BITSIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
14055 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0))) <= DWARF2_ADDR_SIZE)
14058 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode,
14059 VAR_INIT_STATUS_INITIALIZED);
14062 if (GET_CODE (rtl) == SIGN_EXTRACT)
14066 mem_loc_result = op0;
14067 size = INTVAL (XEXP (rtl, 1));
14068 shift = INTVAL (XEXP (rtl, 2));
14069 if (BITS_BIG_ENDIAN)
14070 shift = GET_MODE_BITSIZE (GET_MODE (XEXP (rtl, 0)))
14072 if (shift + size != (int) DWARF2_ADDR_SIZE)
14074 add_loc_descr (&mem_loc_result,
14075 int_loc_descriptor (DWARF2_ADDR_SIZE
14077 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
14079 if (size != (int) DWARF2_ADDR_SIZE)
14081 add_loc_descr (&mem_loc_result,
14082 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
14083 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
14093 /* In theory, we could implement the above. */
14094 /* DWARF cannot represent the unsigned compare operations
14121 case FLOAT_TRUNCATE:
14123 case UNSIGNED_FLOAT:
14126 case FRACT_CONVERT:
14127 case UNSIGNED_FRACT_CONVERT:
14129 case UNSIGNED_SAT_FRACT:
14141 case VEC_DUPLICATE:
14144 /* If delegitimize_address couldn't do anything with the UNSPEC, we
14145 can't express it in the debug info. This can happen e.g. with some
14150 resolve_one_addr (&rtl, NULL);
14154 #ifdef ENABLE_CHECKING
14155 print_rtl (stderr, rtl);
14156 gcc_unreachable ();
14162 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
14163 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14165 return mem_loc_result;
14168 /* Return a descriptor that describes the concatenation of two locations.
14169 This is typically a complex variable. */
14171 static dw_loc_descr_ref
14172 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
14174 dw_loc_descr_ref cc_loc_result = NULL;
14175 dw_loc_descr_ref x0_ref
14176 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14177 dw_loc_descr_ref x1_ref
14178 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14180 if (x0_ref == 0 || x1_ref == 0)
14183 cc_loc_result = x0_ref;
14184 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
14186 add_loc_descr (&cc_loc_result, x1_ref);
14187 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
14189 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
14190 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14192 return cc_loc_result;
14195 /* Return a descriptor that describes the concatenation of N
14198 static dw_loc_descr_ref
14199 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
14202 dw_loc_descr_ref cc_loc_result = NULL;
14203 unsigned int n = XVECLEN (concatn, 0);
14205 for (i = 0; i < n; ++i)
14207 dw_loc_descr_ref ref;
14208 rtx x = XVECEXP (concatn, 0, i);
14210 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
14214 add_loc_descr (&cc_loc_result, ref);
14215 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x)));
14218 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
14219 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14221 return cc_loc_result;
14224 /* Output a proper Dwarf location descriptor for a variable or parameter
14225 which is either allocated in a register or in a memory location. For a
14226 register, we just generate an OP_REG and the register number. For a
14227 memory location we provide a Dwarf postfix expression describing how to
14228 generate the (dynamic) address of the object onto the address stack.
14230 MODE is mode of the decl if this loc_descriptor is going to be used in
14231 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
14232 allowed, VOIDmode otherwise.
14234 If we don't know how to describe it, return 0. */
14236 static dw_loc_descr_ref
14237 loc_descriptor (rtx rtl, enum machine_mode mode,
14238 enum var_init_status initialized)
14240 dw_loc_descr_ref loc_result = NULL;
14242 switch (GET_CODE (rtl))
14245 /* The case of a subreg may arise when we have a local (register)
14246 variable or a formal (register) parameter which doesn't quite fill
14247 up an entire register. For now, just assume that it is
14248 legitimate to make the Dwarf info refer to the whole register which
14249 contains the given subreg. */
14250 loc_result = loc_descriptor (SUBREG_REG (rtl), mode, initialized);
14254 loc_result = reg_loc_descriptor (rtl, initialized);
14259 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
14263 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl),
14265 if (loc_result == NULL)
14266 loc_result = tls_mem_loc_descriptor (rtl);
14267 if (loc_result == NULL)
14269 rtx new_rtl = avoid_constant_pool_reference (rtl);
14270 if (new_rtl != rtl)
14271 loc_result = loc_descriptor (new_rtl, mode, initialized);
14276 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
14281 loc_result = concatn_loc_descriptor (rtl, initialized);
14286 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
14288 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
14289 if (GET_CODE (loc) == EXPR_LIST)
14290 loc = XEXP (loc, 0);
14291 loc_result = loc_descriptor (loc, mode, initialized);
14295 rtl = XEXP (rtl, 1);
14300 rtvec par_elems = XVEC (rtl, 0);
14301 int num_elem = GET_NUM_ELEM (par_elems);
14302 enum machine_mode mode;
14305 /* Create the first one, so we have something to add to. */
14306 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
14307 VOIDmode, initialized);
14308 if (loc_result == NULL)
14310 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
14311 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
14312 for (i = 1; i < num_elem; i++)
14314 dw_loc_descr_ref temp;
14316 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
14317 VOIDmode, initialized);
14320 add_loc_descr (&loc_result, temp);
14321 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
14322 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
14328 if (mode != VOIDmode && mode != BLKmode)
14329 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (mode),
14334 if (mode == VOIDmode)
14335 mode = GET_MODE (rtl);
14337 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
14339 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
14341 /* Note that a CONST_DOUBLE rtx could represent either an integer
14342 or a floating-point constant. A CONST_DOUBLE is used whenever
14343 the constant requires more than one word in order to be
14344 adequately represented. We output CONST_DOUBLEs as blocks. */
14345 loc_result = new_loc_descr (DW_OP_implicit_value,
14346 GET_MODE_SIZE (mode), 0);
14347 if (SCALAR_FLOAT_MODE_P (mode))
14349 unsigned int length = GET_MODE_SIZE (mode);
14350 unsigned char *array
14351 = (unsigned char*) ggc_alloc_atomic (length);
14353 insert_float (rtl, array);
14354 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
14355 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
14356 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
14357 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
14361 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
14362 loc_result->dw_loc_oprnd2.v.val_double
14363 = rtx_to_double_int (rtl);
14369 if (mode == VOIDmode)
14370 mode = GET_MODE (rtl);
14372 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
14374 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
14375 unsigned int length = CONST_VECTOR_NUNITS (rtl);
14376 unsigned char *array = (unsigned char *)
14377 ggc_alloc_atomic (length * elt_size);
14381 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
14382 switch (GET_MODE_CLASS (mode))
14384 case MODE_VECTOR_INT:
14385 for (i = 0, p = array; i < length; i++, p += elt_size)
14387 rtx elt = CONST_VECTOR_ELT (rtl, i);
14388 double_int val = rtx_to_double_int (elt);
14390 if (elt_size <= sizeof (HOST_WIDE_INT))
14391 insert_int (double_int_to_shwi (val), elt_size, p);
14394 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
14395 insert_double (val, p);
14400 case MODE_VECTOR_FLOAT:
14401 for (i = 0, p = array; i < length; i++, p += elt_size)
14403 rtx elt = CONST_VECTOR_ELT (rtl, i);
14404 insert_float (elt, p);
14409 gcc_unreachable ();
14412 loc_result = new_loc_descr (DW_OP_implicit_value,
14413 length * elt_size, 0);
14414 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
14415 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
14416 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
14417 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
14422 if (mode == VOIDmode
14423 || GET_CODE (XEXP (rtl, 0)) == CONST_INT
14424 || GET_CODE (XEXP (rtl, 0)) == CONST_DOUBLE
14425 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
14427 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
14432 if (!const_ok_for_output (rtl))
14435 if (mode != VOIDmode && GET_MODE_SIZE (mode) == DWARF2_ADDR_SIZE
14436 && (dwarf_version >= 4 || !dwarf_strict))
14438 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
14439 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
14440 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
14441 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
14442 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
14447 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE (rtl) == mode
14448 && GET_MODE_SIZE (GET_MODE (rtl)) <= DWARF2_ADDR_SIZE
14449 && (dwarf_version >= 4 || !dwarf_strict))
14451 /* Value expression. */
14452 loc_result = mem_loc_descriptor (rtl, VOIDmode, initialized);
14454 add_loc_descr (&loc_result,
14455 new_loc_descr (DW_OP_stack_value, 0, 0));
14463 /* We need to figure out what section we should use as the base for the
14464 address ranges where a given location is valid.
14465 1. If this particular DECL has a section associated with it, use that.
14466 2. If this function has a section associated with it, use that.
14467 3. Otherwise, use the text section.
14468 XXX: If you split a variable across multiple sections, we won't notice. */
14470 static const char *
14471 secname_for_decl (const_tree decl)
14473 const char *secname;
14475 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
14477 tree sectree = DECL_SECTION_NAME (decl);
14478 secname = TREE_STRING_POINTER (sectree);
14480 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
14482 tree sectree = DECL_SECTION_NAME (current_function_decl);
14483 secname = TREE_STRING_POINTER (sectree);
14485 else if (cfun && in_cold_section_p)
14486 secname = crtl->subsections.cold_section_label;
14488 secname = text_section_label;
14493 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
14496 decl_by_reference_p (tree decl)
14498 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
14499 || TREE_CODE (decl) == VAR_DECL)
14500 && DECL_BY_REFERENCE (decl));
14503 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14506 static dw_loc_descr_ref
14507 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
14508 enum var_init_status initialized)
14510 int have_address = 0;
14511 dw_loc_descr_ref descr;
14512 enum machine_mode mode;
14514 if (want_address != 2)
14516 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
14518 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
14520 varloc = PAT_VAR_LOCATION_LOC (varloc);
14521 if (GET_CODE (varloc) == EXPR_LIST)
14522 varloc = XEXP (varloc, 0);
14523 mode = GET_MODE (varloc);
14524 if (MEM_P (varloc))
14526 rtx addr = XEXP (varloc, 0);
14527 descr = mem_loc_descriptor (addr, mode, initialized);
14532 rtx x = avoid_constant_pool_reference (varloc);
14534 descr = mem_loc_descriptor (x, mode, initialized);
14538 descr = mem_loc_descriptor (varloc, mode, initialized);
14545 if (GET_CODE (varloc) == VAR_LOCATION)
14546 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
14548 mode = DECL_MODE (loc);
14549 descr = loc_descriptor (varloc, mode, initialized);
14556 if (want_address == 2 && !have_address
14557 && (dwarf_version >= 4 || !dwarf_strict))
14559 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
14561 expansion_failed (loc, NULL_RTX,
14562 "DWARF address size mismatch");
14565 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
14568 /* Show if we can't fill the request for an address. */
14569 if (want_address && !have_address)
14571 expansion_failed (loc, NULL_RTX,
14572 "Want address and only have value");
14576 /* If we've got an address and don't want one, dereference. */
14577 if (!want_address && have_address)
14579 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
14580 enum dwarf_location_atom op;
14582 if (size > DWARF2_ADDR_SIZE || size == -1)
14584 expansion_failed (loc, NULL_RTX,
14585 "DWARF address size mismatch");
14588 else if (size == DWARF2_ADDR_SIZE)
14591 op = DW_OP_deref_size;
14593 add_loc_descr (&descr, new_loc_descr (op, size, 0));
14599 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
14600 if it is not possible. */
14602 static dw_loc_descr_ref
14603 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
14605 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
14606 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
14607 else if (dwarf_version >= 3 || !dwarf_strict)
14608 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
14613 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14614 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
14616 static dw_loc_descr_ref
14617 dw_sra_loc_expr (tree decl, rtx loc)
14620 unsigned int padsize = 0;
14621 dw_loc_descr_ref descr, *descr_tail;
14622 unsigned HOST_WIDE_INT decl_size;
14624 enum var_init_status initialized;
14626 if (DECL_SIZE (decl) == NULL
14627 || !host_integerp (DECL_SIZE (decl), 1))
14630 decl_size = tree_low_cst (DECL_SIZE (decl), 1);
14632 descr_tail = &descr;
14634 for (p = loc; p; p = XEXP (p, 1))
14636 unsigned int bitsize = decl_piece_bitsize (p);
14637 rtx loc_note = *decl_piece_varloc_ptr (p);
14638 dw_loc_descr_ref cur_descr;
14639 dw_loc_descr_ref *tail, last = NULL;
14640 unsigned int opsize = 0;
14642 if (loc_note == NULL_RTX
14643 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
14645 padsize += bitsize;
14648 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
14649 varloc = NOTE_VAR_LOCATION (loc_note);
14650 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
14651 if (cur_descr == NULL)
14653 padsize += bitsize;
14657 /* Check that cur_descr either doesn't use
14658 DW_OP_*piece operations, or their sum is equal
14659 to bitsize. Otherwise we can't embed it. */
14660 for (tail = &cur_descr; *tail != NULL;
14661 tail = &(*tail)->dw_loc_next)
14662 if ((*tail)->dw_loc_opc == DW_OP_piece)
14664 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
14668 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
14670 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
14674 if (last != NULL && opsize != bitsize)
14676 padsize += bitsize;
14680 /* If there is a hole, add DW_OP_*piece after empty DWARF
14681 expression, which means that those bits are optimized out. */
14684 if (padsize > decl_size)
14686 decl_size -= padsize;
14687 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
14688 if (*descr_tail == NULL)
14690 descr_tail = &(*descr_tail)->dw_loc_next;
14693 *descr_tail = cur_descr;
14695 if (bitsize > decl_size)
14697 decl_size -= bitsize;
14700 HOST_WIDE_INT offset = 0;
14701 if (GET_CODE (varloc) == VAR_LOCATION
14702 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
14704 varloc = PAT_VAR_LOCATION_LOC (varloc);
14705 if (GET_CODE (varloc) == EXPR_LIST)
14706 varloc = XEXP (varloc, 0);
14710 if (GET_CODE (varloc) == CONST
14711 || GET_CODE (varloc) == SIGN_EXTEND
14712 || GET_CODE (varloc) == ZERO_EXTEND)
14713 varloc = XEXP (varloc, 0);
14714 else if (GET_CODE (varloc) == SUBREG)
14715 varloc = SUBREG_REG (varloc);
14720 /* DW_OP_bit_size offset should be zero for register
14721 or implicit location descriptions and empty location
14722 descriptions, but for memory addresses needs big endian
14724 if (MEM_P (varloc))
14726 unsigned HOST_WIDE_INT memsize
14727 = INTVAL (MEM_SIZE (varloc)) * BITS_PER_UNIT;
14728 if (memsize != bitsize)
14730 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
14731 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
14733 if (memsize < bitsize)
14735 if (BITS_BIG_ENDIAN)
14736 offset = memsize - bitsize;
14740 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
14741 if (*descr_tail == NULL)
14743 descr_tail = &(*descr_tail)->dw_loc_next;
14747 /* If there were any non-empty expressions, add padding till the end of
14749 if (descr != NULL && decl_size != 0)
14751 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
14752 if (*descr_tail == NULL)
14758 /* Return the dwarf representation of the location list LOC_LIST of
14759 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14762 static dw_loc_list_ref
14763 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
14765 const char *endname, *secname;
14767 enum var_init_status initialized;
14768 struct var_loc_node *node;
14769 dw_loc_descr_ref descr;
14770 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
14771 dw_loc_list_ref list = NULL;
14772 dw_loc_list_ref *listp = &list;
14774 /* Now that we know what section we are using for a base,
14775 actually construct the list of locations.
14776 The first location information is what is passed to the
14777 function that creates the location list, and the remaining
14778 locations just get added on to that list.
14779 Note that we only know the start address for a location
14780 (IE location changes), so to build the range, we use
14781 the range [current location start, next location start].
14782 This means we have to special case the last node, and generate
14783 a range of [last location start, end of function label]. */
14785 secname = secname_for_decl (decl);
14787 for (node = loc_list->first; node; node = node->next)
14788 if (GET_CODE (node->loc) == EXPR_LIST
14789 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
14791 if (GET_CODE (node->loc) == EXPR_LIST)
14793 /* This requires DW_OP_{,bit_}piece, which is not usable
14794 inside DWARF expressions. */
14795 if (want_address != 2)
14797 descr = dw_sra_loc_expr (decl, node->loc);
14803 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
14804 varloc = NOTE_VAR_LOCATION (node->loc);
14805 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
14809 /* The variable has a location between NODE->LABEL and
14810 NODE->NEXT->LABEL. */
14812 endname = node->next->label;
14813 /* If the variable has a location at the last label
14814 it keeps its location until the end of function. */
14815 else if (!current_function_decl)
14816 endname = text_end_label;
14819 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
14820 current_function_funcdef_no);
14821 endname = ggc_strdup (label_id);
14824 *listp = new_loc_list (descr, node->label, endname, secname);
14825 listp = &(*listp)->dw_loc_next;
14829 /* Try to avoid the overhead of a location list emitting a location
14830 expression instead, but only if we didn't have more than one
14831 location entry in the first place. If some entries were not
14832 representable, we don't want to pretend a single entry that was
14833 applies to the entire scope in which the variable is
14835 if (list && loc_list->first->next)
14841 /* Return if the loc_list has only single element and thus can be represented
14842 as location description. */
14845 single_element_loc_list_p (dw_loc_list_ref list)
14847 gcc_assert (!list->dw_loc_next || list->ll_symbol);
14848 return !list->ll_symbol;
14851 /* To each location in list LIST add loc descr REF. */
14854 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
14856 dw_loc_descr_ref copy;
14857 add_loc_descr (&list->expr, ref);
14858 list = list->dw_loc_next;
14861 copy = ggc_alloc_dw_loc_descr_node ();
14862 memcpy (copy, ref, sizeof (dw_loc_descr_node));
14863 add_loc_descr (&list->expr, copy);
14864 while (copy->dw_loc_next)
14866 dw_loc_descr_ref new_copy = ggc_alloc_dw_loc_descr_node ();
14867 memcpy (new_copy, copy->dw_loc_next, sizeof (dw_loc_descr_node));
14868 copy->dw_loc_next = new_copy;
14871 list = list->dw_loc_next;
14875 /* Given two lists RET and LIST
14876 produce location list that is result of adding expression in LIST
14877 to expression in RET on each possition in program.
14878 Might be destructive on both RET and LIST.
14880 TODO: We handle only simple cases of RET or LIST having at most one
14881 element. General case would inolve sorting the lists in program order
14882 and merging them that will need some additional work.
14883 Adding that will improve quality of debug info especially for SRA-ed
14887 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
14896 if (!list->dw_loc_next)
14898 add_loc_descr_to_each (*ret, list->expr);
14901 if (!(*ret)->dw_loc_next)
14903 add_loc_descr_to_each (list, (*ret)->expr);
14907 expansion_failed (NULL_TREE, NULL_RTX,
14908 "Don't know how to merge two non-trivial"
14909 " location lists.\n");
14914 /* LOC is constant expression. Try a luck, look it up in constant
14915 pool and return its loc_descr of its address. */
14917 static dw_loc_descr_ref
14918 cst_pool_loc_descr (tree loc)
14920 /* Get an RTL for this, if something has been emitted. */
14921 rtx rtl = lookup_constant_def (loc);
14922 enum machine_mode mode;
14924 if (!rtl || !MEM_P (rtl))
14929 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
14931 /* TODO: We might get more coverage if we was actually delaying expansion
14932 of all expressions till end of compilation when constant pools are fully
14934 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
14936 expansion_failed (loc, NULL_RTX,
14937 "CST value in contant pool but not marked.");
14940 mode = GET_MODE (rtl);
14941 rtl = XEXP (rtl, 0);
14942 return mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
14945 /* Return dw_loc_list representing address of addr_expr LOC
14946 by looking for innder INDIRECT_REF expression and turing it
14947 into simple arithmetics. */
14949 static dw_loc_list_ref
14950 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev)
14953 HOST_WIDE_INT bitsize, bitpos, bytepos;
14954 enum machine_mode mode;
14956 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
14957 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
14959 obj = get_inner_reference (TREE_OPERAND (loc, 0),
14960 &bitsize, &bitpos, &offset, &mode,
14961 &unsignedp, &volatilep, false);
14963 if (bitpos % BITS_PER_UNIT)
14965 expansion_failed (loc, NULL_RTX, "bitfield access");
14968 if (!INDIRECT_REF_P (obj))
14970 expansion_failed (obj,
14971 NULL_RTX, "no indirect ref in inner refrence");
14974 if (!offset && !bitpos)
14975 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1);
14977 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
14978 && (dwarf_version >= 4 || !dwarf_strict))
14980 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0);
14985 /* Variable offset. */
14986 list_ret1 = loc_list_from_tree (offset, 0);
14987 if (list_ret1 == 0)
14989 add_loc_list (&list_ret, list_ret1);
14992 add_loc_descr_to_each (list_ret,
14993 new_loc_descr (DW_OP_plus, 0, 0));
14995 bytepos = bitpos / BITS_PER_UNIT;
14997 add_loc_descr_to_each (list_ret,
14998 new_loc_descr (DW_OP_plus_uconst,
15000 else if (bytepos < 0)
15001 loc_list_plus_const (list_ret, bytepos);
15002 add_loc_descr_to_each (list_ret,
15003 new_loc_descr (DW_OP_stack_value, 0, 0));
15009 /* Generate Dwarf location list representing LOC.
15010 If WANT_ADDRESS is false, expression computing LOC will be computed
15011 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
15012 if WANT_ADDRESS is 2, expression computing address useable in location
15013 will be returned (i.e. DW_OP_reg can be used
15014 to refer to register values). */
15016 static dw_loc_list_ref
15017 loc_list_from_tree (tree loc, int want_address)
15019 dw_loc_descr_ref ret = NULL, ret1 = NULL;
15020 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
15021 int have_address = 0;
15022 enum dwarf_location_atom op;
15024 /* ??? Most of the time we do not take proper care for sign/zero
15025 extending the values properly. Hopefully this won't be a real
15028 switch (TREE_CODE (loc))
15031 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
15034 case PLACEHOLDER_EXPR:
15035 /* This case involves extracting fields from an object to determine the
15036 position of other fields. We don't try to encode this here. The
15037 only user of this is Ada, which encodes the needed information using
15038 the names of types. */
15039 expansion_failed (loc, NULL_RTX, "PLACEHOLDER_EXPR");
15043 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
15044 /* There are no opcodes for these operations. */
15047 case PREINCREMENT_EXPR:
15048 case PREDECREMENT_EXPR:
15049 case POSTINCREMENT_EXPR:
15050 case POSTDECREMENT_EXPR:
15051 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
15052 /* There are no opcodes for these operations. */
15056 /* If we already want an address, see if there is INDIRECT_REF inside
15057 e.g. for &this->field. */
15060 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
15061 (loc, want_address == 2);
15064 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
15065 && (ret = cst_pool_loc_descr (loc)))
15068 /* Otherwise, process the argument and look for the address. */
15069 if (!list_ret && !ret)
15070 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 1);
15074 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
15080 if (DECL_THREAD_LOCAL_P (loc))
15083 enum dwarf_location_atom first_op;
15084 enum dwarf_location_atom second_op;
15085 bool dtprel = false;
15087 if (targetm.have_tls)
15089 /* If this is not defined, we have no way to emit the
15091 if (!targetm.asm_out.output_dwarf_dtprel)
15094 /* The way DW_OP_GNU_push_tls_address is specified, we
15095 can only look up addresses of objects in the current
15096 module. We used DW_OP_addr as first op, but that's
15097 wrong, because DW_OP_addr is relocated by the debug
15098 info consumer, while DW_OP_GNU_push_tls_address
15099 operand shouldn't be. */
15100 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
15102 first_op = DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u;
15104 second_op = DW_OP_GNU_push_tls_address;
15108 if (!targetm.emutls.debug_form_tls_address
15109 || !(dwarf_version >= 3 || !dwarf_strict))
15111 loc = emutls_decl (loc);
15112 first_op = DW_OP_addr;
15113 second_op = DW_OP_form_tls_address;
15116 rtl = rtl_for_decl_location (loc);
15117 if (rtl == NULL_RTX)
15122 rtl = XEXP (rtl, 0);
15123 if (! CONSTANT_P (rtl))
15126 ret = new_loc_descr (first_op, 0, 0);
15127 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
15128 ret->dw_loc_oprnd1.v.val_addr = rtl;
15129 ret->dtprel = dtprel;
15131 ret1 = new_loc_descr (second_op, 0, 0);
15132 add_loc_descr (&ret, ret1);
15140 if (DECL_HAS_VALUE_EXPR_P (loc))
15141 return loc_list_from_tree (DECL_VALUE_EXPR (loc),
15146 case FUNCTION_DECL:
15149 var_loc_list *loc_list = lookup_decl_loc (loc);
15151 if (loc_list && loc_list->first)
15153 list_ret = dw_loc_list (loc_list, loc, want_address);
15154 have_address = want_address != 0;
15157 rtl = rtl_for_decl_location (loc);
15158 if (rtl == NULL_RTX)
15160 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
15163 else if (CONST_INT_P (rtl))
15165 HOST_WIDE_INT val = INTVAL (rtl);
15166 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
15167 val &= GET_MODE_MASK (DECL_MODE (loc));
15168 ret = int_loc_descriptor (val);
15170 else if (GET_CODE (rtl) == CONST_STRING)
15172 expansion_failed (loc, NULL_RTX, "CONST_STRING");
15175 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
15177 ret = new_loc_descr (DW_OP_addr, 0, 0);
15178 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
15179 ret->dw_loc_oprnd1.v.val_addr = rtl;
15183 enum machine_mode mode;
15185 /* Certain constructs can only be represented at top-level. */
15186 if (want_address == 2)
15188 ret = loc_descriptor (rtl, VOIDmode,
15189 VAR_INIT_STATUS_INITIALIZED);
15194 mode = GET_MODE (rtl);
15197 rtl = XEXP (rtl, 0);
15200 ret = mem_loc_descriptor (rtl, mode, VAR_INIT_STATUS_INITIALIZED);
15203 expansion_failed (loc, rtl,
15204 "failed to produce loc descriptor for rtl");
15211 if (!integer_zerop (TREE_OPERAND (loc, 1)))
15215 case MISALIGNED_INDIRECT_REF:
15216 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15220 case COMPOUND_EXPR:
15221 return loc_list_from_tree (TREE_OPERAND (loc, 1), want_address);
15224 case VIEW_CONVERT_EXPR:
15227 return loc_list_from_tree (TREE_OPERAND (loc, 0), want_address);
15229 case COMPONENT_REF:
15230 case BIT_FIELD_REF:
15232 case ARRAY_RANGE_REF:
15233 case REALPART_EXPR:
15234 case IMAGPART_EXPR:
15237 HOST_WIDE_INT bitsize, bitpos, bytepos;
15238 enum machine_mode mode;
15240 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
15242 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
15243 &unsignedp, &volatilep, false);
15245 gcc_assert (obj != loc);
15247 list_ret = loc_list_from_tree (obj,
15249 && !bitpos && !offset ? 2 : 1);
15250 /* TODO: We can extract value of the small expression via shifting even
15251 for nonzero bitpos. */
15254 if (bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
15256 expansion_failed (loc, NULL_RTX,
15257 "bitfield access");
15261 if (offset != NULL_TREE)
15263 /* Variable offset. */
15264 list_ret1 = loc_list_from_tree (offset, 0);
15265 if (list_ret1 == 0)
15267 add_loc_list (&list_ret, list_ret1);
15270 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
15273 bytepos = bitpos / BITS_PER_UNIT;
15275 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
15276 else if (bytepos < 0)
15277 loc_list_plus_const (list_ret, bytepos);
15284 if ((want_address || !host_integerp (loc, 0))
15285 && (ret = cst_pool_loc_descr (loc)))
15287 else if (want_address == 2
15288 && host_integerp (loc, 0)
15289 && (ret = address_of_int_loc_descriptor
15290 (int_size_in_bytes (TREE_TYPE (loc)),
15291 tree_low_cst (loc, 0))))
15293 else if (host_integerp (loc, 0))
15294 ret = int_loc_descriptor (tree_low_cst (loc, 0));
15297 expansion_failed (loc, NULL_RTX,
15298 "Integer operand is not host integer");
15307 if ((ret = cst_pool_loc_descr (loc)))
15310 /* We can construct small constants here using int_loc_descriptor. */
15311 expansion_failed (loc, NULL_RTX,
15312 "constructor or constant not in constant pool");
15315 case TRUTH_AND_EXPR:
15316 case TRUTH_ANDIF_EXPR:
15321 case TRUTH_XOR_EXPR:
15326 case TRUTH_OR_EXPR:
15327 case TRUTH_ORIF_EXPR:
15332 case FLOOR_DIV_EXPR:
15333 case CEIL_DIV_EXPR:
15334 case ROUND_DIV_EXPR:
15335 case TRUNC_DIV_EXPR:
15336 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
15345 case FLOOR_MOD_EXPR:
15346 case CEIL_MOD_EXPR:
15347 case ROUND_MOD_EXPR:
15348 case TRUNC_MOD_EXPR:
15349 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
15354 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15355 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
15356 if (list_ret == 0 || list_ret1 == 0)
15359 add_loc_list (&list_ret, list_ret1);
15362 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
15363 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
15364 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
15365 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
15366 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
15378 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
15381 case POINTER_PLUS_EXPR:
15383 if (host_integerp (TREE_OPERAND (loc, 1), 0))
15385 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15389 loc_list_plus_const (list_ret, tree_low_cst (TREE_OPERAND (loc, 1), 0));
15397 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15404 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15411 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15418 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
15433 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15434 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0);
15435 if (list_ret == 0 || list_ret1 == 0)
15438 add_loc_list (&list_ret, list_ret1);
15441 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
15444 case TRUTH_NOT_EXPR:
15458 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15462 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
15468 const enum tree_code code =
15469 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
15471 loc = build3 (COND_EXPR, TREE_TYPE (loc),
15472 build2 (code, integer_type_node,
15473 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
15474 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
15477 /* ... fall through ... */
15481 dw_loc_descr_ref lhs
15482 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0);
15483 dw_loc_list_ref rhs
15484 = loc_list_from_tree (TREE_OPERAND (loc, 2), 0);
15485 dw_loc_descr_ref bra_node, jump_node, tmp;
15487 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0);
15488 if (list_ret == 0 || lhs == 0 || rhs == 0)
15491 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
15492 add_loc_descr_to_each (list_ret, bra_node);
15494 add_loc_list (&list_ret, rhs);
15495 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
15496 add_loc_descr_to_each (list_ret, jump_node);
15498 add_loc_descr_to_each (list_ret, lhs);
15499 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
15500 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
15502 /* ??? Need a node to point the skip at. Use a nop. */
15503 tmp = new_loc_descr (DW_OP_nop, 0, 0);
15504 add_loc_descr_to_each (list_ret, tmp);
15505 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
15506 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
15510 case FIX_TRUNC_EXPR:
15514 /* Leave front-end specific codes as simply unknown. This comes
15515 up, for instance, with the C STMT_EXPR. */
15516 if ((unsigned int) TREE_CODE (loc)
15517 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
15519 expansion_failed (loc, NULL_RTX,
15520 "language specific tree node");
15524 #ifdef ENABLE_CHECKING
15525 /* Otherwise this is a generic code; we should just lists all of
15526 these explicitly. We forgot one. */
15527 gcc_unreachable ();
15529 /* In a release build, we want to degrade gracefully: better to
15530 generate incomplete debugging information than to crash. */
15535 if (!ret && !list_ret)
15538 if (want_address == 2 && !have_address
15539 && (dwarf_version >= 4 || !dwarf_strict))
15541 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
15543 expansion_failed (loc, NULL_RTX,
15544 "DWARF address size mismatch");
15548 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
15550 add_loc_descr_to_each (list_ret,
15551 new_loc_descr (DW_OP_stack_value, 0, 0));
15554 /* Show if we can't fill the request for an address. */
15555 if (want_address && !have_address)
15557 expansion_failed (loc, NULL_RTX,
15558 "Want address and only have value");
15562 gcc_assert (!ret || !list_ret);
15564 /* If we've got an address and don't want one, dereference. */
15565 if (!want_address && have_address)
15567 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
15569 if (size > DWARF2_ADDR_SIZE || size == -1)
15571 expansion_failed (loc, NULL_RTX,
15572 "DWARF address size mismatch");
15575 else if (size == DWARF2_ADDR_SIZE)
15578 op = DW_OP_deref_size;
15581 add_loc_descr (&ret, new_loc_descr (op, size, 0));
15583 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
15586 list_ret = new_loc_list (ret, NULL, NULL, NULL);
15591 /* Same as above but return only single location expression. */
15592 static dw_loc_descr_ref
15593 loc_descriptor_from_tree (tree loc, int want_address)
15595 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address);
15598 if (ret->dw_loc_next)
15600 expansion_failed (loc, NULL_RTX,
15601 "Location list where only loc descriptor needed");
15607 /* Given a value, round it up to the lowest multiple of `boundary'
15608 which is not less than the value itself. */
15610 static inline HOST_WIDE_INT
15611 ceiling (HOST_WIDE_INT value, unsigned int boundary)
15613 return (((value + boundary - 1) / boundary) * boundary);
15616 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
15617 pointer to the declared type for the relevant field variable, or return
15618 `integer_type_node' if the given node turns out to be an
15619 ERROR_MARK node. */
15622 field_type (const_tree decl)
15626 if (TREE_CODE (decl) == ERROR_MARK)
15627 return integer_type_node;
15629 type = DECL_BIT_FIELD_TYPE (decl);
15630 if (type == NULL_TREE)
15631 type = TREE_TYPE (decl);
15636 /* Given a pointer to a tree node, return the alignment in bits for
15637 it, or else return BITS_PER_WORD if the node actually turns out to
15638 be an ERROR_MARK node. */
15640 static inline unsigned
15641 simple_type_align_in_bits (const_tree type)
15643 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
15646 static inline unsigned
15647 simple_decl_align_in_bits (const_tree decl)
15649 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
15652 /* Return the result of rounding T up to ALIGN. */
15654 static inline double_int
15655 round_up_to_align (double_int t, unsigned int align)
15657 double_int alignd = uhwi_to_double_int (align);
15658 t = double_int_add (t, alignd);
15659 t = double_int_add (t, double_int_minus_one);
15660 t = double_int_div (t, alignd, true, TRUNC_DIV_EXPR);
15661 t = double_int_mul (t, alignd);
15665 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
15666 lowest addressed byte of the "containing object" for the given FIELD_DECL,
15667 or return 0 if we are unable to determine what that offset is, either
15668 because the argument turns out to be a pointer to an ERROR_MARK node, or
15669 because the offset is actually variable. (We can't handle the latter case
15672 static HOST_WIDE_INT
15673 field_byte_offset (const_tree decl)
15675 double_int object_offset_in_bits;
15676 double_int object_offset_in_bytes;
15677 double_int bitpos_int;
15679 if (TREE_CODE (decl) == ERROR_MARK)
15682 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
15684 /* We cannot yet cope with fields whose positions are variable, so
15685 for now, when we see such things, we simply return 0. Someday, we may
15686 be able to handle such cases, but it will be damn difficult. */
15687 if (TREE_CODE (bit_position (decl)) != INTEGER_CST)
15690 bitpos_int = tree_to_double_int (bit_position (decl));
15692 #ifdef PCC_BITFIELD_TYPE_MATTERS
15693 if (PCC_BITFIELD_TYPE_MATTERS)
15696 tree field_size_tree;
15697 double_int deepest_bitpos;
15698 double_int field_size_in_bits;
15699 unsigned int type_align_in_bits;
15700 unsigned int decl_align_in_bits;
15701 double_int type_size_in_bits;
15703 type = field_type (decl);
15704 type_size_in_bits = double_int_type_size_in_bits (type);
15705 type_align_in_bits = simple_type_align_in_bits (type);
15707 field_size_tree = DECL_SIZE (decl);
15709 /* The size could be unspecified if there was an error, or for
15710 a flexible array member. */
15711 if (!field_size_tree)
15712 field_size_tree = bitsize_zero_node;
15714 /* If the size of the field is not constant, use the type size. */
15715 if (TREE_CODE (field_size_tree) == INTEGER_CST)
15716 field_size_in_bits = tree_to_double_int (field_size_tree);
15718 field_size_in_bits = type_size_in_bits;
15720 decl_align_in_bits = simple_decl_align_in_bits (decl);
15722 /* The GCC front-end doesn't make any attempt to keep track of the
15723 starting bit offset (relative to the start of the containing
15724 structure type) of the hypothetical "containing object" for a
15725 bit-field. Thus, when computing the byte offset value for the
15726 start of the "containing object" of a bit-field, we must deduce
15727 this information on our own. This can be rather tricky to do in
15728 some cases. For example, handling the following structure type
15729 definition when compiling for an i386/i486 target (which only
15730 aligns long long's to 32-bit boundaries) can be very tricky:
15732 struct S { int field1; long long field2:31; };
15734 Fortunately, there is a simple rule-of-thumb which can be used
15735 in such cases. When compiling for an i386/i486, GCC will
15736 allocate 8 bytes for the structure shown above. It decides to
15737 do this based upon one simple rule for bit-field allocation.
15738 GCC allocates each "containing object" for each bit-field at
15739 the first (i.e. lowest addressed) legitimate alignment boundary
15740 (based upon the required minimum alignment for the declared
15741 type of the field) which it can possibly use, subject to the
15742 condition that there is still enough available space remaining
15743 in the containing object (when allocated at the selected point)
15744 to fully accommodate all of the bits of the bit-field itself.
15746 This simple rule makes it obvious why GCC allocates 8 bytes for
15747 each object of the structure type shown above. When looking
15748 for a place to allocate the "containing object" for `field2',
15749 the compiler simply tries to allocate a 64-bit "containing
15750 object" at each successive 32-bit boundary (starting at zero)
15751 until it finds a place to allocate that 64- bit field such that
15752 at least 31 contiguous (and previously unallocated) bits remain
15753 within that selected 64 bit field. (As it turns out, for the
15754 example above, the compiler finds it is OK to allocate the
15755 "containing object" 64-bit field at bit-offset zero within the
15758 Here we attempt to work backwards from the limited set of facts
15759 we're given, and we try to deduce from those facts, where GCC
15760 must have believed that the containing object started (within
15761 the structure type). The value we deduce is then used (by the
15762 callers of this routine) to generate DW_AT_location and
15763 DW_AT_bit_offset attributes for fields (both bit-fields and, in
15764 the case of DW_AT_location, regular fields as well). */
15766 /* Figure out the bit-distance from the start of the structure to
15767 the "deepest" bit of the bit-field. */
15768 deepest_bitpos = double_int_add (bitpos_int, field_size_in_bits);
15770 /* This is the tricky part. Use some fancy footwork to deduce
15771 where the lowest addressed bit of the containing object must
15773 object_offset_in_bits
15774 = double_int_sub (deepest_bitpos, type_size_in_bits);
15776 /* Round up to type_align by default. This works best for
15778 object_offset_in_bits
15779 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
15781 if (double_int_ucmp (object_offset_in_bits, bitpos_int) > 0)
15783 object_offset_in_bits
15784 = double_int_sub (deepest_bitpos, type_size_in_bits);
15786 /* Round up to decl_align instead. */
15787 object_offset_in_bits
15788 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
15793 object_offset_in_bits = bitpos_int;
15795 object_offset_in_bytes
15796 = double_int_div (object_offset_in_bits,
15797 uhwi_to_double_int (BITS_PER_UNIT), true,
15799 return double_int_to_shwi (object_offset_in_bytes);
15802 /* The following routines define various Dwarf attributes and any data
15803 associated with them. */
15805 /* Add a location description attribute value to a DIE.
15807 This emits location attributes suitable for whole variables and
15808 whole parameters. Note that the location attributes for struct fields are
15809 generated by the routine `data_member_location_attribute' below. */
15812 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
15813 dw_loc_list_ref descr)
15817 if (single_element_loc_list_p (descr))
15818 add_AT_loc (die, attr_kind, descr->expr);
15820 add_AT_loc_list (die, attr_kind, descr);
15823 /* Add DW_AT_accessibility attribute to DIE if needed. */
15826 add_accessibility_attribute (dw_die_ref die, tree decl)
15828 if (TREE_PROTECTED (decl))
15829 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
15830 else if (TREE_PRIVATE (decl))
15831 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
15834 /* Attach the specialized form of location attribute used for data members of
15835 struct and union types. In the special case of a FIELD_DECL node which
15836 represents a bit-field, the "offset" part of this special location
15837 descriptor must indicate the distance in bytes from the lowest-addressed
15838 byte of the containing struct or union type to the lowest-addressed byte of
15839 the "containing object" for the bit-field. (See the `field_byte_offset'
15842 For any given bit-field, the "containing object" is a hypothetical object
15843 (of some integral or enum type) within which the given bit-field lives. The
15844 type of this hypothetical "containing object" is always the same as the
15845 declared type of the individual bit-field itself (for GCC anyway... the
15846 DWARF spec doesn't actually mandate this). Note that it is the size (in
15847 bytes) of the hypothetical "containing object" which will be given in the
15848 DW_AT_byte_size attribute for this bit-field. (See the
15849 `byte_size_attribute' function below.) It is also used when calculating the
15850 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15851 function below.) */
15854 add_data_member_location_attribute (dw_die_ref die, tree decl)
15856 HOST_WIDE_INT offset;
15857 dw_loc_descr_ref loc_descr = 0;
15859 if (TREE_CODE (decl) == TREE_BINFO)
15861 /* We're working on the TAG_inheritance for a base class. */
15862 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
15864 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15865 aren't at a fixed offset from all (sub)objects of the same
15866 type. We need to extract the appropriate offset from our
15867 vtable. The following dwarf expression means
15869 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15871 This is specific to the V3 ABI, of course. */
15873 dw_loc_descr_ref tmp;
15875 /* Make a copy of the object address. */
15876 tmp = new_loc_descr (DW_OP_dup, 0, 0);
15877 add_loc_descr (&loc_descr, tmp);
15879 /* Extract the vtable address. */
15880 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15881 add_loc_descr (&loc_descr, tmp);
15883 /* Calculate the address of the offset. */
15884 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
15885 gcc_assert (offset < 0);
15887 tmp = int_loc_descriptor (-offset);
15888 add_loc_descr (&loc_descr, tmp);
15889 tmp = new_loc_descr (DW_OP_minus, 0, 0);
15890 add_loc_descr (&loc_descr, tmp);
15892 /* Extract the offset. */
15893 tmp = new_loc_descr (DW_OP_deref, 0, 0);
15894 add_loc_descr (&loc_descr, tmp);
15896 /* Add it to the object address. */
15897 tmp = new_loc_descr (DW_OP_plus, 0, 0);
15898 add_loc_descr (&loc_descr, tmp);
15901 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
15904 offset = field_byte_offset (decl);
15908 if (dwarf_version > 2)
15910 /* Don't need to output a location expression, just the constant. */
15911 add_AT_int (die, DW_AT_data_member_location, offset);
15916 enum dwarf_location_atom op;
15918 /* The DWARF2 standard says that we should assume that the structure
15919 address is already on the stack, so we can specify a structure
15920 field address by using DW_OP_plus_uconst. */
15922 #ifdef MIPS_DEBUGGING_INFO
15923 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
15924 operator correctly. It works only if we leave the offset on the
15928 op = DW_OP_plus_uconst;
15931 loc_descr = new_loc_descr (op, offset, 0);
15935 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
15938 /* Writes integer values to dw_vec_const array. */
15941 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
15945 *dest++ = val & 0xff;
15951 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15953 static HOST_WIDE_INT
15954 extract_int (const unsigned char *src, unsigned int size)
15956 HOST_WIDE_INT val = 0;
15962 val |= *--src & 0xff;
15968 /* Writes double_int values to dw_vec_const array. */
15971 insert_double (double_int val, unsigned char *dest)
15973 unsigned char *p0 = dest;
15974 unsigned char *p1 = dest + sizeof (HOST_WIDE_INT);
15976 if (WORDS_BIG_ENDIAN)
15982 insert_int ((HOST_WIDE_INT) val.low, sizeof (HOST_WIDE_INT), p0);
15983 insert_int ((HOST_WIDE_INT) val.high, sizeof (HOST_WIDE_INT), p1);
15986 /* Writes floating point values to dw_vec_const array. */
15989 insert_float (const_rtx rtl, unsigned char *array)
15991 REAL_VALUE_TYPE rv;
15995 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
15996 real_to_target (val, &rv, GET_MODE (rtl));
15998 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15999 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
16001 insert_int (val[i], 4, array);
16006 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
16007 does not have a "location" either in memory or in a register. These
16008 things can arise in GNU C when a constant is passed as an actual parameter
16009 to an inlined function. They can also arise in C++ where declared
16010 constants do not necessarily get memory "homes". */
16013 add_const_value_attribute (dw_die_ref die, rtx rtl)
16015 switch (GET_CODE (rtl))
16019 HOST_WIDE_INT val = INTVAL (rtl);
16022 add_AT_int (die, DW_AT_const_value, val);
16024 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
16029 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
16030 floating-point constant. A CONST_DOUBLE is used whenever the
16031 constant requires more than one word in order to be adequately
16034 enum machine_mode mode = GET_MODE (rtl);
16036 if (SCALAR_FLOAT_MODE_P (mode))
16038 unsigned int length = GET_MODE_SIZE (mode);
16039 unsigned char *array = (unsigned char *) ggc_alloc_atomic (length);
16041 insert_float (rtl, array);
16042 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
16045 add_AT_double (die, DW_AT_const_value,
16046 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
16052 enum machine_mode mode = GET_MODE (rtl);
16053 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
16054 unsigned int length = CONST_VECTOR_NUNITS (rtl);
16055 unsigned char *array = (unsigned char *) ggc_alloc_atomic
16056 (length * elt_size);
16060 switch (GET_MODE_CLASS (mode))
16062 case MODE_VECTOR_INT:
16063 for (i = 0, p = array; i < length; i++, p += elt_size)
16065 rtx elt = CONST_VECTOR_ELT (rtl, i);
16066 double_int val = rtx_to_double_int (elt);
16068 if (elt_size <= sizeof (HOST_WIDE_INT))
16069 insert_int (double_int_to_shwi (val), elt_size, p);
16072 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
16073 insert_double (val, p);
16078 case MODE_VECTOR_FLOAT:
16079 for (i = 0, p = array; i < length; i++, p += elt_size)
16081 rtx elt = CONST_VECTOR_ELT (rtl, i);
16082 insert_float (elt, p);
16087 gcc_unreachable ();
16090 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
16095 if (dwarf_version >= 4 || !dwarf_strict)
16097 dw_loc_descr_ref loc_result;
16098 resolve_one_addr (&rtl, NULL);
16100 loc_result = new_loc_descr (DW_OP_addr, 0, 0);
16101 loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
16102 loc_result->dw_loc_oprnd1.v.val_addr = rtl;
16103 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
16104 add_AT_loc (die, DW_AT_location, loc_result);
16105 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
16111 if (CONSTANT_P (XEXP (rtl, 0)))
16112 return add_const_value_attribute (die, XEXP (rtl, 0));
16115 if (!const_ok_for_output (rtl))
16118 if (dwarf_version >= 4 || !dwarf_strict)
16123 /* In cases where an inlined instance of an inline function is passed
16124 the address of an `auto' variable (which is local to the caller) we
16125 can get a situation where the DECL_RTL of the artificial local
16126 variable (for the inlining) which acts as a stand-in for the
16127 corresponding formal parameter (of the inline function) will look
16128 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
16129 exactly a compile-time constant expression, but it isn't the address
16130 of the (artificial) local variable either. Rather, it represents the
16131 *value* which the artificial local variable always has during its
16132 lifetime. We currently have no way to represent such quasi-constant
16133 values in Dwarf, so for now we just punt and generate nothing. */
16141 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
16142 && MEM_READONLY_P (rtl)
16143 && GET_MODE (rtl) == BLKmode)
16145 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
16151 /* No other kinds of rtx should be possible here. */
16152 gcc_unreachable ();
16157 /* Determine whether the evaluation of EXPR references any variables
16158 or functions which aren't otherwise used (and therefore may not be
16161 reference_to_unused (tree * tp, int * walk_subtrees,
16162 void * data ATTRIBUTE_UNUSED)
16164 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
16165 *walk_subtrees = 0;
16167 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
16168 && ! TREE_ASM_WRITTEN (*tp))
16170 /* ??? The C++ FE emits debug information for using decls, so
16171 putting gcc_unreachable here falls over. See PR31899. For now
16172 be conservative. */
16173 else if (!cgraph_global_info_ready
16174 && (TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == FUNCTION_DECL))
16176 else if (TREE_CODE (*tp) == VAR_DECL)
16178 struct varpool_node *node = varpool_get_node (*tp);
16179 if (!node || !node->needed)
16182 else if (TREE_CODE (*tp) == FUNCTION_DECL
16183 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
16185 /* The call graph machinery must have finished analyzing,
16186 optimizing and gimplifying the CU by now.
16187 So if *TP has no call graph node associated
16188 to it, it means *TP will not be emitted. */
16189 if (!cgraph_get_node (*tp))
16192 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
16198 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
16199 for use in a later add_const_value_attribute call. */
16202 rtl_for_decl_init (tree init, tree type)
16204 rtx rtl = NULL_RTX;
16206 /* If a variable is initialized with a string constant without embedded
16207 zeros, build CONST_STRING. */
16208 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
16210 tree enttype = TREE_TYPE (type);
16211 tree domain = TYPE_DOMAIN (type);
16212 enum machine_mode mode = TYPE_MODE (enttype);
16214 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
16216 && integer_zerop (TYPE_MIN_VALUE (domain))
16217 && compare_tree_int (TYPE_MAX_VALUE (domain),
16218 TREE_STRING_LENGTH (init) - 1) == 0
16219 && ((size_t) TREE_STRING_LENGTH (init)
16220 == strlen (TREE_STRING_POINTER (init)) + 1))
16222 rtl = gen_rtx_CONST_STRING (VOIDmode,
16223 ggc_strdup (TREE_STRING_POINTER (init)));
16224 rtl = gen_rtx_MEM (BLKmode, rtl);
16225 MEM_READONLY_P (rtl) = 1;
16228 /* Other aggregates, and complex values, could be represented using
16230 else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
16232 /* Vectors only work if their mode is supported by the target.
16233 FIXME: generic vectors ought to work too. */
16234 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
16236 /* If the initializer is something that we know will expand into an
16237 immediate RTL constant, expand it now. We must be careful not to
16238 reference variables which won't be output. */
16239 else if (initializer_constant_valid_p (init, type)
16240 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
16242 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
16244 if (TREE_CODE (type) == VECTOR_TYPE)
16245 switch (TREE_CODE (init))
16250 if (TREE_CONSTANT (init))
16252 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (init);
16253 bool constant_p = true;
16255 unsigned HOST_WIDE_INT ix;
16257 /* Even when ctor is constant, it might contain non-*_CST
16258 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
16259 belong into VECTOR_CST nodes. */
16260 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
16261 if (!CONSTANT_CLASS_P (value))
16263 constant_p = false;
16269 init = build_vector_from_ctor (type, elts);
16279 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
16281 /* If expand_expr returns a MEM, it wasn't immediate. */
16282 gcc_assert (!rtl || !MEM_P (rtl));
16288 /* Generate RTL for the variable DECL to represent its location. */
16291 rtl_for_decl_location (tree decl)
16295 /* Here we have to decide where we are going to say the parameter "lives"
16296 (as far as the debugger is concerned). We only have a couple of
16297 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
16299 DECL_RTL normally indicates where the parameter lives during most of the
16300 activation of the function. If optimization is enabled however, this
16301 could be either NULL or else a pseudo-reg. Both of those cases indicate
16302 that the parameter doesn't really live anywhere (as far as the code
16303 generation parts of GCC are concerned) during most of the function's
16304 activation. That will happen (for example) if the parameter is never
16305 referenced within the function.
16307 We could just generate a location descriptor here for all non-NULL
16308 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
16309 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
16310 where DECL_RTL is NULL or is a pseudo-reg.
16312 Note however that we can only get away with using DECL_INCOMING_RTL as
16313 a backup substitute for DECL_RTL in certain limited cases. In cases
16314 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
16315 we can be sure that the parameter was passed using the same type as it is
16316 declared to have within the function, and that its DECL_INCOMING_RTL
16317 points us to a place where a value of that type is passed.
16319 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
16320 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
16321 because in these cases DECL_INCOMING_RTL points us to a value of some
16322 type which is *different* from the type of the parameter itself. Thus,
16323 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
16324 such cases, the debugger would end up (for example) trying to fetch a
16325 `float' from a place which actually contains the first part of a
16326 `double'. That would lead to really incorrect and confusing
16327 output at debug-time.
16329 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
16330 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
16331 are a couple of exceptions however. On little-endian machines we can
16332 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
16333 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
16334 an integral type that is smaller than TREE_TYPE (decl). These cases arise
16335 when (on a little-endian machine) a non-prototyped function has a
16336 parameter declared to be of type `short' or `char'. In such cases,
16337 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
16338 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
16339 passed `int' value. If the debugger then uses that address to fetch
16340 a `short' or a `char' (on a little-endian machine) the result will be
16341 the correct data, so we allow for such exceptional cases below.
16343 Note that our goal here is to describe the place where the given formal
16344 parameter lives during most of the function's activation (i.e. between the
16345 end of the prologue and the start of the epilogue). We'll do that as best
16346 as we can. Note however that if the given formal parameter is modified
16347 sometime during the execution of the function, then a stack backtrace (at
16348 debug-time) will show the function as having been called with the *new*
16349 value rather than the value which was originally passed in. This happens
16350 rarely enough that it is not a major problem, but it *is* a problem, and
16351 I'd like to fix it.
16353 A future version of dwarf2out.c may generate two additional attributes for
16354 any given DW_TAG_formal_parameter DIE which will describe the "passed
16355 type" and the "passed location" for the given formal parameter in addition
16356 to the attributes we now generate to indicate the "declared type" and the
16357 "active location" for each parameter. This additional set of attributes
16358 could be used by debuggers for stack backtraces. Separately, note that
16359 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
16360 This happens (for example) for inlined-instances of inline function formal
16361 parameters which are never referenced. This really shouldn't be
16362 happening. All PARM_DECL nodes should get valid non-NULL
16363 DECL_INCOMING_RTL values. FIXME. */
16365 /* Use DECL_RTL as the "location" unless we find something better. */
16366 rtl = DECL_RTL_IF_SET (decl);
16368 /* When generating abstract instances, ignore everything except
16369 constants, symbols living in memory, and symbols living in
16370 fixed registers. */
16371 if (! reload_completed)
16374 && (CONSTANT_P (rtl)
16376 && CONSTANT_P (XEXP (rtl, 0)))
16378 && TREE_CODE (decl) == VAR_DECL
16379 && TREE_STATIC (decl))))
16381 rtl = targetm.delegitimize_address (rtl);
16386 else if (TREE_CODE (decl) == PARM_DECL)
16388 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
16390 tree declared_type = TREE_TYPE (decl);
16391 tree passed_type = DECL_ARG_TYPE (decl);
16392 enum machine_mode dmode = TYPE_MODE (declared_type);
16393 enum machine_mode pmode = TYPE_MODE (passed_type);
16395 /* This decl represents a formal parameter which was optimized out.
16396 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
16397 all cases where (rtl == NULL_RTX) just below. */
16398 if (dmode == pmode)
16399 rtl = DECL_INCOMING_RTL (decl);
16400 else if (SCALAR_INT_MODE_P (dmode)
16401 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
16402 && DECL_INCOMING_RTL (decl))
16404 rtx inc = DECL_INCOMING_RTL (decl);
16407 else if (MEM_P (inc))
16409 if (BYTES_BIG_ENDIAN)
16410 rtl = adjust_address_nv (inc, dmode,
16411 GET_MODE_SIZE (pmode)
16412 - GET_MODE_SIZE (dmode));
16419 /* If the parm was passed in registers, but lives on the stack, then
16420 make a big endian correction if the mode of the type of the
16421 parameter is not the same as the mode of the rtl. */
16422 /* ??? This is the same series of checks that are made in dbxout.c before
16423 we reach the big endian correction code there. It isn't clear if all
16424 of these checks are necessary here, but keeping them all is the safe
16426 else if (MEM_P (rtl)
16427 && XEXP (rtl, 0) != const0_rtx
16428 && ! CONSTANT_P (XEXP (rtl, 0))
16429 /* Not passed in memory. */
16430 && !MEM_P (DECL_INCOMING_RTL (decl))
16431 /* Not passed by invisible reference. */
16432 && (!REG_P (XEXP (rtl, 0))
16433 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
16434 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
16435 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
16436 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
16439 /* Big endian correction check. */
16440 && BYTES_BIG_ENDIAN
16441 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
16442 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
16445 int offset = (UNITS_PER_WORD
16446 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
16448 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
16449 plus_constant (XEXP (rtl, 0), offset));
16452 else if (TREE_CODE (decl) == VAR_DECL
16455 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
16456 && BYTES_BIG_ENDIAN)
16458 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
16459 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
16461 /* If a variable is declared "register" yet is smaller than
16462 a register, then if we store the variable to memory, it
16463 looks like we're storing a register-sized value, when in
16464 fact we are not. We need to adjust the offset of the
16465 storage location to reflect the actual value's bytes,
16466 else gdb will not be able to display it. */
16468 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
16469 plus_constant (XEXP (rtl, 0), rsize-dsize));
16472 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
16473 and will have been substituted directly into all expressions that use it.
16474 C does not have such a concept, but C++ and other languages do. */
16475 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
16476 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
16479 rtl = targetm.delegitimize_address (rtl);
16481 /* If we don't look past the constant pool, we risk emitting a
16482 reference to a constant pool entry that isn't referenced from
16483 code, and thus is not emitted. */
16485 rtl = avoid_constant_pool_reference (rtl);
16487 /* Try harder to get a rtl. If this symbol ends up not being emitted
16488 in the current CU, resolve_addr will remove the expression referencing
16490 if (rtl == NULL_RTX
16491 && TREE_CODE (decl) == VAR_DECL
16492 && !DECL_EXTERNAL (decl)
16493 && TREE_STATIC (decl)
16494 && DECL_NAME (decl)
16495 && !DECL_HARD_REGISTER (decl)
16496 && DECL_MODE (decl) != VOIDmode)
16498 rtl = make_decl_rtl_for_debug (decl);
16500 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
16501 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
16508 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
16509 returned. If so, the decl for the COMMON block is returned, and the
16510 value is the offset into the common block for the symbol. */
16513 fortran_common (tree decl, HOST_WIDE_INT *value)
16515 tree val_expr, cvar;
16516 enum machine_mode mode;
16517 HOST_WIDE_INT bitsize, bitpos;
16519 int volatilep = 0, unsignedp = 0;
16521 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
16522 it does not have a value (the offset into the common area), or if it
16523 is thread local (as opposed to global) then it isn't common, and shouldn't
16524 be handled as such. */
16525 if (TREE_CODE (decl) != VAR_DECL
16526 || !TREE_STATIC (decl)
16527 || !DECL_HAS_VALUE_EXPR_P (decl)
16531 val_expr = DECL_VALUE_EXPR (decl);
16532 if (TREE_CODE (val_expr) != COMPONENT_REF)
16535 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset,
16536 &mode, &unsignedp, &volatilep, true);
16538 if (cvar == NULL_TREE
16539 || TREE_CODE (cvar) != VAR_DECL
16540 || DECL_ARTIFICIAL (cvar)
16541 || !TREE_PUBLIC (cvar))
16545 if (offset != NULL)
16547 if (!host_integerp (offset, 0))
16549 *value = tree_low_cst (offset, 0);
16552 *value += bitpos / BITS_PER_UNIT;
16557 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
16558 data attribute for a variable or a parameter. We generate the
16559 DW_AT_const_value attribute only in those cases where the given variable
16560 or parameter does not have a true "location" either in memory or in a
16561 register. This can happen (for example) when a constant is passed as an
16562 actual argument in a call to an inline function. (It's possible that
16563 these things can crop up in other ways also.) Note that one type of
16564 constant value which can be passed into an inlined function is a constant
16565 pointer. This can happen for example if an actual argument in an inlined
16566 function call evaluates to a compile-time constant address. */
16569 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
16570 enum dwarf_attribute attr)
16573 dw_loc_list_ref list;
16574 var_loc_list *loc_list;
16576 if (TREE_CODE (decl) == ERROR_MARK)
16579 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
16580 || TREE_CODE (decl) == RESULT_DECL);
16582 /* Try to get some constant RTL for this decl, and use that as the value of
16585 rtl = rtl_for_decl_location (decl);
16586 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16587 && add_const_value_attribute (die, rtl))
16590 /* See if we have single element location list that is equivalent to
16591 a constant value. That way we are better to use add_const_value_attribute
16592 rather than expanding constant value equivalent. */
16593 loc_list = lookup_decl_loc (decl);
16596 && loc_list->first->next == NULL
16597 && NOTE_P (loc_list->first->loc)
16598 && NOTE_VAR_LOCATION (loc_list->first->loc)
16599 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
16601 struct var_loc_node *node;
16603 node = loc_list->first;
16604 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
16605 if (GET_CODE (rtl) == EXPR_LIST)
16606 rtl = XEXP (rtl, 0);
16607 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
16608 && add_const_value_attribute (die, rtl))
16611 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2);
16614 add_AT_location_description (die, attr, list);
16617 /* None of that worked, so it must not really have a location;
16618 try adding a constant value attribute from the DECL_INITIAL. */
16619 return tree_add_const_value_attribute_for_decl (die, decl);
16622 /* Add VARIABLE and DIE into deferred locations list. */
16625 defer_location (tree variable, dw_die_ref die)
16627 deferred_locations entry;
16628 entry.variable = variable;
16630 VEC_safe_push (deferred_locations, gc, deferred_locations_list, &entry);
16633 /* Helper function for tree_add_const_value_attribute. Natively encode
16634 initializer INIT into an array. Return true if successful. */
16637 native_encode_initializer (tree init, unsigned char *array, int size)
16641 if (init == NULL_TREE)
16645 switch (TREE_CODE (init))
16648 type = TREE_TYPE (init);
16649 if (TREE_CODE (type) == ARRAY_TYPE)
16651 tree enttype = TREE_TYPE (type);
16652 enum machine_mode mode = TYPE_MODE (enttype);
16654 if (GET_MODE_CLASS (mode) != MODE_INT || GET_MODE_SIZE (mode) != 1)
16656 if (int_size_in_bytes (type) != size)
16658 if (size > TREE_STRING_LENGTH (init))
16660 memcpy (array, TREE_STRING_POINTER (init),
16661 TREE_STRING_LENGTH (init));
16662 memset (array + TREE_STRING_LENGTH (init),
16663 '\0', size - TREE_STRING_LENGTH (init));
16666 memcpy (array, TREE_STRING_POINTER (init), size);
16671 type = TREE_TYPE (init);
16672 if (int_size_in_bytes (type) != size)
16674 if (TREE_CODE (type) == ARRAY_TYPE)
16676 HOST_WIDE_INT min_index;
16677 unsigned HOST_WIDE_INT cnt;
16678 int curpos = 0, fieldsize;
16679 constructor_elt *ce;
16681 if (TYPE_DOMAIN (type) == NULL_TREE
16682 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0))
16685 fieldsize = int_size_in_bytes (TREE_TYPE (type));
16686 if (fieldsize <= 0)
16689 min_index = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0);
16690 memset (array, '\0', size);
16692 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
16695 tree val = ce->value;
16696 tree index = ce->index;
16698 if (index && TREE_CODE (index) == RANGE_EXPR)
16699 pos = (tree_low_cst (TREE_OPERAND (index, 0), 0) - min_index)
16702 pos = (tree_low_cst (index, 0) - min_index) * fieldsize;
16707 if (!native_encode_initializer (val, array + pos, fieldsize))
16710 curpos = pos + fieldsize;
16711 if (index && TREE_CODE (index) == RANGE_EXPR)
16713 int count = tree_low_cst (TREE_OPERAND (index, 1), 0)
16714 - tree_low_cst (TREE_OPERAND (index, 0), 0);
16718 memcpy (array + curpos, array + pos, fieldsize);
16719 curpos += fieldsize;
16722 gcc_assert (curpos <= size);
16726 else if (TREE_CODE (type) == RECORD_TYPE
16727 || TREE_CODE (type) == UNION_TYPE)
16729 tree field = NULL_TREE;
16730 unsigned HOST_WIDE_INT cnt;
16731 constructor_elt *ce;
16733 if (int_size_in_bytes (type) != size)
16736 if (TREE_CODE (type) == RECORD_TYPE)
16737 field = TYPE_FIELDS (type);
16740 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (init), cnt, ce);
16741 cnt++, field = field ? TREE_CHAIN (field) : 0)
16743 tree val = ce->value;
16744 int pos, fieldsize;
16746 if (ce->index != 0)
16752 if (field == NULL_TREE || DECL_BIT_FIELD (field))
16755 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
16756 && TYPE_DOMAIN (TREE_TYPE (field))
16757 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
16759 else if (DECL_SIZE_UNIT (field) == NULL_TREE
16760 || !host_integerp (DECL_SIZE_UNIT (field), 0))
16762 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 0);
16763 pos = int_byte_position (field);
16764 gcc_assert (pos + fieldsize <= size);
16766 && !native_encode_initializer (val, array + pos, fieldsize))
16772 case VIEW_CONVERT_EXPR:
16773 case NON_LVALUE_EXPR:
16774 return native_encode_initializer (TREE_OPERAND (init, 0), array, size);
16776 return native_encode_expr (init, array, size) == size;
16780 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16781 attribute is the const value T. */
16784 tree_add_const_value_attribute (dw_die_ref die, tree t)
16787 tree type = TREE_TYPE (t);
16790 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
16794 gcc_assert (!DECL_P (init));
16796 rtl = rtl_for_decl_init (init, type);
16798 return add_const_value_attribute (die, rtl);
16799 /* If the host and target are sane, try harder. */
16800 else if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
16801 && initializer_constant_valid_p (init, type))
16803 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
16804 if (size > 0 && (int) size == size)
16806 unsigned char *array = (unsigned char *)
16807 ggc_alloc_cleared_atomic (size);
16809 if (native_encode_initializer (init, array, size))
16811 add_AT_vec (die, DW_AT_const_value, size, 1, array);
16819 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16820 attribute is the const value of T, where T is an integral constant
16821 variable with static storage duration
16822 (so it can't be a PARM_DECL or a RESULT_DECL). */
16825 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
16829 || (TREE_CODE (decl) != VAR_DECL
16830 && TREE_CODE (decl) != CONST_DECL))
16833 if (TREE_READONLY (decl)
16834 && ! TREE_THIS_VOLATILE (decl)
16835 && DECL_INITIAL (decl))
16840 /* Don't add DW_AT_const_value if abstract origin already has one. */
16841 if (get_AT (var_die, DW_AT_const_value))
16844 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
16847 /* Convert the CFI instructions for the current function into a
16848 location list. This is used for DW_AT_frame_base when we targeting
16849 a dwarf2 consumer that does not support the dwarf3
16850 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16853 static dw_loc_list_ref
16854 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
16857 dw_loc_list_ref list, *list_tail;
16859 dw_cfa_location last_cfa, next_cfa;
16860 const char *start_label, *last_label, *section;
16861 dw_cfa_location remember;
16863 fde = current_fde ();
16864 gcc_assert (fde != NULL);
16866 section = secname_for_decl (current_function_decl);
16870 memset (&next_cfa, 0, sizeof (next_cfa));
16871 next_cfa.reg = INVALID_REGNUM;
16872 remember = next_cfa;
16874 start_label = fde->dw_fde_begin;
16876 /* ??? Bald assumption that the CIE opcode list does not contain
16877 advance opcodes. */
16878 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
16879 lookup_cfa_1 (cfi, &next_cfa, &remember);
16881 last_cfa = next_cfa;
16882 last_label = start_label;
16884 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
16885 switch (cfi->dw_cfi_opc)
16887 case DW_CFA_set_loc:
16888 case DW_CFA_advance_loc1:
16889 case DW_CFA_advance_loc2:
16890 case DW_CFA_advance_loc4:
16891 if (!cfa_equal_p (&last_cfa, &next_cfa))
16893 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16894 start_label, last_label, section);
16896 list_tail = &(*list_tail)->dw_loc_next;
16897 last_cfa = next_cfa;
16898 start_label = last_label;
16900 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
16903 case DW_CFA_advance_loc:
16904 /* The encoding is complex enough that we should never emit this. */
16905 gcc_unreachable ();
16908 lookup_cfa_1 (cfi, &next_cfa, &remember);
16912 if (!cfa_equal_p (&last_cfa, &next_cfa))
16914 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
16915 start_label, last_label, section);
16916 list_tail = &(*list_tail)->dw_loc_next;
16917 start_label = last_label;
16920 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
16921 start_label, fde->dw_fde_end, section);
16923 if (list && list->dw_loc_next)
16929 /* Compute a displacement from the "steady-state frame pointer" to the
16930 frame base (often the same as the CFA), and store it in
16931 frame_pointer_fb_offset. OFFSET is added to the displacement
16932 before the latter is negated. */
16935 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset)
16939 #ifdef FRAME_POINTER_CFA_OFFSET
16940 reg = frame_pointer_rtx;
16941 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
16943 reg = arg_pointer_rtx;
16944 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
16947 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
16948 if (GET_CODE (elim) == PLUS)
16950 offset += INTVAL (XEXP (elim, 1));
16951 elim = XEXP (elim, 0);
16954 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
16955 && (elim == hard_frame_pointer_rtx
16956 || elim == stack_pointer_rtx))
16957 || elim == (frame_pointer_needed
16958 ? hard_frame_pointer_rtx
16959 : stack_pointer_rtx));
16961 frame_pointer_fb_offset = -offset;
16964 /* Generate a DW_AT_name attribute given some string value to be included as
16965 the value of the attribute. */
16968 add_name_attribute (dw_die_ref die, const char *name_string)
16970 if (name_string != NULL && *name_string != 0)
16972 if (demangle_name_func)
16973 name_string = (*demangle_name_func) (name_string);
16975 add_AT_string (die, DW_AT_name, name_string);
16979 /* Generate a DW_AT_comp_dir attribute for DIE. */
16982 add_comp_dir_attribute (dw_die_ref die)
16984 const char *wd = get_src_pwd ();
16990 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
16994 wdlen = strlen (wd);
16995 wd1 = (char *) ggc_alloc_atomic (wdlen + 2);
16997 wd1 [wdlen] = DIR_SEPARATOR;
16998 wd1 [wdlen + 1] = 0;
17002 add_AT_string (die, DW_AT_comp_dir, remap_debug_filename (wd));
17005 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
17009 lower_bound_default (void)
17011 switch (get_AT_unsigned (comp_unit_die, DW_AT_language))
17016 case DW_LANG_C_plus_plus:
17018 case DW_LANG_ObjC_plus_plus:
17021 case DW_LANG_Fortran77:
17022 case DW_LANG_Fortran90:
17023 case DW_LANG_Fortran95:
17027 case DW_LANG_Python:
17028 return dwarf_version >= 4 ? 0 : -1;
17029 case DW_LANG_Ada95:
17030 case DW_LANG_Ada83:
17031 case DW_LANG_Cobol74:
17032 case DW_LANG_Cobol85:
17033 case DW_LANG_Pascal83:
17034 case DW_LANG_Modula2:
17036 return dwarf_version >= 4 ? 1 : -1;
17042 /* Given a tree node describing an array bound (either lower or upper) output
17043 a representation for that bound. */
17046 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
17048 switch (TREE_CODE (bound))
17053 /* All fixed-bounds are represented by INTEGER_CST nodes. */
17056 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (bound));
17059 /* Use the default if possible. */
17060 if (bound_attr == DW_AT_lower_bound
17061 && host_integerp (bound, 0)
17062 && (dflt = lower_bound_default ()) != -1
17063 && tree_low_cst (bound, 0) == dflt)
17066 /* Otherwise represent the bound as an unsigned value with the
17067 precision of its type. The precision and signedness of the
17068 type will be necessary to re-interpret it unambiguously. */
17069 else if (prec < HOST_BITS_PER_WIDE_INT)
17071 unsigned HOST_WIDE_INT mask
17072 = ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
17073 add_AT_unsigned (subrange_die, bound_attr,
17074 TREE_INT_CST_LOW (bound) & mask);
17076 else if (prec == HOST_BITS_PER_WIDE_INT
17077 || TREE_INT_CST_HIGH (bound) == 0)
17078 add_AT_unsigned (subrange_die, bound_attr,
17079 TREE_INT_CST_LOW (bound));
17081 add_AT_double (subrange_die, bound_attr, TREE_INT_CST_HIGH (bound),
17082 TREE_INT_CST_LOW (bound));
17087 case VIEW_CONVERT_EXPR:
17088 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
17098 dw_die_ref decl_die = lookup_decl_die (bound);
17100 /* ??? Can this happen, or should the variable have been bound
17101 first? Probably it can, since I imagine that we try to create
17102 the types of parameters in the order in which they exist in
17103 the list, and won't have created a forward reference to a
17104 later parameter. */
17105 if (decl_die != NULL)
17107 add_AT_die_ref (subrange_die, bound_attr, decl_die);
17115 /* Otherwise try to create a stack operation procedure to
17116 evaluate the value of the array bound. */
17118 dw_die_ref ctx, decl_die;
17119 dw_loc_list_ref list;
17121 list = loc_list_from_tree (bound, 2);
17122 if (list == NULL || single_element_loc_list_p (list))
17124 /* If DW_AT_*bound is not a reference nor constant, it is
17125 a DWARF expression rather than location description.
17126 For that loc_list_from_tree (bound, 0) is needed.
17127 If that fails to give a single element list,
17128 fall back to outputting this as a reference anyway. */
17129 dw_loc_list_ref list2 = loc_list_from_tree (bound, 0);
17130 if (list2 && single_element_loc_list_p (list2))
17132 add_AT_loc (subrange_die, bound_attr, list2->expr);
17139 if (current_function_decl == 0)
17140 ctx = comp_unit_die;
17142 ctx = lookup_decl_die (current_function_decl);
17144 decl_die = new_die (DW_TAG_variable, ctx, bound);
17145 add_AT_flag (decl_die, DW_AT_artificial, 1);
17146 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
17147 add_AT_location_description (decl_die, DW_AT_location, list);
17148 add_AT_die_ref (subrange_die, bound_attr, decl_die);
17154 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
17155 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
17156 Note that the block of subscript information for an array type also
17157 includes information about the element type of the given array type. */
17160 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
17162 unsigned dimension_number;
17164 dw_die_ref subrange_die;
17166 for (dimension_number = 0;
17167 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
17168 type = TREE_TYPE (type), dimension_number++)
17170 tree domain = TYPE_DOMAIN (type);
17172 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
17175 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
17176 and (in GNU C only) variable bounds. Handle all three forms
17178 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
17181 /* We have an array type with specified bounds. */
17182 lower = TYPE_MIN_VALUE (domain);
17183 upper = TYPE_MAX_VALUE (domain);
17185 /* Define the index type. */
17186 if (TREE_TYPE (domain))
17188 /* ??? This is probably an Ada unnamed subrange type. Ignore the
17189 TREE_TYPE field. We can't emit debug info for this
17190 because it is an unnamed integral type. */
17191 if (TREE_CODE (domain) == INTEGER_TYPE
17192 && TYPE_NAME (domain) == NULL_TREE
17193 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
17194 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
17197 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
17201 /* ??? If upper is NULL, the array has unspecified length,
17202 but it does have a lower bound. This happens with Fortran
17204 Since the debugger is definitely going to need to know N
17205 to produce useful results, go ahead and output the lower
17206 bound solo, and hope the debugger can cope. */
17208 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
17210 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
17213 /* Otherwise we have an array type with an unspecified length. The
17214 DWARF-2 spec does not say how to handle this; let's just leave out the
17220 add_byte_size_attribute (dw_die_ref die, tree tree_node)
17224 switch (TREE_CODE (tree_node))
17229 case ENUMERAL_TYPE:
17232 case QUAL_UNION_TYPE:
17233 size = int_size_in_bytes (tree_node);
17236 /* For a data member of a struct or union, the DW_AT_byte_size is
17237 generally given as the number of bytes normally allocated for an
17238 object of the *declared* type of the member itself. This is true
17239 even for bit-fields. */
17240 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
17243 gcc_unreachable ();
17246 /* Note that `size' might be -1 when we get to this point. If it is, that
17247 indicates that the byte size of the entity in question is variable. We
17248 have no good way of expressing this fact in Dwarf at the present time,
17249 so just let the -1 pass on through. */
17250 add_AT_unsigned (die, DW_AT_byte_size, size);
17253 /* For a FIELD_DECL node which represents a bit-field, output an attribute
17254 which specifies the distance in bits from the highest order bit of the
17255 "containing object" for the bit-field to the highest order bit of the
17258 For any given bit-field, the "containing object" is a hypothetical object
17259 (of some integral or enum type) within which the given bit-field lives. The
17260 type of this hypothetical "containing object" is always the same as the
17261 declared type of the individual bit-field itself. The determination of the
17262 exact location of the "containing object" for a bit-field is rather
17263 complicated. It's handled by the `field_byte_offset' function (above).
17265 Note that it is the size (in bytes) of the hypothetical "containing object"
17266 which will be given in the DW_AT_byte_size attribute for this bit-field.
17267 (See `byte_size_attribute' above). */
17270 add_bit_offset_attribute (dw_die_ref die, tree decl)
17272 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
17273 tree type = DECL_BIT_FIELD_TYPE (decl);
17274 HOST_WIDE_INT bitpos_int;
17275 HOST_WIDE_INT highest_order_object_bit_offset;
17276 HOST_WIDE_INT highest_order_field_bit_offset;
17277 HOST_WIDE_INT unsigned bit_offset;
17279 /* Must be a field and a bit field. */
17280 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
17282 /* We can't yet handle bit-fields whose offsets are variable, so if we
17283 encounter such things, just return without generating any attribute
17284 whatsoever. Likewise for variable or too large size. */
17285 if (! host_integerp (bit_position (decl), 0)
17286 || ! host_integerp (DECL_SIZE (decl), 1))
17289 bitpos_int = int_bit_position (decl);
17291 /* Note that the bit offset is always the distance (in bits) from the
17292 highest-order bit of the "containing object" to the highest-order bit of
17293 the bit-field itself. Since the "high-order end" of any object or field
17294 is different on big-endian and little-endian machines, the computation
17295 below must take account of these differences. */
17296 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
17297 highest_order_field_bit_offset = bitpos_int;
17299 if (! BYTES_BIG_ENDIAN)
17301 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
17302 highest_order_object_bit_offset += simple_type_size_in_bits (type);
17306 = (! BYTES_BIG_ENDIAN
17307 ? highest_order_object_bit_offset - highest_order_field_bit_offset
17308 : highest_order_field_bit_offset - highest_order_object_bit_offset);
17310 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
17313 /* For a FIELD_DECL node which represents a bit field, output an attribute
17314 which specifies the length in bits of the given field. */
17317 add_bit_size_attribute (dw_die_ref die, tree decl)
17319 /* Must be a field and a bit field. */
17320 gcc_assert (TREE_CODE (decl) == FIELD_DECL
17321 && DECL_BIT_FIELD_TYPE (decl));
17323 if (host_integerp (DECL_SIZE (decl), 1))
17324 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
17327 /* If the compiled language is ANSI C, then add a 'prototyped'
17328 attribute, if arg types are given for the parameters of a function. */
17331 add_prototyped_attribute (dw_die_ref die, tree func_type)
17333 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
17334 && TYPE_ARG_TYPES (func_type) != NULL)
17335 add_AT_flag (die, DW_AT_prototyped, 1);
17338 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
17339 by looking in either the type declaration or object declaration
17342 static inline dw_die_ref
17343 add_abstract_origin_attribute (dw_die_ref die, tree origin)
17345 dw_die_ref origin_die = NULL;
17347 if (TREE_CODE (origin) != FUNCTION_DECL)
17349 /* We may have gotten separated from the block for the inlined
17350 function, if we're in an exception handler or some such; make
17351 sure that the abstract function has been written out.
17353 Doing this for nested functions is wrong, however; functions are
17354 distinct units, and our context might not even be inline. */
17358 fn = TYPE_STUB_DECL (fn);
17360 fn = decl_function_context (fn);
17362 dwarf2out_abstract_function (fn);
17365 if (DECL_P (origin))
17366 origin_die = lookup_decl_die (origin);
17367 else if (TYPE_P (origin))
17368 origin_die = lookup_type_die (origin);
17370 /* XXX: Functions that are never lowered don't always have correct block
17371 trees (in the case of java, they simply have no block tree, in some other
17372 languages). For these functions, there is nothing we can really do to
17373 output correct debug info for inlined functions in all cases. Rather
17374 than die, we'll just produce deficient debug info now, in that we will
17375 have variables without a proper abstract origin. In the future, when all
17376 functions are lowered, we should re-add a gcc_assert (origin_die)
17380 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
17384 /* We do not currently support the pure_virtual attribute. */
17387 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
17389 if (DECL_VINDEX (func_decl))
17391 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
17393 if (host_integerp (DECL_VINDEX (func_decl), 0))
17394 add_AT_loc (die, DW_AT_vtable_elem_location,
17395 new_loc_descr (DW_OP_constu,
17396 tree_low_cst (DECL_VINDEX (func_decl), 0),
17399 /* GNU extension: Record what type this method came from originally. */
17400 if (debug_info_level > DINFO_LEVEL_TERSE
17401 && DECL_CONTEXT (func_decl))
17402 add_AT_die_ref (die, DW_AT_containing_type,
17403 lookup_type_die (DECL_CONTEXT (func_decl)));
17407 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
17408 given decl. This used to be a vendor extension until after DWARF 4
17409 standardized it. */
17412 add_linkage_attr (dw_die_ref die, tree decl)
17414 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
17416 /* Mimic what assemble_name_raw does with a leading '*'. */
17417 if (name[0] == '*')
17420 if (dwarf_version >= 4)
17421 add_AT_string (die, DW_AT_linkage_name, name);
17423 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
17426 /* Add source coordinate attributes for the given decl. */
17429 add_src_coords_attributes (dw_die_ref die, tree decl)
17431 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
17433 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
17434 add_AT_unsigned (die, DW_AT_decl_line, s.line);
17437 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
17440 add_linkage_name (dw_die_ref die, tree decl)
17442 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
17443 && TREE_PUBLIC (decl)
17444 && !DECL_ABSTRACT (decl)
17445 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
17446 && die->die_tag != DW_TAG_member)
17448 /* Defer until we have an assembler name set. */
17449 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
17451 limbo_die_node *asm_name;
17453 asm_name = ggc_alloc_cleared_limbo_die_node ();
17454 asm_name->die = die;
17455 asm_name->created_for = decl;
17456 asm_name->next = deferred_asm_name;
17457 deferred_asm_name = asm_name;
17459 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
17460 add_linkage_attr (die, decl);
17464 /* Add a DW_AT_name attribute and source coordinate attribute for the
17465 given decl, but only if it actually has a name. */
17468 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
17472 decl_name = DECL_NAME (decl);
17473 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
17475 const char *name = dwarf2_name (decl, 0);
17477 add_name_attribute (die, name);
17478 if (! DECL_ARTIFICIAL (decl))
17479 add_src_coords_attributes (die, decl);
17481 add_linkage_name (die, decl);
17484 #ifdef VMS_DEBUGGING_INFO
17485 /* Get the function's name, as described by its RTL. This may be different
17486 from the DECL_NAME name used in the source file. */
17487 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
17489 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
17490 XEXP (DECL_RTL (decl), 0));
17491 VEC_safe_push (rtx, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
17496 #ifdef VMS_DEBUGGING_INFO
17498 /* Output the debug main pointer die for VMS */
17501 dwarf2out_vms_debug_main_pointer (void)
17503 char label[MAX_ARTIFICIAL_LABEL_BYTES];
17506 /* Allocate the VMS debug main subprogram die. */
17507 die = ggc_alloc_cleared_die_node ();
17508 die->die_tag = DW_TAG_subprogram;
17509 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
17510 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
17511 current_function_funcdef_no);
17512 add_AT_lbl_id (die, DW_AT_entry_pc, label);
17514 /* Make it the first child of comp_unit_die. */
17515 die->die_parent = comp_unit_die;
17516 if (comp_unit_die->die_child)
17518 die->die_sib = comp_unit_die->die_child->die_sib;
17519 comp_unit_die->die_child->die_sib = die;
17523 die->die_sib = die;
17524 comp_unit_die->die_child = die;
17529 /* Push a new declaration scope. */
17532 push_decl_scope (tree scope)
17534 VEC_safe_push (tree, gc, decl_scope_table, scope);
17537 /* Pop a declaration scope. */
17540 pop_decl_scope (void)
17542 VEC_pop (tree, decl_scope_table);
17545 /* Return the DIE for the scope that immediately contains this type.
17546 Non-named types get global scope. Named types nested in other
17547 types get their containing scope if it's open, or global scope
17548 otherwise. All other types (i.e. function-local named types) get
17549 the current active scope. */
17552 scope_die_for (tree t, dw_die_ref context_die)
17554 dw_die_ref scope_die = NULL;
17555 tree containing_scope;
17558 /* Non-types always go in the current scope. */
17559 gcc_assert (TYPE_P (t));
17561 containing_scope = TYPE_CONTEXT (t);
17563 /* Use the containing namespace if it was passed in (for a declaration). */
17564 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
17566 if (context_die == lookup_decl_die (containing_scope))
17569 containing_scope = NULL_TREE;
17572 /* Ignore function type "scopes" from the C frontend. They mean that
17573 a tagged type is local to a parmlist of a function declarator, but
17574 that isn't useful to DWARF. */
17575 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
17576 containing_scope = NULL_TREE;
17578 if (containing_scope == NULL_TREE)
17579 scope_die = comp_unit_die;
17580 else if (TYPE_P (containing_scope))
17582 /* For types, we can just look up the appropriate DIE. But
17583 first we check to see if we're in the middle of emitting it
17584 so we know where the new DIE should go. */
17585 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
17586 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
17591 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
17592 || TREE_ASM_WRITTEN (containing_scope));
17594 /* If none of the current dies are suitable, we get file scope. */
17595 scope_die = comp_unit_die;
17598 scope_die = lookup_type_die (containing_scope);
17601 scope_die = context_die;
17606 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17609 local_scope_p (dw_die_ref context_die)
17611 for (; context_die; context_die = context_die->die_parent)
17612 if (context_die->die_tag == DW_TAG_inlined_subroutine
17613 || context_die->die_tag == DW_TAG_subprogram)
17619 /* Returns nonzero if CONTEXT_DIE is a class. */
17622 class_scope_p (dw_die_ref context_die)
17624 return (context_die
17625 && (context_die->die_tag == DW_TAG_structure_type
17626 || context_die->die_tag == DW_TAG_class_type
17627 || context_die->die_tag == DW_TAG_interface_type
17628 || context_die->die_tag == DW_TAG_union_type));
17631 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17632 whether or not to treat a DIE in this context as a declaration. */
17635 class_or_namespace_scope_p (dw_die_ref context_die)
17637 return (class_scope_p (context_die)
17638 || (context_die && context_die->die_tag == DW_TAG_namespace));
17641 /* Many forms of DIEs require a "type description" attribute. This
17642 routine locates the proper "type descriptor" die for the type given
17643 by 'type', and adds a DW_AT_type attribute below the given die. */
17646 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
17647 int decl_volatile, dw_die_ref context_die)
17649 enum tree_code code = TREE_CODE (type);
17650 dw_die_ref type_die = NULL;
17652 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17653 or fixed-point type, use the inner type. This is because we have no
17654 support for unnamed types in base_type_die. This can happen if this is
17655 an Ada subrange type. Correct solution is emit a subrange type die. */
17656 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
17657 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
17658 type = TREE_TYPE (type), code = TREE_CODE (type);
17660 if (code == ERROR_MARK
17661 /* Handle a special case. For functions whose return type is void, we
17662 generate *no* type attribute. (Note that no object may have type
17663 `void', so this only applies to function return types). */
17664 || code == VOID_TYPE)
17667 type_die = modified_type_die (type,
17668 decl_const || TYPE_READONLY (type),
17669 decl_volatile || TYPE_VOLATILE (type),
17672 if (type_die != NULL)
17673 add_AT_die_ref (object_die, DW_AT_type, type_die);
17676 /* Given an object die, add the calling convention attribute for the
17677 function call type. */
17679 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
17681 enum dwarf_calling_convention value = DW_CC_normal;
17683 value = ((enum dwarf_calling_convention)
17684 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
17686 /* DWARF doesn't provide a way to identify a program's source-level
17687 entry point. DW_AT_calling_convention attributes are only meant
17688 to describe functions' calling conventions. However, lacking a
17689 better way to signal the Fortran main program, we use this for the
17690 time being, following existing custom. */
17692 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "MAIN__"))
17693 value = DW_CC_program;
17695 /* Only add the attribute if the backend requests it, and
17696 is not DW_CC_normal. */
17697 if (value && (value != DW_CC_normal))
17698 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
17701 /* Given a tree pointer to a struct, class, union, or enum type node, return
17702 a pointer to the (string) tag name for the given type, or zero if the type
17703 was declared without a tag. */
17705 static const char *
17706 type_tag (const_tree type)
17708 const char *name = 0;
17710 if (TYPE_NAME (type) != 0)
17714 /* Find the IDENTIFIER_NODE for the type name. */
17715 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
17716 t = TYPE_NAME (type);
17718 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17719 a TYPE_DECL node, regardless of whether or not a `typedef' was
17721 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
17722 && ! DECL_IGNORED_P (TYPE_NAME (type)))
17724 /* We want to be extra verbose. Don't call dwarf_name if
17725 DECL_NAME isn't set. The default hook for decl_printable_name
17726 doesn't like that, and in this context it's correct to return
17727 0, instead of "<anonymous>" or the like. */
17728 if (DECL_NAME (TYPE_NAME (type)))
17729 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
17732 /* Now get the name as a string, or invent one. */
17733 if (!name && t != 0)
17734 name = IDENTIFIER_POINTER (t);
17737 return (name == 0 || *name == '\0') ? 0 : name;
17740 /* Return the type associated with a data member, make a special check
17741 for bit field types. */
17744 member_declared_type (const_tree member)
17746 return (DECL_BIT_FIELD_TYPE (member)
17747 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
17750 /* Get the decl's label, as described by its RTL. This may be different
17751 from the DECL_NAME name used in the source file. */
17754 static const char *
17755 decl_start_label (tree decl)
17758 const char *fnname;
17760 x = DECL_RTL (decl);
17761 gcc_assert (MEM_P (x));
17764 gcc_assert (GET_CODE (x) == SYMBOL_REF);
17766 fnname = XSTR (x, 0);
17771 /* These routines generate the internal representation of the DIE's for
17772 the compilation unit. Debugging information is collected by walking
17773 the declaration trees passed in from dwarf2out_decl(). */
17776 gen_array_type_die (tree type, dw_die_ref context_die)
17778 dw_die_ref scope_die = scope_die_for (type, context_die);
17779 dw_die_ref array_die;
17781 /* GNU compilers represent multidimensional array types as sequences of one
17782 dimensional array types whose element types are themselves array types.
17783 We sometimes squish that down to a single array_type DIE with multiple
17784 subscripts in the Dwarf debugging info. The draft Dwarf specification
17785 say that we are allowed to do this kind of compression in C, because
17786 there is no difference between an array of arrays and a multidimensional
17787 array. We don't do this for Ada to remain as close as possible to the
17788 actual representation, which is especially important against the language
17789 flexibilty wrt arrays of variable size. */
17791 bool collapse_nested_arrays = !is_ada ();
17794 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17795 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17796 if (TYPE_STRING_FLAG (type)
17797 && TREE_CODE (type) == ARRAY_TYPE
17799 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
17801 HOST_WIDE_INT size;
17803 array_die = new_die (DW_TAG_string_type, scope_die, type);
17804 add_name_attribute (array_die, type_tag (type));
17805 equate_type_number_to_die (type, array_die);
17806 size = int_size_in_bytes (type);
17808 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17809 else if (TYPE_DOMAIN (type) != NULL_TREE
17810 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE
17811 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
17813 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
17814 dw_loc_list_ref loc = loc_list_from_tree (szdecl, 2);
17816 size = int_size_in_bytes (TREE_TYPE (szdecl));
17817 if (loc && size > 0)
17819 add_AT_location_description (array_die, DW_AT_string_length, loc);
17820 if (size != DWARF2_ADDR_SIZE)
17821 add_AT_unsigned (array_die, DW_AT_byte_size, size);
17827 /* ??? The SGI dwarf reader fails for array of array of enum types
17828 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
17829 array type comes before the outer array type. We thus call gen_type_die
17830 before we new_die and must prevent nested array types collapsing for this
17833 #ifdef MIPS_DEBUGGING_INFO
17834 gen_type_die (TREE_TYPE (type), context_die);
17835 collapse_nested_arrays = false;
17838 array_die = new_die (DW_TAG_array_type, scope_die, type);
17839 add_name_attribute (array_die, type_tag (type));
17840 equate_type_number_to_die (type, array_die);
17842 if (TREE_CODE (type) == VECTOR_TYPE)
17844 /* The frontend feeds us a representation for the vector as a struct
17845 containing an array. Pull out the array type. */
17846 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
17847 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
17850 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17852 && TREE_CODE (type) == ARRAY_TYPE
17853 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
17854 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
17855 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
17858 /* We default the array ordering. SDB will probably do
17859 the right things even if DW_AT_ordering is not present. It's not even
17860 an issue until we start to get into multidimensional arrays anyway. If
17861 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17862 then we'll have to put the DW_AT_ordering attribute back in. (But if
17863 and when we find out that we need to put these in, we will only do so
17864 for multidimensional arrays. */
17865 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
17868 #ifdef MIPS_DEBUGGING_INFO
17869 /* The SGI compilers handle arrays of unknown bound by setting
17870 AT_declaration and not emitting any subrange DIEs. */
17871 if (! TYPE_DOMAIN (type))
17872 add_AT_flag (array_die, DW_AT_declaration, 1);
17875 add_subscript_info (array_die, type, collapse_nested_arrays);
17877 /* Add representation of the type of the elements of this array type and
17878 emit the corresponding DIE if we haven't done it already. */
17879 element_type = TREE_TYPE (type);
17880 if (collapse_nested_arrays)
17881 while (TREE_CODE (element_type) == ARRAY_TYPE)
17883 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
17885 element_type = TREE_TYPE (element_type);
17888 #ifndef MIPS_DEBUGGING_INFO
17889 gen_type_die (element_type, context_die);
17892 add_type_attribute (array_die, element_type, 0, 0, context_die);
17894 if (get_AT (array_die, DW_AT_name))
17895 add_pubtype (type, array_die);
17898 static dw_loc_descr_ref
17899 descr_info_loc (tree val, tree base_decl)
17901 HOST_WIDE_INT size;
17902 dw_loc_descr_ref loc, loc2;
17903 enum dwarf_location_atom op;
17905 if (val == base_decl)
17906 return new_loc_descr (DW_OP_push_object_address, 0, 0);
17908 switch (TREE_CODE (val))
17911 return descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17913 return loc_descriptor_from_tree (val, 0);
17915 if (host_integerp (val, 0))
17916 return int_loc_descriptor (tree_low_cst (val, 0));
17919 size = int_size_in_bytes (TREE_TYPE (val));
17922 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17925 if (size == DWARF2_ADDR_SIZE)
17926 add_loc_descr (&loc, new_loc_descr (DW_OP_deref, 0, 0));
17928 add_loc_descr (&loc, new_loc_descr (DW_OP_deref_size, size, 0));
17930 case POINTER_PLUS_EXPR:
17932 if (host_integerp (TREE_OPERAND (val, 1), 1)
17933 && (unsigned HOST_WIDE_INT) tree_low_cst (TREE_OPERAND (val, 1), 1)
17936 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17939 loc_descr_plus_const (&loc, tree_low_cst (TREE_OPERAND (val, 1), 0));
17945 loc = descr_info_loc (TREE_OPERAND (val, 0), base_decl);
17948 loc2 = descr_info_loc (TREE_OPERAND (val, 1), base_decl);
17951 add_loc_descr (&loc, loc2);
17952 add_loc_descr (&loc2, new_loc_descr (op, 0, 0));
17974 add_descr_info_field (dw_die_ref die, enum dwarf_attribute attr,
17975 tree val, tree base_decl)
17977 dw_loc_descr_ref loc;
17979 if (host_integerp (val, 0))
17981 add_AT_unsigned (die, attr, tree_low_cst (val, 0));
17985 loc = descr_info_loc (val, base_decl);
17989 add_AT_loc (die, attr, loc);
17992 /* This routine generates DIE for array with hidden descriptor, details
17993 are filled into *info by a langhook. */
17996 gen_descr_array_type_die (tree type, struct array_descr_info *info,
17997 dw_die_ref context_die)
17999 dw_die_ref scope_die = scope_die_for (type, context_die);
18000 dw_die_ref array_die;
18003 array_die = new_die (DW_TAG_array_type, scope_die, type);
18004 add_name_attribute (array_die, type_tag (type));
18005 equate_type_number_to_die (type, array_die);
18007 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
18009 && info->ndimensions >= 2)
18010 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
18012 if (info->data_location)
18013 add_descr_info_field (array_die, DW_AT_data_location, info->data_location,
18015 if (info->associated)
18016 add_descr_info_field (array_die, DW_AT_associated, info->associated,
18018 if (info->allocated)
18019 add_descr_info_field (array_die, DW_AT_allocated, info->allocated,
18022 for (dim = 0; dim < info->ndimensions; dim++)
18024 dw_die_ref subrange_die
18025 = new_die (DW_TAG_subrange_type, array_die, NULL);
18027 if (info->dimen[dim].lower_bound)
18029 /* If it is the default value, omit it. */
18032 if (host_integerp (info->dimen[dim].lower_bound, 0)
18033 && (dflt = lower_bound_default ()) != -1
18034 && tree_low_cst (info->dimen[dim].lower_bound, 0) == dflt)
18037 add_descr_info_field (subrange_die, DW_AT_lower_bound,
18038 info->dimen[dim].lower_bound,
18041 if (info->dimen[dim].upper_bound)
18042 add_descr_info_field (subrange_die, DW_AT_upper_bound,
18043 info->dimen[dim].upper_bound,
18045 if (info->dimen[dim].stride)
18046 add_descr_info_field (subrange_die, DW_AT_byte_stride,
18047 info->dimen[dim].stride,
18051 gen_type_die (info->element_type, context_die);
18052 add_type_attribute (array_die, info->element_type, 0, 0, context_die);
18054 if (get_AT (array_die, DW_AT_name))
18055 add_pubtype (type, array_die);
18060 gen_entry_point_die (tree decl, dw_die_ref context_die)
18062 tree origin = decl_ultimate_origin (decl);
18063 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
18065 if (origin != NULL)
18066 add_abstract_origin_attribute (decl_die, origin);
18069 add_name_and_src_coords_attributes (decl_die, decl);
18070 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
18071 0, 0, context_die);
18074 if (DECL_ABSTRACT (decl))
18075 equate_decl_number_to_die (decl, decl_die);
18077 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
18081 /* Walk through the list of incomplete types again, trying once more to
18082 emit full debugging info for them. */
18085 retry_incomplete_types (void)
18089 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
18090 if (should_emit_struct_debug (VEC_index (tree, incomplete_types, i),
18091 DINFO_USAGE_DIR_USE))
18092 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
18095 /* Determine what tag to use for a record type. */
18097 static enum dwarf_tag
18098 record_type_tag (tree type)
18100 if (! lang_hooks.types.classify_record)
18101 return DW_TAG_structure_type;
18103 switch (lang_hooks.types.classify_record (type))
18105 case RECORD_IS_STRUCT:
18106 return DW_TAG_structure_type;
18108 case RECORD_IS_CLASS:
18109 return DW_TAG_class_type;
18111 case RECORD_IS_INTERFACE:
18112 if (dwarf_version >= 3 || !dwarf_strict)
18113 return DW_TAG_interface_type;
18114 return DW_TAG_structure_type;
18117 gcc_unreachable ();
18121 /* Generate a DIE to represent an enumeration type. Note that these DIEs
18122 include all of the information about the enumeration values also. Each
18123 enumerated type name/value is listed as a child of the enumerated type
18127 gen_enumeration_type_die (tree type, dw_die_ref context_die)
18129 dw_die_ref type_die = lookup_type_die (type);
18131 if (type_die == NULL)
18133 type_die = new_die (DW_TAG_enumeration_type,
18134 scope_die_for (type, context_die), type);
18135 equate_type_number_to_die (type, type_die);
18136 add_name_attribute (type_die, type_tag (type));
18137 if ((dwarf_version >= 4 || !dwarf_strict)
18138 && ENUM_IS_SCOPED (type))
18139 add_AT_flag (type_die, DW_AT_enum_class, 1);
18141 else if (! TYPE_SIZE (type))
18144 remove_AT (type_die, DW_AT_declaration);
18146 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
18147 given enum type is incomplete, do not generate the DW_AT_byte_size
18148 attribute or the DW_AT_element_list attribute. */
18149 if (TYPE_SIZE (type))
18153 TREE_ASM_WRITTEN (type) = 1;
18154 add_byte_size_attribute (type_die, type);
18155 if (TYPE_STUB_DECL (type) != NULL_TREE)
18157 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
18158 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
18161 /* If the first reference to this type was as the return type of an
18162 inline function, then it may not have a parent. Fix this now. */
18163 if (type_die->die_parent == NULL)
18164 add_child_die (scope_die_for (type, context_die), type_die);
18166 for (link = TYPE_VALUES (type);
18167 link != NULL; link = TREE_CHAIN (link))
18169 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
18170 tree value = TREE_VALUE (link);
18172 add_name_attribute (enum_die,
18173 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
18175 if (TREE_CODE (value) == CONST_DECL)
18176 value = DECL_INITIAL (value);
18178 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
18179 /* DWARF2 does not provide a way of indicating whether or
18180 not enumeration constants are signed or unsigned. GDB
18181 always assumes the values are signed, so we output all
18182 values as if they were signed. That means that
18183 enumeration constants with very large unsigned values
18184 will appear to have negative values in the debugger. */
18185 add_AT_int (enum_die, DW_AT_const_value,
18186 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
18190 add_AT_flag (type_die, DW_AT_declaration, 1);
18192 if (get_AT (type_die, DW_AT_name))
18193 add_pubtype (type, type_die);
18198 /* Generate a DIE to represent either a real live formal parameter decl or to
18199 represent just the type of some formal parameter position in some function
18202 Note that this routine is a bit unusual because its argument may be a
18203 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
18204 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
18205 node. If it's the former then this function is being called to output a
18206 DIE to represent a formal parameter object (or some inlining thereof). If
18207 it's the latter, then this function is only being called to output a
18208 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
18209 argument type of some subprogram type.
18210 If EMIT_NAME_P is true, name and source coordinate attributes
18214 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
18215 dw_die_ref context_die)
18217 tree node_or_origin = node ? node : origin;
18218 tree ultimate_origin;
18219 dw_die_ref parm_die
18220 = new_die (DW_TAG_formal_parameter, context_die, node);
18222 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
18224 case tcc_declaration:
18225 ultimate_origin = decl_ultimate_origin (node_or_origin);
18226 if (node || ultimate_origin)
18227 origin = ultimate_origin;
18228 if (origin != NULL)
18229 add_abstract_origin_attribute (parm_die, origin);
18230 else if (emit_name_p)
18231 add_name_and_src_coords_attributes (parm_die, node);
18233 || (! DECL_ABSTRACT (node_or_origin)
18234 && variably_modified_type_p (TREE_TYPE (node_or_origin),
18235 decl_function_context
18236 (node_or_origin))))
18238 tree type = TREE_TYPE (node_or_origin);
18239 if (decl_by_reference_p (node_or_origin))
18240 add_type_attribute (parm_die, TREE_TYPE (type), 0, 0,
18243 add_type_attribute (parm_die, type,
18244 TREE_READONLY (node_or_origin),
18245 TREE_THIS_VOLATILE (node_or_origin),
18248 if (origin == NULL && DECL_ARTIFICIAL (node))
18249 add_AT_flag (parm_die, DW_AT_artificial, 1);
18251 if (node && node != origin)
18252 equate_decl_number_to_die (node, parm_die);
18253 if (! DECL_ABSTRACT (node_or_origin))
18254 add_location_or_const_value_attribute (parm_die, node_or_origin,
18260 /* We were called with some kind of a ..._TYPE node. */
18261 add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
18265 gcc_unreachable ();
18271 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
18272 children DW_TAG_formal_parameter DIEs representing the arguments of the
18275 PARM_PACK must be a function parameter pack.
18276 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
18277 must point to the subsequent arguments of the function PACK_ARG belongs to.
18278 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
18279 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
18280 following the last one for which a DIE was generated. */
18283 gen_formal_parameter_pack_die (tree parm_pack,
18285 dw_die_ref subr_die,
18289 dw_die_ref parm_pack_die;
18291 gcc_assert (parm_pack
18292 && lang_hooks.function_parameter_pack_p (parm_pack)
18295 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
18296 add_src_coords_attributes (parm_pack_die, parm_pack);
18298 for (arg = pack_arg; arg; arg = TREE_CHAIN (arg))
18300 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
18303 gen_formal_parameter_die (arg, NULL,
18304 false /* Don't emit name attribute. */,
18309 return parm_pack_die;
18312 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
18313 at the end of an (ANSI prototyped) formal parameters list. */
18316 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
18318 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
18321 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
18322 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
18323 parameters as specified in some function type specification (except for
18324 those which appear as part of a function *definition*). */
18327 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
18330 tree formal_type = NULL;
18331 tree first_parm_type;
18334 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
18336 arg = DECL_ARGUMENTS (function_or_method_type);
18337 function_or_method_type = TREE_TYPE (function_or_method_type);
18342 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
18344 /* Make our first pass over the list of formal parameter types and output a
18345 DW_TAG_formal_parameter DIE for each one. */
18346 for (link = first_parm_type; link; )
18348 dw_die_ref parm_die;
18350 formal_type = TREE_VALUE (link);
18351 if (formal_type == void_type_node)
18354 /* Output a (nameless) DIE to represent the formal parameter itself. */
18355 parm_die = gen_formal_parameter_die (formal_type, NULL,
18356 true /* Emit name attribute. */,
18358 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
18359 && link == first_parm_type)
18360 || (arg && DECL_ARTIFICIAL (arg)))
18361 add_AT_flag (parm_die, DW_AT_artificial, 1);
18363 link = TREE_CHAIN (link);
18365 arg = TREE_CHAIN (arg);
18368 /* If this function type has an ellipsis, add a
18369 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
18370 if (formal_type != void_type_node)
18371 gen_unspecified_parameters_die (function_or_method_type, context_die);
18373 /* Make our second (and final) pass over the list of formal parameter types
18374 and output DIEs to represent those types (as necessary). */
18375 for (link = TYPE_ARG_TYPES (function_or_method_type);
18376 link && TREE_VALUE (link);
18377 link = TREE_CHAIN (link))
18378 gen_type_die (TREE_VALUE (link), context_die);
18381 /* We want to generate the DIE for TYPE so that we can generate the
18382 die for MEMBER, which has been defined; we will need to refer back
18383 to the member declaration nested within TYPE. If we're trying to
18384 generate minimal debug info for TYPE, processing TYPE won't do the
18385 trick; we need to attach the member declaration by hand. */
18388 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
18390 gen_type_die (type, context_die);
18392 /* If we're trying to avoid duplicate debug info, we may not have
18393 emitted the member decl for this function. Emit it now. */
18394 if (TYPE_STUB_DECL (type)
18395 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
18396 && ! lookup_decl_die (member))
18398 dw_die_ref type_die;
18399 gcc_assert (!decl_ultimate_origin (member));
18401 push_decl_scope (type);
18402 type_die = lookup_type_die (type);
18403 if (TREE_CODE (member) == FUNCTION_DECL)
18404 gen_subprogram_die (member, type_die);
18405 else if (TREE_CODE (member) == FIELD_DECL)
18407 /* Ignore the nameless fields that are used to skip bits but handle
18408 C++ anonymous unions and structs. */
18409 if (DECL_NAME (member) != NULL_TREE
18410 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
18411 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
18413 gen_type_die (member_declared_type (member), type_die);
18414 gen_field_die (member, type_die);
18418 gen_variable_die (member, NULL_TREE, type_die);
18424 /* Generate the DWARF2 info for the "abstract" instance of a function which we
18425 may later generate inlined and/or out-of-line instances of. */
18428 dwarf2out_abstract_function (tree decl)
18430 dw_die_ref old_die;
18434 htab_t old_decl_loc_table;
18436 /* Make sure we have the actual abstract inline, not a clone. */
18437 decl = DECL_ORIGIN (decl);
18439 old_die = lookup_decl_die (decl);
18440 if (old_die && get_AT (old_die, DW_AT_inline))
18441 /* We've already generated the abstract instance. */
18444 /* We can be called while recursively when seeing block defining inlined subroutine
18445 DIE. Be sure to not clobber the outer location table nor use it or we would
18446 get locations in abstract instantces. */
18447 old_decl_loc_table = decl_loc_table;
18448 decl_loc_table = NULL;
18450 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
18451 we don't get confused by DECL_ABSTRACT. */
18452 if (debug_info_level > DINFO_LEVEL_TERSE)
18454 context = decl_class_context (decl);
18456 gen_type_die_for_member
18457 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
18460 /* Pretend we've just finished compiling this function. */
18461 save_fn = current_function_decl;
18462 current_function_decl = decl;
18463 push_cfun (DECL_STRUCT_FUNCTION (decl));
18465 was_abstract = DECL_ABSTRACT (decl);
18466 set_decl_abstract_flags (decl, 1);
18467 dwarf2out_decl (decl);
18468 if (! was_abstract)
18469 set_decl_abstract_flags (decl, 0);
18471 current_function_decl = save_fn;
18472 decl_loc_table = old_decl_loc_table;
18476 /* Helper function of premark_used_types() which gets called through
18479 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18480 marked as unused by prune_unused_types. */
18483 premark_used_types_helper (void **slot, void *data ATTRIBUTE_UNUSED)
18488 type = (tree) *slot;
18489 die = lookup_type_die (type);
18491 die->die_perennial_p = 1;
18495 /* Helper function of premark_types_used_by_global_vars which gets called
18496 through htab_traverse.
18498 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18499 marked as unused by prune_unused_types. The DIE of the type is marked
18500 only if the global variable using the type will actually be emitted. */
18503 premark_types_used_by_global_vars_helper (void **slot,
18504 void *data ATTRIBUTE_UNUSED)
18506 struct types_used_by_vars_entry *entry;
18509 entry = (struct types_used_by_vars_entry *) *slot;
18510 gcc_assert (entry->type != NULL
18511 && entry->var_decl != NULL);
18512 die = lookup_type_die (entry->type);
18515 /* Ask cgraph if the global variable really is to be emitted.
18516 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18517 struct varpool_node *node = varpool_get_node (entry->var_decl);
18518 if (node && node->needed)
18520 die->die_perennial_p = 1;
18521 /* Keep the parent DIEs as well. */
18522 while ((die = die->die_parent) && die->die_perennial_p == 0)
18523 die->die_perennial_p = 1;
18529 /* Mark all members of used_types_hash as perennial. */
18532 premark_used_types (void)
18534 if (cfun && cfun->used_types_hash)
18535 htab_traverse (cfun->used_types_hash, premark_used_types_helper, NULL);
18538 /* Mark all members of types_used_by_vars_entry as perennial. */
18541 premark_types_used_by_global_vars (void)
18543 if (types_used_by_vars_hash)
18544 htab_traverse (types_used_by_vars_hash,
18545 premark_types_used_by_global_vars_helper, NULL);
18548 /* Generate a DIE to represent a declared function (either file-scope or
18552 gen_subprogram_die (tree decl, dw_die_ref context_die)
18554 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
18555 tree origin = decl_ultimate_origin (decl);
18556 dw_die_ref subr_die;
18559 dw_die_ref old_die = lookup_decl_die (decl);
18560 int declaration = (current_function_decl != decl
18561 || class_or_namespace_scope_p (context_die));
18563 premark_used_types ();
18565 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
18566 started to generate the abstract instance of an inline, decided to output
18567 its containing class, and proceeded to emit the declaration of the inline
18568 from the member list for the class. If so, DECLARATION takes priority;
18569 we'll get back to the abstract instance when done with the class. */
18571 /* The class-scope declaration DIE must be the primary DIE. */
18572 if (origin && declaration && class_or_namespace_scope_p (context_die))
18575 gcc_assert (!old_die);
18578 /* Now that the C++ front end lazily declares artificial member fns, we
18579 might need to retrofit the declaration into its class. */
18580 if (!declaration && !origin && !old_die
18581 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
18582 && !class_or_namespace_scope_p (context_die)
18583 && debug_info_level > DINFO_LEVEL_TERSE)
18584 old_die = force_decl_die (decl);
18586 if (origin != NULL)
18588 gcc_assert (!declaration || local_scope_p (context_die));
18590 /* Fixup die_parent for the abstract instance of a nested
18591 inline function. */
18592 if (old_die && old_die->die_parent == NULL)
18593 add_child_die (context_die, old_die);
18595 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18596 add_abstract_origin_attribute (subr_die, origin);
18600 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
18601 struct dwarf_file_data * file_index = lookup_filename (s.file);
18603 if (!get_AT_flag (old_die, DW_AT_declaration)
18604 /* We can have a normal definition following an inline one in the
18605 case of redefinition of GNU C extern inlines.
18606 It seems reasonable to use AT_specification in this case. */
18607 && !get_AT (old_die, DW_AT_inline))
18609 /* Detect and ignore this case, where we are trying to output
18610 something we have already output. */
18614 /* If the definition comes from the same place as the declaration,
18615 maybe use the old DIE. We always want the DIE for this function
18616 that has the *_pc attributes to be under comp_unit_die so the
18617 debugger can find it. We also need to do this for abstract
18618 instances of inlines, since the spec requires the out-of-line copy
18619 to have the same parent. For local class methods, this doesn't
18620 apply; we just use the old DIE. */
18621 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
18622 && (DECL_ARTIFICIAL (decl)
18623 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
18624 && (get_AT_unsigned (old_die, DW_AT_decl_line)
18625 == (unsigned) s.line))))
18627 subr_die = old_die;
18629 /* Clear out the declaration attribute and the formal parameters.
18630 Do not remove all children, because it is possible that this
18631 declaration die was forced using force_decl_die(). In such
18632 cases die that forced declaration die (e.g. TAG_imported_module)
18633 is one of the children that we do not want to remove. */
18634 remove_AT (subr_die, DW_AT_declaration);
18635 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
18639 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18640 add_AT_specification (subr_die, old_die);
18641 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
18642 add_AT_file (subr_die, DW_AT_decl_file, file_index);
18643 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
18644 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
18649 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
18651 if (TREE_PUBLIC (decl))
18652 add_AT_flag (subr_die, DW_AT_external, 1);
18654 add_name_and_src_coords_attributes (subr_die, decl);
18655 if (debug_info_level > DINFO_LEVEL_TERSE)
18657 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
18658 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
18659 0, 0, context_die);
18662 add_pure_or_virtual_attribute (subr_die, decl);
18663 if (DECL_ARTIFICIAL (decl))
18664 add_AT_flag (subr_die, DW_AT_artificial, 1);
18666 add_accessibility_attribute (subr_die, decl);
18671 if (!old_die || !get_AT (old_die, DW_AT_inline))
18673 add_AT_flag (subr_die, DW_AT_declaration, 1);
18675 /* If this is an explicit function declaration then generate
18676 a DW_AT_explicit attribute. */
18677 if (lang_hooks.decls.function_decl_explicit_p (decl)
18678 && (dwarf_version >= 3 || !dwarf_strict))
18679 add_AT_flag (subr_die, DW_AT_explicit, 1);
18681 /* The first time we see a member function, it is in the context of
18682 the class to which it belongs. We make sure of this by emitting
18683 the class first. The next time is the definition, which is
18684 handled above. The two may come from the same source text.
18686 Note that force_decl_die() forces function declaration die. It is
18687 later reused to represent definition. */
18688 equate_decl_number_to_die (decl, subr_die);
18691 else if (DECL_ABSTRACT (decl))
18693 if (DECL_DECLARED_INLINE_P (decl))
18695 if (cgraph_function_possibly_inlined_p (decl))
18696 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
18698 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
18702 if (cgraph_function_possibly_inlined_p (decl))
18703 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
18705 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
18708 if (DECL_DECLARED_INLINE_P (decl)
18709 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
18710 add_AT_flag (subr_die, DW_AT_artificial, 1);
18712 equate_decl_number_to_die (decl, subr_die);
18714 else if (!DECL_EXTERNAL (decl))
18716 HOST_WIDE_INT cfa_fb_offset;
18718 if (!old_die || !get_AT (old_die, DW_AT_inline))
18719 equate_decl_number_to_die (decl, subr_die);
18721 if (!flag_reorder_blocks_and_partition)
18723 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
18724 current_function_funcdef_no);
18725 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
18726 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
18727 current_function_funcdef_no);
18728 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
18730 #if VMS_DEBUGGING_INFO
18731 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18732 Section 2.3 Prologue and Epilogue Attributes:
18733 When a breakpoint is set on entry to a function, it is generally
18734 desirable for execution to be suspended, not on the very first
18735 instruction of the function, but rather at a point after the
18736 function's frame has been set up, after any language defined local
18737 declaration processing has been completed, and before execution of
18738 the first statement of the function begins. Debuggers generally
18739 cannot properly determine where this point is. Similarly for a
18740 breakpoint set on exit from a function. The prologue and epilogue
18741 attributes allow a compiler to communicate the location(s) to use. */
18744 dw_fde_ref fde = &fde_table[current_funcdef_fde];
18746 if (fde->dw_fde_vms_end_prologue)
18747 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
18748 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
18750 if (fde->dw_fde_vms_begin_epilogue)
18751 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
18752 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
18756 add_pubname (decl, subr_die);
18757 add_arange (decl, subr_die);
18760 { /* Do nothing for now; maybe need to duplicate die, one for
18761 hot section and one for cold section, then use the hot/cold
18762 section begin/end labels to generate the aranges... */
18764 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
18765 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
18766 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
18767 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
18769 add_pubname (decl, subr_die);
18770 add_arange (decl, subr_die);
18771 add_arange (decl, subr_die);
18775 #ifdef MIPS_DEBUGGING_INFO
18776 /* Add a reference to the FDE for this routine. */
18777 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
18780 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
18782 /* We define the "frame base" as the function's CFA. This is more
18783 convenient for several reasons: (1) It's stable across the prologue
18784 and epilogue, which makes it better than just a frame pointer,
18785 (2) With dwarf3, there exists a one-byte encoding that allows us
18786 to reference the .debug_frame data by proxy, but failing that,
18787 (3) We can at least reuse the code inspection and interpretation
18788 code that determines the CFA position at various points in the
18790 if (dwarf_version >= 3)
18792 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
18793 add_AT_loc (subr_die, DW_AT_frame_base, op);
18797 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
18798 if (list->dw_loc_next)
18799 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
18801 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
18804 /* Compute a displacement from the "steady-state frame pointer" to
18805 the CFA. The former is what all stack slots and argument slots
18806 will reference in the rtl; the later is what we've told the
18807 debugger about. We'll need to adjust all frame_base references
18808 by this displacement. */
18809 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
18811 if (cfun->static_chain_decl)
18812 add_AT_location_description (subr_die, DW_AT_static_link,
18813 loc_list_from_tree (cfun->static_chain_decl, 2));
18816 /* Generate child dies for template paramaters. */
18817 if (debug_info_level > DINFO_LEVEL_TERSE)
18818 gen_generic_params_dies (decl);
18820 /* Now output descriptions of the arguments for this function. This gets
18821 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18822 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18823 `...' at the end of the formal parameter list. In order to find out if
18824 there was a trailing ellipsis or not, we must instead look at the type
18825 associated with the FUNCTION_DECL. This will be a node of type
18826 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18827 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18828 an ellipsis at the end. */
18830 /* In the case where we are describing a mere function declaration, all we
18831 need to do here (and all we *can* do here) is to describe the *types* of
18832 its formal parameters. */
18833 if (debug_info_level <= DINFO_LEVEL_TERSE)
18835 else if (declaration)
18836 gen_formal_types_die (decl, subr_die);
18839 /* Generate DIEs to represent all known formal parameters. */
18840 tree parm = DECL_ARGUMENTS (decl);
18841 tree generic_decl = lang_hooks.decls.get_generic_function_decl (decl);
18842 tree generic_decl_parm = generic_decl
18843 ? DECL_ARGUMENTS (generic_decl)
18846 /* Now we want to walk the list of parameters of the function and
18847 emit their relevant DIEs.
18849 We consider the case of DECL being an instance of a generic function
18850 as well as it being a normal function.
18852 If DECL is an instance of a generic function we walk the
18853 parameters of the generic function declaration _and_ the parameters of
18854 DECL itself. This is useful because we want to emit specific DIEs for
18855 function parameter packs and those are declared as part of the
18856 generic function declaration. In that particular case,
18857 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18858 That DIE has children DIEs representing the set of arguments
18859 of the pack. Note that the set of pack arguments can be empty.
18860 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18863 Otherwise, we just consider the parameters of DECL. */
18864 while (generic_decl_parm || parm)
18866 if (generic_decl_parm
18867 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
18868 gen_formal_parameter_pack_die (generic_decl_parm,
18873 gen_decl_die (parm, NULL, subr_die);
18874 parm = TREE_CHAIN (parm);
18877 if (generic_decl_parm)
18878 generic_decl_parm = TREE_CHAIN (generic_decl_parm);
18881 /* Decide whether we need an unspecified_parameters DIE at the end.
18882 There are 2 more cases to do this for: 1) the ansi ... declaration -
18883 this is detectable when the end of the arg list is not a
18884 void_type_node 2) an unprototyped function declaration (not a
18885 definition). This just means that we have no info about the
18886 parameters at all. */
18887 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
18888 if (fn_arg_types != NULL)
18890 /* This is the prototyped case, check for.... */
18891 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
18892 gen_unspecified_parameters_die (decl, subr_die);
18894 else if (DECL_INITIAL (decl) == NULL_TREE)
18895 gen_unspecified_parameters_die (decl, subr_die);
18898 /* Output Dwarf info for all of the stuff within the body of the function
18899 (if it has one - it may be just a declaration). */
18900 outer_scope = DECL_INITIAL (decl);
18902 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18903 a function. This BLOCK actually represents the outermost binding contour
18904 for the function, i.e. the contour in which the function's formal
18905 parameters and labels get declared. Curiously, it appears that the front
18906 end doesn't actually put the PARM_DECL nodes for the current function onto
18907 the BLOCK_VARS list for this outer scope, but are strung off of the
18908 DECL_ARGUMENTS list for the function instead.
18910 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18911 the LABEL_DECL nodes for the function however, and we output DWARF info
18912 for those in decls_for_scope. Just within the `outer_scope' there will be
18913 a BLOCK node representing the function's outermost pair of curly braces,
18914 and any blocks used for the base and member initializers of a C++
18915 constructor function. */
18916 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
18918 /* Emit a DW_TAG_variable DIE for a named return value. */
18919 if (DECL_NAME (DECL_RESULT (decl)))
18920 gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
18922 current_function_has_inlines = 0;
18923 decls_for_scope (outer_scope, subr_die, 0);
18925 #if 0 && defined (MIPS_DEBUGGING_INFO)
18926 if (current_function_has_inlines)
18928 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
18929 if (! comp_unit_has_inlines)
18931 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
18932 comp_unit_has_inlines = 1;
18937 /* Add the calling convention attribute if requested. */
18938 add_calling_convention_attribute (subr_die, decl);
18942 /* Returns a hash value for X (which really is a die_struct). */
18945 common_block_die_table_hash (const void *x)
18947 const_dw_die_ref d = (const_dw_die_ref) x;
18948 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
18951 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18952 as decl_id and die_parent of die_struct Y. */
18955 common_block_die_table_eq (const void *x, const void *y)
18957 const_dw_die_ref d = (const_dw_die_ref) x;
18958 const_dw_die_ref e = (const_dw_die_ref) y;
18959 return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
18962 /* Generate a DIE to represent a declared data object.
18963 Either DECL or ORIGIN must be non-null. */
18966 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
18970 tree decl_or_origin = decl ? decl : origin;
18971 tree ultimate_origin;
18972 dw_die_ref var_die;
18973 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
18974 dw_die_ref origin_die;
18975 bool declaration = (DECL_EXTERNAL (decl_or_origin)
18976 || class_or_namespace_scope_p (context_die));
18977 bool specialization_p = false;
18979 ultimate_origin = decl_ultimate_origin (decl_or_origin);
18980 if (decl || ultimate_origin)
18981 origin = ultimate_origin;
18982 com_decl = fortran_common (decl_or_origin, &off);
18984 /* Symbol in common gets emitted as a child of the common block, in the form
18985 of a data member. */
18988 dw_die_ref com_die;
18989 dw_loc_list_ref loc;
18990 die_node com_die_arg;
18992 var_die = lookup_decl_die (decl_or_origin);
18995 if (get_AT (var_die, DW_AT_location) == NULL)
18997 loc = loc_list_from_tree (com_decl, off ? 1 : 2);
19002 /* Optimize the common case. */
19003 if (single_element_loc_list_p (loc)
19004 && loc->expr->dw_loc_opc == DW_OP_addr
19005 && loc->expr->dw_loc_next == NULL
19006 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
19008 loc->expr->dw_loc_oprnd1.v.val_addr
19009 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
19011 loc_list_plus_const (loc, off);
19013 add_AT_location_description (var_die, DW_AT_location, loc);
19014 remove_AT (var_die, DW_AT_declaration);
19020 if (common_block_die_table == NULL)
19021 common_block_die_table
19022 = htab_create_ggc (10, common_block_die_table_hash,
19023 common_block_die_table_eq, NULL);
19025 com_die_arg.decl_id = DECL_UID (com_decl);
19026 com_die_arg.die_parent = context_die;
19027 com_die = (dw_die_ref) htab_find (common_block_die_table, &com_die_arg);
19028 loc = loc_list_from_tree (com_decl, 2);
19029 if (com_die == NULL)
19032 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
19035 com_die = new_die (DW_TAG_common_block, context_die, decl);
19036 add_name_and_src_coords_attributes (com_die, com_decl);
19039 add_AT_location_description (com_die, DW_AT_location, loc);
19040 /* Avoid sharing the same loc descriptor between
19041 DW_TAG_common_block and DW_TAG_variable. */
19042 loc = loc_list_from_tree (com_decl, 2);
19044 else if (DECL_EXTERNAL (decl))
19045 add_AT_flag (com_die, DW_AT_declaration, 1);
19046 add_pubname_string (cnam, com_die); /* ??? needed? */
19047 com_die->decl_id = DECL_UID (com_decl);
19048 slot = htab_find_slot (common_block_die_table, com_die, INSERT);
19049 *slot = (void *) com_die;
19051 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
19053 add_AT_location_description (com_die, DW_AT_location, loc);
19054 loc = loc_list_from_tree (com_decl, 2);
19055 remove_AT (com_die, DW_AT_declaration);
19057 var_die = new_die (DW_TAG_variable, com_die, decl);
19058 add_name_and_src_coords_attributes (var_die, decl);
19059 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
19060 TREE_THIS_VOLATILE (decl), context_die);
19061 add_AT_flag (var_die, DW_AT_external, 1);
19066 /* Optimize the common case. */
19067 if (single_element_loc_list_p (loc)
19068 && loc->expr->dw_loc_opc == DW_OP_addr
19069 && loc->expr->dw_loc_next == NULL
19070 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
19071 loc->expr->dw_loc_oprnd1.v.val_addr
19072 = plus_constant (loc->expr->dw_loc_oprnd1.v.val_addr, off);
19074 loc_list_plus_const (loc, off);
19076 add_AT_location_description (var_die, DW_AT_location, loc);
19078 else if (DECL_EXTERNAL (decl))
19079 add_AT_flag (var_die, DW_AT_declaration, 1);
19080 equate_decl_number_to_die (decl, var_die);
19084 /* If the compiler emitted a definition for the DECL declaration
19085 and if we already emitted a DIE for it, don't emit a second
19086 DIE for it again. Allow re-declarations of DECLs that are
19087 inside functions, though. */
19088 if (old_die && declaration && !local_scope_p (context_die))
19091 /* For static data members, the declaration in the class is supposed
19092 to have DW_TAG_member tag; the specification should still be
19093 DW_TAG_variable referencing the DW_TAG_member DIE. */
19094 if (declaration && class_scope_p (context_die))
19095 var_die = new_die (DW_TAG_member, context_die, decl);
19097 var_die = new_die (DW_TAG_variable, context_die, decl);
19100 if (origin != NULL)
19101 origin_die = add_abstract_origin_attribute (var_die, origin);
19103 /* Loop unrolling can create multiple blocks that refer to the same
19104 static variable, so we must test for the DW_AT_declaration flag.
19106 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
19107 copy decls and set the DECL_ABSTRACT flag on them instead of
19110 ??? Duplicated blocks have been rewritten to use .debug_ranges.
19112 ??? The declare_in_namespace support causes us to get two DIEs for one
19113 variable, both of which are declarations. We want to avoid considering
19114 one to be a specification, so we must test that this DIE is not a
19116 else if (old_die && TREE_STATIC (decl) && ! declaration
19117 && get_AT_flag (old_die, DW_AT_declaration) == 1)
19119 /* This is a definition of a C++ class level static. */
19120 add_AT_specification (var_die, old_die);
19121 specialization_p = true;
19122 if (DECL_NAME (decl))
19124 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
19125 struct dwarf_file_data * file_index = lookup_filename (s.file);
19127 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
19128 add_AT_file (var_die, DW_AT_decl_file, file_index);
19130 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
19131 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
19133 if (old_die->die_tag == DW_TAG_member)
19134 add_linkage_name (var_die, decl);
19138 add_name_and_src_coords_attributes (var_die, decl);
19140 if ((origin == NULL && !specialization_p)
19142 && !DECL_ABSTRACT (decl_or_origin)
19143 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
19144 decl_function_context
19145 (decl_or_origin))))
19147 tree type = TREE_TYPE (decl_or_origin);
19149 if (decl_by_reference_p (decl_or_origin))
19150 add_type_attribute (var_die, TREE_TYPE (type), 0, 0, context_die);
19152 add_type_attribute (var_die, type, TREE_READONLY (decl_or_origin),
19153 TREE_THIS_VOLATILE (decl_or_origin), context_die);
19156 if (origin == NULL && !specialization_p)
19158 if (TREE_PUBLIC (decl))
19159 add_AT_flag (var_die, DW_AT_external, 1);
19161 if (DECL_ARTIFICIAL (decl))
19162 add_AT_flag (var_die, DW_AT_artificial, 1);
19164 add_accessibility_attribute (var_die, decl);
19168 add_AT_flag (var_die, DW_AT_declaration, 1);
19170 if (decl && (DECL_ABSTRACT (decl) || declaration))
19171 equate_decl_number_to_die (decl, var_die);
19174 && (! DECL_ABSTRACT (decl_or_origin)
19175 /* Local static vars are shared between all clones/inlines,
19176 so emit DW_AT_location on the abstract DIE if DECL_RTL is
19178 || (TREE_CODE (decl_or_origin) == VAR_DECL
19179 && TREE_STATIC (decl_or_origin)
19180 && DECL_RTL_SET_P (decl_or_origin)))
19181 /* When abstract origin already has DW_AT_location attribute, no need
19182 to add it again. */
19183 && (origin_die == NULL || get_AT (origin_die, DW_AT_location) == NULL))
19185 if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
19186 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
19187 defer_location (decl_or_origin, var_die);
19189 add_location_or_const_value_attribute (var_die,
19192 add_pubname (decl_or_origin, var_die);
19195 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
19198 /* Generate a DIE to represent a named constant. */
19201 gen_const_die (tree decl, dw_die_ref context_die)
19203 dw_die_ref const_die;
19204 tree type = TREE_TYPE (decl);
19206 const_die = new_die (DW_TAG_constant, context_die, decl);
19207 add_name_and_src_coords_attributes (const_die, decl);
19208 add_type_attribute (const_die, type, 1, 0, context_die);
19209 if (TREE_PUBLIC (decl))
19210 add_AT_flag (const_die, DW_AT_external, 1);
19211 if (DECL_ARTIFICIAL (decl))
19212 add_AT_flag (const_die, DW_AT_artificial, 1);
19213 tree_add_const_value_attribute_for_decl (const_die, decl);
19216 /* Generate a DIE to represent a label identifier. */
19219 gen_label_die (tree decl, dw_die_ref context_die)
19221 tree origin = decl_ultimate_origin (decl);
19222 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
19224 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19226 if (origin != NULL)
19227 add_abstract_origin_attribute (lbl_die, origin);
19229 add_name_and_src_coords_attributes (lbl_die, decl);
19231 if (DECL_ABSTRACT (decl))
19232 equate_decl_number_to_die (decl, lbl_die);
19235 insn = DECL_RTL_IF_SET (decl);
19237 /* Deleted labels are programmer specified labels which have been
19238 eliminated because of various optimizations. We still emit them
19239 here so that it is possible to put breakpoints on them. */
19243 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
19245 /* When optimization is enabled (via -O) some parts of the compiler
19246 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19247 represent source-level labels which were explicitly declared by
19248 the user. This really shouldn't be happening though, so catch
19249 it if it ever does happen. */
19250 gcc_assert (!INSN_DELETED_P (insn));
19252 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
19253 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
19258 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19259 attributes to the DIE for a block STMT, to describe where the inlined
19260 function was called from. This is similar to add_src_coords_attributes. */
19263 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
19265 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
19267 if (dwarf_version >= 3 || !dwarf_strict)
19269 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
19270 add_AT_unsigned (die, DW_AT_call_line, s.line);
19275 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19276 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19279 add_high_low_attributes (tree stmt, dw_die_ref die)
19281 char label[MAX_ARTIFICIAL_LABEL_BYTES];
19283 if (BLOCK_FRAGMENT_CHAIN (stmt)
19284 && (dwarf_version >= 3 || !dwarf_strict))
19288 if (inlined_function_outer_scope_p (stmt))
19290 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19291 BLOCK_NUMBER (stmt));
19292 add_AT_lbl_id (die, DW_AT_entry_pc, label);
19295 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
19297 chain = BLOCK_FRAGMENT_CHAIN (stmt);
19300 add_ranges (chain);
19301 chain = BLOCK_FRAGMENT_CHAIN (chain);
19308 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
19309 BLOCK_NUMBER (stmt));
19310 add_AT_lbl_id (die, DW_AT_low_pc, label);
19311 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
19312 BLOCK_NUMBER (stmt));
19313 add_AT_lbl_id (die, DW_AT_high_pc, label);
19317 /* Generate a DIE for a lexical block. */
19320 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
19322 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
19324 if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
19325 add_high_low_attributes (stmt, stmt_die);
19327 decls_for_scope (stmt, stmt_die, depth);
19330 /* Generate a DIE for an inlined subprogram. */
19333 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
19337 /* The instance of function that is effectively being inlined shall not
19339 gcc_assert (! BLOCK_ABSTRACT (stmt));
19341 decl = block_ultimate_origin (stmt);
19343 /* Emit info for the abstract instance first, if we haven't yet. We
19344 must emit this even if the block is abstract, otherwise when we
19345 emit the block below (or elsewhere), we may end up trying to emit
19346 a die whose origin die hasn't been emitted, and crashing. */
19347 dwarf2out_abstract_function (decl);
19349 if (! BLOCK_ABSTRACT (stmt))
19351 dw_die_ref subr_die
19352 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
19354 add_abstract_origin_attribute (subr_die, decl);
19355 if (TREE_ASM_WRITTEN (stmt))
19356 add_high_low_attributes (stmt, subr_die);
19357 add_call_src_coords_attributes (stmt, subr_die);
19359 decls_for_scope (stmt, subr_die, depth);
19360 current_function_has_inlines = 1;
19364 /* Generate a DIE for a field in a record, or structure. */
19367 gen_field_die (tree decl, dw_die_ref context_die)
19369 dw_die_ref decl_die;
19371 if (TREE_TYPE (decl) == error_mark_node)
19374 decl_die = new_die (DW_TAG_member, context_die, decl);
19375 add_name_and_src_coords_attributes (decl_die, decl);
19376 add_type_attribute (decl_die, member_declared_type (decl),
19377 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
19380 if (DECL_BIT_FIELD_TYPE (decl))
19382 add_byte_size_attribute (decl_die, decl);
19383 add_bit_size_attribute (decl_die, decl);
19384 add_bit_offset_attribute (decl_die, decl);
19387 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
19388 add_data_member_location_attribute (decl_die, decl);
19390 if (DECL_ARTIFICIAL (decl))
19391 add_AT_flag (decl_die, DW_AT_artificial, 1);
19393 add_accessibility_attribute (decl_die, decl);
19395 /* Equate decl number to die, so that we can look up this decl later on. */
19396 equate_decl_number_to_die (decl, decl_die);
19400 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19401 Use modified_type_die instead.
19402 We keep this code here just in case these types of DIEs may be needed to
19403 represent certain things in other languages (e.g. Pascal) someday. */
19406 gen_pointer_type_die (tree type, dw_die_ref context_die)
19409 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
19411 equate_type_number_to_die (type, ptr_die);
19412 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
19413 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19416 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19417 Use modified_type_die instead.
19418 We keep this code here just in case these types of DIEs may be needed to
19419 represent certain things in other languages (e.g. Pascal) someday. */
19422 gen_reference_type_die (tree type, dw_die_ref context_die)
19424 dw_die_ref ref_die, scope_die = scope_die_for (type, context_die);
19426 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
19427 ref_die = new_die (DW_TAG_rvalue_reference_type, scope_die, type);
19429 ref_die = new_die (DW_TAG_reference_type, scope_die, type);
19431 equate_type_number_to_die (type, ref_die);
19432 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
19433 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
19437 /* Generate a DIE for a pointer to a member type. */
19440 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
19443 = new_die (DW_TAG_ptr_to_member_type,
19444 scope_die_for (type, context_die), type);
19446 equate_type_number_to_die (type, ptr_die);
19447 add_AT_die_ref (ptr_die, DW_AT_containing_type,
19448 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
19449 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
19452 /* Generate the DIE for the compilation unit. */
19455 gen_compile_unit_die (const char *filename)
19458 char producer[250];
19459 const char *language_string = lang_hooks.name;
19462 die = new_die (DW_TAG_compile_unit, NULL, NULL);
19466 add_name_attribute (die, filename);
19467 /* Don't add cwd for <built-in>. */
19468 if (!IS_ABSOLUTE_PATH (filename) && filename[0] != '<')
19469 add_comp_dir_attribute (die);
19472 sprintf (producer, "%s %s", language_string, version_string);
19474 #ifdef MIPS_DEBUGGING_INFO
19475 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
19476 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
19477 not appear in the producer string, the debugger reaches the conclusion
19478 that the object file is stripped and has no debugging information.
19479 To get the MIPS/SGI debugger to believe that there is debugging
19480 information in the object file, we add a -g to the producer string. */
19481 if (debug_info_level > DINFO_LEVEL_TERSE)
19482 strcat (producer, " -g");
19485 add_AT_string (die, DW_AT_producer, producer);
19487 language = DW_LANG_C89;
19488 if (strcmp (language_string, "GNU C++") == 0)
19489 language = DW_LANG_C_plus_plus;
19490 else if (strcmp (language_string, "GNU F77") == 0)
19491 language = DW_LANG_Fortran77;
19492 else if (strcmp (language_string, "GNU Pascal") == 0)
19493 language = DW_LANG_Pascal83;
19494 else if (dwarf_version >= 3 || !dwarf_strict)
19496 if (strcmp (language_string, "GNU Ada") == 0)
19497 language = DW_LANG_Ada95;
19498 else if (strcmp (language_string, "GNU Fortran") == 0)
19499 language = DW_LANG_Fortran95;
19500 else if (strcmp (language_string, "GNU Java") == 0)
19501 language = DW_LANG_Java;
19502 else if (strcmp (language_string, "GNU Objective-C") == 0)
19503 language = DW_LANG_ObjC;
19504 else if (strcmp (language_string, "GNU Objective-C++") == 0)
19505 language = DW_LANG_ObjC_plus_plus;
19508 add_AT_unsigned (die, DW_AT_language, language);
19512 case DW_LANG_Fortran77:
19513 case DW_LANG_Fortran90:
19514 case DW_LANG_Fortran95:
19515 /* Fortran has case insensitive identifiers and the front-end
19516 lowercases everything. */
19517 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
19520 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19526 /* Generate the DIE for a base class. */
19529 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
19531 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
19533 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
19534 add_data_member_location_attribute (die, binfo);
19536 if (BINFO_VIRTUAL_P (binfo))
19537 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
19539 if (access == access_public_node)
19540 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
19541 else if (access == access_protected_node)
19542 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
19545 /* Generate a DIE for a class member. */
19548 gen_member_die (tree type, dw_die_ref context_die)
19551 tree binfo = TYPE_BINFO (type);
19554 /* If this is not an incomplete type, output descriptions of each of its
19555 members. Note that as we output the DIEs necessary to represent the
19556 members of this record or union type, we will also be trying to output
19557 DIEs to represent the *types* of those members. However the `type'
19558 function (above) will specifically avoid generating type DIEs for member
19559 types *within* the list of member DIEs for this (containing) type except
19560 for those types (of members) which are explicitly marked as also being
19561 members of this (containing) type themselves. The g++ front- end can
19562 force any given type to be treated as a member of some other (containing)
19563 type by setting the TYPE_CONTEXT of the given (member) type to point to
19564 the TREE node representing the appropriate (containing) type. */
19566 /* First output info about the base classes. */
19569 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
19573 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
19574 gen_inheritance_die (base,
19575 (accesses ? VEC_index (tree, accesses, i)
19576 : access_public_node), context_die);
19579 /* Now output info about the data members and type members. */
19580 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
19582 /* If we thought we were generating minimal debug info for TYPE
19583 and then changed our minds, some of the member declarations
19584 may have already been defined. Don't define them again, but
19585 do put them in the right order. */
19587 child = lookup_decl_die (member);
19589 splice_child_die (context_die, child);
19591 gen_decl_die (member, NULL, context_die);
19594 /* Now output info about the function members (if any). */
19595 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
19597 /* Don't include clones in the member list. */
19598 if (DECL_ABSTRACT_ORIGIN (member))
19601 child = lookup_decl_die (member);
19603 splice_child_die (context_die, child);
19605 gen_decl_die (member, NULL, context_die);
19609 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19610 is set, we pretend that the type was never defined, so we only get the
19611 member DIEs needed by later specification DIEs. */
19614 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
19615 enum debug_info_usage usage)
19617 dw_die_ref type_die = lookup_type_die (type);
19618 dw_die_ref scope_die = 0;
19620 int complete = (TYPE_SIZE (type)
19621 && (! TYPE_STUB_DECL (type)
19622 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
19623 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
19624 complete = complete && should_emit_struct_debug (type, usage);
19626 if (type_die && ! complete)
19629 if (TYPE_CONTEXT (type) != NULL_TREE
19630 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
19631 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
19634 scope_die = scope_die_for (type, context_die);
19636 if (! type_die || (nested && scope_die == comp_unit_die))
19637 /* First occurrence of type or toplevel definition of nested class. */
19639 dw_die_ref old_die = type_die;
19641 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
19642 ? record_type_tag (type) : DW_TAG_union_type,
19644 equate_type_number_to_die (type, type_die);
19646 add_AT_specification (type_die, old_die);
19648 add_name_attribute (type_die, type_tag (type));
19651 remove_AT (type_die, DW_AT_declaration);
19653 /* Generate child dies for template paramaters. */
19654 if (debug_info_level > DINFO_LEVEL_TERSE
19655 && COMPLETE_TYPE_P (type))
19656 gen_generic_params_dies (type);
19658 /* If this type has been completed, then give it a byte_size attribute and
19659 then give a list of members. */
19660 if (complete && !ns_decl)
19662 /* Prevent infinite recursion in cases where the type of some member of
19663 this type is expressed in terms of this type itself. */
19664 TREE_ASM_WRITTEN (type) = 1;
19665 add_byte_size_attribute (type_die, type);
19666 if (TYPE_STUB_DECL (type) != NULL_TREE)
19668 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
19669 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
19672 /* If the first reference to this type was as the return type of an
19673 inline function, then it may not have a parent. Fix this now. */
19674 if (type_die->die_parent == NULL)
19675 add_child_die (scope_die, type_die);
19677 push_decl_scope (type);
19678 gen_member_die (type, type_die);
19681 /* GNU extension: Record what type our vtable lives in. */
19682 if (TYPE_VFIELD (type))
19684 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
19686 gen_type_die (vtype, context_die);
19687 add_AT_die_ref (type_die, DW_AT_containing_type,
19688 lookup_type_die (vtype));
19693 add_AT_flag (type_die, DW_AT_declaration, 1);
19695 /* We don't need to do this for function-local types. */
19696 if (TYPE_STUB_DECL (type)
19697 && ! decl_function_context (TYPE_STUB_DECL (type)))
19698 VEC_safe_push (tree, gc, incomplete_types, type);
19701 if (get_AT (type_die, DW_AT_name))
19702 add_pubtype (type, type_die);
19705 /* Generate a DIE for a subroutine _type_. */
19708 gen_subroutine_type_die (tree type, dw_die_ref context_die)
19710 tree return_type = TREE_TYPE (type);
19711 dw_die_ref subr_die
19712 = new_die (DW_TAG_subroutine_type,
19713 scope_die_for (type, context_die), type);
19715 equate_type_number_to_die (type, subr_die);
19716 add_prototyped_attribute (subr_die, type);
19717 add_type_attribute (subr_die, return_type, 0, 0, context_die);
19718 gen_formal_types_die (type, subr_die);
19720 if (get_AT (subr_die, DW_AT_name))
19721 add_pubtype (type, subr_die);
19724 /* Generate a DIE for a type definition. */
19727 gen_typedef_die (tree decl, dw_die_ref context_die)
19729 dw_die_ref type_die;
19732 if (TREE_ASM_WRITTEN (decl))
19735 TREE_ASM_WRITTEN (decl) = 1;
19736 type_die = new_die (DW_TAG_typedef, context_die, decl);
19737 origin = decl_ultimate_origin (decl);
19738 if (origin != NULL)
19739 add_abstract_origin_attribute (type_die, origin);
19744 add_name_and_src_coords_attributes (type_die, decl);
19745 if (DECL_ORIGINAL_TYPE (decl))
19747 type = DECL_ORIGINAL_TYPE (decl);
19749 gcc_assert (type != TREE_TYPE (decl));
19750 equate_type_number_to_die (TREE_TYPE (decl), type_die);
19754 type = TREE_TYPE (decl);
19756 if (is_naming_typedef_decl (TYPE_NAME (type)))
19758 Here, we are in the case of decl being a typedef naming
19759 an anonymous type, e.g:
19760 typedef struct {...} foo;
19761 In that case TREE_TYPE (decl) is not a typedef variant
19762 type and TYPE_NAME of the anonymous type is set to the
19763 TYPE_DECL of the typedef. This construct is emitted by
19766 TYPE is the anonymous struct named by the typedef
19767 DECL. As we need the DW_AT_type attribute of the
19768 DW_TAG_typedef to point to the DIE of TYPE, let's
19769 generate that DIE right away. add_type_attribute
19770 called below will then pick (via lookup_type_die) that
19771 anonymous struct DIE. */
19772 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
19775 add_type_attribute (type_die, type, TREE_READONLY (decl),
19776 TREE_THIS_VOLATILE (decl), context_die);
19778 if (is_naming_typedef_decl (decl))
19779 /* We want that all subsequent calls to lookup_type_die with
19780 TYPE in argument yield the DW_TAG_typedef we have just
19782 equate_type_number_to_die (type, type_die);
19784 add_accessibility_attribute (type_die, decl);
19787 if (DECL_ABSTRACT (decl))
19788 equate_decl_number_to_die (decl, type_die);
19790 if (get_AT (type_die, DW_AT_name))
19791 add_pubtype (decl, type_die);
19794 /* Generate a DIE for a struct, class, enum or union type. */
19797 gen_tagged_type_die (tree type,
19798 dw_die_ref context_die,
19799 enum debug_info_usage usage)
19803 if (type == NULL_TREE
19804 || !is_tagged_type (type))
19807 /* If this is a nested type whose containing class hasn't been written
19808 out yet, writing it out will cover this one, too. This does not apply
19809 to instantiations of member class templates; they need to be added to
19810 the containing class as they are generated. FIXME: This hurts the
19811 idea of combining type decls from multiple TUs, since we can't predict
19812 what set of template instantiations we'll get. */
19813 if (TYPE_CONTEXT (type)
19814 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
19815 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
19817 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
19819 if (TREE_ASM_WRITTEN (type))
19822 /* If that failed, attach ourselves to the stub. */
19823 push_decl_scope (TYPE_CONTEXT (type));
19824 context_die = lookup_type_die (TYPE_CONTEXT (type));
19827 else if (TYPE_CONTEXT (type) != NULL_TREE
19828 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
19830 /* If this type is local to a function that hasn't been written
19831 out yet, use a NULL context for now; it will be fixed up in
19832 decls_for_scope. */
19833 context_die = lookup_decl_die (TYPE_CONTEXT (type));
19838 context_die = declare_in_namespace (type, context_die);
19842 if (TREE_CODE (type) == ENUMERAL_TYPE)
19844 /* This might have been written out by the call to
19845 declare_in_namespace. */
19846 if (!TREE_ASM_WRITTEN (type))
19847 gen_enumeration_type_die (type, context_die);
19850 gen_struct_or_union_type_die (type, context_die, usage);
19855 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19856 it up if it is ever completed. gen_*_type_die will set it for us
19857 when appropriate. */
19860 /* Generate a type description DIE. */
19863 gen_type_die_with_usage (tree type, dw_die_ref context_die,
19864 enum debug_info_usage usage)
19866 struct array_descr_info info;
19868 if (type == NULL_TREE || type == error_mark_node)
19871 /* If TYPE is a typedef type variant, let's generate debug info
19872 for the parent typedef which TYPE is a type of. */
19873 if (typedef_variant_p (type))
19875 if (TREE_ASM_WRITTEN (type))
19878 /* Prevent broken recursion; we can't hand off to the same type. */
19879 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
19881 /* Use the DIE of the containing namespace as the parent DIE of
19882 the type description DIE we want to generate. */
19883 if (DECL_CONTEXT (TYPE_NAME (type))
19884 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
19885 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
19887 TREE_ASM_WRITTEN (type) = 1;
19889 gen_decl_die (TYPE_NAME (type), NULL, context_die);
19893 /* If type is an anonymous tagged type named by a typedef, let's
19894 generate debug info for the typedef. */
19895 if (is_naming_typedef_decl (TYPE_NAME (type)))
19897 /* Use the DIE of the containing namespace as the parent DIE of
19898 the type description DIE we want to generate. */
19899 if (DECL_CONTEXT (TYPE_NAME (type))
19900 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type))) == NAMESPACE_DECL)
19901 context_die = get_context_die (DECL_CONTEXT (TYPE_NAME (type)));
19903 gen_decl_die (TYPE_NAME (type), NULL, context_die);
19907 /* If this is an array type with hidden descriptor, handle it first. */
19908 if (!TREE_ASM_WRITTEN (type)
19909 && lang_hooks.types.get_array_descr_info
19910 && lang_hooks.types.get_array_descr_info (type, &info)
19911 && (dwarf_version >= 3 || !dwarf_strict))
19913 gen_descr_array_type_die (type, &info, context_die);
19914 TREE_ASM_WRITTEN (type) = 1;
19918 /* We are going to output a DIE to represent the unqualified version
19919 of this type (i.e. without any const or volatile qualifiers) so
19920 get the main variant (i.e. the unqualified version) of this type
19921 now. (Vectors are special because the debugging info is in the
19922 cloned type itself). */
19923 if (TREE_CODE (type) != VECTOR_TYPE)
19924 type = type_main_variant (type);
19926 if (TREE_ASM_WRITTEN (type))
19929 switch (TREE_CODE (type))
19935 case REFERENCE_TYPE:
19936 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
19937 ensures that the gen_type_die recursion will terminate even if the
19938 type is recursive. Recursive types are possible in Ada. */
19939 /* ??? We could perhaps do this for all types before the switch
19941 TREE_ASM_WRITTEN (type) = 1;
19943 /* For these types, all that is required is that we output a DIE (or a
19944 set of DIEs) to represent the "basis" type. */
19945 gen_type_die_with_usage (TREE_TYPE (type), context_die,
19946 DINFO_USAGE_IND_USE);
19950 /* This code is used for C++ pointer-to-data-member types.
19951 Output a description of the relevant class type. */
19952 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
19953 DINFO_USAGE_IND_USE);
19955 /* Output a description of the type of the object pointed to. */
19956 gen_type_die_with_usage (TREE_TYPE (type), context_die,
19957 DINFO_USAGE_IND_USE);
19959 /* Now output a DIE to represent this pointer-to-data-member type
19961 gen_ptr_to_mbr_type_die (type, context_die);
19964 case FUNCTION_TYPE:
19965 /* Force out return type (in case it wasn't forced out already). */
19966 gen_type_die_with_usage (TREE_TYPE (type), context_die,
19967 DINFO_USAGE_DIR_USE);
19968 gen_subroutine_type_die (type, context_die);
19972 /* Force out return type (in case it wasn't forced out already). */
19973 gen_type_die_with_usage (TREE_TYPE (type), context_die,
19974 DINFO_USAGE_DIR_USE);
19975 gen_subroutine_type_die (type, context_die);
19979 gen_array_type_die (type, context_die);
19983 gen_array_type_die (type, context_die);
19986 case ENUMERAL_TYPE:
19989 case QUAL_UNION_TYPE:
19990 gen_tagged_type_die (type, context_die, usage);
19996 case FIXED_POINT_TYPE:
19999 /* No DIEs needed for fundamental types. */
20003 /* Just use DW_TAG_unspecified_type. */
20005 dw_die_ref type_die = lookup_type_die (type);
20006 if (type_die == NULL)
20008 tree name = TYPE_NAME (type);
20009 if (TREE_CODE (name) == TYPE_DECL)
20010 name = DECL_NAME (name);
20011 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die, type);
20012 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
20013 equate_type_number_to_die (type, type_die);
20019 gcc_unreachable ();
20022 TREE_ASM_WRITTEN (type) = 1;
20026 gen_type_die (tree type, dw_die_ref context_die)
20028 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
20031 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
20032 things which are local to the given block. */
20035 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
20037 int must_output_die = 0;
20040 /* Ignore blocks that are NULL. */
20041 if (stmt == NULL_TREE)
20044 inlined_func = inlined_function_outer_scope_p (stmt);
20046 /* If the block is one fragment of a non-contiguous block, do not
20047 process the variables, since they will have been done by the
20048 origin block. Do process subblocks. */
20049 if (BLOCK_FRAGMENT_ORIGIN (stmt))
20053 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
20054 gen_block_die (sub, context_die, depth + 1);
20059 /* Determine if we need to output any Dwarf DIEs at all to represent this
20062 /* The outer scopes for inlinings *must* always be represented. We
20063 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20064 must_output_die = 1;
20067 /* Determine if this block directly contains any "significant"
20068 local declarations which we will need to output DIEs for. */
20069 if (debug_info_level > DINFO_LEVEL_TERSE)
20070 /* We are not in terse mode so *any* local declaration counts
20071 as being a "significant" one. */
20072 must_output_die = ((BLOCK_VARS (stmt) != NULL
20073 || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
20074 && (TREE_USED (stmt)
20075 || TREE_ASM_WRITTEN (stmt)
20076 || BLOCK_ABSTRACT (stmt)));
20077 else if ((TREE_USED (stmt)
20078 || TREE_ASM_WRITTEN (stmt)
20079 || BLOCK_ABSTRACT (stmt))
20080 && !dwarf2out_ignore_block (stmt))
20081 must_output_die = 1;
20084 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20085 DIE for any block which contains no significant local declarations at
20086 all. Rather, in such cases we just call `decls_for_scope' so that any
20087 needed Dwarf info for any sub-blocks will get properly generated. Note
20088 that in terse mode, our definition of what constitutes a "significant"
20089 local declaration gets restricted to include only inlined function
20090 instances and local (nested) function definitions. */
20091 if (must_output_die)
20095 /* If STMT block is abstract, that means we have been called
20096 indirectly from dwarf2out_abstract_function.
20097 That function rightfully marks the descendent blocks (of
20098 the abstract function it is dealing with) as being abstract,
20099 precisely to prevent us from emitting any
20100 DW_TAG_inlined_subroutine DIE as a descendent
20101 of an abstract function instance. So in that case, we should
20102 not call gen_inlined_subroutine_die.
20104 Later though, when cgraph asks dwarf2out to emit info
20105 for the concrete instance of the function decl into which
20106 the concrete instance of STMT got inlined, the later will lead
20107 to the generation of a DW_TAG_inlined_subroutine DIE. */
20108 if (! BLOCK_ABSTRACT (stmt))
20109 gen_inlined_subroutine_die (stmt, context_die, depth);
20112 gen_lexical_block_die (stmt, context_die, depth);
20115 decls_for_scope (stmt, context_die, depth);
20118 /* Process variable DECL (or variable with origin ORIGIN) within
20119 block STMT and add it to CONTEXT_DIE. */
20121 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
20124 tree decl_or_origin = decl ? decl : origin;
20126 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
20127 die = lookup_decl_die (decl_or_origin);
20128 else if (TREE_CODE (decl_or_origin) == TYPE_DECL
20129 && TYPE_DECL_IS_STUB (decl_or_origin))
20130 die = lookup_type_die (TREE_TYPE (decl_or_origin));
20134 if (die != NULL && die->die_parent == NULL)
20135 add_child_die (context_die, die);
20136 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
20137 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
20138 stmt, context_die);
20140 gen_decl_die (decl, origin, context_die);
20143 /* Generate all of the decls declared within a given scope and (recursively)
20144 all of its sub-blocks. */
20147 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
20153 /* Ignore NULL blocks. */
20154 if (stmt == NULL_TREE)
20157 /* Output the DIEs to represent all of the data objects and typedefs
20158 declared directly within this block but not within any nested
20159 sub-blocks. Also, nested function and tag DIEs have been
20160 generated with a parent of NULL; fix that up now. */
20161 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
20162 process_scope_var (stmt, decl, NULL_TREE, context_die);
20163 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
20164 process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
20167 /* If we're at -g1, we're not interested in subblocks. */
20168 if (debug_info_level <= DINFO_LEVEL_TERSE)
20171 /* Output the DIEs to represent all sub-blocks (and the items declared
20172 therein) of this block. */
20173 for (subblocks = BLOCK_SUBBLOCKS (stmt);
20175 subblocks = BLOCK_CHAIN (subblocks))
20176 gen_block_die (subblocks, context_die, depth + 1);
20179 /* Is this a typedef we can avoid emitting? */
20182 is_redundant_typedef (const_tree decl)
20184 if (TYPE_DECL_IS_STUB (decl))
20187 if (DECL_ARTIFICIAL (decl)
20188 && DECL_CONTEXT (decl)
20189 && is_tagged_type (DECL_CONTEXT (decl))
20190 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
20191 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
20192 /* Also ignore the artificial member typedef for the class name. */
20198 /* Return TRUE if TYPE is a typedef that names a type for linkage
20199 purposes. This kind of typedefs is produced by the C++ FE for
20202 typedef struct {...} foo;
20204 In that case, there is no typedef variant type produced for foo.
20205 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20209 is_naming_typedef_decl (const_tree decl)
20211 if (decl == NULL_TREE
20212 || TREE_CODE (decl) != TYPE_DECL
20213 || !is_tagged_type (TREE_TYPE (decl))
20214 || DECL_IS_BUILTIN (decl)
20215 || is_redundant_typedef (decl)
20216 /* It looks like Ada produces TYPE_DECLs that are very similar
20217 to C++ naming typedefs but that have different
20218 semantics. Let's be specific to c++ for now. */
20222 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
20223 && TYPE_NAME (TREE_TYPE (decl)) == decl
20224 && (TYPE_STUB_DECL (TREE_TYPE (decl))
20225 != TYPE_NAME (TREE_TYPE (decl))));
20228 /* Returns the DIE for a context. */
20230 static inline dw_die_ref
20231 get_context_die (tree context)
20235 /* Find die that represents this context. */
20236 if (TYPE_P (context))
20237 return force_type_die (TYPE_MAIN_VARIANT (context));
20239 return force_decl_die (context);
20241 return comp_unit_die;
20244 /* Returns the DIE for decl. A DIE will always be returned. */
20247 force_decl_die (tree decl)
20249 dw_die_ref decl_die;
20250 unsigned saved_external_flag;
20251 tree save_fn = NULL_TREE;
20252 decl_die = lookup_decl_die (decl);
20255 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
20257 decl_die = lookup_decl_die (decl);
20261 switch (TREE_CODE (decl))
20263 case FUNCTION_DECL:
20264 /* Clear current_function_decl, so that gen_subprogram_die thinks
20265 that this is a declaration. At this point, we just want to force
20266 declaration die. */
20267 save_fn = current_function_decl;
20268 current_function_decl = NULL_TREE;
20269 gen_subprogram_die (decl, context_die);
20270 current_function_decl = save_fn;
20274 /* Set external flag to force declaration die. Restore it after
20275 gen_decl_die() call. */
20276 saved_external_flag = DECL_EXTERNAL (decl);
20277 DECL_EXTERNAL (decl) = 1;
20278 gen_decl_die (decl, NULL, context_die);
20279 DECL_EXTERNAL (decl) = saved_external_flag;
20282 case NAMESPACE_DECL:
20283 if (dwarf_version >= 3 || !dwarf_strict)
20284 dwarf2out_decl (decl);
20286 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20287 decl_die = comp_unit_die;
20291 gcc_unreachable ();
20294 /* We should be able to find the DIE now. */
20296 decl_die = lookup_decl_die (decl);
20297 gcc_assert (decl_die);
20303 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20304 always returned. */
20307 force_type_die (tree type)
20309 dw_die_ref type_die;
20311 type_die = lookup_type_die (type);
20314 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
20316 type_die = modified_type_die (type, TYPE_READONLY (type),
20317 TYPE_VOLATILE (type), context_die);
20318 gcc_assert (type_die);
20323 /* Force out any required namespaces to be able to output DECL,
20324 and return the new context_die for it, if it's changed. */
20327 setup_namespace_context (tree thing, dw_die_ref context_die)
20329 tree context = (DECL_P (thing)
20330 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
20331 if (context && TREE_CODE (context) == NAMESPACE_DECL)
20332 /* Force out the namespace. */
20333 context_die = force_decl_die (context);
20335 return context_die;
20338 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20339 type) within its namespace, if appropriate.
20341 For compatibility with older debuggers, namespace DIEs only contain
20342 declarations; all definitions are emitted at CU scope. */
20345 declare_in_namespace (tree thing, dw_die_ref context_die)
20347 dw_die_ref ns_context;
20349 if (debug_info_level <= DINFO_LEVEL_TERSE)
20350 return context_die;
20352 /* If this decl is from an inlined function, then don't try to emit it in its
20353 namespace, as we will get confused. It would have already been emitted
20354 when the abstract instance of the inline function was emitted anyways. */
20355 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
20356 return context_die;
20358 ns_context = setup_namespace_context (thing, context_die);
20360 if (ns_context != context_die)
20364 if (DECL_P (thing))
20365 gen_decl_die (thing, NULL, ns_context);
20367 gen_type_die (thing, ns_context);
20369 return context_die;
20372 /* Generate a DIE for a namespace or namespace alias. */
20375 gen_namespace_die (tree decl, dw_die_ref context_die)
20377 dw_die_ref namespace_die;
20379 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20380 they are an alias of. */
20381 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
20383 /* Output a real namespace or module. */
20384 context_die = setup_namespace_context (decl, comp_unit_die);
20385 namespace_die = new_die (is_fortran ()
20386 ? DW_TAG_module : DW_TAG_namespace,
20387 context_die, decl);
20388 /* For Fortran modules defined in different CU don't add src coords. */
20389 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
20391 const char *name = dwarf2_name (decl, 0);
20393 add_name_attribute (namespace_die, name);
20396 add_name_and_src_coords_attributes (namespace_die, decl);
20397 if (DECL_EXTERNAL (decl))
20398 add_AT_flag (namespace_die, DW_AT_declaration, 1);
20399 equate_decl_number_to_die (decl, namespace_die);
20403 /* Output a namespace alias. */
20405 /* Force out the namespace we are an alias of, if necessary. */
20406 dw_die_ref origin_die
20407 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
20409 if (DECL_CONTEXT (decl) == NULL_TREE
20410 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
20411 context_die = setup_namespace_context (decl, comp_unit_die);
20412 /* Now create the namespace alias DIE. */
20413 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
20414 add_name_and_src_coords_attributes (namespace_die, decl);
20415 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
20416 equate_decl_number_to_die (decl, namespace_die);
20420 /* Generate Dwarf debug information for a decl described by DECL. */
20423 gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
20425 tree decl_or_origin = decl ? decl : origin;
20426 tree class_origin = NULL, ultimate_origin;
20428 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
20431 switch (TREE_CODE (decl_or_origin))
20437 if (!is_fortran ())
20439 /* The individual enumerators of an enum type get output when we output
20440 the Dwarf representation of the relevant enum type itself. */
20444 /* Emit its type. */
20445 gen_type_die (TREE_TYPE (decl), context_die);
20447 /* And its containing namespace. */
20448 context_die = declare_in_namespace (decl, context_die);
20450 gen_const_die (decl, context_die);
20453 case FUNCTION_DECL:
20454 /* Don't output any DIEs to represent mere function declarations,
20455 unless they are class members or explicit block externs. */
20456 if (DECL_INITIAL (decl_or_origin) == NULL_TREE
20457 && DECL_CONTEXT (decl_or_origin) == NULL_TREE
20458 && (current_function_decl == NULL_TREE
20459 || DECL_ARTIFICIAL (decl_or_origin)))
20464 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20465 on local redeclarations of global functions. That seems broken. */
20466 if (current_function_decl != decl)
20467 /* This is only a declaration. */;
20470 /* If we're emitting a clone, emit info for the abstract instance. */
20471 if (origin || DECL_ORIGIN (decl) != decl)
20472 dwarf2out_abstract_function (origin
20473 ? DECL_ORIGIN (origin)
20474 : DECL_ABSTRACT_ORIGIN (decl));
20476 /* If we're emitting an out-of-line copy of an inline function,
20477 emit info for the abstract instance and set up to refer to it. */
20478 else if (cgraph_function_possibly_inlined_p (decl)
20479 && ! DECL_ABSTRACT (decl)
20480 && ! class_or_namespace_scope_p (context_die)
20481 /* dwarf2out_abstract_function won't emit a die if this is just
20482 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20483 that case, because that works only if we have a die. */
20484 && DECL_INITIAL (decl) != NULL_TREE)
20486 dwarf2out_abstract_function (decl);
20487 set_decl_origin_self (decl);
20490 /* Otherwise we're emitting the primary DIE for this decl. */
20491 else if (debug_info_level > DINFO_LEVEL_TERSE)
20493 /* Before we describe the FUNCTION_DECL itself, make sure that we
20494 have described its return type. */
20495 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
20497 /* And its virtual context. */
20498 if (DECL_VINDEX (decl) != NULL_TREE)
20499 gen_type_die (DECL_CONTEXT (decl), context_die);
20501 /* And its containing type. */
20503 origin = decl_class_context (decl);
20504 if (origin != NULL_TREE)
20505 gen_type_die_for_member (origin, decl, context_die);
20507 /* And its containing namespace. */
20508 context_die = declare_in_namespace (decl, context_die);
20511 /* Now output a DIE to represent the function itself. */
20513 gen_subprogram_die (decl, context_die);
20517 /* If we are in terse mode, don't generate any DIEs to represent any
20518 actual typedefs. */
20519 if (debug_info_level <= DINFO_LEVEL_TERSE)
20522 /* In the special case of a TYPE_DECL node representing the declaration
20523 of some type tag, if the given TYPE_DECL is marked as having been
20524 instantiated from some other (original) TYPE_DECL node (e.g. one which
20525 was generated within the original definition of an inline function) we
20526 used to generate a special (abbreviated) DW_TAG_structure_type,
20527 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20528 should be actually referencing those DIEs, as variable DIEs with that
20529 type would be emitted already in the abstract origin, so it was always
20530 removed during unused type prunning. Don't add anything in this
20532 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
20535 if (is_redundant_typedef (decl))
20536 gen_type_die (TREE_TYPE (decl), context_die);
20538 /* Output a DIE to represent the typedef itself. */
20539 gen_typedef_die (decl, context_die);
20543 if (debug_info_level >= DINFO_LEVEL_NORMAL)
20544 gen_label_die (decl, context_die);
20549 /* If we are in terse mode, don't generate any DIEs to represent any
20550 variable declarations or definitions. */
20551 if (debug_info_level <= DINFO_LEVEL_TERSE)
20554 /* Output any DIEs that are needed to specify the type of this data
20556 if (decl_by_reference_p (decl_or_origin))
20557 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
20559 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
20561 /* And its containing type. */
20562 class_origin = decl_class_context (decl_or_origin);
20563 if (class_origin != NULL_TREE)
20564 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
20566 /* And its containing namespace. */
20567 context_die = declare_in_namespace (decl_or_origin, context_die);
20569 /* Now output the DIE to represent the data object itself. This gets
20570 complicated because of the possibility that the VAR_DECL really
20571 represents an inlined instance of a formal parameter for an inline
20573 ultimate_origin = decl_ultimate_origin (decl_or_origin);
20574 if (ultimate_origin != NULL_TREE
20575 && TREE_CODE (ultimate_origin) == PARM_DECL)
20576 gen_formal_parameter_die (decl, origin,
20577 true /* Emit name attribute. */,
20580 gen_variable_die (decl, origin, context_die);
20584 /* Ignore the nameless fields that are used to skip bits but handle C++
20585 anonymous unions and structs. */
20586 if (DECL_NAME (decl) != NULL_TREE
20587 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
20588 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
20590 gen_type_die (member_declared_type (decl), context_die);
20591 gen_field_die (decl, context_die);
20596 if (DECL_BY_REFERENCE (decl_or_origin))
20597 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
20599 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
20600 gen_formal_parameter_die (decl, origin,
20601 true /* Emit name attribute. */,
20605 case NAMESPACE_DECL:
20606 case IMPORTED_DECL:
20607 if (dwarf_version >= 3 || !dwarf_strict)
20608 gen_namespace_die (decl, context_die);
20612 /* Probably some frontend-internal decl. Assume we don't care. */
20613 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
20618 /* Output debug information for global decl DECL. Called from toplev.c after
20619 compilation proper has finished. */
20622 dwarf2out_global_decl (tree decl)
20624 /* Output DWARF2 information for file-scope tentative data object
20625 declarations, file-scope (extern) function declarations (which
20626 had no corresponding body) and file-scope tagged type declarations
20627 and definitions which have not yet been forced out. */
20628 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
20629 dwarf2out_decl (decl);
20632 /* Output debug information for type decl DECL. Called from toplev.c
20633 and from language front ends (to record built-in types). */
20635 dwarf2out_type_decl (tree decl, int local)
20638 dwarf2out_decl (decl);
20641 /* Output debug information for imported module or decl DECL.
20642 NAME is non-NULL name in the lexical block if the decl has been renamed.
20643 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20644 that DECL belongs to.
20645 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20647 dwarf2out_imported_module_or_decl_1 (tree decl,
20649 tree lexical_block,
20650 dw_die_ref lexical_block_die)
20652 expanded_location xloc;
20653 dw_die_ref imported_die = NULL;
20654 dw_die_ref at_import_die;
20656 if (TREE_CODE (decl) == IMPORTED_DECL)
20658 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
20659 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
20663 xloc = expand_location (input_location);
20665 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
20667 at_import_die = force_type_die (TREE_TYPE (decl));
20668 /* For namespace N { typedef void T; } using N::T; base_type_die
20669 returns NULL, but DW_TAG_imported_declaration requires
20670 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20671 if (!at_import_die)
20673 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
20674 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
20675 at_import_die = lookup_type_die (TREE_TYPE (decl));
20676 gcc_assert (at_import_die);
20681 at_import_die = lookup_decl_die (decl);
20682 if (!at_import_die)
20684 /* If we're trying to avoid duplicate debug info, we may not have
20685 emitted the member decl for this field. Emit it now. */
20686 if (TREE_CODE (decl) == FIELD_DECL)
20688 tree type = DECL_CONTEXT (decl);
20690 if (TYPE_CONTEXT (type)
20691 && TYPE_P (TYPE_CONTEXT (type))
20692 && !should_emit_struct_debug (TYPE_CONTEXT (type),
20693 DINFO_USAGE_DIR_USE))
20695 gen_type_die_for_member (type, decl,
20696 get_context_die (TYPE_CONTEXT (type)));
20698 at_import_die = force_decl_die (decl);
20702 if (TREE_CODE (decl) == NAMESPACE_DECL)
20704 if (dwarf_version >= 3 || !dwarf_strict)
20705 imported_die = new_die (DW_TAG_imported_module,
20712 imported_die = new_die (DW_TAG_imported_declaration,
20716 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
20717 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
20719 add_AT_string (imported_die, DW_AT_name,
20720 IDENTIFIER_POINTER (name));
20721 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
20724 /* Output debug information for imported module or decl DECL.
20725 NAME is non-NULL name in context if the decl has been renamed.
20726 CHILD is true if decl is one of the renamed decls as part of
20727 importing whole module. */
20730 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
20733 /* dw_die_ref at_import_die; */
20734 dw_die_ref scope_die;
20736 if (debug_info_level <= DINFO_LEVEL_TERSE)
20741 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
20742 We need decl DIE for reference and scope die. First, get DIE for the decl
20745 /* Get the scope die for decl context. Use comp_unit_die for global module
20746 or decl. If die is not found for non globals, force new die. */
20748 && TYPE_P (context)
20749 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
20752 if (!(dwarf_version >= 3 || !dwarf_strict))
20755 scope_die = get_context_die (context);
20759 gcc_assert (scope_die->die_child);
20760 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
20761 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
20762 scope_die = scope_die->die_child;
20765 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
20766 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
20770 /* Write the debugging output for DECL. */
20773 dwarf2out_decl (tree decl)
20775 dw_die_ref context_die = comp_unit_die;
20777 switch (TREE_CODE (decl))
20782 case FUNCTION_DECL:
20783 /* What we would really like to do here is to filter out all mere
20784 file-scope declarations of file-scope functions which are never
20785 referenced later within this translation unit (and keep all of ones
20786 that *are* referenced later on) but we aren't clairvoyant, so we have
20787 no idea which functions will be referenced in the future (i.e. later
20788 on within the current translation unit). So here we just ignore all
20789 file-scope function declarations which are not also definitions. If
20790 and when the debugger needs to know something about these functions,
20791 it will have to hunt around and find the DWARF information associated
20792 with the definition of the function.
20794 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
20795 nodes represent definitions and which ones represent mere
20796 declarations. We have to check DECL_INITIAL instead. That's because
20797 the C front-end supports some weird semantics for "extern inline"
20798 function definitions. These can get inlined within the current
20799 translation unit (and thus, we need to generate Dwarf info for their
20800 abstract instances so that the Dwarf info for the concrete inlined
20801 instances can have something to refer to) but the compiler never
20802 generates any out-of-lines instances of such things (despite the fact
20803 that they *are* definitions).
20805 The important point is that the C front-end marks these "extern
20806 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
20807 them anyway. Note that the C++ front-end also plays some similar games
20808 for inline function definitions appearing within include files which
20809 also contain `#pragma interface' pragmas. */
20810 if (DECL_INITIAL (decl) == NULL_TREE)
20813 /* If we're a nested function, initially use a parent of NULL; if we're
20814 a plain function, this will be fixed up in decls_for_scope. If
20815 we're a method, it will be ignored, since we already have a DIE. */
20816 if (decl_function_context (decl)
20817 /* But if we're in terse mode, we don't care about scope. */
20818 && debug_info_level > DINFO_LEVEL_TERSE)
20819 context_die = NULL;
20823 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
20824 declaration and if the declaration was never even referenced from
20825 within this entire compilation unit. We suppress these DIEs in
20826 order to save space in the .debug section (by eliminating entries
20827 which are probably useless). Note that we must not suppress
20828 block-local extern declarations (whether used or not) because that
20829 would screw-up the debugger's name lookup mechanism and cause it to
20830 miss things which really ought to be in scope at a given point. */
20831 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
20834 /* For local statics lookup proper context die. */
20835 if (TREE_STATIC (decl) && decl_function_context (decl))
20836 context_die = lookup_decl_die (DECL_CONTEXT (decl));
20838 /* If we are in terse mode, don't generate any DIEs to represent any
20839 variable declarations or definitions. */
20840 if (debug_info_level <= DINFO_LEVEL_TERSE)
20845 if (debug_info_level <= DINFO_LEVEL_TERSE)
20847 if (!is_fortran ())
20849 if (TREE_STATIC (decl) && decl_function_context (decl))
20850 context_die = lookup_decl_die (DECL_CONTEXT (decl));
20853 case NAMESPACE_DECL:
20854 case IMPORTED_DECL:
20855 if (debug_info_level <= DINFO_LEVEL_TERSE)
20857 if (lookup_decl_die (decl) != NULL)
20862 /* Don't emit stubs for types unless they are needed by other DIEs. */
20863 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
20866 /* Don't bother trying to generate any DIEs to represent any of the
20867 normal built-in types for the language we are compiling. */
20868 if (DECL_IS_BUILTIN (decl))
20870 /* OK, we need to generate one for `bool' so GDB knows what type
20871 comparisons have. */
20873 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
20874 && ! DECL_IGNORED_P (decl))
20875 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
20880 /* If we are in terse mode, don't generate any DIEs for types. */
20881 if (debug_info_level <= DINFO_LEVEL_TERSE)
20884 /* If we're a function-scope tag, initially use a parent of NULL;
20885 this will be fixed up in decls_for_scope. */
20886 if (decl_function_context (decl))
20887 context_die = NULL;
20895 gen_decl_die (decl, NULL, context_die);
20898 /* Write the debugging output for DECL. */
20901 dwarf2out_function_decl (tree decl)
20903 dwarf2out_decl (decl);
20905 htab_empty (decl_loc_table);
20908 /* Output a marker (i.e. a label) for the beginning of the generated code for
20909 a lexical block. */
20912 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
20913 unsigned int blocknum)
20915 switch_to_section (current_function_section ());
20916 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
20919 /* Output a marker (i.e. a label) for the end of the generated code for a
20923 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
20925 switch_to_section (current_function_section ());
20926 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
20929 /* Returns nonzero if it is appropriate not to emit any debugging
20930 information for BLOCK, because it doesn't contain any instructions.
20932 Don't allow this for blocks with nested functions or local classes
20933 as we would end up with orphans, and in the presence of scheduling
20934 we may end up calling them anyway. */
20937 dwarf2out_ignore_block (const_tree block)
20942 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
20943 if (TREE_CODE (decl) == FUNCTION_DECL
20944 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
20946 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
20948 decl = BLOCK_NONLOCALIZED_VAR (block, i);
20949 if (TREE_CODE (decl) == FUNCTION_DECL
20950 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
20957 /* Hash table routines for file_hash. */
20960 file_table_eq (const void *p1_p, const void *p2_p)
20962 const struct dwarf_file_data *const p1 =
20963 (const struct dwarf_file_data *) p1_p;
20964 const char *const p2 = (const char *) p2_p;
20965 return strcmp (p1->filename, p2) == 0;
20969 file_table_hash (const void *p_p)
20971 const struct dwarf_file_data *const p = (const struct dwarf_file_data *) p_p;
20972 return htab_hash_string (p->filename);
20975 /* Lookup FILE_NAME (in the list of filenames that we know about here in
20976 dwarf2out.c) and return its "index". The index of each (known) filename is
20977 just a unique number which is associated with only that one filename. We
20978 need such numbers for the sake of generating labels (in the .debug_sfnames
20979 section) and references to those files numbers (in the .debug_srcinfo
20980 and.debug_macinfo sections). If the filename given as an argument is not
20981 found in our current list, add it to the list and assign it the next
20982 available unique index number. In order to speed up searches, we remember
20983 the index of the filename was looked up last. This handles the majority of
20986 static struct dwarf_file_data *
20987 lookup_filename (const char *file_name)
20990 struct dwarf_file_data * created;
20992 /* Check to see if the file name that was searched on the previous
20993 call matches this file name. If so, return the index. */
20994 if (file_table_last_lookup
20995 && (file_name == file_table_last_lookup->filename
20996 || strcmp (file_table_last_lookup->filename, file_name) == 0))
20997 return file_table_last_lookup;
20999 /* Didn't match the previous lookup, search the table. */
21000 slot = htab_find_slot_with_hash (file_table, file_name,
21001 htab_hash_string (file_name), INSERT);
21003 return (struct dwarf_file_data *) *slot;
21005 created = ggc_alloc_dwarf_file_data ();
21006 created->filename = file_name;
21007 created->emitted_number = 0;
21012 /* If the assembler will construct the file table, then translate the compiler
21013 internal file table number into the assembler file table number, and emit
21014 a .file directive if we haven't already emitted one yet. The file table
21015 numbers are different because we prune debug info for unused variables and
21016 types, which may include filenames. */
21019 maybe_emit_file (struct dwarf_file_data * fd)
21021 if (! fd->emitted_number)
21023 if (last_emitted_file)
21024 fd->emitted_number = last_emitted_file->emitted_number + 1;
21026 fd->emitted_number = 1;
21027 last_emitted_file = fd;
21029 if (DWARF2_ASM_LINE_DEBUG_INFO)
21031 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
21032 output_quoted_string (asm_out_file,
21033 remap_debug_filename (fd->filename));
21034 fputc ('\n', asm_out_file);
21038 return fd->emitted_number;
21041 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21042 That generation should happen after function debug info has been
21043 generated. The value of the attribute is the constant value of ARG. */
21046 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
21048 die_arg_entry entry;
21053 if (!tmpl_value_parm_die_table)
21054 tmpl_value_parm_die_table
21055 = VEC_alloc (die_arg_entry, gc, 32);
21059 VEC_safe_push (die_arg_entry, gc,
21060 tmpl_value_parm_die_table,
21064 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21065 by append_entry_to_tmpl_value_parm_die_table. This function must
21066 be called after function DIEs have been generated. */
21069 gen_remaining_tmpl_value_param_die_attribute (void)
21071 if (tmpl_value_parm_die_table)
21077 VEC_iterate (die_arg_entry, tmpl_value_parm_die_table, i, e);
21079 tree_add_const_value_attribute (e->die, e->arg);
21084 /* Replace DW_AT_name for the decl with name. */
21087 dwarf2out_set_name (tree decl, tree name)
21093 die = TYPE_SYMTAB_DIE (decl);
21097 dname = dwarf2_name (name, 0);
21101 attr = get_AT (die, DW_AT_name);
21104 struct indirect_string_node *node;
21106 node = find_AT_string (dname);
21107 /* replace the string. */
21108 attr->dw_attr_val.v.val_str = node;
21112 add_name_attribute (die, dname);
21115 /* Called by the final INSN scan whenever we see a direct function call.
21116 Make an entry into the direct call table, recording the point of call
21117 and a reference to the target function's debug entry. */
21120 dwarf2out_direct_call (tree targ)
21123 tree origin = decl_ultimate_origin (targ);
21125 /* If this is a clone, use the abstract origin as the target. */
21129 e.poc_label_num = poc_label_num++;
21130 e.poc_decl = current_function_decl;
21131 e.targ_die = force_decl_die (targ);
21132 VEC_safe_push (dcall_entry, gc, dcall_table, &e);
21134 /* Drop a label at the return point to mark the point of call. */
21135 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LPOC", e.poc_label_num);
21138 /* Returns a hash value for X (which really is a struct vcall_insn). */
21141 vcall_insn_table_hash (const void *x)
21143 return (hashval_t) ((const struct vcall_insn *) x)->insn_uid;
21146 /* Return nonzero if insn_uid of struct vcall_insn *X is the same as
21147 insnd_uid of *Y. */
21150 vcall_insn_table_eq (const void *x, const void *y)
21152 return (((const struct vcall_insn *) x)->insn_uid
21153 == ((const struct vcall_insn *) y)->insn_uid);
21156 /* Associate VTABLE_SLOT with INSN_UID in the VCALL_INSN_TABLE. */
21159 store_vcall_insn (unsigned int vtable_slot, int insn_uid)
21161 struct vcall_insn *item = ggc_alloc_vcall_insn ();
21162 struct vcall_insn **slot;
21165 item->insn_uid = insn_uid;
21166 item->vtable_slot = vtable_slot;
21167 slot = (struct vcall_insn **)
21168 htab_find_slot_with_hash (vcall_insn_table, &item,
21169 (hashval_t) insn_uid, INSERT);
21173 /* Return the VTABLE_SLOT associated with INSN_UID. */
21175 static unsigned int
21176 lookup_vcall_insn (unsigned int insn_uid)
21178 struct vcall_insn item;
21179 struct vcall_insn *p;
21181 item.insn_uid = insn_uid;
21182 item.vtable_slot = 0;
21183 p = (struct vcall_insn *) htab_find_with_hash (vcall_insn_table,
21185 (hashval_t) insn_uid);
21187 return (unsigned int) -1;
21188 return p->vtable_slot;
21192 /* Called when lowering indirect calls to RTL. We make a note of INSN_UID
21193 and the OBJ_TYPE_REF_TOKEN from ADDR. For C++ virtual calls, the token
21194 is the vtable slot index that we will need to put in the virtual call
21198 dwarf2out_virtual_call_token (tree addr, int insn_uid)
21200 if (is_cxx() && TREE_CODE (addr) == OBJ_TYPE_REF)
21202 tree token = OBJ_TYPE_REF_TOKEN (addr);
21203 if (TREE_CODE (token) == INTEGER_CST)
21204 store_vcall_insn (TREE_INT_CST_LOW (token), insn_uid);
21208 /* Called when scheduling RTL, when a CALL_INSN is split. Copies the
21209 OBJ_TYPE_REF_TOKEN previously associated with OLD_INSN and associates it
21213 dwarf2out_copy_call_info (rtx old_insn, rtx new_insn)
21215 unsigned int vtable_slot = lookup_vcall_insn (INSN_UID (old_insn));
21217 if (vtable_slot != (unsigned int) -1)
21218 store_vcall_insn (vtable_slot, INSN_UID (new_insn));
21221 /* Called by the final INSN scan whenever we see a virtual function call.
21222 Make an entry into the virtual call table, recording the point of call
21223 and the slot index of the vtable entry used to call the virtual member
21224 function. The slot index was associated with the INSN_UID during the
21225 lowering to RTL. */
21228 dwarf2out_virtual_call (int insn_uid)
21230 unsigned int vtable_slot = lookup_vcall_insn (insn_uid);
21233 if (vtable_slot == (unsigned int) -1)
21236 e.poc_label_num = poc_label_num++;
21237 e.vtable_slot = vtable_slot;
21238 VEC_safe_push (vcall_entry, gc, vcall_table, &e);
21240 /* Drop a label at the return point to mark the point of call. */
21241 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LPOC", e.poc_label_num);
21244 /* Called by the final INSN scan whenever we see a var location. We
21245 use it to drop labels in the right places, and throw the location in
21246 our lookup table. */
21249 dwarf2out_var_location (rtx loc_note)
21251 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
21252 struct var_loc_node *newloc;
21254 static const char *last_label;
21255 static const char *last_postcall_label;
21256 static bool last_in_cold_section_p;
21259 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
21262 next_real = next_real_insn (loc_note);
21263 /* If there are no instructions which would be affected by this note,
21264 don't do anything. */
21265 if (next_real == NULL_RTX)
21268 /* If there were any real insns between note we processed last time
21269 and this note (or if it is the first note), clear
21270 last_{,postcall_}label so that they are not reused this time. */
21271 if (last_var_location_insn == NULL_RTX
21272 || last_var_location_insn != next_real
21273 || last_in_cold_section_p != in_cold_section_p)
21276 last_postcall_label = NULL;
21279 decl = NOTE_VAR_LOCATION_DECL (loc_note);
21280 newloc = add_var_loc_to_decl (decl, loc_note,
21281 NOTE_DURING_CALL_P (loc_note)
21282 ? last_postcall_label : last_label);
21283 if (newloc == NULL)
21286 /* If there were no real insns between note we processed last time
21287 and this note, use the label we emitted last time. Otherwise
21288 create a new label and emit it. */
21289 if (last_label == NULL)
21291 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
21292 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
21294 last_label = ggc_strdup (loclabel);
21297 if (!NOTE_DURING_CALL_P (loc_note))
21298 newloc->label = last_label;
21301 if (!last_postcall_label)
21303 sprintf (loclabel, "%s-1", last_label);
21304 last_postcall_label = ggc_strdup (loclabel);
21306 newloc->label = last_postcall_label;
21309 last_var_location_insn = next_real;
21310 last_in_cold_section_p = in_cold_section_p;
21313 /* We need to reset the locations at the beginning of each
21314 function. We can't do this in the end_function hook, because the
21315 declarations that use the locations won't have been output when
21316 that hook is called. Also compute have_multiple_function_sections here. */
21319 dwarf2out_begin_function (tree fun)
21321 if (function_section (fun) != text_section)
21322 have_multiple_function_sections = true;
21324 dwarf2out_note_section_used ();
21327 /* Output a label to mark the beginning of a source code line entry
21328 and record information relating to this source line, in
21329 'line_info_table' for later output of the .debug_line section. */
21332 dwarf2out_source_line (unsigned int line, const char *filename,
21333 int discriminator, bool is_stmt)
21335 static bool last_is_stmt = true;
21337 if (debug_info_level >= DINFO_LEVEL_NORMAL
21340 int file_num = maybe_emit_file (lookup_filename (filename));
21342 switch_to_section (current_function_section ());
21344 /* If requested, emit something human-readable. */
21345 if (flag_debug_asm)
21346 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
21349 if (DWARF2_ASM_LINE_DEBUG_INFO)
21351 /* Emit the .loc directive understood by GNU as. */
21352 fprintf (asm_out_file, "\t.loc %d %d 0", file_num, line);
21353 if (is_stmt != last_is_stmt)
21355 fprintf (asm_out_file, " is_stmt %d", is_stmt ? 1 : 0);
21356 last_is_stmt = is_stmt;
21358 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
21359 fprintf (asm_out_file, " discriminator %d", discriminator);
21360 fputc ('\n', asm_out_file);
21362 /* Indicate that line number info exists. */
21363 line_info_table_in_use++;
21365 else if (function_section (current_function_decl) != text_section)
21367 dw_separate_line_info_ref line_info;
21368 targetm.asm_out.internal_label (asm_out_file,
21369 SEPARATE_LINE_CODE_LABEL,
21370 separate_line_info_table_in_use);
21372 /* Expand the line info table if necessary. */
21373 if (separate_line_info_table_in_use
21374 == separate_line_info_table_allocated)
21376 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
21377 separate_line_info_table
21378 = GGC_RESIZEVEC (dw_separate_line_info_entry,
21379 separate_line_info_table,
21380 separate_line_info_table_allocated);
21381 memset (separate_line_info_table
21382 + separate_line_info_table_in_use,
21384 (LINE_INFO_TABLE_INCREMENT
21385 * sizeof (dw_separate_line_info_entry)));
21388 /* Add the new entry at the end of the line_info_table. */
21390 = &separate_line_info_table[separate_line_info_table_in_use++];
21391 line_info->dw_file_num = file_num;
21392 line_info->dw_line_num = line;
21393 line_info->function = current_function_funcdef_no;
21397 dw_line_info_ref line_info;
21399 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
21400 line_info_table_in_use);
21402 /* Expand the line info table if necessary. */
21403 if (line_info_table_in_use == line_info_table_allocated)
21405 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
21407 = GGC_RESIZEVEC (dw_line_info_entry, line_info_table,
21408 line_info_table_allocated);
21409 memset (line_info_table + line_info_table_in_use, 0,
21410 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
21413 /* Add the new entry at the end of the line_info_table. */
21414 line_info = &line_info_table[line_info_table_in_use++];
21415 line_info->dw_file_num = file_num;
21416 line_info->dw_line_num = line;
21421 /* Record the beginning of a new source file. */
21424 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
21426 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
21428 /* Record the beginning of the file for break_out_includes. */
21429 dw_die_ref bincl_die;
21431 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
21432 add_AT_string (bincl_die, DW_AT_name, remap_debug_filename (filename));
21435 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21437 int file_num = maybe_emit_file (lookup_filename (filename));
21439 switch_to_section (debug_macinfo_section);
21440 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
21441 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
21444 dw2_asm_output_data_uleb128 (file_num, "file %s", filename);
21448 /* Record the end of a source file. */
21451 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
21453 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
21454 /* Record the end of the file for break_out_includes. */
21455 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
21457 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21459 switch_to_section (debug_macinfo_section);
21460 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
21464 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21465 the tail part of the directive line, i.e. the part which is past the
21466 initial whitespace, #, whitespace, directive-name, whitespace part. */
21469 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
21470 const char *buffer ATTRIBUTE_UNUSED)
21472 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21474 switch_to_section (debug_macinfo_section);
21475 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
21476 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
21477 dw2_asm_output_nstring (buffer, -1, "The macro");
21481 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21482 the tail part of the directive line, i.e. the part which is past the
21483 initial whitespace, #, whitespace, directive-name, whitespace part. */
21486 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
21487 const char *buffer ATTRIBUTE_UNUSED)
21489 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21491 switch_to_section (debug_macinfo_section);
21492 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
21493 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
21494 dw2_asm_output_nstring (buffer, -1, "The macro");
21498 /* Set up for Dwarf output at the start of compilation. */
21501 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
21503 /* Allocate the file_table. */
21504 file_table = htab_create_ggc (50, file_table_hash,
21505 file_table_eq, NULL);
21507 /* Allocate the decl_die_table. */
21508 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
21509 decl_die_table_eq, NULL);
21511 /* Allocate the decl_loc_table. */
21512 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
21513 decl_loc_table_eq, NULL);
21515 /* Allocate the initial hunk of the decl_scope_table. */
21516 decl_scope_table = VEC_alloc (tree, gc, 256);
21518 /* Allocate the initial hunk of the abbrev_die_table. */
21519 abbrev_die_table = ggc_alloc_cleared_vec_dw_die_ref
21520 (ABBREV_DIE_TABLE_INCREMENT);
21521 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
21522 /* Zero-th entry is allocated, but unused. */
21523 abbrev_die_table_in_use = 1;
21525 /* Allocate the initial hunk of the line_info_table. */
21526 line_info_table = ggc_alloc_cleared_vec_dw_line_info_entry
21527 (LINE_INFO_TABLE_INCREMENT);
21528 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
21530 /* Zero-th entry is allocated, but unused. */
21531 line_info_table_in_use = 1;
21533 /* Allocate the pubtypes and pubnames vectors. */
21534 pubname_table = VEC_alloc (pubname_entry, gc, 32);
21535 pubtype_table = VEC_alloc (pubname_entry, gc, 32);
21537 /* Allocate the table that maps insn UIDs to vtable slot indexes. */
21538 vcall_insn_table = htab_create_ggc (10, vcall_insn_table_hash,
21539 vcall_insn_table_eq, NULL);
21541 /* Generate the initial DIE for the .debug section. Note that the (string)
21542 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
21543 will (typically) be a relative pathname and that this pathname should be
21544 taken as being relative to the directory from which the compiler was
21545 invoked when the given (base) source file was compiled. We will fill
21546 in this value in dwarf2out_finish. */
21547 comp_unit_die = gen_compile_unit_die (NULL);
21549 incomplete_types = VEC_alloc (tree, gc, 64);
21551 used_rtx_array = VEC_alloc (rtx, gc, 32);
21553 debug_info_section = get_section (DEBUG_INFO_SECTION,
21554 SECTION_DEBUG, NULL);
21555 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
21556 SECTION_DEBUG, NULL);
21557 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
21558 SECTION_DEBUG, NULL);
21559 debug_macinfo_section = get_section (DEBUG_MACINFO_SECTION,
21560 SECTION_DEBUG, NULL);
21561 debug_line_section = get_section (DEBUG_LINE_SECTION,
21562 SECTION_DEBUG, NULL);
21563 debug_loc_section = get_section (DEBUG_LOC_SECTION,
21564 SECTION_DEBUG, NULL);
21565 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
21566 SECTION_DEBUG, NULL);
21567 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
21568 SECTION_DEBUG, NULL);
21569 debug_dcall_section = get_section (DEBUG_DCALL_SECTION,
21570 SECTION_DEBUG, NULL);
21571 debug_vcall_section = get_section (DEBUG_VCALL_SECTION,
21572 SECTION_DEBUG, NULL);
21573 debug_str_section = get_section (DEBUG_STR_SECTION,
21574 DEBUG_STR_SECTION_FLAGS, NULL);
21575 debug_ranges_section = get_section (DEBUG_RANGES_SECTION,
21576 SECTION_DEBUG, NULL);
21577 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
21578 SECTION_DEBUG, NULL);
21580 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
21581 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
21582 DEBUG_ABBREV_SECTION_LABEL, 0);
21583 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
21584 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
21585 COLD_TEXT_SECTION_LABEL, 0);
21586 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
21588 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
21589 DEBUG_INFO_SECTION_LABEL, 0);
21590 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
21591 DEBUG_LINE_SECTION_LABEL, 0);
21592 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
21593 DEBUG_RANGES_SECTION_LABEL, 0);
21594 switch_to_section (debug_abbrev_section);
21595 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
21596 switch_to_section (debug_info_section);
21597 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
21598 switch_to_section (debug_line_section);
21599 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
21601 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
21603 switch_to_section (debug_macinfo_section);
21604 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
21605 DEBUG_MACINFO_SECTION_LABEL, 0);
21606 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
21609 switch_to_section (text_section);
21610 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
21611 if (flag_reorder_blocks_and_partition)
21613 cold_text_section = unlikely_text_section ();
21614 switch_to_section (cold_text_section);
21615 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
21620 /* Called before cgraph_optimize starts outputtting functions, variables
21621 and toplevel asms into assembly. */
21624 dwarf2out_assembly_start (void)
21626 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE && dwarf2out_do_cfi_asm ())
21628 #ifndef TARGET_UNWIND_INFO
21629 if (USING_SJLJ_EXCEPTIONS || (!flag_unwind_tables && !flag_exceptions))
21631 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
21635 /* A helper function for dwarf2out_finish called through
21636 htab_traverse. Emit one queued .debug_str string. */
21639 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
21641 struct indirect_string_node *node = (struct indirect_string_node *) *h;
21643 if (node->label && node->refcount)
21645 switch_to_section (debug_str_section);
21646 ASM_OUTPUT_LABEL (asm_out_file, node->label);
21647 assemble_string (node->str, strlen (node->str) + 1);
21653 #if ENABLE_ASSERT_CHECKING
21654 /* Verify that all marks are clear. */
21657 verify_marks_clear (dw_die_ref die)
21661 gcc_assert (! die->die_mark);
21662 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
21664 #endif /* ENABLE_ASSERT_CHECKING */
21666 /* Clear the marks for a die and its children.
21667 Be cool if the mark isn't set. */
21670 prune_unmark_dies (dw_die_ref die)
21676 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
21679 /* Given DIE that we're marking as used, find any other dies
21680 it references as attributes and mark them as used. */
21683 prune_unused_types_walk_attribs (dw_die_ref die)
21688 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
21690 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
21692 /* A reference to another DIE.
21693 Make sure that it will get emitted.
21694 If it was broken out into a comdat group, don't follow it. */
21695 if (dwarf_version < 4
21696 || a->dw_attr == DW_AT_specification
21697 || a->dw_attr_val.v.val_die_ref.die->die_id.die_type_node == NULL)
21698 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
21700 /* Set the string's refcount to 0 so that prune_unused_types_mark
21701 accounts properly for it. */
21702 if (AT_class (a) == dw_val_class_str)
21703 a->dw_attr_val.v.val_str->refcount = 0;
21708 /* Mark DIE as being used. If DOKIDS is true, then walk down
21709 to DIE's children. */
21712 prune_unused_types_mark (dw_die_ref die, int dokids)
21716 if (die->die_mark == 0)
21718 /* We haven't done this node yet. Mark it as used. */
21721 /* We also have to mark its parents as used.
21722 (But we don't want to mark our parents' kids due to this.) */
21723 if (die->die_parent)
21724 prune_unused_types_mark (die->die_parent, 0);
21726 /* Mark any referenced nodes. */
21727 prune_unused_types_walk_attribs (die);
21729 /* If this node is a specification,
21730 also mark the definition, if it exists. */
21731 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
21732 prune_unused_types_mark (die->die_definition, 1);
21735 if (dokids && die->die_mark != 2)
21737 /* We need to walk the children, but haven't done so yet.
21738 Remember that we've walked the kids. */
21741 /* If this is an array type, we need to make sure our
21742 kids get marked, even if they're types. If we're
21743 breaking out types into comdat sections, do this
21744 for all type definitions. */
21745 if (die->die_tag == DW_TAG_array_type
21746 || (dwarf_version >= 4
21747 && is_type_die (die) && ! is_declaration_die (die)))
21748 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
21750 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
21754 /* For local classes, look if any static member functions were emitted
21755 and if so, mark them. */
21758 prune_unused_types_walk_local_classes (dw_die_ref die)
21762 if (die->die_mark == 2)
21765 switch (die->die_tag)
21767 case DW_TAG_structure_type:
21768 case DW_TAG_union_type:
21769 case DW_TAG_class_type:
21772 case DW_TAG_subprogram:
21773 if (!get_AT_flag (die, DW_AT_declaration)
21774 || die->die_definition != NULL)
21775 prune_unused_types_mark (die, 1);
21782 /* Mark children. */
21783 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
21786 /* Walk the tree DIE and mark types that we actually use. */
21789 prune_unused_types_walk (dw_die_ref die)
21793 /* Don't do anything if this node is already marked and
21794 children have been marked as well. */
21795 if (die->die_mark == 2)
21798 switch (die->die_tag)
21800 case DW_TAG_structure_type:
21801 case DW_TAG_union_type:
21802 case DW_TAG_class_type:
21803 if (die->die_perennial_p)
21806 for (c = die->die_parent; c; c = c->die_parent)
21807 if (c->die_tag == DW_TAG_subprogram)
21810 /* Finding used static member functions inside of classes
21811 is needed just for local classes, because for other classes
21812 static member function DIEs with DW_AT_specification
21813 are emitted outside of the DW_TAG_*_type. If we ever change
21814 it, we'd need to call this even for non-local classes. */
21816 prune_unused_types_walk_local_classes (die);
21818 /* It's a type node --- don't mark it. */
21821 case DW_TAG_const_type:
21822 case DW_TAG_packed_type:
21823 case DW_TAG_pointer_type:
21824 case DW_TAG_reference_type:
21825 case DW_TAG_rvalue_reference_type:
21826 case DW_TAG_volatile_type:
21827 case DW_TAG_typedef:
21828 case DW_TAG_array_type:
21829 case DW_TAG_interface_type:
21830 case DW_TAG_friend:
21831 case DW_TAG_variant_part:
21832 case DW_TAG_enumeration_type:
21833 case DW_TAG_subroutine_type:
21834 case DW_TAG_string_type:
21835 case DW_TAG_set_type:
21836 case DW_TAG_subrange_type:
21837 case DW_TAG_ptr_to_member_type:
21838 case DW_TAG_file_type:
21839 if (die->die_perennial_p)
21842 /* It's a type node --- don't mark it. */
21846 /* Mark everything else. */
21850 if (die->die_mark == 0)
21854 /* Now, mark any dies referenced from here. */
21855 prune_unused_types_walk_attribs (die);
21860 /* Mark children. */
21861 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
21864 /* Increment the string counts on strings referred to from DIE's
21868 prune_unused_types_update_strings (dw_die_ref die)
21873 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
21874 if (AT_class (a) == dw_val_class_str)
21876 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
21878 /* Avoid unnecessarily putting strings that are used less than
21879 twice in the hash table. */
21881 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
21884 slot = htab_find_slot_with_hash (debug_str_hash, s->str,
21885 htab_hash_string (s->str),
21887 gcc_assert (*slot == NULL);
21893 /* Remove from the tree DIE any dies that aren't marked. */
21896 prune_unused_types_prune (dw_die_ref die)
21900 gcc_assert (die->die_mark);
21901 prune_unused_types_update_strings (die);
21903 if (! die->die_child)
21906 c = die->die_child;
21908 dw_die_ref prev = c;
21909 for (c = c->die_sib; ! c->die_mark; c = c->die_sib)
21910 if (c == die->die_child)
21912 /* No marked children between 'prev' and the end of the list. */
21914 /* No marked children at all. */
21915 die->die_child = NULL;
21918 prev->die_sib = c->die_sib;
21919 die->die_child = prev;
21924 if (c != prev->die_sib)
21926 prune_unused_types_prune (c);
21927 } while (c != die->die_child);
21930 /* A helper function for dwarf2out_finish called through
21931 htab_traverse. Clear .debug_str strings that we haven't already
21932 decided to emit. */
21935 prune_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
21937 struct indirect_string_node *node = (struct indirect_string_node *) *h;
21939 if (!node->label || !node->refcount)
21940 htab_clear_slot (debug_str_hash, h);
21945 /* Remove dies representing declarations that we never use. */
21948 prune_unused_types (void)
21951 limbo_die_node *node;
21952 comdat_type_node *ctnode;
21954 dcall_entry *dcall;
21956 #if ENABLE_ASSERT_CHECKING
21957 /* All the marks should already be clear. */
21958 verify_marks_clear (comp_unit_die);
21959 for (node = limbo_die_list; node; node = node->next)
21960 verify_marks_clear (node->die);
21961 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21962 verify_marks_clear (ctnode->root_die);
21963 #endif /* ENABLE_ASSERT_CHECKING */
21965 /* Mark types that are used in global variables. */
21966 premark_types_used_by_global_vars ();
21968 /* Set the mark on nodes that are actually used. */
21969 prune_unused_types_walk (comp_unit_die);
21970 for (node = limbo_die_list; node; node = node->next)
21971 prune_unused_types_walk (node->die);
21972 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21974 prune_unused_types_walk (ctnode->root_die);
21975 prune_unused_types_mark (ctnode->type_die, 1);
21978 /* Also set the mark on nodes referenced from the
21979 pubname_table or arange_table. */
21980 for (i = 0; VEC_iterate (pubname_entry, pubname_table, i, pub); i++)
21981 prune_unused_types_mark (pub->die, 1);
21982 for (i = 0; i < arange_table_in_use; i++)
21983 prune_unused_types_mark (arange_table[i], 1);
21985 /* Mark nodes referenced from the direct call table. */
21986 for (i = 0; VEC_iterate (dcall_entry, dcall_table, i, dcall); i++)
21987 prune_unused_types_mark (dcall->targ_die, 1);
21989 /* Get rid of nodes that aren't marked; and update the string counts. */
21990 if (debug_str_hash && debug_str_hash_forced)
21991 htab_traverse (debug_str_hash, prune_indirect_string, NULL);
21992 else if (debug_str_hash)
21993 htab_empty (debug_str_hash);
21994 prune_unused_types_prune (comp_unit_die);
21995 for (node = limbo_die_list; node; node = node->next)
21996 prune_unused_types_prune (node->die);
21997 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
21998 prune_unused_types_prune (ctnode->root_die);
22000 /* Leave the marks clear. */
22001 prune_unmark_dies (comp_unit_die);
22002 for (node = limbo_die_list; node; node = node->next)
22003 prune_unmark_dies (node->die);
22004 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
22005 prune_unmark_dies (ctnode->root_die);
22008 /* Set the parameter to true if there are any relative pathnames in
22011 file_table_relative_p (void ** slot, void *param)
22013 bool *p = (bool *) param;
22014 struct dwarf_file_data *d = (struct dwarf_file_data *) *slot;
22015 if (!IS_ABSOLUTE_PATH (d->filename))
22023 /* Routines to manipulate hash table of comdat type units. */
22026 htab_ct_hash (const void *of)
22029 const comdat_type_node *const type_node = (const comdat_type_node *) of;
22031 memcpy (&h, type_node->signature, sizeof (h));
22036 htab_ct_eq (const void *of1, const void *of2)
22038 const comdat_type_node *const type_node_1 = (const comdat_type_node *) of1;
22039 const comdat_type_node *const type_node_2 = (const comdat_type_node *) of2;
22041 return (! memcmp (type_node_1->signature, type_node_2->signature,
22042 DWARF_TYPE_SIGNATURE_SIZE));
22045 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
22046 to the location it would have been added, should we know its
22047 DECL_ASSEMBLER_NAME when we added other attributes. This will
22048 probably improve compactness of debug info, removing equivalent
22049 abbrevs, and hide any differences caused by deferring the
22050 computation of the assembler name, triggered by e.g. PCH. */
22053 move_linkage_attr (dw_die_ref die)
22055 unsigned ix = VEC_length (dw_attr_node, die->die_attr);
22056 dw_attr_node linkage = *VEC_index (dw_attr_node, die->die_attr, ix - 1);
22058 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
22059 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
22063 dw_attr_node *prev = VEC_index (dw_attr_node, die->die_attr, ix - 1);
22065 if (prev->dw_attr == DW_AT_decl_line || prev->dw_attr == DW_AT_name)
22069 if (ix != VEC_length (dw_attr_node, die->die_attr) - 1)
22071 VEC_pop (dw_attr_node, die->die_attr);
22072 VEC_quick_insert (dw_attr_node, die->die_attr, ix, &linkage);
22076 /* Helper function for resolve_addr, attempt to resolve
22077 one CONST_STRING, return non-zero if not successful. Similarly verify that
22078 SYMBOL_REFs refer to variables emitted in the current CU. */
22081 resolve_one_addr (rtx *addr, void *data ATTRIBUTE_UNUSED)
22085 if (GET_CODE (rtl) == CONST_STRING)
22087 size_t len = strlen (XSTR (rtl, 0)) + 1;
22088 tree t = build_string (len, XSTR (rtl, 0));
22089 tree tlen = build_int_cst (NULL_TREE, len - 1);
22091 = build_array_type (char_type_node, build_index_type (tlen));
22092 rtl = lookup_constant_def (t);
22093 if (!rtl || !MEM_P (rtl))
22095 rtl = XEXP (rtl, 0);
22096 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
22101 if (GET_CODE (rtl) == SYMBOL_REF
22102 && SYMBOL_REF_DECL (rtl)
22103 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
22106 if (GET_CODE (rtl) == CONST
22107 && for_each_rtx (&XEXP (rtl, 0), resolve_one_addr, NULL))
22113 /* Helper function for resolve_addr, handle one location
22114 expression, return false if at least one CONST_STRING or SYMBOL_REF in
22115 the location list couldn't be resolved. */
22118 resolve_addr_in_expr (dw_loc_descr_ref loc)
22120 for (; loc; loc = loc->dw_loc_next)
22121 if (((loc->dw_loc_opc == DW_OP_addr || loc->dtprel)
22122 && resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr, NULL))
22123 || (loc->dw_loc_opc == DW_OP_implicit_value
22124 && loc->dw_loc_oprnd2.val_class == dw_val_class_addr
22125 && resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr, NULL)))
22130 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
22131 an address in .rodata section if the string literal is emitted there,
22132 or remove the containing location list or replace DW_AT_const_value
22133 with DW_AT_location and empty location expression, if it isn't found
22134 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
22135 to something that has been emitted in the current CU. */
22138 resolve_addr (dw_die_ref die)
22142 dw_loc_list_ref *curr;
22145 for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, a); ix++)
22146 switch (AT_class (a))
22148 case dw_val_class_loc_list:
22149 curr = AT_loc_list_ptr (a);
22152 if (!resolve_addr_in_expr ((*curr)->expr))
22154 dw_loc_list_ref next = (*curr)->dw_loc_next;
22155 if (next && (*curr)->ll_symbol)
22157 gcc_assert (!next->ll_symbol);
22158 next->ll_symbol = (*curr)->ll_symbol;
22163 curr = &(*curr)->dw_loc_next;
22165 if (!AT_loc_list (a))
22167 remove_AT (die, a->dw_attr);
22171 case dw_val_class_loc:
22172 if (!resolve_addr_in_expr (AT_loc (a)))
22174 remove_AT (die, a->dw_attr);
22178 case dw_val_class_addr:
22179 if (a->dw_attr == DW_AT_const_value
22180 && resolve_one_addr (&a->dw_attr_val.v.val_addr, NULL))
22182 remove_AT (die, a->dw_attr);
22190 FOR_EACH_CHILD (die, c, resolve_addr (c));
22193 /* Output stuff that dwarf requires at the end of every file,
22194 and generate the DWARF-2 debugging info. */
22197 dwarf2out_finish (const char *filename)
22199 limbo_die_node *node, *next_node;
22200 comdat_type_node *ctnode;
22201 htab_t comdat_type_table;
22202 dw_die_ref die = 0;
22205 gen_remaining_tmpl_value_param_die_attribute ();
22207 /* Add the name for the main input file now. We delayed this from
22208 dwarf2out_init to avoid complications with PCH. */
22209 add_name_attribute (comp_unit_die, remap_debug_filename (filename));
22210 if (!IS_ABSOLUTE_PATH (filename))
22211 add_comp_dir_attribute (comp_unit_die);
22212 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
22215 htab_traverse (file_table, file_table_relative_p, &p);
22217 add_comp_dir_attribute (comp_unit_die);
22220 for (i = 0; i < VEC_length (deferred_locations, deferred_locations_list); i++)
22222 add_location_or_const_value_attribute (
22223 VEC_index (deferred_locations, deferred_locations_list, i)->die,
22224 VEC_index (deferred_locations, deferred_locations_list, i)->variable,
22228 /* Traverse the limbo die list, and add parent/child links. The only
22229 dies without parents that should be here are concrete instances of
22230 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
22231 For concrete instances, we can get the parent die from the abstract
22233 for (node = limbo_die_list; node; node = next_node)
22235 next_node = node->next;
22238 if (die->die_parent == NULL)
22240 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
22243 add_child_die (origin->die_parent, die);
22244 else if (die == comp_unit_die)
22246 else if (seen_error ())
22247 /* It's OK to be confused by errors in the input. */
22248 add_child_die (comp_unit_die, die);
22251 /* In certain situations, the lexical block containing a
22252 nested function can be optimized away, which results
22253 in the nested function die being orphaned. Likewise
22254 with the return type of that nested function. Force
22255 this to be a child of the containing function.
22257 It may happen that even the containing function got fully
22258 inlined and optimized out. In that case we are lost and
22259 assign the empty child. This should not be big issue as
22260 the function is likely unreachable too. */
22261 tree context = NULL_TREE;
22263 gcc_assert (node->created_for);
22265 if (DECL_P (node->created_for))
22266 context = DECL_CONTEXT (node->created_for);
22267 else if (TYPE_P (node->created_for))
22268 context = TYPE_CONTEXT (node->created_for);
22270 gcc_assert (context
22271 && (TREE_CODE (context) == FUNCTION_DECL
22272 || TREE_CODE (context) == NAMESPACE_DECL));
22274 origin = lookup_decl_die (context);
22276 add_child_die (origin, die);
22278 add_child_die (comp_unit_die, die);
22283 limbo_die_list = NULL;
22285 resolve_addr (comp_unit_die);
22287 for (node = deferred_asm_name; node; node = node->next)
22289 tree decl = node->created_for;
22290 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
22292 add_linkage_attr (node->die, decl);
22293 move_linkage_attr (node->die);
22297 deferred_asm_name = NULL;
22299 /* Walk through the list of incomplete types again, trying once more to
22300 emit full debugging info for them. */
22301 retry_incomplete_types ();
22303 if (flag_eliminate_unused_debug_types)
22304 prune_unused_types ();
22306 /* Generate separate CUs for each of the include files we've seen.
22307 They will go into limbo_die_list. */
22308 if (flag_eliminate_dwarf2_dups && dwarf_version < 4)
22309 break_out_includes (comp_unit_die);
22311 /* Generate separate COMDAT sections for type DIEs. */
22312 if (dwarf_version >= 4)
22314 break_out_comdat_types (comp_unit_die);
22316 /* Each new type_unit DIE was added to the limbo die list when created.
22317 Since these have all been added to comdat_type_list, clear the
22319 limbo_die_list = NULL;
22321 /* For each new comdat type unit, copy declarations for incomplete
22322 types to make the new unit self-contained (i.e., no direct
22323 references to the main compile unit). */
22324 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
22325 copy_decls_for_unworthy_types (ctnode->root_die);
22326 copy_decls_for_unworthy_types (comp_unit_die);
22328 /* In the process of copying declarations from one unit to another,
22329 we may have left some declarations behind that are no longer
22330 referenced. Prune them. */
22331 prune_unused_types ();
22334 /* Traverse the DIE's and add add sibling attributes to those DIE's
22335 that have children. */
22336 add_sibling_attributes (comp_unit_die);
22337 for (node = limbo_die_list; node; node = node->next)
22338 add_sibling_attributes (node->die);
22339 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
22340 add_sibling_attributes (ctnode->root_die);
22342 /* Output a terminator label for the .text section. */
22343 switch_to_section (text_section);
22344 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
22345 if (flag_reorder_blocks_and_partition)
22347 switch_to_section (unlikely_text_section ());
22348 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
22351 /* We can only use the low/high_pc attributes if all of the code was
22353 if (!have_multiple_function_sections
22354 || !(dwarf_version >= 3 || !dwarf_strict))
22356 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
22357 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
22362 unsigned fde_idx = 0;
22363 bool range_list_added = false;
22365 /* We need to give .debug_loc and .debug_ranges an appropriate
22366 "base address". Use zero so that these addresses become
22367 absolute. Historically, we've emitted the unexpected
22368 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
22369 Emit both to give time for other tools to adapt. */
22370 add_AT_addr (comp_unit_die, DW_AT_low_pc, const0_rtx);
22371 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
22373 if (text_section_used)
22374 add_ranges_by_labels (comp_unit_die, text_section_label,
22375 text_end_label, &range_list_added);
22376 if (flag_reorder_blocks_and_partition && cold_text_section_used)
22377 add_ranges_by_labels (comp_unit_die, cold_text_section_label,
22378 cold_end_label, &range_list_added);
22380 for (fde_idx = 0; fde_idx < fde_table_in_use; fde_idx++)
22382 dw_fde_ref fde = &fde_table[fde_idx];
22384 if (fde->dw_fde_switched_sections)
22386 if (!fde->in_std_section)
22387 add_ranges_by_labels (comp_unit_die,
22388 fde->dw_fde_hot_section_label,
22389 fde->dw_fde_hot_section_end_label,
22390 &range_list_added);
22391 if (!fde->cold_in_std_section)
22392 add_ranges_by_labels (comp_unit_die,
22393 fde->dw_fde_unlikely_section_label,
22394 fde->dw_fde_unlikely_section_end_label,
22395 &range_list_added);
22397 else if (!fde->in_std_section)
22398 add_ranges_by_labels (comp_unit_die, fde->dw_fde_begin,
22399 fde->dw_fde_end, &range_list_added);
22402 if (range_list_added)
22406 /* Output location list section if necessary. */
22407 if (have_location_lists)
22409 /* Output the location lists info. */
22410 switch_to_section (debug_loc_section);
22411 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
22412 DEBUG_LOC_SECTION_LABEL, 0);
22413 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
22414 output_location_lists (die);
22417 if (debug_info_level >= DINFO_LEVEL_NORMAL)
22418 add_AT_lineptr (comp_unit_die, DW_AT_stmt_list,
22419 debug_line_section_label);
22421 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22422 add_AT_macptr (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
22424 /* Output all of the compilation units. We put the main one last so that
22425 the offsets are available to output_pubnames. */
22426 for (node = limbo_die_list; node; node = node->next)
22427 output_comp_unit (node->die, 0);
22429 comdat_type_table = htab_create (100, htab_ct_hash, htab_ct_eq, NULL);
22430 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
22432 void **slot = htab_find_slot (comdat_type_table, ctnode, INSERT);
22434 /* Don't output duplicate types. */
22435 if (*slot != HTAB_EMPTY_ENTRY)
22438 /* Add a pointer to the line table for the main compilation unit
22439 so that the debugger can make sense of DW_AT_decl_file
22441 if (debug_info_level >= DINFO_LEVEL_NORMAL)
22442 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
22443 debug_line_section_label);
22445 output_comdat_type_unit (ctnode);
22448 htab_delete (comdat_type_table);
22450 /* Output the main compilation unit if non-empty or if .debug_macinfo
22451 has been emitted. */
22452 output_comp_unit (comp_unit_die, debug_info_level >= DINFO_LEVEL_VERBOSE);
22454 /* Output the abbreviation table. */
22455 switch_to_section (debug_abbrev_section);
22456 output_abbrev_section ();
22458 /* Output public names table if necessary. */
22459 if (!VEC_empty (pubname_entry, pubname_table))
22461 switch_to_section (debug_pubnames_section);
22462 output_pubnames (pubname_table);
22465 /* Output public types table if necessary. */
22466 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
22467 It shouldn't hurt to emit it always, since pure DWARF2 consumers
22468 simply won't look for the section. */
22469 if (!VEC_empty (pubname_entry, pubtype_table))
22471 switch_to_section (debug_pubtypes_section);
22472 output_pubnames (pubtype_table);
22475 /* Output direct and virtual call tables if necessary. */
22476 if (!VEC_empty (dcall_entry, dcall_table))
22478 switch_to_section (debug_dcall_section);
22479 output_dcall_table ();
22481 if (!VEC_empty (vcall_entry, vcall_table))
22483 switch_to_section (debug_vcall_section);
22484 output_vcall_table ();
22487 /* Output the address range information. We only put functions in the arange
22488 table, so don't write it out if we don't have any. */
22489 if (fde_table_in_use)
22491 switch_to_section (debug_aranges_section);
22495 /* Output ranges section if necessary. */
22496 if (ranges_table_in_use)
22498 switch_to_section (debug_ranges_section);
22499 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
22503 /* Output the source line correspondence table. We must do this
22504 even if there is no line information. Otherwise, on an empty
22505 translation unit, we will generate a present, but empty,
22506 .debug_info section. IRIX 6.5 `nm' will then complain when
22507 examining the file. This is done late so that any filenames
22508 used by the debug_info section are marked as 'used'. */
22509 if (! DWARF2_ASM_LINE_DEBUG_INFO)
22511 switch_to_section (debug_line_section);
22512 output_line_info ();
22515 /* Have to end the macro section. */
22516 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
22518 switch_to_section (debug_macinfo_section);
22519 dw2_asm_output_data (1, 0, "End compilation unit");
22522 /* If we emitted any DW_FORM_strp form attribute, output the string
22524 if (debug_str_hash)
22525 htab_traverse (debug_str_hash, output_indirect_string, NULL);
22529 /* This should never be used, but its address is needed for comparisons. */
22530 const struct gcc_debug_hooks dwarf2_debug_hooks =
22534 0, /* assembly_start */
22537 0, /* start_source_file */
22538 0, /* end_source_file */
22539 0, /* begin_block */
22541 0, /* ignore_block */
22542 0, /* source_line */
22543 0, /* begin_prologue */
22544 0, /* end_prologue */
22545 0, /* begin_epilogue */
22546 0, /* end_epilogue */
22547 0, /* begin_function */
22548 0, /* end_function */
22549 0, /* function_decl */
22550 0, /* global_decl */
22552 0, /* imported_module_or_decl */
22553 0, /* deferred_inline_function */
22554 0, /* outlining_inline_function */
22556 0, /* handle_pch */
22557 0, /* var_location */
22558 0, /* switch_text_section */
22559 0, /* direct_call */
22560 0, /* virtual_call_token */
22561 0, /* copy_call_info */
22562 0, /* virtual_call */
22564 0 /* start_end_main_source_file */
22567 #endif /* DWARF2_DEBUGGING_INFO */
22569 #include "gt-dwarf2out.h"